diff --git a/.travis.yml b/.travis.yml index 037c8305..2a52403d 100644 --- a/.travis.yml +++ b/.travis.yml @@ -1,30 +1,34 @@ -osx_image: xcode6.4 +osx_image: xcode7.1 language: objective-c env: - global: - LC_CTYPE="en_US.UTF-8" matrix: - - CONFIGURATION="Code Coverage" SCHEME="XCDYouTubeKit iOS Static Library" DESTINATION="platform=iOS Simulator,name=iPhone 5s" OBJROOT="build" - - CONFIGURATION="Release" SCHEME="XCDYouTubeKit iOS Static Library" DESTINATION="platform=iOS Simulator,name=iPhone 5s,OS=8.1" - - CONFIGURATION="Release" SCHEME="XCDYouTubeKit iOS Static Library" DESTINATION="platform=iOS Simulator,name=iPhone 5s,OS=8.2" - - CONFIGURATION="Release" SCHEME="XCDYouTubeKit iOS Static Library" DESTINATION="platform=iOS Simulator,name=iPhone 5s,OS=8.3" - - CONFIGURATION="Release" SCHEME="XCDYouTubeKit iOS Static Library" DESTINATION="platform=iOS Simulator,name=iPhone 5s,OS=8.4" - - CONFIGURATION="Release" SCHEME="XCDYouTubeKit iOS Static Library" DESTINATION="platform=iOS Simulator,name=iPhone 4s" RUN_CLANG_STATIC_ANALYZER="YES" - - CONFIGURATION="Release" SCHEME="XCDYouTubeKit iOS Static Library" DESTINATION="platform=iOS Simulator,name=iPhone 5s" RUN_CLANG_STATIC_ANALYZER="YES" - - CONFIGURATION="Release" SCHEME="XCDYouTubeKit iOS Framework" DESTINATION="platform=iOS Simulator,name=iPhone 4s" RUN_CLANG_STATIC_ANALYZER="YES" - - CONFIGURATION="Release" SCHEME="XCDYouTubeKit iOS Framework" DESTINATION="platform=iOS Simulator,name=iPhone 5s" RUN_CLANG_STATIC_ANALYZER="YES" - - CONFIGURATION="Release" SCHEME="XCDYouTubeKit OS X" DESTINATION="platform=OS X" RUN_CLANG_STATIC_ANALYZER="YES" + - 'DESTINATION="platform=iOS Simulator,name=iPhone 5s" CONFIGURATION="Code Coverage" SCHEME="XCDYouTubeKit iOS Static Library" OBJROOT="build"' + - 'DESTINATION="platform=iOS Simulator,name=iPhone 5s,OS=8.1" CONFIGURATION="Release" SCHEME="XCDYouTubeKit iOS Static Library"' + - 'DESTINATION="platform=iOS Simulator,name=iPhone 5s,OS=8.2" CONFIGURATION="Release" SCHEME="XCDYouTubeKit iOS Static Library"' + - 'DESTINATION="platform=iOS Simulator,name=iPhone 5s,OS=8.3" CONFIGURATION="Release" SCHEME="XCDYouTubeKit iOS Static Library"' + - 'DESTINATION="platform=iOS Simulator,name=iPhone 5s,OS=8.4" CONFIGURATION="Release" SCHEME="XCDYouTubeKit iOS Static Library"' + - 'DESTINATION="platform=iOS Simulator,name=iPhone 5s,OS=9.0" CONFIGURATION="Release" SCHEME="XCDYouTubeKit iOS Static Library"' + - 'DESTINATION="platform=iOS Simulator,name=iPhone 5s,OS=9.1" CONFIGURATION="Release" SCHEME="XCDYouTubeKit iOS Static Library"' + - 'DESTINATION="platform=iOS Simulator,name=iPhone 5s,OS=9.1" CONFIGURATION="Release" SCHEME="XCDYouTubeKit iOS Static Library" IPHONEOS_DEPLOYMENT_TARGET="9.1"' + - 'DESTINATION="platform=iOS Simulator,name=iPhone 4s" CONFIGURATION="Release" SCHEME="XCDYouTubeKit iOS Static Library" RUN_CLANG_STATIC_ANALYZER="YES"' + - 'DESTINATION="platform=iOS Simulator,name=iPhone 5s" CONFIGURATION="Release" SCHEME="XCDYouTubeKit iOS Static Library" RUN_CLANG_STATIC_ANALYZER="YES"' + - 'DESTINATION="platform=iOS Simulator,name=iPhone 4s" CONFIGURATION="Release" SCHEME="XCDYouTubeKit iOS Framework" RUN_CLANG_STATIC_ANALYZER="YES"' + - 'DESTINATION="platform=iOS Simulator,name=iPhone 5s" CONFIGURATION="Release" SCHEME="XCDYouTubeKit iOS Framework" RUN_CLANG_STATIC_ANALYZER="YES"' + - 'DESTINATION="platform=OS X" CONFIGURATION="Release" SCHEME="XCDYouTubeKit OS X" RUN_CLANG_STATIC_ANALYZER="YES"' + - 'DESTINATION="platform=OS X" CONFIGURATION="Release" SCHEME="XCDYouTubeKit OS X" MACOSX_DEPLOYMENT_TARGET="10.10"' + - 'DESTINATION="platform=tvOS Simulator,name=Apple TV 1080p" CONFIGURATION="Release" SCHEME="XCDYouTubeKit tvOS" RUN_CLANG_STATIC_ANALYZER="YES"' before_install: - xcrun simctl list install: - - brew update; brew update - - brew install coreutils - - gem install xcpretty --no-rdoc --no-ri --no-document --quiet - gem install xcpretty-travis-formatter --no-rdoc --no-ri --no-document --quiet - sudo easy_install cpp-coveralls script: + - open -b com.apple.iphonesimulator # Workaround https://github.com/travis-ci/travis-ci/issues/3040 - ./Scripts/run-tests.sh after_success: - - if [ "$CONFIGURATION" == "Code Coverage" ]; then - coveralls --include XCDYouTubeKit; - fi + - '[ "$CONFIGURATION" == "Code Coverage" ] && coveralls --include XCDYouTubeKit' +after_failure: + - cat xcodebuild.log + - cat $TMPDIR/com.apple.dt.XCTest-status/Session*.log + - cat ~/Library/Logs/DiagnosticReports/xctest*.crash + - sleep 5 \ No newline at end of file diff --git a/CHANGELOG.md b/CHANGELOG.md index d991fd3d..a36b3074 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -1,3 +1,10 @@ +#### Version 2.4.0 + +* Support for tvOS. (#182) +* Replaced deprecated methods and classes: now using `NSURLSession` instead of `NSURLConnection` internally. (#190, #210) +* Support for Objective-C generics where applicable. +* The `XCDYouTubeVideoOperation` class has changed back from a synchronous to an asynchronous operation and can be started on the main thread. + #### Version 2.3.3 * Adaptation to YouTube API change. (#193, #194, #196, #197, #198, #202) diff --git a/README.md b/README.md index 97d75f92..8bfc137e 100644 --- a/README.md +++ b/README.md @@ -4,7 +4,7 @@ [![Coverage Status](https://img.shields.io/coveralls/0xced/XCDYouTubeKit/master.svg?style=flat)](https://coveralls.io/r/0xced/XCDYouTubeKit?branch=master) [![Platform](https://img.shields.io/cocoapods/p/XCDYouTubeKit.svg?style=flat)](http://cocoadocs.org/docsets/XCDYouTubeKit/) [![Pod Version](https://img.shields.io/cocoapods/v/XCDYouTubeKit.svg?style=flat)](https://cocoapods.org/pods/XCDYouTubeKit) -[![Carthage Compatibility](https://img.shields.io/badge/carthage-✓-f2a77e.svg?style=flat)](https://github.com/Carthage/Carthage/) +[![Carthage Compatibility](https://img.shields.io/badge/Carthage-compatible-4BC51D.svg?style=flat)](https://github.com/Carthage/Carthage/) [![License](https://img.shields.io/cocoapods/l/XCDYouTubeKit.svg?style=flat)](LICENSE) **XCDYouTubeKit** is a YouTube video player for iOS and OS X. @@ -29,13 +29,15 @@ XCDYouTubeKit is against the YouTube [Terms of Service](https://www.youtube.com/ XCDYouTubeKit is available through CocoaPods and Carthage. CocoaPods: + ```ruby -pod "XCDYouTubeKit", "~> 2.3.3" +pod "XCDYouTubeKit", "~> 2.4.0" ``` Carthage: + ```objc -github "0xced/XCDYouTubeKit" ~> 2.3.3 +github "0xced/XCDYouTubeKit" ~> 2.4.0 ``` Alternatively, you can manually use the provided static library on iOS or dynamic framework on OS X. In order to use the iOS static library, you must: @@ -51,22 +53,6 @@ These steps will ensure that `#import ` will work XCDYouTubeKit is [fully documented](http://cocoadocs.org/docsets/XCDYouTubeKit/). -### iOS and OS X - -```objc -NSString *videoIdentifier = @"EdeVaT-zZt4"; // A 11 characters YouTube video identifier -[[XCDYouTubeClient defaultClient] getVideoWithIdentifier:videoIdentifier completionHandler:^(XCDYouTubeVideo *video, NSError *error) { - if (video) - { - // Do something with the `video` object - } - else - { - // Handle error - } -}]; -``` - ### iOS only On iOS, you can use the class `XCDYouTubeVideoPlayerViewController` the same way you use a `MPMoviePlayerViewController`, except you initialize it with a YouTube video identifier instead of a content URL. @@ -74,8 +60,24 @@ On iOS, you can use the class `XCDYouTubeVideoPlayerViewController` the same way #### Present the video in full-screen ```objc -XCDYouTubeVideoPlayerViewController *videoPlayerViewController = [[XCDYouTubeVideoPlayerViewController alloc] initWithVideoIdentifier:@"9bZkp7q19f0"]; -[self presentMoviePlayerViewControllerAnimated:videoPlayerViewController]; +- (void) playVideo +{ + XCDYouTubeVideoPlayerViewController *videoPlayerViewController = [[XCDYouTubeVideoPlayerViewController alloc] initWithVideoIdentifier:@"9bZkp7q19f0"]; + [[NSNotificationCenter defaultCenter] addObserver:self selector:@selector(moviePlayerPlaybackDidFinish:) name:MPMoviePlayerPlaybackDidFinishNotification object:videoPlayerViewController.moviePlayer]; + [self presentMoviePlayerViewControllerAnimated:videoPlayerViewController]; +} + +- (void) moviePlayerPlaybackDidFinish:(NSNotification *)notification +{ + [[NSNotificationCenter defaultCenter] removeObserver:self name:MPMoviePlayerPlaybackDidFinishNotification object:notification.object]; + MPMovieFinishReason finishReason = [notification.userInfo[MPMoviePlayerPlaybackDidFinishReasonUserInfoKey] integerValue]; + if (finishReason == MPMovieFinishReasonPlaybackError) + { + NSError *error = notification.userInfo[XCDMoviePlayerPlaybackDidFinishErrorUserInfoKey]; + // Handle error + } +} + ``` #### Present the video in a non full-screen view @@ -86,6 +88,22 @@ XCDYouTubeVideoPlayerViewController *videoPlayerViewController = [[XCDYouTubeVid [videoPlayerViewController.moviePlayer play]; ``` +### iOS and OS X + +```objc +NSString *videoIdentifier = @"EdeVaT-zZt4"; // A 11 characters YouTube video identifier +[[XCDYouTubeClient defaultClient] getVideoWithIdentifier:videoIdentifier completionHandler:^(XCDYouTubeVideo *video, NSError *error) { + if (video) + { + // Do something with the `video` object + } + else + { + // Handle error + } +}]; +``` + See the demo project for more sample code. ## Logging diff --git a/Scripts/run-tests.sh b/Scripts/run-tests.sh index b0d71ade..c2c5f112 100755 --- a/Scripts/run-tests.sh +++ b/Scripts/run-tests.sh @@ -6,11 +6,9 @@ set -o pipefail : ${CONFIGURATION:="Release"} : ${DESTINATION:="platform=iOS Simulator,name=iPhone 5s"} -COMMAND="" -gstdbuf --version > /dev/null && COMMAND+="gstdbuf -o 0 " -COMMAND+="xcodebuild clean test -project XCDYouTubeKit.xcodeproj -scheme '${SCHEME}' -configuration '${CONFIGURATION}' -destination '${DESTINATION}'" +COMMAND="env NSUnbufferedIO=YES xcodebuild clean test -project XCDYouTubeKit.xcodeproj -scheme '${SCHEME}' -configuration '${CONFIGURATION}' -destination '${DESTINATION}'" -for BUILD_SETTING in OBJROOT RUN_CLANG_STATIC_ANALYZER; do +for BUILD_SETTING in OBJROOT RUN_CLANG_STATIC_ANALYZER IPHONEOS_DEPLOYMENT_TARGET MACOSX_DEPLOYMENT_TARGET; do VALUE=`eval echo \\$"${BUILD_SETTING}"` if [ ! -z "${VALUE}" ]; then COMMAND+=" ${BUILD_SETTING}='${VALUE}'" @@ -18,8 +16,9 @@ for BUILD_SETTING in OBJROOT RUN_CLANG_STATIC_ANALYZER; do fi done -xcpretty --version > /dev/null && COMMAND+=" | xcpretty -c" -xcpretty-travis-formatter > /dev/null && COMMAND+=" -f `xcpretty-travis-formatter`" +COMMAND+=" | tee xcodebuild.log" + +xcpretty --version > /dev/null 2>&1 && COMMAND+=" | xcpretty -c" && xcpretty-travis-formatter > /dev/null 2>&1 && COMMAND+=" -f `xcpretty-travis-formatter`" set -x -eval "${COMMAND}" +eval "${COMMAND}" && rm xcodebuild.log diff --git a/XCDYouTubeKit Demo/OS X Demo/AppDelegate.m b/XCDYouTubeKit Demo/OS X Demo/AppDelegate.m index 8dc6e4cd..ea290d36 100644 --- a/XCDYouTubeKit Demo/OS X Demo/AppDelegate.m +++ b/XCDYouTubeKit Demo/OS X Demo/AppDelegate.m @@ -13,7 +13,7 @@ @implementation AppDelegate - (void) applicationDidFinishLaunching:(NSNotification *)aNotification { - [[NSUserDefaults standardUserDefaults] registerDefaults:@{ @"VideoIdentifier": @"EdeVaT-zZt4" }]; + [[NSUserDefaults standardUserDefaults] registerDefaults:@{ @"VideoIdentifier": @"6v2L2UGZJAM" }]; [DDLog addLogger:[DDASLLogger sharedInstance]]; } diff --git a/XCDYouTubeKit Demo/OS X Demo/Base.lproj/MainMenu.xib b/XCDYouTubeKit Demo/OS X Demo/Base.lproj/MainMenu.xib index a60881a2..96875fb2 100644 --- a/XCDYouTubeKit Demo/OS X Demo/Base.lproj/MainMenu.xib +++ b/XCDYouTubeKit Demo/OS X Demo/Base.lproj/MainMenu.xib @@ -1,8 +1,9 @@ - + - - + + + @@ -11,7 +12,7 @@ - + @@ -672,7 +673,7 @@ - + @@ -680,15 +681,14 @@ - + - - + @@ -697,7 +697,7 @@ - + @@ -711,13 +711,14 @@ - + + @@ -728,6 +729,7 @@ + diff --git a/XCDYouTubeKit Demo/OS X Demo/Supporting Files/XCDYouTubeKit OS X Demo-Info.plist b/XCDYouTubeKit Demo/OS X Demo/Supporting Files/XCDYouTubeKit OS X Demo-Info.plist index 91cc9184..c1af0763 100644 --- a/XCDYouTubeKit Demo/OS X Demo/Supporting Files/XCDYouTubeKit OS X Demo-Info.plist +++ b/XCDYouTubeKit Demo/OS X Demo/Supporting Files/XCDYouTubeKit OS X Demo-Info.plist @@ -9,7 +9,7 @@ CFBundleIconFile CFBundleIdentifier - ch.pitaya.xcdyoutubekit.demo.osx + $(PRODUCT_BUNDLE_IDENTIFIER) CFBundleInfoDictionaryVersion 6.0 CFBundleName diff --git a/XCDYouTubeKit Demo/Podfile b/XCDYouTubeKit Demo/Podfile index c81799f8..c87ce977 100644 --- a/XCDYouTubeKit Demo/Podfile +++ b/XCDYouTubeKit Demo/Podfile @@ -16,3 +16,9 @@ target 'XCDYouTubeKit OS X Demo' do platform :osx, '10.9' import_pods end + +target 'XCDYouTubeKit tvOS Demo' do + plugin 'cocoapods-expert-difficulty' + platform :tvos, '9.0' + pod 'Google-API-Client/YouTube', '~> 1.0.422' +end diff --git a/XCDYouTubeKit Demo/Podfile.lock b/XCDYouTubeKit Demo/Podfile.lock index d1cf25ae..c6cd3a8a 100644 --- a/XCDYouTubeKit Demo/Podfile.lock +++ b/XCDYouTubeKit Demo/Podfile.lock @@ -7,6 +7,16 @@ PODS: - CocoaLumberjack/Core - CocoaLumberjack/Extensions (2.0.1): - CocoaLumberjack/Default + - Google-API-Client/Common (1.0.422): + - gtm-http-fetcher (~> 1.0.141) + - gtm-oauth2 (~> 1.0.125) + - Google-API-Client/YouTube (1.0.422): + - Google-API-Client/Common + - gtm-http-fetcher (~> 1.0.141) + - gtm-oauth2 (~> 1.0.125) + - gtm-http-fetcher (1.0.141) + - gtm-oauth2 (1.0.126): + - gtm-http-fetcher (~> 1.0.141) - NSLogger (1.5.1): - NSLogger/Standard (= 1.5.1) - NSLogger/Standard (1.5.1) @@ -15,11 +25,15 @@ PODS: - NSLogger (~> 1.5.1) DEPENDENCIES: + - Google-API-Client/YouTube (~> 1.0.422) - XCDLumberjackNSLogger (~> 1.0.0) SPEC CHECKSUMS: CocoaLumberjack: 019d1361244274a6138c788c6cb80baabc13fb8f + Google-API-Client: cb712cf122f1d7fda966de4c2bc551324573366c + gtm-http-fetcher: 6d4617e7d343b6e4c082b777541c334eb6f5d81e + gtm-oauth2: 2a18b824e4f8a02df6cfe987beb59ae9d9697f9d NSLogger: 5ed223a2436df96244e033be750656dacdeec034 XCDLumberjackNSLogger: 867392d7b40490e1b15aac9c1acee0952bf33d61 -COCOAPODS: 0.38.2 +COCOAPODS: 0.39.0 diff --git a/XCDYouTubeKit Demo/Pods/Google-API-Client/Source/GTLDefines.h b/XCDYouTubeKit Demo/Pods/Google-API-Client/Source/GTLDefines.h new file mode 100644 index 00000000..b12eb9eb --- /dev/null +++ b/XCDYouTubeKit Demo/Pods/Google-API-Client/Source/GTLDefines.h @@ -0,0 +1,144 @@ +/* Copyright (c) 2011 Google Inc. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +// +// GTLDefines.h +// + +// Ensure Apple's conditionals we depend on are defined. +#import +#import + +// +// The developer may choose to define these in the project: +// +// #define GTL_TARGET_NAMESPACE Xxx // preface all GTL class names with Xxx (recommended for building plug-ins) +// #define GTL_FOUNDATION_ONLY 1 // builds without AppKit or Carbon (default for iPhone builds) +// #define STRIP_GTM_FETCH_LOGGING 1 // omit http logging code (default for iPhone release builds) +// +// Mac developers may find GTL_SIMPLE_DESCRIPTIONS and STRIP_GTM_FETCH_LOGGING useful for +// reducing code size. +// + +// Define later OS versions when building on earlier versions +#ifdef MAC_OS_X_VERSION_10_0 + #ifndef MAC_OS_X_VERSION_10_6 + #define MAC_OS_X_VERSION_10_6 1060 + #endif +#endif + + +#ifdef GTL_TARGET_NAMESPACE +// prefix all GTL class names with GTL_TARGET_NAMESPACE for this target + #import "GTLTargetNamespace.h" +#endif + +// Provide a common definition for externing constants/functions +#if defined(__cplusplus) + #define GTL_EXTERN extern "C" +#else + #define GTL_EXTERN extern +#endif + +#if TARGET_OS_IPHONE // iPhone SDK + + #define GTL_IPHONE 1 + +#endif + +#if GTL_IPHONE + + #define GTL_FOUNDATION_ONLY 1 + +#endif + +// +// GTL_ASSERT is like NSAssert, but takes a variable number of arguments: +// +// GTL_ASSERT(condition, @"Problem in argument %@", argStr); +// +// GTL_DEBUG_ASSERT is similar, but compiles in only for debug builds +// + +#ifndef GTL_ASSERT + // we directly invoke the NSAssert handler so we can pass on the varargs + #if !defined(NS_BLOCK_ASSERTIONS) + #define GTL_ASSERT(condition, ...) \ + do { \ + if (!(condition)) { \ + [[NSAssertionHandler currentHandler] \ + handleFailureInFunction:[NSString stringWithUTF8String:__PRETTY_FUNCTION__] \ + file:[NSString stringWithUTF8String:__FILE__] \ + lineNumber:__LINE__ \ + description:__VA_ARGS__]; \ + } \ + } while(0) + #else + #define GTL_ASSERT(condition, ...) do { } while (0) + #endif // !defined(NS_BLOCK_ASSERTIONS) +#endif // GTL_ASSERT + +#ifndef GTL_DEBUG_ASSERT + #if DEBUG + #define GTL_DEBUG_ASSERT(condition, ...) GTL_ASSERT(condition, __VA_ARGS__) + #else + #define GTL_DEBUG_ASSERT(condition, ...) do { } while (0) + #endif +#endif + +#ifndef GTL_DEBUG_LOG + #if DEBUG + #define GTL_DEBUG_LOG(...) NSLog(__VA_ARGS__) + #else + #define GTL_DEBUG_LOG(...) do { } while (0) + #endif +#endif + +#ifndef STRIP_GTM_FETCH_LOGGING + #if GTL_IPHONE && !DEBUG + #define STRIP_GTM_FETCH_LOGGING 1 + #else + #define STRIP_GTM_FETCH_LOGGING 0 + #endif +#endif + +// Some support for advanced clang static analysis functionality +// See http://clang-analyzer.llvm.org/annotations.html +#ifndef __has_feature // Optional. + #define __has_feature(x) 0 // Compatibility with non-clang compilers. +#endif +#ifndef NS_RETURNS_NOT_RETAINED + #if __has_feature(attribute_ns_returns_not_retained) + #define NS_RETURNS_NOT_RETAINED __attribute__((ns_returns_not_retained)) + #else + #define NS_RETURNS_NOT_RETAINED + #endif +#endif + +#ifndef __has_attribute + #define __has_attribute(x) 0 +#endif + +#if 1 + // We will start using nonnull declarations once the static analyzer seems + // to support it without false positives. + #define GTL_NONNULL(x) +#else + #if __has_attribute(nonnull) + #define GTL_NONNULL(x) __attribute__((nonnull x)) + #else + #define GTL_NONNULL(x) + #endif +#endif diff --git a/XCDYouTubeKit Demo/Pods/Google-API-Client/Source/Objects/GTLBatchQuery.h b/XCDYouTubeKit Demo/Pods/Google-API-Client/Source/Objects/GTLBatchQuery.h new file mode 100644 index 00000000..d4fb1d38 --- /dev/null +++ b/XCDYouTubeKit Demo/Pods/Google-API-Client/Source/Objects/GTLBatchQuery.h @@ -0,0 +1,57 @@ +/* Copyright (c) 2011 Google Inc. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +// +// GTLBatchQuery.h +// + +// Batch query documentation: +// https://code.google.com/p/google-api-objectivec-client/wiki/Introduction#Batch_Operations + +#import "GTLQuery.h" + +@interface GTLBatchQuery : NSObject { + @private + NSMutableArray *queries_; + NSMutableDictionary *requestIDMap_; + BOOL skipAuthorization_; + NSDictionary *additionalHTTPHeaders_; + NSDictionary *urlQueryParameters_; +} + +// Queries included in this batch. Each query should have a unique requestID. +@property (retain) NSArray *queries; + +// Clients may set this to YES to disallow authorization. Defaults to NO. +@property (assign) BOOL shouldSkipAuthorization; + +// Any additional HTTP headers for this batch. +// +// These headers override the same keys from the service object's +// additionalHTTPHeaders. +@property (copy) NSDictionary *additionalHTTPHeaders; + +// Any URL query parameters to add to the query (useful for debugging with some +// services). +@property (copy) NSDictionary *urlQueryParameters; + ++ (id)batchQuery; ++ (id)batchQueryWithQueries:(NSArray *)array; + +- (void)addQuery:(GTLQuery *)query GTL_NONNULL((1)); + +- (GTLQuery *)queryForRequestID:(NSString *)requestID GTL_NONNULL((1)); + +@end diff --git a/XCDYouTubeKit Demo/Pods/Google-API-Client/Source/Objects/GTLBatchQuery.m b/XCDYouTubeKit Demo/Pods/Google-API-Client/Source/Objects/GTLBatchQuery.m new file mode 100644 index 00000000..c584368c --- /dev/null +++ b/XCDYouTubeKit Demo/Pods/Google-API-Client/Source/Objects/GTLBatchQuery.m @@ -0,0 +1,135 @@ +/* Copyright (c) 2011 Google Inc. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +// +// GTLBatchQuery.m +// + +#import "GTLBatchQuery.h" + +@implementation GTLBatchQuery + +@synthesize shouldSkipAuthorization = skipAuthorization_, + additionalHTTPHeaders = additionalHTTPHeaders_, + urlQueryParameters = urlQueryParameters_; + ++ (id)batchQuery { + GTLBatchQuery *obj = [[[self alloc] init] autorelease]; + return obj; +} + ++ (id)batchQueryWithQueries:(NSArray *)queries { + GTLBatchQuery *obj = [self batchQuery]; + obj.queries = queries; + return obj; +} + +- (id)copyWithZone:(NSZone *)zone { + // Deep copy the list of queries + NSArray *copiesOfQueries = [[[NSArray alloc] initWithArray:self.queries + copyItems:YES] autorelease]; + GTLBatchQuery *newBatch = [[[self class] allocWithZone:zone] init]; + newBatch.queries = copiesOfQueries; + newBatch.shouldSkipAuthorization = self.shouldSkipAuthorization; + newBatch.additionalHTTPHeaders = self.additionalHTTPHeaders; + return newBatch; +} + +- (void)dealloc { + [queries_ release]; + [additionalHTTPHeaders_ release]; + [urlQueryParameters_ release]; + [requestIDMap_ release]; + + [super dealloc]; +} + +- (NSString *)description { + NSArray *queries = self.queries; + NSArray *methodNames = [queries valueForKey:@"methodName"]; + NSArray *dedupedNames = [[NSSet setWithArray:methodNames] allObjects]; + NSString *namesStr = [dedupedNames componentsJoinedByString:@","]; + + return [NSString stringWithFormat:@"%@ %p (queries:%lu methods:%@)", + [self class], self, (unsigned long) [queries count], namesStr]; +} + +#pragma mark - + +- (BOOL)isBatchQuery { + return YES; +} + +- (GTLUploadParameters *)uploadParameters { + // File upload is not supported for batches + return nil; +} + +- (void)executionDidStop { + NSArray *queries = self.queries; + [queries makeObjectsPerformSelector:@selector(executionDidStop)]; +} + +- (GTLQuery *)queryForRequestID:(NSString *)requestID { + GTLQuery *result = [requestIDMap_ objectForKey:requestID]; + if (result) return result; + + // We've not before tried to look up a query, or the map is stale + [requestIDMap_ release]; + requestIDMap_ = [[NSMutableDictionary alloc] init]; + + for (GTLQuery *query in queries_) { + [requestIDMap_ setObject:query forKey:query.requestID]; + } + + result = [requestIDMap_ objectForKey:requestID]; + return result; +} + +#pragma mark - + +- (void)setQueries:(NSArray *)array { +#if DEBUG + for (id obj in array) { + GTLQuery *query = obj; + GTL_DEBUG_ASSERT([query isKindOfClass:[GTLQuery class]], + @"unexpected query class: %@", [obj class]); + GTL_DEBUG_ASSERT(query.uploadParameters == nil, + @"batch may not contain upload: %@", query); + } +#endif + + [queries_ autorelease]; + queries_ = [array mutableCopy]; +} + +- (NSArray *)queries { + return queries_; +} + +- (void)addQuery:(GTLQuery *)query { + GTL_DEBUG_ASSERT([query isKindOfClass:[GTLQuery class]], + @"unexpected query class: %@", [query class]); + GTL_DEBUG_ASSERT(query.uploadParameters == nil, + @"batch may not contain upload: %@", query); + + if (queries_ == nil) { + queries_ = [[NSMutableArray alloc] init]; + } + + [queries_ addObject:query]; +} + +@end diff --git a/XCDYouTubeKit Demo/Pods/Google-API-Client/Source/Objects/GTLBatchResult.h b/XCDYouTubeKit Demo/Pods/Google-API-Client/Source/Objects/GTLBatchResult.h new file mode 100644 index 00000000..9675aaf7 --- /dev/null +++ b/XCDYouTubeKit Demo/Pods/Google-API-Client/Source/Objects/GTLBatchResult.h @@ -0,0 +1,58 @@ +/* Copyright (c) 2011 Google Inc. +* +* Licensed under the Apache License, Version 2.0 (the "License"); +* you may not use this file except in compliance with the License. +* You may obtain a copy of the License at +* +* http://www.apache.org/licenses/LICENSE-2.0 +* +* Unless required by applicable law or agreed to in writing, software +* distributed under the License is distributed on an "AS IS" BASIS, +* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +* See the License for the specific language governing permissions and +* limitations under the License. +*/ + +// +// GTLBatchResult.h +// + +#import "GTLObject.h" + +@interface GTLBatchResult : GTLObject { + @private + NSMutableDictionary *successes_; + NSMutableDictionary *failures_; +} + +// Dictionaries of results for all queries in the batch +// +// Dictionary keys are requestID strings; objects are results or +// GTLErrorObjects. +// +// For successes with no returned object (such as from delete operations), +// the object for the dictionary entry is NSNull. +// +// +// The original query for each result is available from the service ticket, +// for example +// +// NSDictionary *successes = batchResults.successes; +// for (NSString *requestID in successes) { +// GTLObject *obj = [successes objectForKey:requestID]; +// GTLQuery *query = [ticket queryForRequestID:requestID]; +// NSLog(@"Query %@ returned object %@", query, obj); +// } +// +// NSDictionary *failures = batchResults.failures; +// for (NSString *requestID in failures) { +// GTLErrorObject *errorObj = [failures objectForKey:requestID]; +// GTLQuery *query = [ticket queryForRequestID:requestID]; +// NSLog(@"Query %@ failed with error %@", query, errorObj); +// } +// + +@property (retain) NSMutableDictionary *successes; +@property (retain) NSMutableDictionary *failures; + +@end diff --git a/XCDYouTubeKit Demo/Pods/Google-API-Client/Source/Objects/GTLBatchResult.m b/XCDYouTubeKit Demo/Pods/Google-API-Client/Source/Objects/GTLBatchResult.m new file mode 100644 index 00000000..f17748d5 --- /dev/null +++ b/XCDYouTubeKit Demo/Pods/Google-API-Client/Source/Objects/GTLBatchResult.m @@ -0,0 +1,92 @@ +/* Copyright (c) 2011 Google Inc. +* +* Licensed under the Apache License, Version 2.0 (the "License"); +* you may not use this file except in compliance with the License. +* You may obtain a copy of the License at +* +* http://www.apache.org/licenses/LICENSE-2.0 +* +* Unless required by applicable law or agreed to in writing, software +* distributed under the License is distributed on an "AS IS" BASIS, +* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +* See the License for the specific language governing permissions and +* limitations under the License. +*/ + +// +// GTLBatchResult.m +// + +#import "GTLBatchResult.h" + +#import "GTLErrorObject.h" + +@implementation GTLBatchResult + +@synthesize successes = successes_, + failures = failures_; + +- (id)copyWithZone:(NSZone *)zone { + GTLBatchResult* newObject = [super copyWithZone:zone]; + newObject.successes = [[self.successes mutableCopyWithZone:zone] autorelease]; + newObject.failures = [[self.failures mutableCopyWithZone:zone] autorelease]; + return newObject; +} + +- (void)dealloc { + [successes_ release]; + [failures_ release]; + + [super dealloc]; +} + +- (NSString *)description { + return [NSString stringWithFormat:@"%@ %p (successes:%lu failures:%lu)", + [self class], self, + (unsigned long) [self.successes count], + (unsigned long) [self.failures count]]; +} + +#pragma mark - + +- (void)createItemsWithClassMap:(NSDictionary *)batchClassMap { + // This is called by GTLObject objectForJSON:defaultClass: + // JSON is defined to be a dictionary, but for batch results, it really + // is any array. + id json = self.JSON; + GTL_DEBUG_ASSERT([json isKindOfClass:[NSArray class]], + @"didn't get an array for the batch results"); + NSArray *jsonArray = json; + + NSMutableDictionary *successes = [NSMutableDictionary dictionary]; + NSMutableDictionary *failures = [NSMutableDictionary dictionary]; + + for (NSMutableDictionary *rpcResponse in jsonArray) { + NSString *responseID = [rpcResponse objectForKey:@"id"]; + + NSMutableDictionary *errorJSON = [rpcResponse objectForKey:@"error"]; + if (errorJSON) { + GTLErrorObject *errorObject = [GTLErrorObject objectWithJSON:errorJSON]; + [failures setValue:errorObject forKey:responseID]; + } else { + NSMutableDictionary *resultJSON = [rpcResponse objectForKey:@"result"]; + + NSDictionary *surrogates = self.surrogates; + Class defaultClass = [batchClassMap objectForKey:responseID]; + + id resultObject = [[self class] objectForJSON:resultJSON + defaultClass:defaultClass + surrogates:surrogates + batchClassMap:nil]; + if (resultObject == nil) { + // methods like delete return no object + resultObject = [NSNull null]; + } + [successes setValue:resultObject forKey:responseID]; + } + } + self.successes = successes; + self.failures = failures; +} + +@end diff --git a/XCDYouTubeKit Demo/Pods/Google-API-Client/Source/Objects/GTLDateTime.h b/XCDYouTubeKit Demo/Pods/Google-API-Client/Source/Objects/GTLDateTime.h new file mode 100644 index 00000000..f6b1ffb3 --- /dev/null +++ b/XCDYouTubeKit Demo/Pods/Google-API-Client/Source/Objects/GTLDateTime.h @@ -0,0 +1,60 @@ +/* Copyright (c) 2011 Google Inc. +* +* Licensed under the Apache License, Version 2.0 (the "License"); +* you may not use this file except in compliance with the License. +* You may obtain a copy of the License at +* +* http://www.apache.org/licenses/LICENSE-2.0 +* +* Unless required by applicable law or agreed to in writing, software +* distributed under the License is distributed on an "AS IS" BASIS, +* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +* See the License for the specific language governing permissions and +* limitations under the License. +*/ + +// +// GTLDateTime.h +// +// This is an immutable class representing a date and optionally a +// time with time zone. +// + +#import +#import "GTLDefines.h" + +@interface GTLDateTime : NSObject { + NSDateComponents *dateComponents_; + NSInteger milliseconds_; // This is only for the fraction of a second 0-999 + NSInteger offsetSeconds_; // may be NSUndefinedDateComponent + BOOL isUniversalTime_; // preserves "Z" + NSTimeZone *timeZone_; // specific time zone by name, if known +} + ++ (GTLDateTime *)dateTimeWithRFC3339String:(NSString *)str; + +// timeZone may be nil if the time zone is not known. ++ (GTLDateTime *)dateTimeWithDate:(NSDate *)date timeZone:(NSTimeZone *)tz; + +// Use this method to make a dateTime for an all-day event (date only, so +// hasTime is NO.) ++ (GTLDateTime *)dateTimeForAllDayWithDate:(NSDate *)date; + ++ (GTLDateTime *)dateTimeWithDateComponents:(NSDateComponents *)date; + +@property (nonatomic, readonly) NSDate *date; +@property (nonatomic, readonly) NSCalendar *calendar; + +@property (nonatomic, readonly) NSString *RFC3339String; +@property (nonatomic, readonly) NSString *stringValue; // same as RFC3339String + +@property (nonatomic, readonly, retain) NSTimeZone *timeZone; +@property (nonatomic, readonly, copy) NSDateComponents *dateComponents; +@property (nonatomic, readonly) NSInteger milliseconds; // This is only for the fraction of a second 0-999 + +@property (nonatomic, readonly) BOOL hasTime; +@property (nonatomic, readonly) NSInteger offsetSeconds; +@property (nonatomic, readonly, getter=isUniversalTime) BOOL universalTime; + + +@end diff --git a/XCDYouTubeKit Demo/Pods/Google-API-Client/Source/Objects/GTLDateTime.m b/XCDYouTubeKit Demo/Pods/Google-API-Client/Source/Objects/GTLDateTime.m new file mode 100644 index 00000000..e15684bd --- /dev/null +++ b/XCDYouTubeKit Demo/Pods/Google-API-Client/Source/Objects/GTLDateTime.m @@ -0,0 +1,543 @@ +/* Copyright (c) 2011 Google Inc. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +// +// GTLDateTime.m +// + +#import "GTLDateTime.h" + +#if (!TARGET_OS_IPHONE && defined(MAC_OS_X_VERSION_10_10) && MAC_OS_X_VERSION_MAX_ALLOWED >= MAC_OS_X_VERSION_10_10) \ + || (TARGET_OS_IPHONE && defined(__IPHONE_8_0) && __IPHONE_OS_VERSION_MAX_ALLOWED >= __IPHONE_8_0) +#define GTL_NEW_CALENDAR_ENUMS 1 +#else +#define GTL_NEW_CALENDAR_ENUMS 0 +#endif + +#if GTL_NEW_CALENDAR_ENUMS +static const NSInteger kGTLUndefinedDateComponent = NSDateComponentUndefined; +#else +static const NSInteger kGTLUndefinedDateComponent = NSUndefinedDateComponent; +#endif + + +@interface GTLDateTime () + +- (void)setFromDate:(NSDate *)date timeZone:(NSTimeZone *)tz; +- (void)setFromRFC3339String:(NSString *)str; + +@property (nonatomic, retain, readwrite) NSTimeZone *timeZone; +@property (nonatomic, copy, readwrite) NSDateComponents *dateComponents; +@property (nonatomic, assign, readwrite) NSInteger milliseconds; + +@property (nonatomic, assign, readwrite) BOOL hasTime; +@property (nonatomic, assign, readwrite) NSInteger offsetSeconds; +@property (nonatomic, assign, getter=isUniversalTime, readwrite) BOOL universalTime; + +@end + +static NSCharacterSet *gDashSet = nil; +static NSCharacterSet *gTSet = nil; +static NSCharacterSet *gColonSet = nil; +static NSCharacterSet *gPlusMinusZSet = nil; +static NSMutableDictionary *gCalendarsForTimeZones = nil; + +@implementation GTLDateTime + +// A note about milliseconds_: +// RFC 3339 has support for fractions of a second. NSDateComponents is all +// NSInteger based, so it can't handle a fraction of a second. NSDate is +// built on NSTimeInterval so it has sub-millisecond precision. GTL takes +// the compromise of supporting the RFC's optional fractional second support +// by maintaining a number of milliseconds past what fits in the +// NSDateComponents. The parsing and string conversions will include +// 3 decimal digits (hence milliseconds). When going to a string, the decimal +// digits are only included if the milliseconds are non zero. + +@dynamic date; +@dynamic calendar; +@dynamic RFC3339String; +@dynamic stringValue; +@dynamic timeZone; +@dynamic hasTime; + +@synthesize dateComponents = dateComponents_, + milliseconds = milliseconds_, + offsetSeconds = offsetSeconds_, + universalTime = isUniversalTime_; + ++ (void)initialize { + // Note that initialize is guaranteed by the runtime to be called in a + // thread-safe manner. + if (gDashSet == nil) { + gDashSet = [[NSCharacterSet characterSetWithCharactersInString:@"-"] retain]; + gTSet = [[NSCharacterSet characterSetWithCharactersInString:@"Tt "] retain]; + gColonSet = [[NSCharacterSet characterSetWithCharactersInString:@":"] retain]; + gPlusMinusZSet = [[NSCharacterSet characterSetWithCharactersInString:@"+-zZ"] retain]; + + gCalendarsForTimeZones = [[NSMutableDictionary alloc] init]; + } +} + ++ (GTLDateTime *)dateTimeWithRFC3339String:(NSString *)str { + if (str == nil) return nil; + + GTLDateTime *result = [[[self alloc] init] autorelease]; + [result setFromRFC3339String:str]; + return result; +} + ++ (GTLDateTime *)dateTimeWithDate:(NSDate *)date timeZone:(NSTimeZone *)tz { + if (date == nil) return nil; + + GTLDateTime *result = [[[self alloc] init] autorelease]; + [result setFromDate:date timeZone:tz]; + return result; +} + ++ (GTLDateTime *)dateTimeForAllDayWithDate:(NSDate *)date { + if (date == nil) return nil; + + GTLDateTime *result = [[[self alloc] init] autorelease]; + [result setFromDate:date timeZone:nil]; + result.hasTime = NO; + return result; +} + ++ (GTLDateTime *)dateTimeWithDateComponents:(NSDateComponents *)components { +#if GTL_NEW_CALENDAR_ENUMS + NSString *calendarID = NSCalendarIdentifierGregorian; +#else + NSString *calendarID = NSGregorianCalendar; +#endif + NSCalendar *cal = [[[NSCalendar alloc] initWithCalendarIdentifier:calendarID] autorelease]; + NSDate *date = [cal dateFromComponents:components]; +#if GTL_IPHONE + NSTimeZone *tz = [components timeZone]; +#else + // NSDateComponents added timeZone: in Mac OS X 10.7. + NSTimeZone *tz = nil; + if ([components respondsToSelector:@selector(timeZone)]) { + tz = [components timeZone]; + } +#endif + return [self dateTimeWithDate:date timeZone:tz]; +} + +- (void)dealloc { + [dateComponents_ release]; + [timeZone_ release]; + [super dealloc]; +} + +- (id)copyWithZone:(NSZone *)zone { + // Object is immutable + return [self retain]; +} + +// On 10.9 and iOS 7 (and possibly earlier systems) NSDateComponents isEqual: works; check if +// we're guaranteed to be running on those systems or later. +#if (!TARGET_OS_IPHONE && defined(MAC_OS_X_VERSION_10_9) && MAC_OS_X_VERSION_MIN_REQUIRED >= MAC_OS_X_VERSION_10_9) \ + || (TARGET_OS_IPHONE && defined(__IPHONE_7_0) && __IPHONE_OS_VERSION_MIN_REQUIRED >= __IPHONE_7_0) + #define GTL_CAN_TRUST_DATE_COMPONENTS_ISEQUAL 1 +#else + #define GTL_CAN_TRUST_DATE_COMPONENTS_ISEQUAL 0 +#endif + +// weekOfMonth and weekOfYear are available on 10.7 and iOS 5; check that we're building +// for at least those systems. +#if (!TARGET_OS_IPHONE && defined(MAC_OS_X_VERSION_10_7) && MAC_OS_X_VERSION_MIN_REQUIRED >= MAC_OS_X_VERSION_10_7) \ + || (TARGET_OS_IPHONE && defined(__IPHONE_5_0) && __IPHONE_OS_VERSION_MIN_REQUIRED >= __IPHONE_5_0) + #define GTL_HAS_WEEK_OF_MONTH 1 +#else + #define GTL_HAS_WEEK_OF_MONTH 0 +#endif + +// week is not available starting with 10.10 and iOS 8 SDKs; check that we're not building +// with those SDKs. +#if (!TARGET_OS_IPHONE && defined(MAC_OS_X_VERSION_10_10) && MAC_OS_X_VERSION_MAX_ALLOWED >= MAC_OS_X_VERSION_10_10) \ +|| (TARGET_OS_IPHONE && defined(__IPHONE_8_0) && __IPHONE_OS_VERSION_MAX_ALLOWED >= __IPHONE_8_0) + #define GTL_HAS_WEEK 0 +#else + #define GTL_HAS_WEEK 1 +#endif + +// until NSDateComponent implements isEqual, we'll use this +#if !GTL_CAN_TRUST_DATE_COMPONENTS_ISEQUAL +- (BOOL)doesDateComponents:(NSDateComponents *)dc1 + equalDateComponents:(NSDateComponents *)dc2 { + + return [dc1 era] == [dc2 era] + && [dc1 year] == [dc2 year] + && [dc1 month] == [dc2 month] + && [dc1 day] == [dc2 day] + && [dc1 hour] == [dc2 hour] + && [dc1 minute] == [dc2 minute] + && [dc1 second] == [dc2 second] +#if GTL_HAS_WEEK_OF_MONTH + && [dc1 weekOfMonth] == [dc2 weekOfMonth] + && [dc1 weekOfYear] == [dc2 weekOfYear] +#endif +#if GTL_HAS_WEEK + && [dc1 week] == [dc2 week] +#endif + && [dc1 weekday] == [dc2 weekday] + + && [dc1 weekdayOrdinal] == [dc2 weekdayOrdinal]; + +} +#endif // !GTL_CAN_TRUST_DATE_COMPONENTS_ISEQUAL + +- (BOOL)isEqual:(GTLDateTime *)other { + + if (self == other) return YES; + if (![other isKindOfClass:[GTLDateTime class]]) return NO; + +#if GTL_CAN_TRUST_DATE_COMPONENTS_ISEQUAL + BOOL areDateComponentsEqual = [self.dateComponents isEqual:other.dateComponents]; +#else + BOOL areDateComponentsEqual = [self doesDateComponents:self.dateComponents + equalDateComponents:other.dateComponents]; +#endif + + NSTimeZone *tz1 = self.timeZone; + NSTimeZone *tz2 = other.timeZone; + BOOL areTimeZonesEqual = (tz1 == tz2 || (tz2 && [tz1 isEqual:tz2])); + + return self.offsetSeconds == other.offsetSeconds + && self.isUniversalTime == other.isUniversalTime + && self.milliseconds == other.milliseconds + && areDateComponentsEqual + && areTimeZonesEqual; +} + +- (NSString *)description { + return [NSString stringWithFormat:@"%@ %p: {%@}", + [self class], self, self.RFC3339String]; +} + +- (NSTimeZone *)timeZone { + if (timeZone_) { + return timeZone_; + } + + if (self.isUniversalTime) { + NSTimeZone *ztz = [NSTimeZone timeZoneWithName:@"Universal"]; + return ztz; + } + + NSInteger offsetSeconds = self.offsetSeconds; + + if (offsetSeconds != kGTLUndefinedDateComponent) { + NSTimeZone *tz = [NSTimeZone timeZoneForSecondsFromGMT:offsetSeconds]; + return tz; + } + return nil; +} + +- (void)setTimeZone:(NSTimeZone *)timeZone { + [timeZone_ release]; + timeZone_ = [timeZone retain]; + + if (timeZone) { + NSInteger offsetSeconds = [timeZone secondsFromGMTForDate:self.date]; + self.offsetSeconds = offsetSeconds; + } else { + self.offsetSeconds = kGTLUndefinedDateComponent; + } +} + +- (NSCalendar *)calendarForTimeZone:(NSTimeZone *)tz { + NSCalendar *cal = nil; + @synchronized(gCalendarsForTimeZones) { + id tzKey = (tz ? tz : [NSNull null]); + cal = [gCalendarsForTimeZones objectForKey:tzKey]; + if (cal == nil) { +#if GTL_NEW_CALENDAR_ENUMS + NSString *calendarID = NSCalendarIdentifierGregorian; +#else + NSString *calendarID = NSGregorianCalendar; +#endif + cal = [[[NSCalendar alloc] initWithCalendarIdentifier:calendarID] autorelease]; + if (tz) { + [cal setTimeZone:tz]; + } + [gCalendarsForTimeZones setObject:cal forKey:tzKey]; + } + } + return cal; +} + +- (NSCalendar *)calendar { + NSTimeZone *tz = self.timeZone; + return [self calendarForTimeZone:tz]; +} + +- (NSDate *)date { + NSDateComponents *dateComponents = self.dateComponents; + NSTimeInterval extraMillisecondsAsSeconds = 0.0; + NSCalendar *cal; + + if (!self.hasTime) { + // We're not keeping track of a time, but NSDate always is based on + // an absolute time. We want to avoid returning an NSDate where the + // calendar date appears different from what was used to create our + // date-time object. + // + // We'll make a copy of the date components, setting the time on our + // copy to noon GMT, since that ensures the date renders correctly for + // any time zone. + NSDateComponents *noonDateComponents = [[dateComponents copy] autorelease]; + [noonDateComponents setHour:12]; + [noonDateComponents setMinute:0]; + [noonDateComponents setSecond:0]; + dateComponents = noonDateComponents; + + NSTimeZone *gmt = [NSTimeZone timeZoneWithName:@"Universal"]; + cal = [self calendarForTimeZone:gmt]; + } else { + cal = self.calendar; + + // Add in the fractional seconds that don't fit into NSDateComponents. + extraMillisecondsAsSeconds = ((NSTimeInterval)self.milliseconds) / 1000.0; + } + + NSDate *date = [cal dateFromComponents:dateComponents]; + + // Add in any milliseconds that didn't fit into the dateComponents. + if (extraMillisecondsAsSeconds > 0.0) { +#if GTL_IPHONE || (MAC_OS_X_VERSION_MIN_REQUIRED > MAC_OS_X_VERSION_10_5) + date = [date dateByAddingTimeInterval:extraMillisecondsAsSeconds]; +#else + date = [date addTimeInterval:extraMillisecondsAsSeconds]; +#endif + } + + return date; +} + +- (NSString *)stringValue { + return self.RFC3339String; +} + +- (NSString *)RFC3339String { + NSDateComponents *dateComponents = self.dateComponents; + NSInteger offset = self.offsetSeconds; + + NSString *timeString = @""; // timeString like "T15:10:46-08:00" + + if (self.hasTime) { + + NSString *timeOffsetString; // timeOffsetString like "-08:00" + + if (self.isUniversalTime) { + timeOffsetString = @"Z"; + } else if (offset == kGTLUndefinedDateComponent) { + // unknown offset is rendered as -00:00 per + // http://www.ietf.org/rfc/rfc3339.txt section 4.3 + timeOffsetString = @"-00:00"; + } else { + NSString *sign = @"+"; + if (offset < 0) { + sign = @"-"; + offset = -offset; + } + timeOffsetString = [NSString stringWithFormat:@"%@%02ld:%02ld", + sign, (long)(offset/(60*60)) % 24, (long)(offset / 60) % 60]; + } + + NSString *fractionalSecondsString = @""; + if (self.milliseconds > 0.0) { + fractionalSecondsString = [NSString stringWithFormat:@".%03ld", (long)self.milliseconds]; + } + + timeString = [NSString stringWithFormat:@"T%02ld:%02ld:%02ld%@%@", + (long)[dateComponents hour], (long)[dateComponents minute], + (long)[dateComponents second], fractionalSecondsString, timeOffsetString]; + } + + // full dateString like "2006-11-17T15:10:46-08:00" + NSString *dateString = [NSString stringWithFormat:@"%04ld-%02ld-%02ld%@", + (long)[dateComponents year], (long)[dateComponents month], + (long)[dateComponents day], timeString]; + + return dateString; +} + +- (void)setFromDate:(NSDate *)date timeZone:(NSTimeZone *)tz { + NSCalendar *cal = [self calendarForTimeZone:tz]; + +#if GTL_NEW_CALENDAR_ENUMS + NSUInteger const kComponentBits = (NSCalendarUnitYear | NSCalendarUnitMonth + | NSCalendarUnitDay | NSCalendarUnitHour | NSCalendarUnitMinute + | NSCalendarUnitSecond); +#else + NSUInteger const kComponentBits = (NSYearCalendarUnit | NSMonthCalendarUnit + | NSDayCalendarUnit | NSHourCalendarUnit | NSMinuteCalendarUnit + | NSSecondCalendarUnit); +#endif + + NSDateComponents *components = [cal components:kComponentBits fromDate:date]; + self.dateComponents = components; + + // Extract the fractional seconds. + NSTimeInterval asTimeInterval = [date timeIntervalSince1970]; + NSTimeInterval worker = asTimeInterval - trunc(asTimeInterval); + self.milliseconds = (NSInteger)round(worker * 1000.0); + + self.universalTime = NO; + + NSInteger offset = kGTLUndefinedDateComponent; + + if (tz) { + offset = [tz secondsFromGMTForDate:date]; + + if (offset == 0 && [tz isEqualToTimeZone:[NSTimeZone timeZoneWithName:@"Universal"]]) { + self.universalTime = YES; + } + } + self.offsetSeconds = offset; + + // though offset seconds are authoritative, we'll retain the time zone + // since we can't regenerate it reliably from just the offset + timeZone_ = [tz retain]; +} + +- (void)setFromRFC3339String:(NSString *)str { + + NSInteger year = kGTLUndefinedDateComponent; + NSInteger month = kGTLUndefinedDateComponent; + NSInteger day = kGTLUndefinedDateComponent; + NSInteger hour = kGTLUndefinedDateComponent; + NSInteger minute = kGTLUndefinedDateComponent; + NSInteger sec = kGTLUndefinedDateComponent; + NSInteger milliseconds = 0; + double secDouble = -1.0; + NSString* sign = nil; + NSInteger offsetHour = 0; + NSInteger offsetMinute = 0; + + if ([str length] > 0) { + NSScanner* scanner = [NSScanner scannerWithString:str]; + // There should be no whitespace, so no skip characters. + [scanner setCharactersToBeSkipped:nil]; + + // for example, scan 2006-11-17T15:10:46-08:00 + // or 2006-11-17T15:10:46Z + if (// yyyy-mm-dd + [scanner scanInteger:&year] && + [scanner scanCharactersFromSet:gDashSet intoString:NULL] && + [scanner scanInteger:&month] && + [scanner scanCharactersFromSet:gDashSet intoString:NULL] && + [scanner scanInteger:&day] && + // Thh:mm:ss + [scanner scanCharactersFromSet:gTSet intoString:NULL] && + [scanner scanInteger:&hour] && + [scanner scanCharactersFromSet:gColonSet intoString:NULL] && + [scanner scanInteger:&minute] && + [scanner scanCharactersFromSet:gColonSet intoString:NULL] && + [scanner scanDouble:&secDouble]) { + + // At this point we got secDouble, pull it apart. + sec = (NSInteger)secDouble; + double worker = secDouble - ((double)sec); + milliseconds = (NSInteger)round(worker * 1000.0); + + // Finish parsing, now the offset info. + if (// Z or +hh:mm + [scanner scanCharactersFromSet:gPlusMinusZSet intoString:&sign] && + [scanner scanInteger:&offsetHour] && + [scanner scanCharactersFromSet:gColonSet intoString:NULL] && + [scanner scanInteger:&offsetMinute]) { + } + } + } + + NSDateComponents *dateComponents = [[[NSDateComponents alloc] init] autorelease]; + [dateComponents setYear:year]; + [dateComponents setMonth:month]; + [dateComponents setDay:day]; + [dateComponents setHour:hour]; + [dateComponents setMinute:minute]; + [dateComponents setSecond:sec]; + + self.dateComponents = dateComponents; + self.milliseconds = milliseconds; + + // determine the offset, like from Z, or -08:00:00.0 + + self.timeZone = nil; + + NSInteger totalOffset = kGTLUndefinedDateComponent; + self.universalTime = NO; + + if ([sign caseInsensitiveCompare:@"Z"] == NSOrderedSame) { + + self.universalTime = YES; + totalOffset = 0; + + } else if (sign != nil) { + + totalOffset = (60 * offsetMinute) + (60 * 60 * offsetHour); + + if ([sign isEqual:@"-"]) { + + if (totalOffset == 0) { + // special case: offset of -0.00 means undefined offset + totalOffset = kGTLUndefinedDateComponent; + } else { + totalOffset *= -1; + } + } + } + + self.offsetSeconds = totalOffset; +} + +- (BOOL)hasTime { + NSDateComponents *dateComponents = self.dateComponents; + + BOOL hasTime = ([dateComponents hour] != kGTLUndefinedDateComponent + && [dateComponents minute] != kGTLUndefinedDateComponent); + + return hasTime; +} + +- (void)setHasTime:(BOOL)shouldHaveTime { + + // we'll set time values to zero or kUndefinedDateComponent as appropriate + BOOL hadTime = self.hasTime; + + if (shouldHaveTime && !hadTime) { + [dateComponents_ setHour:0]; + [dateComponents_ setMinute:0]; + [dateComponents_ setSecond:0]; + milliseconds_ = 0; + offsetSeconds_ = kGTLUndefinedDateComponent; + isUniversalTime_ = NO; + + } else if (hadTime && !shouldHaveTime) { + [dateComponents_ setHour:kGTLUndefinedDateComponent]; + [dateComponents_ setMinute:kGTLUndefinedDateComponent]; + [dateComponents_ setSecond:kGTLUndefinedDateComponent]; + milliseconds_ = 0; + offsetSeconds_ = kGTLUndefinedDateComponent; + isUniversalTime_ = NO; + self.timeZone = nil; + } +} + + +@end diff --git a/XCDYouTubeKit Demo/Pods/Google-API-Client/Source/Objects/GTLErrorObject.h b/XCDYouTubeKit Demo/Pods/Google-API-Client/Source/Objects/GTLErrorObject.h new file mode 100644 index 00000000..c2ec67db --- /dev/null +++ b/XCDYouTubeKit Demo/Pods/Google-API-Client/Source/Objects/GTLErrorObject.h @@ -0,0 +1,45 @@ +/* Copyright (c) 2011 Google Inc. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +// +// GTLErrorObject.h +// + +#import "GTLObject.h" + +@class GTLErrorObjectData; + +@interface GTLErrorObject : GTLObject +@property (retain) NSNumber *code; +@property (retain) NSString *message; +@property (retain) NSArray *data; // of GTLErrorObjectData + +// Convenience accessor for creating an NSError from a GTLErrorObject. +@property (readonly) NSError *foundationError; + +// Convenience accessor for extracting the GTLErrorObject that was used to +// create an NSError. +// +// Returns nil if the error was not originally from a GTLErrorObject. ++ (GTLErrorObject *)underlyingObjectForError:(NSError *)foundationError; + +@end + +@interface GTLErrorObjectData : GTLObject +@property (retain) NSString *domain; +@property (retain) NSString *reason; +@property (retain) NSString *message; +@property (retain) NSString *location; +@end diff --git a/XCDYouTubeKit Demo/Pods/Google-API-Client/Source/Objects/GTLErrorObject.m b/XCDYouTubeKit Demo/Pods/Google-API-Client/Source/Objects/GTLErrorObject.m new file mode 100644 index 00000000..1fa1023a --- /dev/null +++ b/XCDYouTubeKit Demo/Pods/Google-API-Client/Source/Objects/GTLErrorObject.m @@ -0,0 +1,78 @@ +/* Copyright (c) 2011 Google Inc. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +// +// GTLErrorObject.m +// + +#import "GTLErrorObject.h" +#import "GTLService.h" + +@implementation GTLErrorObject + +@dynamic code; +@dynamic message; +@dynamic data; + ++ (NSDictionary *)arrayPropertyToClassMap { + NSDictionary *map = [NSDictionary dictionaryWithObject:[GTLErrorObjectData class] + forKey:@"data"]; + return map; +} + +- (NSError *)foundationError { + NSMutableDictionary *userInfo; + + // This structured GTLErrorObject will be available in the error's userInfo + // dictionary + userInfo = [NSMutableDictionary dictionaryWithObject:self + forKey:kGTLStructuredErrorKey]; + + NSString *reasonStr = self.message; + if (reasonStr) { + // We always store an error in the userInfo key "error" + [userInfo setObject:reasonStr + forKey:kGTLServerErrorStringKey]; + + // Store a user-readable "reason" to show up when an error is logged, + // in parentheses like NSError does it + NSString *parenthesized = [NSString stringWithFormat:@"(%@)", reasonStr]; + [userInfo setObject:parenthesized + forKey:NSLocalizedFailureReasonErrorKey]; + } + + NSInteger code = [self.code integerValue]; + NSError *error = [NSError errorWithDomain:kGTLJSONRPCErrorDomain + code:code + userInfo:userInfo]; + return error; +} + ++ (GTLErrorObject *)underlyingObjectForError:(NSError *)foundationError { + NSDictionary *userInfo = [foundationError userInfo]; + GTLErrorObject *errorObj = [userInfo objectForKey:kGTLStructuredErrorKey]; + return errorObj; +} + +@end + +@implementation GTLErrorObjectData +@dynamic domain; +@dynamic reason; +@dynamic message; +@dynamic location; +@end + + diff --git a/XCDYouTubeKit Demo/Pods/Google-API-Client/Source/Objects/GTLObject.h b/XCDYouTubeKit Demo/Pods/Google-API-Client/Source/Objects/GTLObject.h new file mode 100644 index 00000000..787ae0ea --- /dev/null +++ b/XCDYouTubeKit Demo/Pods/Google-API-Client/Source/Objects/GTLObject.h @@ -0,0 +1,198 @@ +/* Copyright (c) 2011 Google Inc. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +// +// GTLObject.h +// + +// GTLObject documentation: +// https://code.google.com/p/google-api-objectivec-client/wiki/Introduction#Objects_and_Queries + +#import + +#import "GTLDefines.h" +#import "GTLUtilities.h" +#import "GTLDateTime.h" + +@protocol GTLCollectionProtocol +@optional +@property (retain) NSArray *items; +@end + +@protocol GTLBatchItemCreationProtocol +- (void)createItemsWithClassMap:(NSDictionary *)batchClassMap; +@end + +@interface GTLObject : NSObject { + + @private + + NSMutableDictionary *json_; + + // Used when creating the subobjects from this one. + NSDictionary *surrogates_; + + // Any complex object hung off this object goes into the cache so the + // next fetch will get the same object back instead of having to recreate + // it. + NSMutableDictionary *childCache_; + + // Anything defined by the client; retained but not used internally; not + // copied by copyWithZone: + NSMutableDictionary *userProperties_; +} + +@property (nonatomic, retain) NSMutableDictionary *JSON; +@property (nonatomic, retain) NSDictionary *surrogates; +@property (nonatomic, retain) NSMutableDictionary *userProperties; + +/////////////////////////////////////////////////////////////////////////////// +// +// Public methods +// +// These methods are intended for users of the library +// + ++ (id)object; ++ (id)objectWithJSON:(NSMutableDictionary *)dict; + +- (id)copyWithZone:(NSZone *)zone; + +- (NSString *)JSONString; + +// generic access to json; also creates it if necessary +- (void)setJSONValue:(id)obj forKey:(NSString *)key GTL_NONNULL((2)); +- (id)JSONValueForKey:(NSString *)key; + +// Returns the list of keys in this object's JSON that aren't listed as +// properties on the object. +- (NSArray *)additionalJSONKeys; + +// Any keys in the JSON that aren't listed as @properties on the object +// are counted as "additional properties". These allow you to get/set them. +- (id)additionalPropertyForName:(NSString *)name; +- (void)setAdditionalProperty:(id)obj forName:(NSString *)name GTL_NONNULL((2)); +- (NSDictionary *)additionalProperties; + +// User properties are supported for client convenience, but are not copied by +// copyWithZone. User Properties keys beginning with _ are reserved by the library. +// +// Set nil for obj to remove the property. +- (void)setProperty:(id)obj forKey:(NSString *)key GTL_NONNULL((2)); +- (id)propertyForKey:(NSString *)key GTL_NONNULL((1)); + +// userData is stored as a property with key "_userData" +- (void)setUserData:(id)obj; +- (id)userData; + +// Makes a partial query-compatible string describing the fields present +// in this object. (Note: only the first element of any array is examined.) +// +// http://code.google.com/apis/tasks/v1/performance.html#partial +// +- (NSString *)fieldsDescription; + +// Makes an object containing only the changes needed to do a partial update +// (patch), where the patch would be to change an object from the original +// to the receiver, such as +// +// GTLSomeObject *patchObject = [newVersion patchObjectFromOriginal:oldVersion]; +// +// http://code.google.com/apis/tasks/v1/performance.html#patch +// +// NOTE: this method returns nil if there are no changes between the original +// and the receiver. +- (id)patchObjectFromOriginal:(GTLObject *)original; + +// Method creating a null value to set object properties for patch queries that +// delete fields. Do not use this except when setting an object property for +// a patch query. ++ (id)nullValue; + +/////////////////////////////////////////////////////////////////////////////// +// +// Protected methods +// +// These methods are intended for subclasses of GTLObject +// + +// class registration ("kind" strings) for subclasses ++ (Class)registeredObjectClassForKind:(NSString *)kind; ++ (void)registerObjectClassForKind:(NSString *)kind; + +// creation of objects from a JSON dictionary ++ (GTLObject *)objectForJSON:(NSMutableDictionary *)json + defaultClass:(Class)defaultClass + surrogates:(NSDictionary *)surrogates + batchClassMap:(NSDictionary *)batchClassMap; + +// property-to-key mapping (for JSON keys which are not used as method names) ++ (NSDictionary *)propertyToJSONKeyMap; + +// property-to-Class mapping for array properties (to say what is in the array) ++ (NSDictionary *)arrayPropertyToClassMap; + +// The default class for additional JSON keys ++ (Class)classForAdditionalProperties; + +@end + +// Collection objects with an "items" property should derive from GTLCollection +// object. This provides support for fast object enumeration, the +// itemAtIndex: convenience method, and indexed subscripts. +// +// Subclasses must implement the items method dynamically. +@interface GTLCollectionObject : GTLObject { + @private + NSDictionary *identifierMap_; +} + +// itemAtIndex: and objectAtIndexedSubscript: return nil when the index exceeds +// the bounds of the items array. +- (id)itemAtIndex:(NSUInteger)idx; + +- (id)objectAtIndexedSubscript:(NSInteger)idx; + +// itemForIdentifier: looks up items from the collection object by identifier, +// and returns the first one. +// +// Typically, items will have a unique identifier (with key "id" in the +// object's JSON). This method returns the first item found in the collection +// with the specified identifier. +// +// The first time this method is used, the collection will cache a map of +// identifiers to items. If the items list for the instance somehow changes, +// use the reset method below to force a new cache to be created for this +// collection. +- (id)itemForIdentifier:(NSString *)key GTL_NONNULL((1)); + +// Identifiers for all items are cached when the first one is obtained. +// This method resets the cache. It is needed only if the item list has +// changed. +- (void)resetIdentifierMap; + +@end + +@interface GTLCollectionObject (DynamicMethods) +- (NSArray *)items; +@end + +// Base object use for when an service method directly returns an array instead +// of an object. Normally methods should return an object with an 'items' +// property, but this exists for the methods not up to spec. +@interface GTLResultArray : GTLCollectionObject +// This method should only be called by subclasses. +- (NSArray *)itemsWithItemClass:(Class)itemClass; +@end diff --git a/XCDYouTubeKit Demo/Pods/Google-API-Client/Source/Objects/GTLObject.m b/XCDYouTubeKit Demo/Pods/Google-API-Client/Source/Objects/GTLObject.m new file mode 100644 index 00000000..f7979c84 --- /dev/null +++ b/XCDYouTubeKit Demo/Pods/Google-API-Client/Source/Objects/GTLObject.m @@ -0,0 +1,725 @@ +/* Copyright (c) 2011 Google Inc. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +// +// GTLObject.m +// + +#include + +#import "GTLObject.h" +#import "GTLRuntimeCommon.h" +#import "GTLJSONParser.h" + +static NSString *const kUserDataPropertyKey = @"_userData"; + +@interface GTLObject () ++ (NSMutableArray *)allDeclaredProperties; ++ (NSArray *)allKnownKeys; + ++ (NSArray *)fieldsElementsForJSON:(NSDictionary *)targetJSON; ++ (NSString *)fieldsDescriptionForJSON:(NSDictionary *)targetJSON; + ++ (NSMutableDictionary *)patchDictionaryForJSON:(NSDictionary *)newJSON + fromOriginalJSON:(NSDictionary *)originalJSON; +@end + +@implementation GTLObject + +@synthesize JSON = json_, + surrogates = surrogates_, + userProperties = userProperties_; + ++ (id)object { + return [[[self alloc] init] autorelease]; +} + ++ (id)objectWithJSON:(NSMutableDictionary *)dict { + GTLObject *obj = [self object]; + obj.JSON = dict; + return obj; +} + ++ (NSDictionary *)propertyToJSONKeyMap { + return nil; +} + ++ (NSDictionary *)arrayPropertyToClassMap { + return nil; +} + ++ (Class)classForAdditionalProperties { + return Nil; +} + +- (BOOL)isEqual:(GTLObject *)other { + if (self == other) return YES; + if (other == nil) return NO; + + // The objects should be the same class, or one should be a subclass of the + // other's class + if (![other isKindOfClass:[self class]] + && ![self isKindOfClass:[other class]]) return NO; + + // What we're not comparing here: + // properties + return GTL_AreEqualOrBothNil(json_, [other JSON]); +} + +// By definition, for two objects to potentially be considered equal, +// they must have the same hash value. The hash is mostly ignored, +// but removeObjectsInArray: in Leopard does seem to check the hash, +// and NSObject's default hash method just returns the instance pointer. +// We'll define hash here for all of our GTLObjects. +- (NSUInteger)hash { + return (NSUInteger) (void *) [GTLObject class]; +} + +- (id)copyWithZone:(NSZone *)zone { + GTLObject* newObject = [[[self class] allocWithZone:zone] init]; + CFPropertyListRef ref = CFPropertyListCreateDeepCopy(kCFAllocatorDefault, + json_, kCFPropertyListMutableContainers); + GTL_DEBUG_ASSERT(ref != NULL, @"GTLObject: copy failed (probably a non-plist type in the JSON)"); + newObject.JSON = [NSMakeCollectable(ref) autorelease]; + newObject.surrogates = self.surrogates; + + // What we're not copying: + // userProperties + return newObject; +} + +- (NSString *)descriptionWithLocale:(id)locale { + return [self description]; +} + +- (void)dealloc { + [json_ release]; + [surrogates_ release]; + [childCache_ release]; + [userProperties_ release]; + + [super dealloc]; +} + +#pragma mark JSON values + +- (void)setJSONValue:(id)obj forKey:(NSString *)key { + NSMutableDictionary *dict = self.JSON; + if (dict == nil && obj != nil) { + dict = [NSMutableDictionary dictionaryWithCapacity:1]; + self.JSON = dict; + } + [dict setValue:obj forKey:key]; +} + +- (id)JSONValueForKey:(NSString *)key { + id obj = [self.JSON objectForKey:key]; + return obj; +} + +- (NSString *)JSONString { + NSError *error = nil; + NSString *str = [GTLJSONParser stringWithObject:[self JSON] + humanReadable:YES + error:&error]; + if (error) { + return [error description]; + } + return str; +} + +- (NSArray *)additionalJSONKeys { + NSArray *knownKeys = [[self class] allKnownKeys]; + NSMutableArray *result = [NSMutableArray arrayWithArray:[json_ allKeys]]; + [result removeObjectsInArray:knownKeys]; + // Return nil instead of an empty array. + if ([result count] == 0) { + result = nil; + } + return result; +} + +#pragma mark Partial - Fields + +- (NSString *)fieldsDescription { + NSString *str = [GTLObject fieldsDescriptionForJSON:self.JSON]; + return str; +} + ++ (NSString *)fieldsDescriptionForJSON:(NSDictionary *)targetJSON { + // Internal routine: recursively generate a string field description + // by joining elements + NSArray *array = [self fieldsElementsForJSON:targetJSON]; + NSString *str = [array componentsJoinedByString:@","]; + return str; +} + ++ (NSArray *)fieldsElementsForJSON:(NSDictionary *)targetJSON { + // Internal routine: recursively generate an array of field description + // element strings + NSMutableArray *resultFields = [NSMutableArray array]; + + // Sorting the dictionary keys gives us deterministic results when iterating + NSArray *sortedKeys = [[targetJSON allKeys] sortedArrayUsingSelector:@selector(caseInsensitiveCompare:)]; + for (NSString *key in sortedKeys) { + // We'll build a comma-separated list of fields + id value = [targetJSON objectForKey:key]; + if ([value isKindOfClass:[NSString class]] + || [value isKindOfClass:[NSNumber class]]) { + // Basic type (string, number), so the key is what we want + [resultFields addObject:key]; + } else if ([value isKindOfClass:[NSDictionary class]]) { + // Object (dictionary): "parent/child1,parent/child2,parent/child3" + NSArray *subElements = [self fieldsElementsForJSON:value]; + for (NSString *subElem in subElements) { + NSString *prepended = [NSString stringWithFormat:@"%@/%@", + key, subElem]; + [resultFields addObject:prepended]; + } + } else if ([value isKindOfClass:[NSArray class]]) { + // Array; we'll generate from the first array entry: + // "parent(child1,child2,child3)" + // + // Open question: should this instead create the union of elements for + // all items in the array, rather than just get fields from the first + // array object? + if ([(NSArray *)value count] > 0) { + id firstObj = [value objectAtIndex:0]; + if ([firstObj isKindOfClass:[NSDictionary class]]) { + // An array of objects + NSString *contentsStr = [self fieldsDescriptionForJSON:firstObj]; + NSString *encapsulated = [NSString stringWithFormat:@"%@(%@)", + key, contentsStr]; + [resultFields addObject:encapsulated]; + } else { + // An array of some basic type, or of arrays + [resultFields addObject:key]; + } + } + } else { + GTL_ASSERT(0, @"GTLObject unknown field element for %@ (%@)", + key, NSStringFromClass([value class])); + } + } + return resultFields; +} + +#pragma mark Partial - Patch + +- (id)patchObjectFromOriginal:(GTLObject *)original { + id resultObj; + NSMutableDictionary *resultJSON = [GTLObject patchDictionaryForJSON:self.JSON + fromOriginalJSON:original.JSON]; + if ([resultJSON count] > 0) { + resultObj = [[self class] objectWithJSON:resultJSON]; + } else { + // Client apps should not attempt to patch with an object containing + // empty JSON + resultObj = nil; + } + return resultObj; +} + ++ (NSMutableDictionary *)patchDictionaryForJSON:(NSDictionary *)newJSON + fromOriginalJSON:(NSDictionary *)originalJSON { + // Internal recursive routine to create an object suitable for + // our patch semantics + NSMutableDictionary *resultJSON = [NSMutableDictionary dictionary]; + + // Iterate through keys present in the old object + NSArray *originalKeys = [originalJSON allKeys]; + for (NSString *key in originalKeys) { + id originalValue = [originalJSON objectForKey:key]; + id newValue = [newJSON valueForKey:key]; + if (newValue == nil) { + // There is no new value for this key, so set the value to NSNull + [resultJSON setValue:[NSNull null] forKey:key]; + } else if (!GTL_AreEqualOrBothNil(originalValue, newValue)) { + // The values for this key differ + if ([originalValue isKindOfClass:[NSDictionary class]] + && [newValue isKindOfClass:[NSDictionary class]]) { + // Both are objects; recurse + NSMutableDictionary *subDict = [self patchDictionaryForJSON:newValue + fromOriginalJSON:originalValue]; + [resultJSON setValue:subDict forKey:key]; + } else { + // They are non-object values; the new replaces the old. Per the + // documentation for patch, this replaces entire arrays. + [resultJSON setValue:newValue forKey:key]; + } + } else { + // The values are the same; omit this key-value pair + } + } + + // Iterate through keys present only in the new object, and add them to the + // result + NSMutableArray *newKeys = [NSMutableArray arrayWithArray:[newJSON allKeys]]; + [newKeys removeObjectsInArray:originalKeys]; + + for (NSString *key in newKeys) { + id value = [newJSON objectForKey:key]; + [resultJSON setValue:value forKey:key]; + } + return resultJSON; +} + ++ (id)nullValue { + return [NSNull null]; +} + +#pragma mark Additional Properties + +- (id)additionalPropertyForName:(NSString *)name { + // Return the cached object, if any, before creating one. + id result = [self cacheChildForKey:name]; + if (result != nil) { + return result; + } + + Class defaultClass = [[self class] classForAdditionalProperties]; + id jsonObj = [self JSONValueForKey:name]; + BOOL shouldCache = NO; + if (jsonObj != nil) { + NSDictionary *surrogates = self.surrogates; + result = [GTLRuntimeCommon objectFromJSON:jsonObj + defaultClass:defaultClass + surrogates:surrogates + isCacheable:&shouldCache]; + } + + [self setCacheChild:(shouldCache ? result : nil) + forKey:name]; + return result; +} + +- (void)setAdditionalProperty:(id)obj forName:(NSString *)name { + BOOL shouldCache = NO; + Class defaultClass = [[self class] classForAdditionalProperties]; + id json = [GTLRuntimeCommon jsonFromAPIObject:obj + expectedClass:defaultClass + isCacheable:&shouldCache]; + [self setJSONValue:json forKey:name]; + [self setCacheChild:(shouldCache ? obj : nil) + forKey:name]; +} + +- (NSDictionary *)additionalProperties { + NSMutableDictionary *result = [NSMutableDictionary dictionary]; + + NSArray *propertyNames = [self additionalJSONKeys]; + for (NSString *name in propertyNames) { + id obj = [self additionalPropertyForName:name]; + [result setObject:obj forKey:name]; + } + + return result; +} + +#pragma mark Child Cache methods + +// There is no property for childCache_ as there shouldn't be KVC/KVO +// support for it, it's an implementation detail. + +- (void)setCacheChild:(id)obj forKey:(NSString *)key { + if (childCache_ == nil && obj != nil) { + childCache_ = [[NSMutableDictionary alloc] initWithObjectsAndKeys: + obj, key, nil]; + } else { + [childCache_ setValue:obj forKey:key]; + } +} + +- (id)cacheChildForKey:(NSString *)key { + id obj = [childCache_ objectForKey:key]; + return obj; +} + +#pragma mark userData and user properties + +- (void)setUserData:(id)userData { + [self setProperty:userData forKey:kUserDataPropertyKey]; +} + +- (id)userData { + // be sure the returned pointer has the life of the autorelease pool, + // in case self is released immediately + return [[[self propertyForKey:kUserDataPropertyKey] retain] autorelease]; +} + +- (void)setProperty:(id)obj forKey:(NSString *)key { + if (obj == nil) { + // user passed in nil, so delete the property + [userProperties_ removeObjectForKey:key]; + } else { + // be sure the property dictionary exists + if (userProperties_ == nil) { + self.userProperties = [NSMutableDictionary dictionary]; + } + [userProperties_ setObject:obj forKey:key]; + } +} + +- (id)propertyForKey:(NSString *)key { + id obj = [userProperties_ objectForKey:key]; + + // be sure the returned pointer has the life of the autorelease pool, + // in case self is released immediately + return [[obj retain] autorelease]; +} + +#pragma mark Support methods + ++ (NSMutableArray *)allDeclaredProperties { + NSMutableArray *array = [NSMutableArray array]; + + // walk from this class up the hierarchy to GTLObject + Class topClass = class_getSuperclass([GTLObject class]); + for (Class currClass = self; + currClass != topClass; + currClass = class_getSuperclass(currClass)) { + // step through this class's properties, and add the property names to the + // array + objc_property_t *properties = class_copyPropertyList(currClass, NULL); + if (properties) { + for (objc_property_t *prop = properties; + *prop != NULL; + ++prop) { + const char *propName = property_getName(*prop); + // We only want dynamic properties; their attributes contain ",D". + const char *attr = property_getAttributes(*prop); + const char *dynamicMarker = strstr(attr, ",D"); + if (dynamicMarker && + (dynamicMarker[2] == 0 || dynamicMarker[2] == ',' )) { + [array addObject:[NSString stringWithUTF8String:propName]]; + } + } + free(properties); + } + } + return array; +} + ++ (NSArray *)allKnownKeys { + NSArray *allProps = [self allDeclaredProperties]; + NSMutableArray *knownKeys = [NSMutableArray arrayWithArray:allProps]; + + NSDictionary *propMap = [GTLObject propertyToJSONKeyMapForClass:[self class]]; + + NSUInteger idx = 0; + for (NSString *propName in allProps) { + NSString *jsonKey = [propMap objectForKey:propName]; + if (jsonKey) { + [knownKeys replaceObjectAtIndex:idx + withObject:jsonKey]; + } + ++idx; + } + return knownKeys; +} + +- (NSString *)description { + // find the list of declared and otherwise known JSON keys for this class + NSArray *knownKeys = [[self class] allKnownKeys]; + + NSMutableString *descStr = [NSMutableString string]; + + NSString *spacer = @""; + for (NSString *key in json_) { + NSString *value = nil; + // show question mark for JSON keys not supported by a declared property: + // foo?:"Hi mom." + NSString *qmark = [knownKeys containsObject:key] ? @"" : @"?"; + + // determine property value to dislay + id rawValue = [json_ valueForKey:key]; + if ([rawValue isKindOfClass:[NSDictionary class]]) { + // for dictionaries, show the list of keys: + // {key1,key2,key3} + NSString *subkeyList = [[rawValue allKeys] componentsJoinedByString:@","]; + value = [NSString stringWithFormat:@"{%@}", subkeyList]; + } else if ([rawValue isKindOfClass:[NSArray class]]) { + // for arrays, show the number of items in the array: + // [3] + value = [NSString stringWithFormat:@"[%lu]", (unsigned long)[(NSArray *)rawValue count]]; + } else if ([rawValue isKindOfClass:[NSString class]]) { + // for strings, show the string in quotes: + // "Hi mom." + value = [NSString stringWithFormat:@"\"%@\"", rawValue]; + } else { + // for numbers, show just the number + value = [rawValue description]; + } + [descStr appendFormat:@"%@%@%@:%@", spacer, key, qmark, value]; + spacer = @" "; + } + + NSString *str = [NSString stringWithFormat:@"%@ %p: {%@}", + [self class], self, descStr]; + return str; +} + +#pragma mark Class Registration + +static NSMutableDictionary *gKindMap = nil; + ++ (Class)registeredObjectClassForKind:(NSString *)kind { + Class resultClass = [gKindMap objectForKey:kind]; + return resultClass; +} + ++ (void)registerObjectClassForKind:(NSString *)kind { + // there's no autorelease pool in place at +load time, so we'll create our own + NSAutoreleasePool *pool = [[NSAutoreleasePool alloc] init]; + + if (gKindMap == nil) { + gKindMap = [[NSMutableDictionary alloc] init]; + } + + Class selfClass = [self class]; + +#if DEBUG + // ensure this is a unique registration + if ([gKindMap objectForKey:kind] != nil ) { + GTL_DEBUG_LOG(@"%@ (%@) registration conflicts with %@", + selfClass, kind, [gKindMap objectForKey:kind]); + } + if ([[gKindMap allKeysForObject:selfClass] count] != 0) { + GTL_DEBUG_LOG(@"%@ (%@) registration conflicts with %@", + selfClass, kind, [gKindMap allKeysForObject:selfClass]); + } +#endif + + [gKindMap setValue:selfClass forKey:kind]; + + // we drain here to keep the clang static analyzer quiet + [pool drain]; +} + +#pragma mark Object Instantiation + ++ (GTLObject *)objectForJSON:(NSMutableDictionary *)json + defaultClass:(Class)defaultClass + surrogates:(NSDictionary *)surrogates + batchClassMap:(NSDictionary *)batchClassMap { + if ([json isEqual:[NSNull null]] || [json count] == 0) { + if (json != nil && defaultClass != Nil) { + // The JSON included an empty dictionary, and a return class + // was specified. + return [defaultClass object]; + } + // No actual result, such as the response from a delete. + return nil; + } + + // Determine the class to instantiate, based on the original fetch + // request or by looking up "kind" string from the registration at + // +load time of GTLObject subclasses + // + // We're letting the dynamic kind override the default class so + // feeds of heterogenous entries can use the defaultClass as a + // fallback + Class classToCreate = defaultClass; + NSString *kind = nil; + if ([json isKindOfClass:[NSDictionary class]]) { + kind = [json valueForKey:@"kind"]; + if ([kind isKindOfClass:[NSString class]] && [kind length] > 0 && ![NSStringFromClass(defaultClass) hasSuffix:@"ResourceId"]) { + Class dynamicClass = [GTLObject registeredObjectClassForKind:kind]; + if (dynamicClass) { + classToCreate = dynamicClass; + } + } + } + + // Warn the developer that no specific class of GTLObject + // was requested with the fetch call, and no class is found + // compiled in to match the "kind" attribute of the JSON + // returned by the server + GTL_ASSERT(classToCreate != nil, + @"Could not find registered GTLObject subclass to " + "match JSON with kind \"%@\"", kind); + + if (classToCreate == nil) { + classToCreate = [self class]; + } + + // See if the top-level class for the JSON is listed in the surrogates; + // if so, instantiate the surrogate class instead + Class baseSurrogate = [surrogates objectForKey:classToCreate]; + if (baseSurrogate) { + classToCreate = baseSurrogate; + } + + // now instantiate the GTLObject + GTLObject *parsedObject = [classToCreate object]; + + parsedObject.surrogates = surrogates; + parsedObject.JSON = json; + + // it's time to instantiate inner items + if ([parsedObject conformsToProtocol:@protocol(GTLBatchItemCreationProtocol)]) { + id batch = + (id ) parsedObject; + [batch createItemsWithClassMap:batchClassMap]; + } + + return parsedObject; +} + +#pragma mark Runtime Utilities + +static NSMutableDictionary *gJSONKeyMapCache = nil; +static NSMutableDictionary *gArrayPropertyToClassMapCache = nil; + ++ (void)initialize { + // Note that initialize is guaranteed by the runtime to be called in a + // thread-safe manner + if (gJSONKeyMapCache == nil) { + gJSONKeyMapCache = [[NSMutableDictionary alloc] init]; + } + if (gArrayPropertyToClassMapCache == nil) { + gArrayPropertyToClassMapCache = [[NSMutableDictionary alloc] init]; + } +} + ++ (NSDictionary *)propertyToJSONKeyMapForClass:(Class)aClass { + NSDictionary *resultMap = + [GTLUtilities mergedClassDictionaryForSelector:@selector(propertyToJSONKeyMap) + startClass:aClass + ancestorClass:[GTLObject class] + cache:gJSONKeyMapCache]; + return resultMap; +} + ++ (NSDictionary *)arrayPropertyToClassMapForClass:(Class)aClass { + NSDictionary *resultMap = + [GTLUtilities mergedClassDictionaryForSelector:@selector(arrayPropertyToClassMap) + startClass:aClass + ancestorClass:[GTLObject class] + cache:gArrayPropertyToClassMapCache]; + return resultMap; +} + +#pragma mark Runtime Support + ++ (Class)ancestorClass { + return [GTLObject class]; +} + ++ (BOOL)resolveInstanceMethod:(SEL)sel { + BOOL resolved = [GTLRuntimeCommon resolveInstanceMethod:sel onClass:self]; + if (resolved) + return YES; + + return [super resolveInstanceMethod:sel]; +} + +@end + +@implementation GTLCollectionObject +// Subclasses must implement the items method dynamically. + +- (void)dealloc { + [identifierMap_ release]; + [super dealloc]; +} + +- (id)itemAtIndex:(NSUInteger)idx { + NSArray *items = [self performSelector:@selector(items)]; + if (idx < [items count]) { + return [items objectAtIndex:idx]; + } + return nil; +} + +- (id)objectAtIndexedSubscript:(NSInteger)idx { + if (idx >= 0) { + return [self itemAtIndex:(NSUInteger)idx]; + } + return nil; +} + +- (id)itemForIdentifier:(NSString *)key { + if (identifierMap_ == nil) { + NSArray *items = [self performSelector:@selector(items)]; + NSMutableDictionary *dict = + [NSMutableDictionary dictionaryWithCapacity:[items count]]; + for (id item in items) { + id identifier = [item valueForKey:@"identifier"]; + if (identifier != nil && identifier != [NSNull null]) { + if ([dict objectForKey:identifier] == nil) { + [dict setObject:item forKey:identifier]; + } + } + } + identifierMap_ = [dict copy]; + } + return [identifierMap_ objectForKey:key]; +} + +- (void)resetIdentifierMap { + [identifierMap_ release]; + identifierMap_ = nil; +} + +// NSFastEnumeration protocol +- (NSUInteger)countByEnumeratingWithState:(NSFastEnumerationState *)state + objects:(id *)stackbuf + count:(NSUInteger)len { + NSArray *items = [self performSelector:@selector(items)]; + NSUInteger result = [items countByEnumeratingWithState:state + objects:stackbuf + count:len]; + return result; +} + +@end + +@implementation GTLResultArray + +- (NSArray *)itemsWithItemClass:(Class)itemClass { + // Return the cached array before creating on demand. + NSString *cacheKey = @"result_array_items"; + NSMutableArray *cachedArray = [self cacheChildForKey:cacheKey]; + if (cachedArray != nil) { + return cachedArray; + } + NSArray *result = nil; + NSArray *array = (NSArray *)[self JSON]; + if (array != nil) { + if ([array isKindOfClass:[NSArray class]]) { + NSDictionary *surrogates = self.surrogates; + result = [GTLRuntimeCommon objectFromJSON:array + defaultClass:itemClass + surrogates:surrogates + isCacheable:NULL]; + } else { +#if DEBUG + if (![array isKindOfClass:[NSNull class]]) { + GTL_DEBUG_LOG(@"GTLObject: unexpected JSON: %@ should be an array, actually is a %@:\n%@", + NSStringFromClass([self class]), + NSStringFromClass([array class]), + array); + } +#endif + result = array; + } + } + + [self setCacheChild:result forKey:cacheKey]; + return result; +} + +@end diff --git a/XCDYouTubeKit Demo/Pods/Google-API-Client/Source/Objects/GTLQuery.h b/XCDYouTubeKit Demo/Pods/Google-API-Client/Source/Objects/GTLQuery.h new file mode 100644 index 00000000..5334dc98 --- /dev/null +++ b/XCDYouTubeKit Demo/Pods/Google-API-Client/Source/Objects/GTLQuery.h @@ -0,0 +1,133 @@ +/* Copyright (c) 2011 Google Inc. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +// +// GTLQuery.h +// + +// Query documentation: +// https://code.google.com/p/google-api-objectivec-client/wiki/Introduction#Query_Operations + +#import "GTLObject.h" +#import "GTLUploadParameters.h" + +@protocol GTLQueryProtocol +- (BOOL)isBatchQuery; +- (BOOL)shouldSkipAuthorization; +- (void)executionDidStop; +- (NSDictionary *)additionalHTTPHeaders; +- (NSDictionary *)urlQueryParameters; +- (GTLUploadParameters *)uploadParameters; +@end + +@protocol GTLQueryCollectionProtocol +@optional +@property (retain) NSString *pageToken; +@property (retain) NSNumber *startIndex; +@end + +@class GTLServiceTicket; + +@interface GTLQuery : NSObject { + @private + NSString *methodName_; + NSMutableDictionary *json_; + GTLObject *bodyObject_; + NSMutableDictionary *childCache_; + NSString *requestID_; + GTLUploadParameters *uploadParameters_; + NSDictionary *urlQueryParameters_; + NSDictionary *additionalHTTPHeaders_; + Class expectedObjectClass_; + BOOL skipAuthorization_; + void (^completionBlock_)(GTLServiceTicket *ticket, id object, NSError *error); +} + +// The rpc method name. +@property (readonly) NSString *methodName; + +// The JSON dictionary of all the parameters set on this query. +@property (retain) NSMutableDictionary *JSON; + +// The object set to be uploaded with the query. +@property (retain) GTLObject *bodyObject; + +// Each query must have a request ID string. The user may replace the +// default assigned request ID with a custom string, provided that if +// used in a batch query, all request IDs in the batch must be unique. +@property (copy) NSString *requestID; + +// For queries which support file upload, the MIME type and file handle +// or data must be provided. +@property (copy) GTLUploadParameters *uploadParameters; + +// Any URL query parameters to add to the query (useful for debugging with some +// services). +@property (copy) NSDictionary *urlQueryParameters; + +// Any additional HTTP headers for this query. Not valid when this query +// is added to a batch. +// +// These headers override the same keys from the service object's +// additionalHTTPHeaders. +@property (copy) NSDictionary *additionalHTTPHeaders; + +// The GTLObject subclass expected for results (used if the result doesn't +// include a kind attribute). +@property (assign) Class expectedObjectClass; + +// Clients may set this to YES to disallow authorization. Defaults to NO. +@property (assign) BOOL shouldSkipAuthorization; + +// Clients may provide an optional callback block to be called immediately +// before the executeQuery: callback. +// +// The completionBlock property is particularly useful for queries executed +// in a batch. +// +// Errors passed to the completionBlock will have an "underlying" GTLErrorObject +// when the server returned an error for this specific query: +// +// GTLErrorObject *errorObj = [GTLErrorObject underlyingObjectForError:error]; +// if (errorObj) { +// // the server returned this error for this specific query +// } else { +// // the batch execution failed +// } +@property (copy) void (^completionBlock)(GTLServiceTicket *ticket, id object, NSError *error); + +// methodName is the RPC method name to use. ++ (id)queryWithMethodName:(NSString *)methodName GTL_NONNULL((1)); + +// methodName is the RPC method name to use. +- (id)initWithMethodName:(NSString *)method GTL_NONNULL((1)); + +// If you need to set a parameter that is not listed as a property for a +// query class, you can do so via this api. If you need to clear it after +// setting, pass nil for obj. +- (void)setCustomParameter:(id)obj forKey:(NSString *)key GTL_NONNULL((2)); + +// Auto-generated request IDs ++ (NSString *)nextRequestID; + +// Methods for subclasses to override. ++ (NSDictionary *)parameterNameMap; ++ (NSDictionary *)arrayPropertyToClassMap; +@end + +// The library doesn't use GTLQueryCollectionImpl, but it provides a concrete implementation +// of the protocol so the methods do not cause a private method error in Xcode. +@interface GTLQueryCollectionImpl : GTLQuery +@end diff --git a/XCDYouTubeKit Demo/Pods/Google-API-Client/Source/Objects/GTLQuery.m b/XCDYouTubeKit Demo/Pods/Google-API-Client/Source/Objects/GTLQuery.m new file mode 100644 index 00000000..f9125654 --- /dev/null +++ b/XCDYouTubeKit Demo/Pods/Google-API-Client/Source/Objects/GTLQuery.m @@ -0,0 +1,262 @@ +/* Copyright (c) 2011 Google Inc. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +// +// GTLQuery.m +// + +#include + +#import "GTLQuery.h" +#import "GTLRuntimeCommon.h" +#import "GTLUtilities.h" + +@interface GTLQuery () +@end + +@implementation GTLQuery + +// Implementation Note: bodyObject could be done as a dynamic property and map +// it to the key "resource". But we expose the object on the ServiceTicket +// for developers, and so sending it through the plumbing already in the +// parameters and outside of that gets into a grey area. For requests sent +// via this class, we don't need to touch the JSON, but for developers that +// have to use the lower level apis for something we'd need to know to add +// it to the JSON. + +@synthesize methodName = methodName_, + JSON = json_, + bodyObject = bodyObject_, + requestID = requestID_, + uploadParameters = uploadParameters_, + urlQueryParameters = urlQueryParameters_, + additionalHTTPHeaders = additionalHTTPHeaders_, + expectedObjectClass = expectedObjectClass_, + shouldSkipAuthorization = skipAuthorization_, + completionBlock = completionBlock_; + ++ (id)queryWithMethodName:(NSString *)methodName { + return [[[self alloc] initWithMethodName:methodName] autorelease]; +} + +- (id)initWithMethodName:(NSString *)methodName { + self = [super init]; + if (self) { + requestID_ = [[[self class] nextRequestID] retain]; + + methodName_ = [methodName copy]; + if ([methodName_ length] == 0) { + [self release]; + self = nil; + } + } + return self; +} + +- (void)dealloc { + [methodName_ release]; + [json_ release]; + [bodyObject_ release]; + [childCache_ release]; + [requestID_ release]; + [uploadParameters_ release]; + [urlQueryParameters_ release]; + [additionalHTTPHeaders_ release]; + [completionBlock_ release]; + + [super dealloc]; +} + + +- (id)copyWithZone:(NSZone *)zone { + GTLQuery *query = + [[[self class] allocWithZone:zone] initWithMethodName:self.methodName]; + + if ([json_ count] > 0) { + // Deep copy the parameters + CFPropertyListRef ref = CFPropertyListCreateDeepCopy(kCFAllocatorDefault, + json_, kCFPropertyListMutableContainers); + query.JSON = [NSMakeCollectable(ref) autorelease]; + } + query.bodyObject = self.bodyObject; + query.requestID = self.requestID; + query.uploadParameters = self.uploadParameters; + query.urlQueryParameters = self.urlQueryParameters; + query.additionalHTTPHeaders = self.additionalHTTPHeaders; + query.expectedObjectClass = self.expectedObjectClass; + query.shouldSkipAuthorization = self.shouldSkipAuthorization; + query.completionBlock = self.completionBlock; + return query; +} + +- (NSString *)description { + NSArray *keys = [self.JSON allKeys]; + NSArray *params = [keys sortedArrayUsingSelector:@selector(compare:)]; + NSString *paramsSummary = @""; + if ([params count] > 0) { + paramsSummary = [NSString stringWithFormat:@" params:(%@)", + [params componentsJoinedByString:@","]]; + } + + keys = [self.urlQueryParameters allKeys]; + NSArray *urlQParams = [keys sortedArrayUsingSelector:@selector(compare:)]; + NSString *urlQParamsSummary = @""; + if ([urlQParams count] > 0) { + urlQParamsSummary = [NSString stringWithFormat:@" urlQParams:(%@)", + [urlQParams componentsJoinedByString:@","]]; + } + + GTLObject *bodyObj = self.bodyObject; + NSString *bodyObjSummary = @""; + if (bodyObj != nil) { + bodyObjSummary = [NSString stringWithFormat:@" bodyObject:%@", [bodyObj class]]; + } + + NSString *uploadStr = @""; + GTLUploadParameters *uploadParams = self.uploadParameters; + if (uploadParams) { + uploadStr = [NSString stringWithFormat:@" %@", uploadParams]; + } + + return [NSString stringWithFormat:@"%@ %p: {method:%@%@%@%@%@}", + [self class], self, self.methodName, + paramsSummary, urlQParamsSummary, bodyObjSummary, uploadStr]; +} + +- (void)setCustomParameter:(id)obj forKey:(NSString *)key { + [self setJSONValue:obj forKey:key]; +} + +- (BOOL)isBatchQuery { + return NO; +} + +- (void)executionDidStop { + self.completionBlock = nil; +} + ++ (NSString *)nextRequestID { + static unsigned long lastRequestID = 0; + NSString *result; + + @synchronized([GTLQuery class]) { + ++lastRequestID; + result = [NSString stringWithFormat:@"gtl_%lu", + (unsigned long) lastRequestID]; + } + return result; +} + +#pragma mark GTLRuntimeCommon Support + +- (void)setJSONValue:(id)obj forKey:(NSString *)key { + NSMutableDictionary *dict = self.JSON; + if (dict == nil && obj != nil) { + dict = [NSMutableDictionary dictionaryWithCapacity:1]; + self.JSON = dict; + } + [dict setValue:obj forKey:key]; +} + +- (id)JSONValueForKey:(NSString *)key { + id obj = [self.JSON objectForKey:key]; + return obj; +} + +// There is no property for childCache_ as there shouldn't be KVC/KVO +// support for it, it's an implementation detail. + +- (void)setCacheChild:(id)obj forKey:(NSString *)key { + if (childCache_ == nil && obj != nil) { + childCache_ = + [[NSMutableDictionary alloc] initWithObjectsAndKeys:obj, key, nil]; + } else { + [childCache_ setValue:obj forKey:key]; + } +} + +- (id)cacheChildForKey:(NSString *)key { + id obj = [childCache_ objectForKey:key]; + return obj; +} + +#pragma mark Methods for Subclasses to Override + ++ (NSDictionary *)parameterNameMap { + return nil; +} + ++ (NSDictionary *)arrayPropertyToClassMap { + return nil; +} + +#pragma mark Runtime Utilities + +static NSMutableDictionary *gQueryParameterNameMapCache = nil; +static NSMutableDictionary *gQueryArrayPropertyToClassMapCache = nil; + ++ (void)initialize { + // note that initialize is guaranteed by the runtime to be called in a + // thread-safe manner + if (gQueryParameterNameMapCache == nil) { + gQueryParameterNameMapCache = [[NSMutableDictionary alloc] init]; + } + if (gQueryArrayPropertyToClassMapCache == nil) { + gQueryArrayPropertyToClassMapCache = [[NSMutableDictionary alloc] init]; + } +} + ++ (NSDictionary *)propertyToJSONKeyMapForClass:(Class)aClass { + NSDictionary *resultMap = + [GTLUtilities mergedClassDictionaryForSelector:@selector(parameterNameMap) + startClass:aClass + ancestorClass:[GTLQuery class] + cache:gQueryParameterNameMapCache]; + return resultMap; +} + ++ (NSDictionary *)arrayPropertyToClassMapForClass:(Class)aClass { + NSDictionary *resultMap = + [GTLUtilities mergedClassDictionaryForSelector:@selector(arrayPropertyToClassMap) + startClass:aClass + ancestorClass:[GTLQuery class] + cache:gQueryArrayPropertyToClassMapCache]; + return resultMap; +} + +#pragma mark Runtime Support + +- (NSDictionary *)surrogates { + // Stub method just needed for RumtimeCommon, query doesn't use surrogates. + return nil; +} + ++ (Class)ancestorClass { + return [GTLQuery class]; +} + ++ (BOOL)resolveInstanceMethod:(SEL)sel { + BOOL resolved = [GTLRuntimeCommon resolveInstanceMethod:sel onClass:self]; + if (resolved) + return YES; + + return [super resolveInstanceMethod:sel]; +} + +@end + +@implementation GTLQueryCollectionImpl +@dynamic pageToken, startIndex; +@end diff --git a/XCDYouTubeKit Demo/Pods/Google-API-Client/Source/Objects/GTLRuntimeCommon.h b/XCDYouTubeKit Demo/Pods/Google-API-Client/Source/Objects/GTLRuntimeCommon.h new file mode 100644 index 00000000..28822b5e --- /dev/null +++ b/XCDYouTubeKit Demo/Pods/Google-API-Client/Source/Objects/GTLRuntimeCommon.h @@ -0,0 +1,57 @@ +/* Copyright (c) 2011 Google Inc. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +// +// GTLRuntimeCommon.h +// + + +#import + +#import "GTLDefines.h" + +// This protocol and support class are an internal implementation detail so +// GTLObject and GTLQuery can share some code. + +@protocol GTLRuntimeCommon +@required +// Get/Set properties +- (void)setJSONValue:(id)obj forKey:(NSString *)key; +- (id)JSONValueForKey:(NSString *)key; +// Child cache +- (void)setCacheChild:(id)obj forKey:(NSString *)key; +- (id)cacheChildForKey:(NSString *)key; +// Surrogate class mappings. +- (NSDictionary *)surrogates; +// Key map ++ (NSDictionary *)propertyToJSONKeyMapForClass:(Class)aClass; +// Array item types ++ (NSDictionary *)arrayPropertyToClassMapForClass:(Class)aClass; +// The parent class for dynamic support ++ (Class)ancestorClass; +@end + +@interface GTLRuntimeCommon : NSObject +// Wire things up. ++ (BOOL)resolveInstanceMethod:(SEL)sel onClass:(Class)onClass; +// Helpers ++ (id)objectFromJSON:(id)json + defaultClass:(Class)defaultClass + surrogates:(NSDictionary *)surrogates + isCacheable:(BOOL*)isCacheable; ++ (id)jsonFromAPIObject:(id)obj + expectedClass:(Class)expectedClass + isCacheable:(BOOL*)isCacheable; +@end diff --git a/XCDYouTubeKit Demo/Pods/Google-API-Client/Source/Objects/GTLRuntimeCommon.m b/XCDYouTubeKit Demo/Pods/Google-API-Client/Source/Objects/GTLRuntimeCommon.m new file mode 100644 index 00000000..5efaa74a --- /dev/null +++ b/XCDYouTubeKit Demo/Pods/Google-API-Client/Source/Objects/GTLRuntimeCommon.m @@ -0,0 +1,1187 @@ +/* Copyright (c) 2011 Google Inc. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +// +// GTLRuntimeCommon.m +// + +#include +#include + +#import "GTLRuntimeCommon.h" + +#import "GTLDateTime.h" +#import "GTLObject.h" +#import "GTLUtilities.h" + +static NSString *const kReturnClassKey = @"returnClass"; +static NSString *const kContainedClassKey = @"containedClass"; +static NSString *const kJSONKey = @"jsonKey"; + +// Note: NSObject's class is used as a marker for the expected/default class +// when Discovery says it can be any type of object. + +@implementation GTLRuntimeCommon + +// Helper to generically convert JSON to an api object type. ++ (id)objectFromJSON:(id)json + defaultClass:(Class)defaultClass + surrogates:(NSDictionary *)surrogates + isCacheable:(BOOL*)isCacheable { + id result = nil; + BOOL canBeCached = YES; + + // TODO(TVL): use defaultClass to validate things like expectedClass is + // done in jsonFromAPIObject:expectedClass:isCacheable:? + + if ([json isKindOfClass:[NSDictionary class]]) { + // If no default, or the default was any object, then default to base + // object here (and hope there is a kind to get the right thing). + if ((defaultClass == Nil) || [defaultClass isEqual:[NSObject class]]) { + defaultClass = [GTLObject class]; + } + result = [GTLObject objectForJSON:json + defaultClass:defaultClass + surrogates:surrogates + batchClassMap:nil]; + } else if ([json isKindOfClass:[NSArray class]]) { + NSArray *jsonArray = json; + // make an object for each JSON dictionary in the array + NSMutableArray *resultArray = [NSMutableArray arrayWithCapacity:[jsonArray count]]; + for (id jsonItem in jsonArray) { + id item = [self objectFromJSON:jsonItem + defaultClass:defaultClass + surrogates:surrogates + isCacheable:NULL]; + [resultArray addObject:item]; + } + result = resultArray; + } else if ([json isKindOfClass:[NSString class]]) { + // DateTimes live in JSON as strings, so convert + if ([defaultClass isEqual:[GTLDateTime class]]) { + result = [GTLDateTime dateTimeWithRFC3339String:json]; + } else { + result = json; + canBeCached = NO; + } + } else if ([json isKindOfClass:[NSNumber class]] || + [json isKindOfClass:[NSNull class]]) { + result = json; + canBeCached = NO; + } else { + GTL_DEBUG_LOG(@"GTLRuntimeCommon: unsupported class '%s' in objectFromJSON", + class_getName([json class])); + } + + if (isCacheable) { + *isCacheable = canBeCached; + } + return result; +} + +// Helper to generically convert an api object type to JSON. +// |expectedClass| is the type that was expected for |obj|. ++ (id)jsonFromAPIObject:(id)obj + expectedClass:(Class)expectedClass + isCacheable:(BOOL*)isCacheable { + id result = nil; + BOOL canBeCached = YES; + BOOL checkExpected = (expectedClass != Nil); + + if ([obj isKindOfClass:[NSString class]]) { + result = [[obj copy] autorelease]; + canBeCached = NO; + } else if ([obj isKindOfClass:[NSNumber class]] || + [obj isKindOfClass:[NSNull class]]) { + result = obj; + canBeCached = NO; + } else if ([obj isKindOfClass:[GTLObject class]]) { + result = [obj JSON]; + if (result == nil) { + // adding an empty object; it should have a JSON dictionary so it can + // hold future assignments + [obj setJSON:[NSMutableDictionary dictionary]]; + result = [obj JSON]; + } + } else if ([obj isKindOfClass:[NSArray class]]) { + checkExpected = NO; + NSArray *array = obj; + // get the JSON for each thing in the array + NSMutableArray *resultArray = [NSMutableArray arrayWithCapacity:[array count]]; + for (id item in array) { + id itemJSON = [self jsonFromAPIObject:item + expectedClass:expectedClass + isCacheable:NULL]; + [resultArray addObject:itemJSON]; + } + result = resultArray; + } else if ([obj isKindOfClass:[GTLDateTime class]]) { + // DateTimes live in JSON as strings, so convert. + GTLDateTime *dateTime = obj; + result = [dateTime stringValue]; + } else { + checkExpected = NO; + if (obj) { + GTL_DEBUG_LOG(@"GTLRuntimeCommon: unsupported class '%s' in jsonFromAPIObject", + class_getName([obj class])); + } + } + + if (checkExpected) { + // If the default was any object, then clear it to skip validation checks. + if ([expectedClass isEqual:[NSObject class]] || + [obj isKindOfClass:[NSNull class]]) { + expectedClass = nil; + } + if (expectedClass && ![obj isKindOfClass:expectedClass]) { + GTL_DEBUG_LOG(@"GTLRuntimeCommon: jsonFromAPIObject expected class '%s' instead got '%s'", + class_getName(expectedClass), class_getName([obj class])); + } + } + + if (isCacheable) { + *isCacheable = canBeCached; + } + return result; +} + +#pragma mark JSON/Object Utilities + +static NSMutableDictionary *gDispatchCache = nil; + +static CFStringRef SelectorKeyCopyDescriptionCallBack(const void *key) { + // Make a CFString from the key + NSString *name = NSStringFromSelector((SEL) key); + CFStringRef str = CFStringCreateCopy(kCFAllocatorDefault, (CFStringRef) name); + return str; +} + +// Save the dispatch details for the specified class and selector ++ (void)setStoredDispatchForClass:(Class)dispatchClass + selector:(SEL)sel + returnClass:(Class)returnClass + containedClass:(Class)containedClass + jsonKey:(NSString *)jsonKey { + // cache structure: + // class -> + // selector -> + // returnClass + // containedClass + // jsonKey + @synchronized([GTLRuntimeCommon class]) { + if (gDispatchCache == nil) { + gDispatchCache = [[NSMutableDictionary alloc] init]; + } + + CFMutableDictionaryRef classDict = + (CFMutableDictionaryRef) [gDispatchCache objectForKey:dispatchClass]; + if (classDict == nil) { + // We create a CFDictionary since the keys are raw selectors rather than + // NSStrings + const CFDictionaryKeyCallBacks keyCallBacks = { + .version = 0, + .retain = NULL, + .release = NULL, + .copyDescription = SelectorKeyCopyDescriptionCallBack, + .equal = NULL, // defaults to pointer comparison + .hash = NULL // defaults to the pointer value + }; + const CFIndex capacity = 0; // no limit + classDict = CFDictionaryCreateMutable(kCFAllocatorDefault, capacity, + &keyCallBacks, + &kCFTypeDictionaryValueCallBacks); + [gDispatchCache setObject:(id)classDict + forKey:(id)dispatchClass]; + CFRelease(classDict); + } + + NSDictionary *selDict = (NSDictionary *)CFDictionaryGetValue(classDict, sel); + if (selDict == nil) { + selDict = [NSDictionary dictionaryWithObjectsAndKeys: + jsonKey, kJSONKey, + returnClass, kReturnClassKey, // can be nil (primitive types) + containedClass, kContainedClassKey, // may be nil + nil]; + CFDictionarySetValue(classDict, sel, selDict); + } else { + // we already have a dictionary for this selector on this class, which is + // surprising + GTL_DEBUG_LOG(@"Storing duplicate dispatch for %@ selector %@", + dispatchClass, NSStringFromSelector(sel)); + } + } +} + ++ (BOOL)getStoredDispatchForClass:(Class)dispatchClass + selector:(SEL)sel + returnClass:(Class *)outReturnClass + containedClass:(Class *)outContainedClass + jsonKey:(NSString **)outJsonKey { + @synchronized([GTLRuntimeCommon class]) { + // walk from this class up the hierarchy to the ancestor class + Class topClass = class_getSuperclass([dispatchClass ancestorClass]); + for (Class currClass = dispatchClass; + currClass != topClass; + currClass = class_getSuperclass(currClass)) { + + CFMutableDictionaryRef classDict = + (CFMutableDictionaryRef) [gDispatchCache objectForKey:currClass]; + if (classDict) { + NSMutableDictionary *selDict = + (NSMutableDictionary *) CFDictionaryGetValue(classDict, sel); + if (selDict) { + if (outReturnClass) { + *outReturnClass = [selDict objectForKey:kReturnClassKey]; + } + if (outContainedClass) { + *outContainedClass = [selDict objectForKey:kContainedClassKey]; + } + if (outJsonKey) { + *outJsonKey = [selDict objectForKey:kJSONKey]; + } + return YES; + } + } + } + } + GTL_DEBUG_LOG(@"Failed to find stored dispatch info for %@ %s", + dispatchClass, sel_getName(sel)); + return NO; +} + +#pragma mark IMPs - getters and setters for specific object types + +#if !defined(__LP64__) || !__LP64__ + +// NSInteger on 32bit +static NSInteger DynamicInteger32Getter(id self, SEL sel) { + // get an NSInteger (NSNumber) from the JSON dictionary + NSString *jsonKey = nil; + Class selfClass = [self class]; + if ([GTLRuntimeCommon getStoredDispatchForClass:selfClass + selector:sel + returnClass:NULL + containedClass:NULL + jsonKey:&jsonKey]) { + NSNumber *num = [self JSONValueForKey:jsonKey]; + num = GTL_EnsureNSNumber(num); + NSInteger result = [num integerValue]; + return result; + } + return 0; +} + +static void DynamicInteger32Setter(id self, SEL sel, NSInteger val) { + // save an NSInteger (NSNumber) into the JSON dictionary + NSString *jsonKey = nil; + Class selfClass = [self class]; + if ([GTLRuntimeCommon getStoredDispatchForClass:selfClass + selector:sel + returnClass:NULL + containedClass:NULL + jsonKey:&jsonKey]) { + NSNumber *num = [NSNumber numberWithInteger:val]; + [self setJSONValue:num forKey:jsonKey]; + } +} + +// NSUInteger on 32bit +static NSUInteger DynamicUInteger32Getter(id self, SEL sel) { + // get an NSUInteger (NSNumber) from the JSON dictionary + NSString *jsonKey = nil; + Class selfClass = [self class]; + if ([GTLRuntimeCommon getStoredDispatchForClass:selfClass + selector:sel + returnClass:NULL + containedClass:NULL + jsonKey:&jsonKey]) { + NSNumber *num = [self JSONValueForKey:jsonKey]; + num = GTL_EnsureNSNumber(num); + NSUInteger result = [num unsignedIntegerValue]; + return result; + } + return 0; +} + +static void DynamicUInteger32Setter(id self, SEL sel, NSUInteger val) { + // save an NSUInteger (NSNumber) into the JSON dictionary + NSString *jsonKey = nil; + Class selfClass = [self class]; + if ([GTLRuntimeCommon getStoredDispatchForClass:selfClass + selector:sel + returnClass:NULL + containedClass:NULL + jsonKey:&jsonKey]) { + NSNumber *num = [NSNumber numberWithUnsignedInteger:val]; + [self setJSONValue:num forKey:jsonKey]; + } +} + +#endif // !__LP64__ + +// NSInteger on 64bit, long long on 32bit and 64bit +static long long DynamicLongLongGetter(id self, SEL sel) { + // get a long long (NSNumber) from the JSON dictionary + NSString *jsonKey = nil; + Class selfClass = [self class]; + if ([GTLRuntimeCommon getStoredDispatchForClass:selfClass + selector:sel + returnClass:NULL + containedClass:NULL + jsonKey:&jsonKey]) { + NSNumber *num = [self JSONValueForKey:jsonKey]; + num = GTL_EnsureNSNumber(num); + long long result = [num longLongValue]; + return result; + } + return 0; +} + +static void DynamicLongLongSetter(id self, SEL sel, long long val) { + // save a long long (NSNumber) into the JSON dictionary + NSString *jsonKey = nil; + Class selfClass = [self class]; + if ([GTLRuntimeCommon getStoredDispatchForClass:selfClass + selector:sel + returnClass:NULL + containedClass:NULL + jsonKey:&jsonKey]) { + NSNumber *num = [NSNumber numberWithLongLong:val]; + [self setJSONValue:num forKey:jsonKey]; + } +} + +// NSUInteger on 64bit, unsiged long long on 32bit and 64bit +static unsigned long long DynamicULongLongGetter(id self, SEL sel) { + // get an unsigned long long (NSNumber) from the JSON dictionary + NSString *jsonKey = nil; + Class selfClass = [self class]; + if ([GTLRuntimeCommon getStoredDispatchForClass:selfClass + selector:sel + returnClass:NULL + containedClass:NULL + jsonKey:&jsonKey]) { + NSNumber *num = [self JSONValueForKey:jsonKey]; + num = GTL_EnsureNSNumber(num); + unsigned long long result = [num unsignedLongLongValue]; + return result; + } + return 0; +} + +static void DynamicULongLongSetter(id self, SEL sel, unsigned long long val) { + // save an unsigned long long (NSNumber) into the JSON dictionary + NSString *jsonKey = nil; + Class selfClass = [self class]; + if ([GTLRuntimeCommon getStoredDispatchForClass:selfClass + selector:sel + returnClass:NULL + containedClass:NULL + jsonKey:&jsonKey]) { + NSNumber *num = [NSNumber numberWithUnsignedLongLong:val]; + [self setJSONValue:num forKey:jsonKey]; + } +} + +// float +static float DynamicFloatGetter(id self, SEL sel) { + // get a float (NSNumber) from the JSON dictionary + NSString *jsonKey = nil; + Class selfClass = [self class]; + if ([GTLRuntimeCommon getStoredDispatchForClass:selfClass + selector:sel + returnClass:NULL + containedClass:NULL + jsonKey:&jsonKey]) { + NSNumber *num = [self JSONValueForKey:jsonKey]; + num = GTL_EnsureNSNumber(num); + float result = [num floatValue]; + return result; + } + return 0.0f; +} + +static void DynamicFloatSetter(id self, SEL sel, float val) { + // save a float (NSNumber) into the JSON dictionary + NSString *jsonKey = nil; + Class selfClass = [self class]; + if ([GTLRuntimeCommon getStoredDispatchForClass:selfClass + selector:sel + returnClass:NULL + containedClass:NULL + jsonKey:&jsonKey]) { + NSNumber *num = [NSNumber numberWithFloat:val]; + [self setJSONValue:num forKey:jsonKey]; + } +} + +// double +static double DynamicDoubleGetter(id self, SEL sel) { + // get a double (NSNumber) from the JSON dictionary + NSString *jsonKey = nil; + Class selfClass = [self class]; + if ([GTLRuntimeCommon getStoredDispatchForClass:selfClass + selector:sel + returnClass:NULL + containedClass:NULL + jsonKey:&jsonKey]) { + NSNumber *num = [self JSONValueForKey:jsonKey]; + num = GTL_EnsureNSNumber(num); + double result = [num doubleValue]; + return result; + } + return 0.0; +} + +static void DynamicDoubleSetter(id self, SEL sel, double val) { + // save a double (NSNumber) into the JSON dictionary + NSString *jsonKey = nil; + Class selfClass = [self class]; + if ([GTLRuntimeCommon getStoredDispatchForClass:selfClass + selector:sel + returnClass:NULL + containedClass:NULL + jsonKey:&jsonKey]) { + NSNumber *num = [NSNumber numberWithDouble:val]; + [self setJSONValue:num forKey:jsonKey]; + } +} + +// BOOL +static BOOL DynamicBooleanGetter(id self, SEL sel) { + // get a BOOL (NSNumber) from the JSON dictionary + NSString *jsonKey = nil; + Class selfClass = [self class]; + if ([GTLRuntimeCommon getStoredDispatchForClass:selfClass + selector:sel + returnClass:NULL + containedClass:NULL + jsonKey:&jsonKey]) { + NSNumber *num = [self JSONValueForKey:jsonKey]; + BOOL flag = [num boolValue]; + return flag; + } + return NO; +} + +static void DynamicBooleanSetter(id self, SEL sel, BOOL val) { + // save a BOOL (NSNumber) into the JSON dictionary + NSString *jsonKey = nil; + Class selfClass = [self class]; + if ([GTLRuntimeCommon getStoredDispatchForClass:selfClass + selector:sel + returnClass:NULL + containedClass:NULL + jsonKey:&jsonKey]) { + NSNumber *num = [NSNumber numberWithBool:val]; + [self setJSONValue:num forKey:jsonKey]; + } +} + +// NSString +static NSString *DynamicStringGetter(id self, SEL sel) { + // get an NSString from the JSON dictionary + NSString *jsonKey = nil; + Class selfClass = [self class]; + if ([GTLRuntimeCommon getStoredDispatchForClass:selfClass + selector:sel + returnClass:NULL + containedClass:NULL + jsonKey:&jsonKey]) { + + NSString *str = [self JSONValueForKey:jsonKey]; + return str; + } + return nil; +} + +static void DynamicStringSetter(id self, SEL sel, + NSString *str) { + // save an NSString into the JSON dictionary + NSString *jsonKey = nil; + Class selfClass = [self class]; + if ([GTLRuntimeCommon getStoredDispatchForClass:selfClass + selector:sel + returnClass:NULL + containedClass:NULL + jsonKey:&jsonKey]) { + NSString *copiedStr = [str copy]; + [self setJSONValue:copiedStr forKey:jsonKey]; + [copiedStr release]; + } +} + +// GTLDateTime +static GTLDateTime *DynamicDateTimeGetter(id self, SEL sel) { + // get a GTLDateTime from the JSON dictionary + NSString *jsonKey = nil; + Class selfClass = [self class]; + if ([GTLRuntimeCommon getStoredDispatchForClass:selfClass + selector:sel + returnClass:NULL + containedClass:NULL + jsonKey:&jsonKey]) { + + // Return the cached object before creating on demand. + GTLDateTime *cachedDateTime = [self cacheChildForKey:jsonKey]; + if (cachedDateTime != nil) { + return cachedDateTime; + } + NSString *str = [self JSONValueForKey:jsonKey]; + id cacheValue, resultValue; + if (![str isKindOfClass:[NSNull class]]) { + GTLDateTime *dateTime = [GTLDateTime dateTimeWithRFC3339String:str]; + + cacheValue = dateTime; + resultValue = dateTime; + } else { + cacheValue = nil; + resultValue = [NSNull null]; + } + [self setCacheChild:cacheValue forKey:jsonKey]; + return resultValue; + } + return nil; +} + +static void DynamicDateTimeSetter(id self, SEL sel, + GTLDateTime *dateTime) { + // save an GTLDateTime into the JSON dictionary + NSString *jsonKey = nil; + Class selfClass = [self class]; + if ([GTLRuntimeCommon getStoredDispatchForClass:selfClass + selector:sel + returnClass:NULL + containedClass:NULL + jsonKey:&jsonKey]) { + id cacheValue, jsonValue; + if (![dateTime isKindOfClass:[NSNull class]]) { + jsonValue = [dateTime stringValue]; + cacheValue = dateTime; + } else { + jsonValue = [NSNull null]; + cacheValue = nil; + } + + [self setJSONValue:jsonValue forKey:jsonKey]; + [self setCacheChild:cacheValue forKey:jsonKey]; + } +} + +// NSNumber +static NSNumber *DynamicNumberGetter(id self, SEL sel) { + // get an NSNumber from the JSON dictionary + NSString *jsonKey = nil; + Class selfClass = [self class]; + if ([GTLRuntimeCommon getStoredDispatchForClass:selfClass + selector:sel + returnClass:NULL + containedClass:NULL + jsonKey:&jsonKey]) { + + NSNumber *num = [self JSONValueForKey:jsonKey]; + num = GTL_EnsureNSNumber(num); + return num; + } + return nil; +} + +static void DynamicNumberSetter(id self, SEL sel, + NSNumber *num) { + // save an NSNumber into the JSON dictionary + NSString *jsonKey = nil; + Class selfClass = [self class]; + if ([GTLRuntimeCommon getStoredDispatchForClass:selfClass + selector:sel + returnClass:NULL + containedClass:NULL + jsonKey:&jsonKey]) { + [self setJSONValue:num forKey:jsonKey]; + } +} + +// GTLObject +static GTLObject *DynamicObjectGetter(id self, SEL sel) { + // get a GTLObject from the JSON dictionary + NSString *jsonKey = nil; + Class returnClass = nil; + Class selfClass = [self class]; + if ([GTLRuntimeCommon getStoredDispatchForClass:selfClass + selector:sel + returnClass:&returnClass + containedClass:NULL + jsonKey:&jsonKey]) { + + // Return the cached object before creating on demand. + GTLObject *cachedObj = [self cacheChildForKey:jsonKey]; + if (cachedObj != nil) { + return cachedObj; + } + NSMutableDictionary *dict = [self JSONValueForKey:jsonKey]; + if ([dict isKindOfClass:[NSMutableDictionary class]]) { + // get the class of the object being returned, and instantiate it + if (returnClass == Nil) { + returnClass = [GTLObject class]; + } + + NSDictionary *surrogates = self.surrogates; + GTLObject *obj = [GTLObject objectForJSON:dict + defaultClass:returnClass + surrogates:surrogates + batchClassMap:nil]; + [self setCacheChild:obj forKey:jsonKey]; + return obj; + } else if ([dict isKindOfClass:[NSNull class]]) { + [self setCacheChild:nil forKey:jsonKey]; + return (id) [NSNull null]; + } else if (dict != nil) { + // unexpected; probably got a string -- let the caller figure it out + GTL_DEBUG_LOG(@"GTLObject: unexpected JSON: %@.%@ should be a dictionary, actually is a %@:\n%@", + NSStringFromClass(selfClass), NSStringFromSelector(sel), + NSStringFromClass([dict class]), dict); + return (GTLObject *)dict; + } + } + return nil; +} + +static void DynamicObjectSetter(id self, SEL sel, + GTLObject *obj) { + // save a GTLObject into the JSON dictionary + NSString *jsonKey = nil; + Class selfClass = [self class]; + if ([GTLRuntimeCommon getStoredDispatchForClass:selfClass + selector:sel + returnClass:NULL + containedClass:NULL + jsonKey:&jsonKey]) { + id cacheValue, jsonValue; + if (![obj isKindOfClass:[NSNull class]]) { + NSMutableDictionary *dict = [obj JSON]; + if (dict == nil && obj != nil) { + // adding an empty object; it should have a JSON dictionary so it can + // hold future assignments + obj.JSON = [NSMutableDictionary dictionary]; + jsonValue = obj.JSON; + } else { + jsonValue = dict; + } + cacheValue = obj; + } else { + jsonValue = [NSNull null]; + cacheValue = nil; + } + [self setJSONValue:jsonValue forKey:jsonKey]; + [self setCacheChild:cacheValue forKey:jsonKey]; + } +} + +// get an NSArray of GTLObjects, NSStrings, or NSNumbers from the +// JSON dictionary for this object +static NSMutableArray *DynamicArrayGetter(id self, SEL sel) { + NSString *jsonKey = nil; + Class containedClass = nil; + Class selfClass = [self class]; + if ([GTLRuntimeCommon getStoredDispatchForClass:selfClass + selector:sel + returnClass:NULL + containedClass:&containedClass + jsonKey:&jsonKey]) { + + // Return the cached array before creating on demand. + NSMutableArray *cachedArray = [self cacheChildForKey:jsonKey]; + if (cachedArray != nil) { + return cachedArray; + } + NSMutableArray *result = nil; + NSArray *array = [self JSONValueForKey:jsonKey]; + if (array != nil) { + if ([array isKindOfClass:[NSArray class]]) { + NSDictionary *surrogates = self.surrogates; + result = [GTLRuntimeCommon objectFromJSON:array + defaultClass:containedClass + surrogates:surrogates + isCacheable:NULL]; + } else { +#if DEBUG + if (![array isKindOfClass:[NSNull class]]) { + GTL_DEBUG_LOG(@"GTLObject: unexpected JSON: %@.%@ should be an array, actually is a %@:\n%@", + NSStringFromClass(selfClass), NSStringFromSelector(sel), + NSStringFromClass([array class]), array); + } +#endif + result = (NSMutableArray *)array; + } + } + + [self setCacheChild:result forKey:jsonKey]; + return result; + } + return nil; +} + +static void DynamicArraySetter(id self, SEL sel, + NSMutableArray *array) { + // save an array of GTLObjects objects into the JSON dictionary + NSString *jsonKey = nil; + Class selfClass = [self class]; + Class containedClass = nil; + if ([GTLRuntimeCommon getStoredDispatchForClass:selfClass + selector:sel + returnClass:NULL + containedClass:&containedClass + jsonKey:&jsonKey]) { + id json = [GTLRuntimeCommon jsonFromAPIObject:array + expectedClass:containedClass + isCacheable:NULL]; + [self setJSONValue:json forKey:jsonKey]; + [self setCacheChild:array forKey:jsonKey]; + } +} + +// type 'id' +static id DynamicNSObjectGetter(id self, SEL sel) { + NSString *jsonKey = nil; + Class returnClass = nil; + Class selfClass = [self class]; + if ([GTLRuntimeCommon getStoredDispatchForClass:selfClass + selector:sel + returnClass:&returnClass + containedClass:NULL + jsonKey:&jsonKey]) { + + // Return the cached object before creating on demand. + id cachedObj = [self cacheChildForKey:jsonKey]; + if (cachedObj != nil) { + return cachedObj; + } + + id jsonObj = [self JSONValueForKey:jsonKey]; + if (jsonObj != nil) { + BOOL shouldCache = NO; + NSDictionary *surrogates = self.surrogates; + id result = [GTLRuntimeCommon objectFromJSON:jsonObj + defaultClass:nil + surrogates:surrogates + isCacheable:&shouldCache]; + + [self setCacheChild:(shouldCache ? result : nil) + forKey:jsonKey]; + return result; + } + } + return nil; +} + +static void DynamicNSObjectSetter(id self, SEL sel, id obj) { + NSString *jsonKey = nil; + Class selfClass = [self class]; + if ([GTLRuntimeCommon getStoredDispatchForClass:selfClass + selector:sel + returnClass:NULL + containedClass:NULL + jsonKey:&jsonKey]) { + BOOL shouldCache = NO; + id json = [GTLRuntimeCommon jsonFromAPIObject:obj + expectedClass:Nil + isCacheable:&shouldCache]; + [self setJSONValue:json forKey:jsonKey]; + [self setCacheChild:(shouldCache ? obj : nil) + forKey:jsonKey]; + } +} + +#pragma mark Runtime lookup support + +static objc_property_t PropertyForSel(Class startClass, + SEL sel, BOOL isSetter, + Class *outFoundClass) { + const char *selName = sel_getName(sel); + const char *baseName = selName; + size_t baseNameLen = strlen(baseName); + if (isSetter) { + baseName += 3; // skip "set" + baseNameLen -= 4; // subtract "set" and the final colon + } + + // walk from this class up the hierarchy to the ancestor class + Class topClass = class_getSuperclass([startClass ancestorClass]); + for (Class currClass = startClass; + currClass != topClass; + currClass = class_getSuperclass(currClass)) { + // step through this class's properties + objc_property_t foundProp = NULL; + objc_property_t *properties = class_copyPropertyList(currClass, NULL); + if (properties) { + for (objc_property_t *prop = properties; *prop != NULL; ++prop) { + const char *propAttrs = property_getAttributes(*prop); + const char *dynamicMarker = strstr(propAttrs, ",D"); + if (!dynamicMarker || + (dynamicMarker[2] != 0 && dynamicMarker[2] != ',' )) { + // It isn't dynamic, skip it. + continue; + } + + if (!isSetter) { + // See if this property has an explicit getter=. (the attributes always start with a T, + // so we can check for the leading ','. + const char *getterMarker = strstr(propAttrs, ",G"); + if (getterMarker) { + const char *getterStart = getterMarker + 2; + const char *getterEnd = getterStart; + while ((*getterEnd != 0) && (*getterEnd != ',')) { + ++getterEnd; + } + size_t getterLen = (size_t)(getterEnd - getterStart); + if ((strncmp(selName, getterStart, getterLen) == 0) + && (selName[getterLen] == 0)) { + // return the actual property + foundProp = *prop; + // if requested, return the class containing the property + if (outFoundClass) *outFoundClass = currClass; + break; + } + } // if (getterMarker) + } // if (!isSetter) + + // Search for an exact-name match (a getter), but case-insensitive on the + // first character (in case baseName comes from a setter) + const char *propName = property_getName(*prop); + size_t propNameLen = strlen(propName); + if (baseNameLen == propNameLen + && strncasecmp(baseName, propName, 1) == 0 + && (baseNameLen <= 1 + || strncmp(baseName + 1, propName + 1, baseNameLen - 1) == 0)) { + // return the actual property + foundProp = *prop; + + // if requested, return the class containing the property + if (outFoundClass) *outFoundClass = currClass; + break; + } + } // for (prop in properties) + free(properties); + } + if (foundProp) return foundProp; + } + + // not found; this occasionally happens when the system looks for a method + // like "getFoo" or "descriptionWithLocale:indent:" + return NULL; +} + +typedef struct { + const char *attributePrefix; + + const char *setterEncoding; + IMP setterFunction; + const char *getterEncoding; + IMP getterFunction; + + // These are the "fixed" return classes, but some properties will require + // looking up the return class instead (because it is a subclass of + // GTLObject). + const char *returnClassName; + Class returnClass; + BOOL extractReturnClass; + +} GTLDynamicImpInfo; + +static const GTLDynamicImpInfo *DynamicImpInfoForProperty(objc_property_t prop, + Class *outReturnClass) { + + if (outReturnClass) *outReturnClass = nil; + + // dynamic method resolution: + // http://developer.apple.com/library/ios/#documentation/Cocoa/Conceptual/ObjCRuntimeGuide/Articles/ocrtDynamicResolution.html + // + // property runtimes: + // http://developer.apple.com/library/ios/#documentation/Cocoa/Conceptual/ObjCRuntimeGuide/Articles/ocrtPropertyIntrospection.html + + // Get and parse the property attributes, which look something like + // T@"NSString",&,D,P + // Ti,D -- NSInteger on 32bit + // Tq,D -- NSInteger on 64bit, long long on 32bit & 64bit + // TB,D -- BOOL comes as bool on 64bit iOS + // Tc,D -- BOOL comes as char otherwise + // T@"NSString",D + // T@"GTLLink",D + // T@"NSArray",D + + + static GTLDynamicImpInfo kImplInfo[] = { +#if !defined(__LP64__) || !__LP64__ + { // NSInteger on 32bit + "Ti", + "v@:i", (IMP)DynamicInteger32Setter, + "i@:", (IMP)DynamicInteger32Getter, + nil, nil, + NO + }, + { // NSUInteger on 32bit + "TI", + "v@:I", (IMP)DynamicUInteger32Setter, + "I@:", (IMP)DynamicUInteger32Getter, + nil, nil, + NO + }, +#endif + { // NSInteger on 64bit, long long on 32bit and 64bit. + "Tq", + "v@:q", (IMP)DynamicLongLongSetter, + "q@:", (IMP)DynamicLongLongGetter, + nil, nil, + NO + }, + { // NSUInteger on 64bit, long long on 32bit and 64bit. + "TQ", + "v@:Q", (IMP)DynamicULongLongSetter, + "Q@:", (IMP)DynamicULongLongGetter, + nil, nil, + NO + }, + { // float + "Tf", + "v@:f", (IMP)DynamicFloatSetter, + "f@:", (IMP)DynamicFloatGetter, + nil, nil, + NO + }, + { // double + "Td", + "v@:d", (IMP)DynamicDoubleSetter, + "d@:", (IMP)DynamicDoubleGetter, + nil, nil, + NO + }, +// This conditional matches the one in iPhoneOS.platform version of +// that controls the definition of BOOL. +#if !defined(OBJC_HIDE_64) && TARGET_OS_IPHONE && (defined(__LP64__) && __LP64__) + { // BOOL as bool + "TB", + "v@:B", (IMP)DynamicBooleanSetter, + "B@:", (IMP)DynamicBooleanGetter, + nil, nil, + NO + }, +#else + { // BOOL as char + "Tc", + "v@:c", (IMP)DynamicBooleanSetter, + "c@:", (IMP)DynamicBooleanGetter, + nil, nil, + NO + }, +#endif + { // NSString + "T@\"NSString\"", + "v@:@", (IMP)DynamicStringSetter, + "@@:", (IMP)DynamicStringGetter, + "NSString", nil, + NO + }, + { // NSNumber + "T@\"NSNumber\"", + "v@:@", (IMP)DynamicNumberSetter, + "@@:", (IMP)DynamicNumberGetter, + "NSNumber", nil, + NO + }, + { // GTLDateTime +#if !defined(GTL_TARGET_NAMESPACE) + "T@\"GTLDateTime\"", + "v@:@", (IMP)DynamicDateTimeSetter, + "@@:", (IMP)DynamicDateTimeGetter, + "GTLDateTime", nil, + NO +#else + "T@\"" GTL_TARGET_NAMESPACE_STRING "_" "GTLDateTime\"", + "v@:@", (IMP)DynamicDateTimeSetter, + "@@:", (IMP)DynamicDateTimeGetter, + GTL_TARGET_NAMESPACE_STRING "_" "GTLDateTime", nil, + NO +#endif + }, + { // NSArray with type + "T@\"NSArray\"", + "v@:@", (IMP)DynamicArraySetter, + "@@:", (IMP)DynamicArrayGetter, + "NSArray", nil, + NO + }, + { // id (any of the objects above) + "T@,", + "v@:@", (IMP)DynamicNSObjectSetter, + "@@:", (IMP)DynamicNSObjectGetter, + "NSObject", nil, + NO + }, + { // GTLObject - Last, cause it's a special case and prefix is general + "T@\"", + "v@:@", (IMP)DynamicObjectSetter, + "@@:", (IMP)DynamicObjectGetter, + nil, nil, + YES + }, + }; + + static BOOL hasLookedUpClasses = NO; + if (!hasLookedUpClasses) { + // Unfortunately, you can't put [NSString class] into the static structure, + // so this lookup has to be done at runtime. + hasLookedUpClasses = YES; + for (uint32_t idx = 0; idx < sizeof(kImplInfo)/sizeof(kImplInfo[0]); ++idx) { + if (kImplInfo[idx].returnClassName) { + kImplInfo[idx].returnClass = objc_getClass(kImplInfo[idx].returnClassName); + NSCAssert1(kImplInfo[idx].returnClass != nil, + @"GTLRuntimeCommon: class lookup failed: %s", kImplInfo[idx].returnClassName); + } + } + } + + const char *attr = property_getAttributes(prop); + + const char *dynamicMarker = strstr(attr, ",D"); + if (!dynamicMarker || + (dynamicMarker[2] != 0 && dynamicMarker[2] != ',' )) { + GTL_DEBUG_LOG(@"GTLRuntimeCommon: property %s isn't dynamic, attributes %s", + property_getName(prop), attr ? attr : "(nil)"); + return NULL; + } + + const GTLDynamicImpInfo *result = NULL; + + // Cycle over the list + + for (uint32_t idx = 0; idx < sizeof(kImplInfo)/sizeof(kImplInfo[0]); ++idx) { + const char *attributePrefix = kImplInfo[idx].attributePrefix; + if (strncmp(attr, attributePrefix, strlen(attributePrefix)) == 0) { + result = &kImplInfo[idx]; + if (outReturnClass) *outReturnClass = result->returnClass; + break; + } + } + + if (result == NULL) { + GTL_DEBUG_LOG(@"GTLRuntimeCommon: unexpected attributes %s for property %s", + attr ? attr : "(nil)", property_getName(prop)); + return NULL; + } + + if (result->extractReturnClass && outReturnClass) { + + // add a null at the next quotation mark + char *attrCopy = strdup(attr); + char *classNameStart = attrCopy + 3; + char *classNameEnd = strstr(classNameStart, "\""); + if (classNameEnd) { + *classNameEnd = '\0'; + + // Lookup the return class + *outReturnClass = objc_getClass(classNameStart); + if (*outReturnClass == nil) { + GTL_DEBUG_LOG(@"GTLRuntimeCommon: did not find class with name \"%s\" " + "for property \"%s\" with attributes \"%s\"", + classNameStart, property_getName(prop), attr); + } + } else { + GTL_DEBUG_LOG(@"GTLRuntimeCommon: Failed to find end of class name for " + "property \"%s\" with attributes \"%s\"", + property_getName(prop), attr); + } + free(attrCopy); + } + + return result; +} + +#pragma mark Runtime - wiring point + ++ (BOOL)resolveInstanceMethod:(SEL)sel onClass:(Class)onClass { + // dynamic method resolution: + // http://developer.apple.com/library/ios/#documentation/Cocoa/Conceptual/ObjCRuntimeGuide/Articles/ocrtDynamicResolution.html + // + // property runtimes: + // http://developer.apple.com/library/ios/#documentation/Cocoa/Conceptual/ObjCRuntimeGuide/Articles/ocrtPropertyIntrospection.html + + const char *selName = sel_getName(sel); + size_t selNameLen = strlen(selName); + char lastChar = selName[selNameLen - 1]; + BOOL isSetter = (lastChar == ':'); + + // look for a declared property matching this selector name exactly + Class foundClass = nil; + + objc_property_t prop = PropertyForSel(onClass, sel, isSetter, &foundClass); + if (prop != NULL && foundClass != nil) { + + Class returnClass = nil; + const GTLDynamicImpInfo *implInfo = DynamicImpInfoForProperty(prop, + &returnClass); + if (implInfo == NULL) { + GTL_DEBUG_LOG(@"GTLRuntimeCommon: unexpected return type class %s for " + "property \"%s\" of class \"%s\"", + returnClass ? class_getName(returnClass) : "", + property_getName(prop), + class_getName(onClass)); + } + + if (implInfo != NULL) { + IMP imp = ( isSetter ? implInfo->setterFunction : implInfo->getterFunction ); + const char *encoding = ( isSetter ? implInfo->setterEncoding : implInfo->getterEncoding ); + + class_addMethod(foundClass, sel, imp, encoding); + + const char *propName = property_getName(prop); + NSString *propStr = [NSString stringWithUTF8String:propName]; + + // replace the property name with the proper JSON key if it's + // special-cased with a map in the found class; otherwise, the property + // name is the JSON key + NSDictionary *keyMap = + [[foundClass ancestorClass] propertyToJSONKeyMapForClass:foundClass]; + NSString *jsonKey = [keyMap objectForKey:propStr]; + if (jsonKey == nil) { + jsonKey = propStr; + } + + Class containedClass = nil; + + // For arrays we need to look up what the contained class is. + if (imp == (IMP)DynamicArraySetter || imp == (IMP)DynamicArrayGetter) { + NSDictionary *classMap = + [[foundClass ancestorClass] arrayPropertyToClassMapForClass:foundClass]; + containedClass = [classMap objectForKey:jsonKey]; + if (containedClass == Nil) { + GTL_DEBUG_LOG(@"GTLRuntimeCommon: expected array item class for " + "property \"%s\" of class \"%s\"", + property_getName(prop), class_getName(foundClass)); + } + } + + // save the dispatch info to the cache + [GTLRuntimeCommon setStoredDispatchForClass:foundClass + selector:sel + returnClass:returnClass + containedClass:containedClass + jsonKey:jsonKey]; + return YES; + } + } + + return NO; +} + +@end diff --git a/XCDYouTubeKit Demo/Pods/Google-API-Client/Source/Objects/GTLService.h b/XCDYouTubeKit Demo/Pods/Google-API-Client/Source/Objects/GTLService.h new file mode 100644 index 00000000..7415274e --- /dev/null +++ b/XCDYouTubeKit Demo/Pods/Google-API-Client/Source/Objects/GTLService.h @@ -0,0 +1,597 @@ +/* Copyright (c) 2011 Google Inc. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +// +// GTLService.h +// + +// Service object documentation: +// https://code.google.com/p/google-api-objectivec-client/wiki/Introduction#Services_and_Tickets + +#import + +#import "GTLDefines.h" + +// Fetcher bridging macros -- Internal library use only. +// +// GTL_USE_SESSION_FETCHER should be set to force the GTL library to use +// GTMSessionFetcher rather than the older GTMHTTPFetcher. The session +// fetcher requires iOS 7/OS X 10.9 and supports out-of-process uploads. + +#ifndef GTL_USE_SESSION_FETCHER + #if GTM_USE_SESSION_FETCHER + #define GTL_USE_SESSION_FETCHER 1 + #else + #define GTL_USE_SESSION_FETCHER 0 + #endif // GTM_USE_SESSION_FETCHER +#endif // GTL_USE_SESSION_FETCHER + +#if GTL_USE_SESSION_FETCHER + #define GTLUploadFetcherClass GTMSessionUploadFetcher + #define GTLUploadFetcherClassStr @"GTMSessionUploadFetcher" + + #import "GTMSessionFetcher.h" + #import "GTMSessionFetcherService.h" +#else + // !GTL_USE_SESSION_FETCHER + #define GTLUploadFetcherClass GTMHTTPUploadFetcher + #define GTLUploadFetcherClassStr @"GTMHTTPUploadFetcher" + + #import "GTMHTTPFetcher.h" + #import "GTMHTTPFetcherService.h" +#endif // GTL_USE_SESSION_FETCHER + +#import "GTLBatchQuery.h" +#import "GTLBatchResult.h" +#import "GTLDateTime.h" +#import "GTLErrorObject.h" +#import "GTLFramework.h" +#import "GTLJSONParser.h" +#import "GTLObject.h" +#import "GTLQuery.h" +#import "GTLUtilities.h" + +// Error domains +extern NSString *const kGTLServiceErrorDomain; +enum { + kGTLErrorQueryResultMissing = -3000, + kGTLErrorWaitTimedOut = -3001 +}; + +extern NSString *const kGTLJSONRPCErrorDomain; + +// We'll consistently store the server error string in the userInfo under +// this key +extern NSString *const kGTLServerErrorStringKey; + +extern Class const kGTLUseRegisteredClass; + +extern NSUInteger const kGTLStandardUploadChunkSize; + +// When servers return us structured JSON errors, the NSError will +// contain a GTLErrorObject in the userInfo dictionary under the key +// kGTLStructuredErrorsKey +extern NSString *const kGTLStructuredErrorKey; + +// When specifying an ETag for updating or deleting a single entry, use +// kGTLETagWildcard to tell the server to replace the current value +// unconditionally. Do not use this in entries in a batch feed. +extern NSString *const kGTLETagWildcard; + +// Notifications when parsing of a fetcher feed or entry begins or ends +extern NSString *const kGTLServiceTicketParsingStartedNotification; +extern NSString *const kGTLServiceTicketParsingStoppedNotification ; + +@class GTLServiceTicket; + +// Block types used for fetch callbacks + +typedef void (^GTLServiceCompletionHandler)(GTLServiceTicket *ticket, id object, NSError *error); + +typedef void (^GTLServiceUploadProgressBlock)(GTLServiceTicket *ticket, unsigned long long numberOfBytesRead, unsigned long long dataLength); + +typedef BOOL (^GTLServiceRetryBlock)(GTLServiceTicket *ticket, BOOL suggestedWillRetry, NSError *error); + +#pragma mark - + +// +// Service base class +// + +@interface GTLService : NSObject { + @private + NSOperationQueue *parseQueue_; + NSString *userAgent_; + GTMBridgeFetcherService *fetcherService_; + NSString *userAgentAddition_; + + NSMutableDictionary *serviceProperties_; // initial values for properties in future tickets + + NSDictionary *surrogates_; // initial value for surrogates in future tickets + + SEL uploadProgressSelector_; // optional + + GTLServiceRetryBlock retryBlock_; + GTLServiceUploadProgressBlock uploadProgressBlock_; + + NSUInteger uploadChunkSize_; // zero when uploading via multi-part MIME http body + + BOOL isRetryEnabled_; // user allows auto-retries + SEL retrySelector_; // optional; set with setServiceRetrySelector + NSTimeInterval maxRetryInterval_; // default to 600. seconds + + BOOL shouldFetchNextPages_; + + BOOL allowInsecureQueries_; + + NSString *apiKey_; + BOOL isRESTDataWrapperRequired_; + NSString *apiVersion_; + NSURL *rpcURL_; + NSURL *rpcUploadURL_; + NSDictionary *urlQueryParameters_; + NSDictionary *additionalHTTPHeaders_; +} + +#pragma mark Query Execution + +// The finishedSelector has a signature matching: +// +// - (void)serviceTicket:(GTLServiceTicket *)ticket +// finishedWithObject:(GTLObject *)object +// error:(NSError *)error +// +// If an error occurs, the error parameter will be non-nil. Otherwise, +// the object parameter will point to a GTLObject, if any was returned by +// the fetch. (Delete fetches return no object, so the second parameter will +// be nil.) +// +// If the query object is a GTLBatchQuery, the object passed to the callback +// will be a GTLBatchResult; see the batch query documentation: +// https://code.google.com/p/google-api-objectivec-client/wiki/Introduction#Batch_Operations + +- (GTLServiceTicket *)executeQuery:(id)query + delegate:(id)delegate + didFinishSelector:(SEL)finishedSelector GTL_NONNULL((1)); + +- (GTLServiceTicket *)executeQuery:(id)query + completionHandler:(GTLServiceCompletionHandler)handler GTL_NONNULL((1)); + +// Automatic page fetches +// +// Tickets can optionally do a sequence of fetches for queries where +// repeated requests with nextPageToken or nextStartIndex values is required to +// retrieve items of all pages of the response collection. The client's +// callback is invoked only when all items have been retrieved, or an error has +// occurred. During the fetch, the items accumulated so far are available from +// the ticket. +// +// Note that the final object may be a combination of multiple page responses +// so it may not be the same as if all results had been returned in a single +// page. Some fields of the response such as total item counts may reflect only +// the final page's values. +// +// Automatic page fetches will return an error if more than 25 page fetches are +// required. For debug builds, this will log a warning to the console when more +// than 2 page fetches occur, as a reminder that the query's maxResults +// parameter should probably be increased to specify more items returned per +// page. +// +// Default value is NO. +@property (nonatomic, assign) BOOL shouldFetchNextPages; + +// Retrying; see comments on retry support at the top of GTMHTTPFetcher. +// +// Default value is NO. +@property (nonatomic, assign, getter=isRetryEnabled) BOOL retryEnabled; + +// Some services require a developer key for quotas and limits. Setting this +// will include it on all request sent to this service via a GTLQuery class. +@property (nonatomic, copy) NSString *APIKey; + +// An authorizer adds user authentication headers to the request as needed. +@property (nonatomic, retain) id authorizer; + +// Retry selector is optional for retries. +// +// If present, it should have the signature: +// -(BOOL)ticket:(GTLServiceTicket *)ticket willRetry:(BOOL)suggestedWillRetry forError:(NSError *)error +// and return YES to cause a retry. Note that unlike the fetcher retry +// selector, this selector's first argument is a ticket, not a fetcher. + +@property (nonatomic, assign) SEL retrySelector; +@property (copy) GTLServiceRetryBlock retryBlock; + +@property (nonatomic, assign) NSTimeInterval maxRetryInterval; + +// +// Fetches may be done using RPC or REST APIs, without creating +// a GTLQuery object +// + +#pragma mark RPC Fetch Methods + +// +// These methods may be used for RPC fetches without creating a GTLQuery object +// + +- (GTLServiceTicket *)fetchObjectWithMethodNamed:(NSString *)methodName + parameters:(NSDictionary *)parameters + objectClass:(Class)objectClass + delegate:(id)delegate + didFinishSelector:(SEL)finishedSelector GTL_NONNULL((1)); + +- (GTLServiceTicket *)fetchObjectWithMethodNamed:(NSString *)methodName + insertingObject:(GTLObject *)bodyObject + objectClass:(Class)objectClass + delegate:(id)delegate + didFinishSelector:(SEL)finishedSelector GTL_NONNULL((1)); + +- (GTLServiceTicket *)fetchObjectWithMethodNamed:(NSString *)methodName + parameters:(NSDictionary *)parameters + insertingObject:(GTLObject *)bodyObject + objectClass:(Class)objectClass + delegate:(id)delegate + didFinishSelector:(SEL)finishedSelector GTL_NONNULL((1)); + +- (GTLServiceTicket *)fetchObjectWithMethodNamed:(NSString *)methodName + parameters:(NSDictionary *)parameters + objectClass:(Class)objectClass + completionHandler:(GTLServiceCompletionHandler)handler GTL_NONNULL((1)); + +- (GTLServiceTicket *)fetchObjectWithMethodNamed:(NSString *)methodName + insertingObject:(GTLObject *)bodyObject + objectClass:(Class)objectClass + completionHandler:(GTLServiceCompletionHandler)handler GTL_NONNULL((1)); + +- (GTLServiceTicket *)fetchObjectWithMethodNamed:(NSString *)methodName + parameters:(NSDictionary *)parameters + insertingObject:(GTLObject *)bodyObject + objectClass:(Class)objectClass + completionHandler:(GTLServiceCompletionHandler)handler GTL_NONNULL((1)); + +#pragma mark REST Fetch Methods + +- (GTLServiceTicket *)fetchObjectWithURL:(NSURL *)objectURL + delegate:(id)delegate + didFinishSelector:(SEL)finishedSelector GTL_NONNULL((1)); + +- (GTLServiceTicket *)fetchObjectWithURL:(NSURL *)objectURL + objectClass:(Class)objectClass + delegate:(id)delegate + didFinishSelector:(SEL)finishedSelector GTL_NONNULL((1)); + +- (GTLServiceTicket *)fetchPublicObjectWithURL:(NSURL *)objectURL + objectClass:(Class)objectClass + delegate:(id)delegate + didFinishSelector:(SEL)finishedSelector GTL_NONNULL((1)); + +- (GTLServiceTicket *)fetchObjectByInsertingObject:(GTLObject *)bodyToPut + forURL:(NSURL *)destinationURL + delegate:(id)delegate + didFinishSelector:(SEL)finishedSelector GTL_NONNULL((1,2)); + +- (GTLServiceTicket *)fetchObjectByUpdatingObject:(GTLObject *)bodyToPut + forURL:(NSURL *)destinationURL + delegate:(id)delegate + didFinishSelector:(SEL)finishedSelector GTL_NONNULL((1,2)); + +- (GTLServiceTicket *)deleteResourceURL:(NSURL *)destinationURL + ETag:(NSString *)etagOrNil + delegate:(id)delegate + didFinishSelector:(SEL)finishedSelector GTL_NONNULL((1)); + +- (GTLServiceTicket *)fetchObjectWithURL:(NSURL *)objectURL + completionHandler:(GTLServiceCompletionHandler)handler GTL_NONNULL((1)); + +- (GTLServiceTicket *)fetchObjectByInsertingObject:(GTLObject *)bodyToPut + forURL:(NSURL *)destinationURL + completionHandler:(GTLServiceCompletionHandler)handler GTL_NONNULL((1)); + +- (GTLServiceTicket *)fetchObjectByUpdatingObject:(GTLObject *)bodyToPut + forURL:(NSURL *)destinationURL + completionHandler:(GTLServiceCompletionHandler)handler GTL_NONNULL((1)); + +- (GTLServiceTicket *)deleteResourceURL:(NSURL *)destinationURL + ETag:(NSString *)etagOrNil + completionHandler:(GTLServiceCompletionHandler)handler GTL_NONNULL((1)); + +#pragma mark User Properties + +// Properties and userData are supported for client convenience. +// +// Property keys beginning with _ are reserved by the library. +// +// The service properties dictionary is copied to become the initial property +// dictionary for each ticket. +- (void)setServiceProperty:(id)obj forKey:(NSString *)key GTL_NONNULL((2)); // pass nil obj to remove property +- (id)servicePropertyForKey:(NSString *)key GTL_NONNULL((1)); + +@property (nonatomic, copy) NSDictionary *serviceProperties; + +// The service userData becomes the initial value for each future ticket's +// userData. +@property (nonatomic, retain) id serviceUserData; + +#pragma mark Request Settings + +// Set the surrogates to be used for future tickets. Surrogates are subclasses +// to be used instead of standard classes when creating objects from the JSON. +// For example, this code will make the framework generate objects +// using MyCalendarItemSubclass instead of GTLItemCalendar and +// MyCalendarEventSubclass instead of GTLItemCalendarEvent. +// +// NSDictionary *surrogates = [NSDictionary dictionaryWithObjectsAndKeys: +// [MyCalendarEntrySubclass class], [GTLItemCalendar class], +// [MyCalendarEventSubclass class], [GTLItemCalendarEvent class], +// nil]; +// [calendarService setServiceSurrogates:surrogates]; +// +@property (nonatomic, retain) NSDictionary *surrogates; + +// On iOS 4 and later, the fetch may optionally continue in the background +// until finished or stopped by OS expiration. +// +// The default value is NO. +// +// For Mac OS X, background fetches are always supported, and this property +// is ignored. +@property (nonatomic, assign) BOOL shouldFetchInBackground; + +// Callbacks can be invoked on an operation queue rather than via the run loop +// starting on 10.7 and iOS 6. Do not specify both run loop modes and an +// operation queue. Specifying a delegate queue typically looks like this: +// +// service.delegateQueue = [[[NSOperationQueue alloc] init] autorelease]; +// +// Since the callbacks will be on a thread of the operation queue, the client +// may re-dispatch from the callbacks to a known dispatch queue or to the +// main queue. +@property (nonatomic, retain) NSOperationQueue *delegateQueue; + +// Run loop modes are used for scheduling NSURLConnections. +// +// The default value, nil, schedules connections using the current run +// loop mode. To use the service during a modal dialog, be sure to specify +// NSModalPanelRunLoopMode as one of the modes. +@property (nonatomic, retain) NSArray *runLoopModes; + +// Normally, API requests must be made only via SSL to protect the user's +// data and the authentication token. This property allows the application +// to make non-SSL requests and localhost requests for testing. +// +// Defaults to NO. +@property (nonatomic, assign) BOOL allowInsecureQueries; + +// Applications needing an additional identifier in the server logs may specify +// one. +@property (nonatomic, copy) NSString *userAgentAddition; + +// Applications have a default user-agent based on the application signature +// in the Info.plist settings. Most applications should not explicitly set +// this property. +@property (nonatomic, copy) NSString *userAgent; + +// The request user agent includes the library and OS version appended to the +// base userAgent, along with the optional addition string. +@property (nonatomic, readonly) NSString *requestUserAgent; + +// Applications may call requestForURL:httpMethod to get a request with the +// proper user-agent and ETag headers +// +// For http method, pass nil (for default GET method), POST, PUT, or DELETE +- (NSMutableURLRequest *)requestForURL:(NSURL *)url + ETag:(NSString *)etagOrNil + httpMethod:(NSString *)httpMethodOrNil GTL_NONNULL((1)); + +// objectRequestForURL returns an NSMutableURLRequest for a JSON GTL object +// +// The object is the object being sent to the server, or nil; +// the http method may be nil for GET, or POST, PUT, DELETE +- (NSMutableURLRequest *)objectRequestForURL:(NSURL *)url + object:(GTLObject *)object + ETag:(NSString *)etag + httpMethod:(NSString *)httpMethod + isREST:(BOOL)isREST + additionalHeaders:(NSDictionary *)additionalHeaders + ticket:(GTLServiceTicket *)ticket GTL_NONNULL((1)); + +// The queue used for parsing JSON responses (previously this property +// was called operationQueue) +@property (nonatomic, retain) NSOperationQueue *parseQueue; + +// The fetcher service object issues the fetcher instances +// for this API service +@property (nonatomic, retain) GTMBridgeFetcherService *fetcherService; + +// Default storage for cookies is in the service object's fetchHistory. +// +// Apps that want to share cookies between all standalone fetchers and the +// service object may specify static application-wide cookie storage, +// kGTMHTTPFetcherCookieStorageMethodStatic. +#if !GTL_USE_SESSION_FETCHER +@property (nonatomic, assign) NSInteger cookieStorageMethod; +#endif + +// When sending REST style queries, should the payload be wrapped in a "data" +// element, and will the reply be wrapped in an "data" element. +@property (nonatomic, assign) BOOL isRESTDataWrapperRequired; + +// Any url query parameters to add to urls (useful for debugging with some +// services). +@property (copy) NSDictionary *urlQueryParameters; + +// Any extra http headers to set on requests for GTLObjects. +@property (copy) NSDictionary *additionalHTTPHeaders; + +// The service API version. +@property (nonatomic, copy) NSString *apiVersion; + +// The URL for sending RPC requests for this service. +@property (nonatomic, retain) NSURL *rpcURL; + +// The URL for sending RPC requests which initiate file upload. +@property (nonatomic, retain) NSURL *rpcUploadURL; + +// Set a non-zero value to enable uploading via chunked fetches +// (resumable uploads); typically this defaults to kGTLStandardUploadChunkSize +// for service subclasses that support chunked uploads +@property (nonatomic, assign) NSUInteger serviceUploadChunkSize; + +// Service subclasses may specify their own default chunk size ++ (NSUInteger)defaultServiceUploadChunkSize; + +// The service uploadProgressSelector becomes the initial value for each future +// ticket's uploadProgressSelector. +// +// The optional uploadProgressSelector will be called in the delegate as bytes +// are uploaded to the server. It should have a signature matching +// +// - (void)ticket:(GTLServiceTicket *)ticket +// hasDeliveredByteCount:(unsigned long long)numberOfBytesRead +// ofTotalByteCount:(unsigned long long)dataLength; +@property (nonatomic, assign) SEL uploadProgressSelector; + +@property (copy) GTLServiceUploadProgressBlock uploadProgressBlock; + +// Wait synchronously for fetch to complete (strongly discouraged) +// +// This just runs the current event loop until the fetch completes +// or the timout limit is reached. This may discard unexpected events +// that occur while spinning, so it's really not appropriate for use +// in serious applications. +// +// Returns true if an object was successfully fetched. If the wait +// timed out, returns false and the returned error is nil. +// +// The returned object or error, if any, will be already autoreleased +// +// This routine will likely be removed in some future releases of the library. +- (BOOL)waitForTicket:(GTLServiceTicket *)ticket + timeout:(NSTimeInterval)timeoutInSeconds + fetchedObject:(GTLObject **)outObjectOrNil + error:(NSError **)outErrorOrNil GTL_NONNULL((1)); +@end + +#pragma mark - + +// +// Ticket base class +// +@interface GTLServiceTicket : NSObject { + GTLService *service_; + + NSMutableDictionary *ticketProperties_; + NSDictionary *surrogates_; + + GTMBridgeFetcher *objectFetcher_; + SEL uploadProgressSelector_; + BOOL shouldFetchNextPages_; + BOOL isRetryEnabled_; + SEL retrySelector_; + NSTimeInterval maxRetryInterval_; + + GTLServiceRetryBlock retryBlock_; + GTLServiceUploadProgressBlock uploadProgressBlock_; + + GTLObject *postedObject_; + GTLObject *fetchedObject_; + id executingQuery_; + id originalQuery_; + NSError *fetchError_; + BOOL hasCalledCallback_; + NSUInteger pagesFetchedCounter_; + + NSString *apiKey_; + BOOL isREST_; + + NSOperation *parseOperation_; +} + ++ (id)ticketForService:(GTLService *)service; + +- (id)initWithService:(GTLService *)service; + +- (id)service; + +#pragma mark Execution Control +// if cancelTicket is called, the fetch is stopped if it is in progress, +// the callbacks will not be called, and the ticket will no longer be useful +// (though the client must still release the ticket if it retained the ticket) +- (void)cancelTicket; + +// chunked upload tickets may be paused +- (void)pauseUpload; +- (void)resumeUpload; +- (BOOL)isUploadPaused; + +@property (nonatomic, retain) GTMBridgeFetcher *objectFetcher; +@property (nonatomic, assign) SEL uploadProgressSelector; + +// Services which do not require an user authorization may require a developer +// API key for quota management +@property (nonatomic, copy) NSString *APIKey; + +#pragma mark User Properties + +// Properties and userData are supported for client convenience. +// +// Property keys beginning with _ are reserved by the library. +- (void)setProperty:(id)obj forKey:(NSString *)key GTL_NONNULL((1)); // pass nil obj to remove property +- (id)propertyForKey:(NSString *)key; + +@property (nonatomic, copy) NSDictionary *properties; +@property (nonatomic, retain) id userData; + +#pragma mark Payload + +@property (nonatomic, retain) GTLObject *postedObject; +@property (nonatomic, retain) GTLObject *fetchedObject; +@property (nonatomic, retain) id executingQuery; // Query currently being fetched by this ticket +@property (nonatomic, retain) id originalQuery; // Query used to create this ticket +- (GTLQuery *)queryForRequestID:(NSString *)requestID GTL_NONNULL((1)); // Returns the query from within the batch with the given id. + +@property (nonatomic, retain) NSDictionary *surrogates; + +#pragma mark Retry + +@property (nonatomic, assign, getter=isRetryEnabled) BOOL retryEnabled; +@property (nonatomic, assign) SEL retrySelector; +@property (copy) GTLServiceRetryBlock retryBlock; +@property (nonatomic, assign) NSTimeInterval maxRetryInterval; + +#pragma mark Status + +@property (nonatomic, readonly) NSInteger statusCode; // server status from object fetch +@property (nonatomic, retain) NSError *fetchError; +@property (nonatomic, assign) BOOL hasCalledCallback; + +#pragma mark Pagination + +@property (nonatomic, assign) BOOL shouldFetchNextPages; +@property (nonatomic, assign) NSUInteger pagesFetchedCounter; + +#pragma mark Upload + +@property (copy) GTLServiceUploadProgressBlock uploadProgressBlock; + +@end + + +// Category to provide opaque access to tickets stored in fetcher properties +@interface GTMBridgeFetcher (GTLServiceTicketAdditions) +- (id)ticket; +@end + diff --git a/XCDYouTubeKit Demo/Pods/Google-API-Client/Source/Objects/GTLService.m b/XCDYouTubeKit Demo/Pods/Google-API-Client/Source/Objects/GTLService.m new file mode 100644 index 00000000..c1ea5010 --- /dev/null +++ b/XCDYouTubeKit Demo/Pods/Google-API-Client/Source/Objects/GTLService.m @@ -0,0 +1,2524 @@ +/* Copyright (c) 2011 Google Inc. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +// +// GTLService.m +// + +#import +#if TARGET_OS_MAC +#include +#endif + +#if TARGET_OS_IPHONE +#import +#endif + +#import "GTLService.h" + +NSString* const kGTLServiceErrorDomain = @"com.google.GTLServiceDomain"; +NSString* const kGTLJSONRPCErrorDomain = @"com.google.GTLJSONRPCErrorDomain"; +NSString* const kGTLServerErrorStringKey = @"error"; +Class const kGTLUseRegisteredClass = nil; +NSUInteger const kGTLStandardUploadChunkSize = NSUIntegerMax; +NSString* const kGTLStructuredErrorKey = @"GTLStructuredError"; +NSString* const kGTLETagWildcard = @"*"; + +NSString* const kGTLServiceTicketParsingStartedNotification = @"kGTLServiceTicketParsingStartedNotification"; +NSString* const kGTLServiceTicketParsingStoppedNotification = @"kGTLServiceTicketParsingStoppedNotification"; + + +static NSString *const kServiceUserDataPropertyKey = @"_userData"; + +static NSString* const kFetcherDelegateKey = @"_delegate"; +static NSString* const kFetcherObjectClassKey = @"_objectClass"; +static NSString* const kFetcherFinishedSelectorKey = @"_finishedSelector"; +static NSString* const kFetcherCompletionHandlerKey = @"_completionHandler"; +static NSString* const kFetcherTicketKey = @"_ticket"; +static NSString* const kFetcherFetchErrorKey = @"_fetchError"; +static NSString* const kFetcherParsingNotificationKey = @"_parseNotification"; +static NSString* const kFetcherParsedObjectKey = @"_parsedObject"; +static NSString* const kFetcherBatchClassMapKey = @"_batchClassMap"; +static NSString* const kFetcherCallbackThreadKey = @"_callbackThread"; +static NSString* const kFetcherCallbackRunLoopModesKey = @"_runLoopModes"; + +static const NSUInteger kMaxNumberOfNextPagesFetched = 25; + +// we'll enforce 50K chunks minimum just to avoid the server getting hit +// with too many small upload chunks +static const NSUInteger kMinimumUploadChunkSize = 50000; +static const NSUInteger kStandardUploadChunkSize = NSUIntegerMax; + +// Helper to get the ETag if it is defined on an object. +static NSString *ETagIfPresent(GTLObject *obj) { + NSString *result = [obj.JSON objectForKey:@"etag"]; + return result; +} + +@interface GTLServiceTicket () +@property (retain) NSOperation *parseOperation; +@property (assign) BOOL isREST; +@end + +// category to provide opaque access to tickets stored in fetcher properties +@implementation GTMBridgeFetcher (GTLServiceTicketAdditions) +- (id)ticket { + return [self propertyForKey:kFetcherTicketKey]; +} +@end + +// If the upload fetcher class is available, it can be used for chunked uploads +// +// We locally declare some methods of the upload fetcher so we +// do not need to import the header, as some projects may not have it available +@interface GTLUploadFetcherClass : GTMBridgeFetcher + +#if GTL_USE_SESSION_FETCHER ++ (instancetype)uploadFetcherWithRequest:(NSURLRequest *)request + uploadMIMEType:(NSString *)uploadMIMEType + chunkSize:(int64_t)chunkSize + fetcherService:(GTMSessionFetcherService *)fetcherServiceOrNil; + ++ (instancetype)uploadFetcherWithLocation:(NSURL *)uploadLocationURL + uploadMIMEType:(NSString *)uploadMIMEType + chunkSize:(int64_t)chunkSize + fetcherService:(GTMSessionFetcherService *)fetcherServiceOrNil; + +@property(strong) NSURL *uploadLocationURL; +@property(strong) NSData *uploadData; +@property(strong) NSURL *uploadFileURL; +@property(strong) NSFileHandle *uploadFileHandle; +#else ++ (instancetype)uploadFetcherWithRequest:(NSURLRequest *)request + uploadData:(NSData *)data + uploadMIMEType:(NSString *)uploadMIMEType + chunkSize:(NSUInteger)chunkSize + fetcherService:(GTMBridgeFetcherService *)fetcherService; ++ (instancetype)uploadFetcherWithRequest:(NSURLRequest *)request + uploadFileHandle:(NSFileHandle *)uploadFileHandle + uploadMIMEType:(NSString *)uploadMIMEType + chunkSize:(NSUInteger)chunkSize + fetcherService:(GTMBridgeFetcherService *)fetcherService; +// Use the old fetcher. ++ (instancetype)uploadFetcherWithLocation:(NSURL *)location + uploadFileHandle:(NSFileHandle *)fileHandle + uploadMIMEType:(NSString *)uploadMIMEType + chunkSize:(NSUInteger)chunkSize + fetcherService:(GTMBridgeFetcherService *)fetcherService; +#endif // GTL_USE_SESSION_FETCHER + +- (void)pauseFetching; +- (void)resumeFetching; +- (BOOL)isPaused; +@end + + +@interface GTLService () +- (void)prepareToParseObjectForFetcher:(GTMBridgeFetcher *)fetcher; +- (void)handleParsedObjectForFetcher:(GTMBridgeFetcher *)fetcher; +- (BOOL)fetchNextPageWithQuery:(GTLQuery *)query + delegate:(id)delegate + didFinishedSelector:(SEL)finishedSelector + completionHandler:(GTLServiceCompletionHandler)completionHandler + ticket:(GTLServiceTicket *)ticket; +- (id )nextPageQueryForQuery:(GTLQuery *)query + result:(GTLObject *)object + ticket:(GTLServiceTicket *)ticket; +- (GTLObject *)mergedNewResultObject:(GTLObject *)newResult + oldResultObject:(GTLObject *)oldResult + forQuery:(GTLQuery *)query; +- (GTLUploadFetcherClass *)uploadFetcherWithRequest:(NSURLRequest *)request + fetcherService:(GTMBridgeFetcherService *)fetcherService + params:(GTLUploadParameters *)uploadParams; ++ (void)invokeCallback:(SEL)callbackSel + target:(id)target + ticket:(id)ticket + object:(id)object + error:(id)error; +- (BOOL)invokeRetrySelector:(SEL)retrySelector + delegate:(id)delegate + ticket:(GTLServiceTicket *)ticket + willRetry:(BOOL)willRetry + error:(NSError *)error; +- (BOOL)objectFetcher:(GTMBridgeFetcher *)fetcher + willRetry:(BOOL)willRetry + forError:(NSError *)error; +- (void)objectFetcher:(GTMBridgeFetcher *)fetcher + finishedWithData:(NSData *)data + error:(NSError *)error; +- (void)parseObjectFromDataOfFetcher:(GTMBridgeFetcher *)fetcher; +@end + +@interface GTLObject (StandardProperties) +@property (retain) NSString *ETag; +@property (retain) NSString *nextPageToken; +@property (retain) NSNumber *nextStartIndex; +@end + +@implementation GTLService + +@synthesize userAgentAddition = userAgentAddition_, + fetcherService = fetcherService_, + parseQueue = parseQueue_, + shouldFetchNextPages = shouldFetchNextPages_, + surrogates = surrogates_, + uploadProgressSelector = uploadProgressSelector_, + retryEnabled = isRetryEnabled_, + retrySelector = retrySelector_, + maxRetryInterval = maxRetryInterval_, + APIKey = apiKey_, + isRESTDataWrapperRequired = isRESTDataWrapperRequired_, + urlQueryParameters = urlQueryParameters_, + additionalHTTPHeaders = additionalHTTPHeaders_, + apiVersion = apiVersion_, + rpcURL = rpcURL_, + rpcUploadURL = rpcUploadURL_, + allowInsecureQueries = allowInsecureQueries_, + retryBlock = retryBlock_, + uploadProgressBlock = uploadProgressBlock_; + ++ (Class)ticketClass { + return [GTLServiceTicket class]; +} + +- (id)init { + self = [super init]; + if (self) { + +#if GTL_IPHONE || (MAC_OS_X_VERSION_MIN_REQUIRED > MAC_OS_X_VERSION_10_5) + // For 10.6 and up, always use an operation queue + parseQueue_ = [[NSOperationQueue alloc] init]; +#elif !GTL_SKIP_PARSE_THREADING + // Avoid NSOperationQueue prior to 10.5.6, per + // http://www.mikeash.com/?page=pyblog/use-nsoperationqueue.html + SInt32 bcdSystemVersion = 0; + (void) Gestalt(gestaltSystemVersion, &bcdSystemVersion); + + if (bcdSystemVersion >= 0x1057) { + parseQueue_ = [[NSOperationQueue alloc] init]; + } +#else + // parseQueue_ defaults to nil, so parsing will be done immediately + // on the current thread +#endif + + fetcherService_ = [[GTMBridgeFetcherService alloc] init]; + + NSUInteger chunkSize = [[self class] defaultServiceUploadChunkSize]; + self.serviceUploadChunkSize = chunkSize; + } + return self; +} + +- (void)dealloc { + [parseQueue_ release]; + [userAgent_ release]; + [fetcherService_ release]; + [userAgentAddition_ release]; + [serviceProperties_ release]; + [surrogates_ release]; + [uploadProgressBlock_ release]; + [retryBlock_ release]; + [apiKey_ release]; + [apiVersion_ release]; + [rpcURL_ release]; + [rpcUploadURL_ release]; + [urlQueryParameters_ release]; + [additionalHTTPHeaders_ release]; + + [super dealloc]; +} + +- (NSString *)requestUserAgent { + NSString *userAgent = self.userAgent; + if ([userAgent length] == 0) { + // the service instance is missing an explicit user-agent; use the bundle ID + // or process name + NSBundle *owningBundle = [NSBundle bundleForClass:[self class]]; + if (owningBundle == nil + || [[owningBundle bundleIdentifier] isEqual:@"com.google.GTLFramework"]) { + + owningBundle = [NSBundle mainBundle]; + } + + userAgent = GTMBridgeApplicationIdentifier(owningBundle); + } + + NSString *requestUserAgent = userAgent; + + // if the user agent already specifies the library version, we'll + // use it verbatim in the request + NSString *libraryString = @"google-api-objc-client"; + NSRange libRange = [userAgent rangeOfString:libraryString + options:NSCaseInsensitiveSearch]; + if (libRange.location == NSNotFound) { + // the user agent doesn't specify the client library, so append that + // information, and the system version + NSString *libVersionString = GTLFrameworkVersionString(); + + NSString *systemString = GTMBridgeSystemVersionString(); + + // We don't clean this with GTMCleanedUserAgentString so spaces are + // preserved + NSString *userAgentAddition = self.userAgentAddition; + NSString *customString = userAgentAddition ? + [@" " stringByAppendingString:userAgentAddition] : @""; + + // Google servers look for gzip in the user agent before sending gzip- + // encoded responses. See Service.java + requestUserAgent = [NSString stringWithFormat:@"%@ %@/%@ %@%@ (gzip)", + userAgent, libraryString, libVersionString, systemString, customString]; + } + return requestUserAgent; +} + +- (NSMutableURLRequest *)requestForURL:(NSURL *)url + ETag:(NSString *)etag + httpMethod:(NSString *)httpMethod + ticket:(GTLServiceTicket *)ticket { + + // subclasses may add headers to this + NSMutableURLRequest *request = [[[NSMutableURLRequest alloc] initWithURL:url + cachePolicy:NSURLRequestReloadIgnoringCacheData + timeoutInterval:60] autorelease]; + NSString *requestUserAgent = self.requestUserAgent; + [request setValue:requestUserAgent forHTTPHeaderField:@"User-Agent"]; + + if ([httpMethod length] > 0) { + [request setHTTPMethod:httpMethod]; + } + + if ([etag length] > 0) { + + // it's rather unexpected for an etagged object to be provided for a GET, + // but we'll check for an etag anyway, similar to HttpGDataRequest.java, + // and if present use it to request only an unchanged resource + + BOOL isDoingHTTPGet = (httpMethod == nil + || [httpMethod caseInsensitiveCompare:@"GET"] == NSOrderedSame); + + if (isDoingHTTPGet) { + + // set the etag header, even if weak, indicating we don't want + // another copy of the resource if it's the same as the object + [request setValue:etag forHTTPHeaderField:@"If-None-Match"]; + + } else { + + // if we're doing PUT or DELETE, set the etag header indicating + // we only want to update the resource if our copy matches the current + // one (unless the etag is weak and so shouldn't be a constraint at all) + BOOL isWeakETag = [etag hasPrefix:@"W/"]; + + BOOL isModifying = + [httpMethod caseInsensitiveCompare:@"PUT"] == NSOrderedSame + || [httpMethod caseInsensitiveCompare:@"DELETE"] == NSOrderedSame + || [httpMethod caseInsensitiveCompare:@"PATCH"] == NSOrderedSame; + + if (isModifying && !isWeakETag) { + [request setValue:etag forHTTPHeaderField:@"If-Match"]; + } + } + } + + return request; +} + +- (NSMutableURLRequest *)requestForURL:(NSURL *)url + ETag:(NSString *)etag + httpMethod:(NSString *)httpMethod { + // this public entry point authenticates from the service object but + // not from the auth token in the ticket + return [self requestForURL:url ETag:etag httpMethod:httpMethod ticket:nil]; +} + +// objectRequestForURL returns an NSMutableURLRequest for a GTLObject +// +// the object is the object being sent to the server, or nil; +// the http method may be nil for get, or POST, PUT, DELETE + +- (NSMutableURLRequest *)objectRequestForURL:(NSURL *)url + object:(GTLObject *)object + ETag:(NSString *)etag + httpMethod:(NSString *)httpMethod + isREST:(BOOL)isREST + additionalHeaders:(NSDictionary *)additionalHeaders + ticket:(GTLServiceTicket *)ticket { + if (object) { + // if the object being sent has an etag, add it to the request header to + // avoid retrieving a duplicate or to avoid writing over an updated + // version of the resource on the server + // + // Typically, delete requests will provide an explicit ETag parameter, and + // other requests will have the ETag carried inside the object being updated + if (etag == nil) { + SEL selEtag = @selector(ETag); + if ([object respondsToSelector:selEtag]) { + etag = [object performSelector:selEtag]; + } + } + } + + NSMutableURLRequest *request = [self requestForURL:url + ETag:etag + httpMethod:httpMethod + ticket:ticket]; + NSString *acceptValue; + NSString *contentTypeValue; + if (isREST) { + acceptValue = @"application/json"; + contentTypeValue = @"application/json; charset=utf-8"; + } else { + acceptValue = @"application/json-rpc"; + contentTypeValue = @"application/json-rpc; charset=utf-8"; + } + [request setValue:acceptValue forHTTPHeaderField:@"Accept"]; + [request setValue:contentTypeValue forHTTPHeaderField:@"Content-Type"]; + + [request setValue:@"no-cache" forHTTPHeaderField:@"Cache-Control"]; + + // Add the additional http headers from the service, and then from the query + NSDictionary *headers = self.additionalHTTPHeaders; + for (NSString *key in headers) { + NSString *value = [headers valueForKey:key]; + [request setValue:value forHTTPHeaderField:key]; + } + + headers = additionalHeaders; + for (NSString *key in headers) { + NSString *value = [headers valueForKey:key]; + [request setValue:value forHTTPHeaderField:key]; + } + + return request; +} + +#pragma mark - + +// common fetch starting method + +- (GTLServiceTicket *)fetchObjectWithURL:(NSURL *)targetURL + objectClass:(Class)objectClass + bodyObject:(GTLObject *)bodyObject + dataToPost:(NSData *)dataToPost + ETag:(NSString *)etag + httpMethod:(NSString *)httpMethod + mayAuthorize:(BOOL)mayAuthorize + isREST:(BOOL)isREST + delegate:(id)delegate + didFinishSelector:(SEL)finishedSelector + completionHandler:(id)completionHandler // GTLServiceCompletionHandler + executingQuery:(id)query + ticket:(GTLServiceTicket *)ticket { + + GTMBridgeAssertValidSelector(delegate, finishedSelector, @encode(GTLServiceTicket *), @encode(GTLObject *), @encode(NSError *), 0); + + // The completionHandler argument is declared as an id, not as a block + // pointer, so this can be built with the 10.6 SDK and still run on 10.5. + // If the argument were declared as a block pointer, the invocation for + // fetchObjectWithURL: created in GTLService would cause an exception + // since 10.5's NSInvocation cannot deal with encoding of block pointers. + + GTL_DEBUG_ASSERT(targetURL != nil, @"no url?"); + if (targetURL == nil) return nil; + + // we need to create a ticket unless one was created earlier (like during + // authentication) + if (!ticket) { + ticket = [[[self class] ticketClass] ticketForService:self]; + } + + ticket.isREST = isREST; + + // Add any service specific query parameters. + NSDictionary *urlQueryParameters = self.urlQueryParameters; + if ([urlQueryParameters count] > 0) { + targetURL = [GTLUtilities URLWithString:[targetURL absoluteString] + queryParameters:urlQueryParameters]; + } + + // If this is REST and there is a developer key, add it onto the url. RPC + // adds the key into the payload, not on the url. + NSString *apiKey = self.APIKey; + if (isREST && [apiKey length] > 0) { + NSString *const kDeveloperAPIQueryParamKey = @"key"; + NSDictionary *queryParameters; + queryParameters = [NSDictionary dictionaryWithObject:apiKey + forKey:kDeveloperAPIQueryParamKey]; + targetURL = [GTLUtilities URLWithString:[targetURL absoluteString] + queryParameters:queryParameters]; + } + + NSDictionary *additionalHeaders = query.additionalHTTPHeaders; + + NSMutableURLRequest *request = [self objectRequestForURL:targetURL + object:bodyObject + ETag:etag + httpMethod:httpMethod + isREST:isREST + additionalHeaders:additionalHeaders + ticket:ticket]; + + GTMBridgeAssertValidSelector(delegate, ticket.uploadProgressSelector, + @encode(GTLServiceTicket *), @encode(unsigned long long), + @encode(unsigned long long), 0); + GTMBridgeAssertValidSelector(delegate, ticket.retrySelector, + @encode(GTLServiceTicket *), @encode(BOOL), @encode(NSError *), 0); + + ticket.postedObject = bodyObject; + + ticket.executingQuery = query; + if (ticket.originalQuery == nil) { + ticket.originalQuery = query; + } + + GTMBridgeFetcherService *fetcherService = self.fetcherService; + GTMBridgeFetcher *fetcher; + + GTLUploadParameters *uploadParams = query.uploadParameters; + if (uploadParams == nil) { + // Not uploading a file with this request + fetcher = [fetcherService fetcherWithRequest:request]; + } else { + fetcher = [self uploadFetcherWithRequest:request + fetcherService:fetcherService + params:uploadParams]; + } + + if (self.allowInsecureQueries) { + fetcher.allowLocalhostRequest = YES; + fetcher.allowedInsecureSchemes = @[ @"http" ]; + } + + if (finishedSelector) { + // if we don't have a method name, default to the finished selector as + // a useful fetcher log comment + fetcher.comment = NSStringFromSelector(finishedSelector); + } + + // allow the user to specify static app-wide cookies for fetching +#if !GTL_USE_SESSION_FETCHER + NSInteger cookieStorageMethod = [self cookieStorageMethod]; + if (cookieStorageMethod >= 0) { + fetcher.cookieStorageMethod = cookieStorageMethod; + } +#endif + + if (!mayAuthorize) { + fetcher.authorizer = nil; + } + + // copy the ticket's retry settings into the fetcher + fetcher.retryEnabled = ticket.retryEnabled; + fetcher.maxRetryInterval = ticket.maxRetryInterval; + + BOOL shouldExamineRetries; + shouldExamineRetries = (ticket.retrySelector != nil + || ticket.retryBlock != nil); + if (shouldExamineRetries) { +#if GTL_USE_SESSION_FETCHER + __block GTMBridgeFetcher *fetcherRef = fetcher; + fetcher.retryBlock = ^(BOOL suggestedWillRetry, NSError *error, + GTMSessionFetcherRetryResponse response) { + BOOL shouldRetry = [self objectFetcher:fetcherRef + willRetry:suggestedWillRetry + forError:error]; + response(shouldRetry); + }; +#else + [fetcher setRetrySelector:@selector(objectFetcher:willRetry:forError:)]; +#endif + } + + // remember the object fetcher in the ticket + ticket.objectFetcher = fetcher; + + // add parameters used by the callbacks + + [fetcher setProperty:objectClass forKey:kFetcherObjectClassKey]; + + [fetcher setProperty:delegate forKey:kFetcherDelegateKey]; + + [fetcher setProperty:NSStringFromSelector(finishedSelector) + forKey:kFetcherFinishedSelectorKey]; + + [fetcher setProperty:ticket + forKey:kFetcherTicketKey]; + + // copy the completion handler block to the heap; this does nothing if the + // block is already on the heap + completionHandler = [[completionHandler copy] autorelease]; + [fetcher setProperty:completionHandler + forKey:kFetcherCompletionHandlerKey]; + + // set the upload data + fetcher.bodyData = dataToPost; +#if GTL_USE_SESSION_FETCHER + BOOL didFetch = YES; + [fetcher beginFetchWithDelegate:self + didFinishSelector:@selector(objectFetcher:finishedWithData:error:)]; +#else + // failed fetches call the failure selector, which will delete the ticket + BOOL didFetch = [fetcher beginFetchWithDelegate:self + didFinishSelector:@selector(objectFetcher:finishedWithData:error:)]; +#endif + + // If something weird happens and the networking callbacks have been called + // already synchronously, we don't want to return the ticket since the caller + // will never know when to stop retaining it, so we'll make sure the + // success/failure callbacks have not yet been called by checking the + // ticket + if (!didFetch || ticket.hasCalledCallback) { + fetcher.properties = nil; + return nil; + } + + return ticket; +} + +- (GTLUploadFetcherClass *)uploadFetcherWithRequest:(NSURLRequest *)request + fetcherService:(GTMBridgeFetcherService *)fetcherService + params:(GTLUploadParameters *)uploadParams { + // Hang on to the user's requested chunk size, and ensure it's not tiny + NSUInteger uploadChunkSize = [self serviceUploadChunkSize]; + if (uploadChunkSize < kMinimumUploadChunkSize) { + uploadChunkSize = kMinimumUploadChunkSize; + } + +#ifdef GTL_TARGET_NAMESPACE + // Prepend the class name prefix + Class uploadClass = NSClassFromString(@GTL_TARGET_NAMESPACE_STRING + @"_" GTLUploadFetcherClassStr); +#else + Class uploadClass = NSClassFromString(GTLUploadFetcherClassStr); +#endif + GTL_ASSERT(uploadClass != nil, GTLUploadFetcherClassStr @" needed"); + + NSString *uploadMIMEType = uploadParams.MIMEType; + NSData *uploadData = uploadParams.data; +#if GTL_USE_SESSION_FETCHER + NSURL *uploadFileURL = uploadParams.fileURL; +#endif + NSFileHandle *uploadFileHandle = uploadParams.fileHandle; + NSURL *uploadLocationURL = uploadParams.uploadLocationURL; + + // Create the upload fetcher. + GTLUploadFetcherClass *fetcher; +#if GTL_USE_SESSION_FETCHER + if (uploadLocationURL) { + // Resuming with the session fetcher and a file URL. + GTL_DEBUG_ASSERT(uploadFileURL != nil, @"Resume requires a file URL"); + fetcher = [uploadClass uploadFetcherWithLocation:uploadLocationURL + uploadMIMEType:uploadMIMEType + chunkSize:(int64_t)uploadChunkSize + fetcherService:fetcherService]; + fetcher.uploadFileURL = uploadFileURL; + } else { + fetcher = [uploadClass uploadFetcherWithRequest:request + uploadMIMEType:uploadMIMEType + chunkSize:(int64_t)uploadChunkSize + fetcherService:fetcherService]; + if (uploadFileURL) { + fetcher.uploadFileURL = uploadFileURL; + } else if (uploadData) { + fetcher.uploadData = uploadData; + } else if (uploadFileHandle) { + fetcher.uploadFileHandle = uploadFileHandle; + } + } +#else // !GTL_USE_SESSION_FETCHER + if (uploadLocationURL) { + // Resuming with the session fetcher and a file handle. + GTL_DEBUG_ASSERT(uploadFileHandle != nil, + @"Resume requires a file handle"); + fetcher = [uploadClass uploadFetcherWithLocation:uploadLocationURL + uploadFileHandle:uploadFileHandle + uploadMIMEType:uploadMIMEType + chunkSize:uploadChunkSize + fetcherService:fetcherService]; + } else if (uploadData) { + fetcher = [uploadClass uploadFetcherWithRequest:request + uploadData:uploadData + uploadMIMEType:uploadMIMEType + chunkSize:uploadChunkSize + fetcherService:fetcherService]; + } else { + fetcher = [uploadClass uploadFetcherWithRequest:request + uploadFileHandle:uploadFileHandle + uploadMIMEType:uploadMIMEType + chunkSize:uploadChunkSize + fetcherService:fetcherService]; + } +#endif // GTL_USE_SESSION_FETCHER + + NSString *slug = [uploadParams slug]; + if ([slug length] > 0) { + [[fetcher mutableRequest] setValue:slug forHTTPHeaderField:@"Slug"]; + } + return fetcher; +} + +#pragma mark - + +// RPC fetch methods + +- (NSDictionary *)rpcPayloadForMethodNamed:(NSString *)methodName + parameters:(NSDictionary *)parameters + bodyObject:(GTLObject *)bodyObject + requestID:(NSString *)requestID { + GTL_DEBUG_ASSERT([requestID length] > 0, @"Got an empty request id"); + + // First, merge the developer key and bodyObject into the parameters. + + NSString *apiKey = self.APIKey; + NSUInteger apiKeyLen = [apiKey length]; + + NSString *const kDeveloperAPIParamKey = @"key"; + NSString *const kBodyObjectParamKey = @"resource"; + + NSDictionary *finalParams; + if ((apiKeyLen == 0) && (bodyObject == nil)) { + // Nothing needs to be added, just send the dict along. + finalParams = parameters; + } else { + NSMutableDictionary *worker = [NSMutableDictionary dictionary]; + if ([parameters count] > 0) { + [worker addEntriesFromDictionary:parameters]; + } + if ((apiKeyLen > 0) + && ([worker objectForKey:kDeveloperAPIParamKey] == nil)) { + [worker setObject:apiKey forKey:kDeveloperAPIParamKey]; + } + if (bodyObject != nil) { + GTL_DEBUG_ASSERT([parameters objectForKey:kBodyObjectParamKey] == nil, + @"There was already something under the 'data' key?!"); + NSMutableDictionary *json = [bodyObject JSON]; + if (json != nil) { + [worker setObject:json forKey:kBodyObjectParamKey]; + } + } + finalParams = worker; + } + + // Now, build up the full dictionary for the JSON-RPC (this is the body of + // the HTTP PUT). + + // Spec calls for the jsonrpc entry. Google doesn't require it, but include + // it so the code can work with other servers. + NSMutableDictionary *rpcPayload = [NSMutableDictionary dictionaryWithObjectsAndKeys: + @"2.0", @"jsonrpc", + methodName, @"method", + requestID, @"id", + nil]; + + // Google extension, provide the version of the api. + NSString *apiVersion = self.apiVersion; + if ([apiVersion length] > 0) { + [rpcPayload setObject:apiVersion forKey:@"apiVersion"]; + } + + if ([finalParams count] > 0) { + [rpcPayload setObject:finalParams forKey:@"params"]; + } + + return rpcPayload; +} + +- (GTLServiceTicket *)fetchObjectWithMethodNamed:(NSString *)methodName + objectClass:(Class)objectClass + parameters:(NSDictionary *)parameters + bodyObject:(GTLObject *)bodyObject + requestID:(NSString *)requestID + urlQueryParameters:(NSDictionary *)urlQueryParameters + delegate:(id)delegate + didFinishSelector:(SEL)finishedSelector + completionHandler:(id)completionHandler // GTLServiceCompletionHandler + executingQuery:(id)executingQuery + ticket:(GTLServiceTicket *)ticket { + GTL_DEBUG_ASSERT([methodName length] > 0, @"Got an empty method name"); + if ([methodName length] == 0) return nil; + + // If we didn't get a requestID, assign one (call came from one of the public + // calls that doesn't take a GTLQuery object). + if (requestID == nil) { + requestID = [GTLQuery nextRequestID]; + } + + NSData *dataToPost = nil; + GTLUploadParameters *uploadParameters = executingQuery.uploadParameters; + BOOL shouldSendBody = !uploadParameters.shouldSendUploadOnly; + if (shouldSendBody) { + NSDictionary *rpcPayload = [self rpcPayloadForMethodNamed:methodName + parameters:parameters + bodyObject:bodyObject + requestID:requestID]; + + NSError *error = nil; + dataToPost = [GTLJSONParser dataWithObject:rpcPayload + humanReadable:NO + error:&error]; + if (dataToPost == nil) { + // There is the chance something went into parameters that wasn't valid. + GTL_DEBUG_LOG(@"JSON generation error: %@", error); + return nil; + } + } + + BOOL isUploading = (uploadParameters != nil); + NSURL *rpcURL = (isUploading ? self.rpcUploadURL : self.rpcURL); + + if ([urlQueryParameters count] > 0) { + rpcURL = [GTLUtilities URLWithString:[rpcURL absoluteString] + queryParameters:urlQueryParameters]; + } + + BOOL mayAuthorize = (executingQuery ? + !executingQuery.shouldSkipAuthorization : YES); + + GTLServiceTicket *resultTicket = [self fetchObjectWithURL:rpcURL + objectClass:objectClass + bodyObject:bodyObject + dataToPost:dataToPost + ETag:nil + httpMethod:@"POST" + mayAuthorize:mayAuthorize + isREST:NO + delegate:delegate + didFinishSelector:finishedSelector + completionHandler:completionHandler + executingQuery:executingQuery + ticket:ticket]; + + // Set the fetcher log comment to default to the method name + NSUInteger pageNumber = resultTicket.pagesFetchedCounter; + if (pageNumber == 0) { + resultTicket.objectFetcher.comment = methodName; + } else { + // Also put the page number in the log comment + [resultTicket.objectFetcher setCommentWithFormat:@"%@ (page %lu)", + methodName, (unsigned long) (pageNumber + 1)]; + } + + return resultTicket; +} + +- (GTLServiceTicket *)executeBatchQuery:(GTLBatchQuery *)batch + delegate:(id)delegate + didFinishSelector:(SEL)finishedSelector + completionHandler:(id)completionHandler // GTLServiceCompletionHandler + ticket:(GTLServiceTicket *)ticket { + GTLBatchQuery *batchCopy = [[batch copy] autorelease]; + NSArray *queries = batchCopy.queries; + NSUInteger numberOfQueries = [queries count]; + if (numberOfQueries == 0) return nil; + + // Build up the array of RPC calls. + NSMutableArray *rpcPayloads = [NSMutableArray arrayWithCapacity:numberOfQueries]; + NSMutableSet *requestIDs = [NSMutableSet setWithCapacity:numberOfQueries]; + for (GTLQuery *query in queries) { + NSString *methodName = query.methodName; + NSDictionary *parameters = query.JSON; + GTLObject *bodyObject = query.bodyObject; + NSString *requestID = query.requestID; + + if ([methodName length] == 0 || [requestID length] == 0) { + GTL_DEBUG_ASSERT(0, @"Invalid query - id:%@ method:%@", + requestID, methodName); + return nil; + } + + GTL_DEBUG_ASSERT(query.additionalHTTPHeaders == nil, + @"additionalHTTPHeaders disallowed on queries added to a batch - query %@ (%@)", + requestID, methodName); + + GTL_DEBUG_ASSERT(query.urlQueryParameters == nil, + @"urlQueryParameters disallowed on queries added to a batch - query %@ (%@)", + requestID, methodName); + + GTL_DEBUG_ASSERT(query.uploadParameters == nil, + @"uploadParameters disallowed on queries added to a batch - query %@ (%@)", + requestID, methodName); + + NSDictionary *rpcPayload = [self rpcPayloadForMethodNamed:methodName + parameters:parameters + bodyObject:bodyObject + requestID:requestID]; + [rpcPayloads addObject:rpcPayload]; + + if ([requestIDs containsObject:requestID]) { + GTL_DEBUG_LOG(@"Duplicate request id in batch: %@", requestID); + return nil; + } + [requestIDs addObject:requestID]; + } + + NSError *error = nil; + NSData *dataToPost = nil; + dataToPost = [GTLJSONParser dataWithObject:rpcPayloads + humanReadable:NO + error:&error]; + if (dataToPost == nil) { + // There is the chance something went into parameters that wasn't valid. + GTL_DEBUG_LOG(@"JSON generation error: %@", error); + return nil; + } + + BOOL mayAuthorize = (batchCopy ? !batchCopy.shouldSkipAuthorization : YES); + + NSURL *rpcURL = self.rpcURL; + + // We'll use the batch query's URL parameters, and ignore the URL parameters + // specified on the individual queries. + NSDictionary *urlQueryParameters = batch.urlQueryParameters; + if ([urlQueryParameters count] > 0) { + rpcURL = [GTLUtilities URLWithString:[rpcURL absoluteString] + queryParameters:urlQueryParameters]; + } + + GTLServiceTicket *resultTicket = [self fetchObjectWithURL:rpcURL + objectClass:[GTLBatchResult class] + bodyObject:nil + dataToPost:dataToPost + ETag:nil + httpMethod:@"POST" + mayAuthorize:mayAuthorize + isREST:NO + delegate:delegate + didFinishSelector:finishedSelector + completionHandler:completionHandler + executingQuery:batch + ticket:ticket]; + +#if !STRIP_GTM_FETCH_LOGGING + // Set the fetcher log comment + // + // Because this has expensive set operations, it's conditionally + // compiled in + NSArray *methodNames = [queries valueForKey:@"methodName"]; + methodNames = [[NSSet setWithArray:methodNames] allObjects]; // de-dupe + NSString *methodsStr = [methodNames componentsJoinedByString:@", "]; + + NSUInteger pageNumber = ticket.pagesFetchedCounter; + NSString *pageStr = @""; + if (pageNumber > 0) { + pageStr = [NSString stringWithFormat:@"page %lu, ", + (unsigned long) pageNumber + 1]; + } + [resultTicket.objectFetcher setCommentWithFormat:@"batch: %@ (%@%lu queries)", + methodsStr, pageStr, (unsigned long) numberOfQueries]; +#endif + + return resultTicket; +} + + +#pragma mark - + +// REST fetch methods + +- (GTLServiceTicket *)fetchObjectWithURL:(NSURL *)targetURL + objectClass:(Class)objectClass + bodyObject:(GTLObject *)bodyObject + ETag:(NSString *)etag + httpMethod:(NSString *)httpMethod + mayAuthorize:(BOOL)mayAuthorize + delegate:(id)delegate + didFinishSelector:(SEL)finishedSelector + completionHandler:(id)completionHandler // GTLServiceCompletionHandler + ticket:(GTLServiceTicket *)ticket { + // if no URL was supplied, treat this as if the fetch failed (below) + // and immediately return a nil ticket, skipping the callbacks + // + // this might be considered normal (say, updating a read-only entry + // that lacks an edit link) though higher-level calls may assert or + // return errors depending on the specific usage + if (targetURL == nil) return nil; + + NSData *dataToPost = nil; + if (bodyObject != nil) { + NSError *error = nil; + + NSDictionary *whatToSend; + NSDictionary *json = bodyObject.JSON; + if (isRESTDataWrapperRequired_) { + // create the top-level "data" object + NSDictionary *dataDict = [NSDictionary dictionaryWithObject:json + forKey:@"data"]; + whatToSend = dataDict; + } else { + whatToSend = json; + } + dataToPost = [GTLJSONParser dataWithObject:whatToSend + humanReadable:NO + error:&error]; + if (dataToPost == nil) { + GTL_DEBUG_LOG(@"JSON generation error: %@", error); + } + } + + return [self fetchObjectWithURL:targetURL + objectClass:objectClass + bodyObject:bodyObject + dataToPost:dataToPost + ETag:etag + httpMethod:httpMethod + mayAuthorize:mayAuthorize + isREST:YES + delegate:delegate + didFinishSelector:finishedSelector + completionHandler:completionHandler + executingQuery:nil + ticket:ticket]; +} + +- (void)invokeProgressCallbackForTicket:(GTLServiceTicket *)ticket + deliveredBytes:(unsigned long long)numReadSoFar + totalBytes:(unsigned long long)total { + + SEL progressSelector = [ticket uploadProgressSelector]; + if (progressSelector) { + + GTMBridgeFetcher *fetcher = ticket.objectFetcher; + id delegate = [fetcher propertyForKey:kFetcherDelegateKey]; + + NSMethodSignature *signature = [delegate methodSignatureForSelector:progressSelector]; + NSInvocation *invocation = [NSInvocation invocationWithMethodSignature:signature]; + + [invocation setSelector:progressSelector]; + [invocation setTarget:delegate]; + [invocation setArgument:&ticket atIndex:2]; + [invocation setArgument:&numReadSoFar atIndex:3]; + [invocation setArgument:&total atIndex:4]; + [invocation invoke]; + } + + GTLServiceUploadProgressBlock block = ticket.uploadProgressBlock; + if (block) { + block(ticket, numReadSoFar, total); + } +} + +// sentData callback from fetcher +- (void)objectFetcher:(GTMBridgeFetcher *)fetcher + didSendBytes:(NSInteger)bytesSent + totalBytesSent:(NSInteger)totalBytesSent +totalBytesExpectedToSend:(NSInteger)totalBytesExpected { + + GTLServiceTicket *ticket = [fetcher propertyForKey:kFetcherTicketKey]; + + [self invokeProgressCallbackForTicket:ticket + deliveredBytes:(unsigned long long)totalBytesSent + totalBytes:(unsigned long long)totalBytesExpected]; +} + +- (void)objectFetcher:(GTMBridgeFetcher *)fetcher finishedWithData:(NSData *)data error:(NSError *)error { + // we now have the JSON data for an object, or an error + if (error == nil) { + if ([data length] > 0) { + [self prepareToParseObjectForFetcher:fetcher]; + } else { + // no data (such as when deleting) + [self handleParsedObjectForFetcher:fetcher]; + } + } else { + // There was an error from the fetch + NSInteger status = [error code]; + if (status >= 300) { + // Return the HTTP error status code along with a more descriptive error + // from within the HTTP response payload. + NSData *responseData = fetcher.downloadedData; + if ([responseData length] > 0) { + NSDictionary *responseHeaders = fetcher.responseHeaders; + NSString *contentType = [responseHeaders objectForKey:@"Content-Type"]; + + if ([data length] > 0) { + if ([contentType hasPrefix:@"application/json"]) { + NSError *parseError = nil; + NSMutableDictionary *jsonWrapper = [GTLJSONParser objectWithData:data + error:&parseError]; + if (parseError) { + // We could not parse the JSON payload + error = parseError; + } else { + // Convert the JSON error payload into a structured error + NSMutableDictionary *errorJSON = [jsonWrapper valueForKey:@"error"]; + GTLErrorObject *errorObject = [GTLErrorObject objectWithJSON:errorJSON]; + error = [errorObject foundationError]; + } + } else { + // No structured JSON error was available; make a plaintext server + // error response visible in the error object. + NSString *reasonStr = [[[NSString alloc] initWithData:data + encoding:NSUTF8StringEncoding] autorelease]; + NSDictionary *userInfo = [NSDictionary dictionaryWithObject:reasonStr + forKey:NSLocalizedFailureReasonErrorKey]; + error = [NSError errorWithDomain:kGTMBridgeFetcherStatusDomain + code:status + userInfo:userInfo]; + } + } else { + // Response data length is zero; we'll settle for returning the + // fetcher's error. + } + } + } + + // store the error, call the callbacks, and bail + [fetcher setProperty:error + forKey:kFetcherFetchErrorKey]; + + [self handleParsedObjectForFetcher:fetcher]; + } +} + +// Three methods handle parsing of the fetched JSON data: +// - prepareToParse posts a start notification and then spawns off parsing +// on the operation queue (if there's an operation queue) +// - parseObject does the parsing of the JSON string +// - handleParsedObject posts the stop notification and calls the callback +// with the parsed object or an error +// +// The middle method may run on a separate thread. + +- (void)prepareToParseObjectForFetcher:(GTMBridgeFetcher *)fetcher { + // save the current thread into the fetcher, since we'll handle additional + // fetches and callbacks on this thread + [fetcher setProperty:[NSThread currentThread] + forKey:kFetcherCallbackThreadKey]; + + // copy the run loop modes, if any, so we don't need to access them + // from the parsing thread + [fetcher setProperty:[[[self runLoopModes] copy] autorelease] + forKey:kFetcherCallbackRunLoopModesKey]; + + // we post parsing notifications now to ensure they're on caller's + // original thread + GTLServiceTicket *ticket = [fetcher propertyForKey:kFetcherTicketKey]; + NSNotificationCenter *defaultNC = [NSNotificationCenter defaultCenter]; + [defaultNC postNotificationName:kGTLServiceTicketParsingStartedNotification + object:ticket]; + [fetcher setProperty:@"1" + forKey:kFetcherParsingNotificationKey]; + + id executingQuery = ticket.executingQuery; + if ([executingQuery isBatchQuery]) { + // build a dictionary of expected classes for the batch responses + GTLBatchQuery *batchQuery = executingQuery; + NSArray *queries = batchQuery.queries; + NSDictionary *batchClassMap = [NSMutableDictionary dictionaryWithCapacity:[queries count]]; + for (GTLQuery *query in queries) { + [batchClassMap setValue:query.expectedObjectClass + forKey:query.requestID]; + } + [fetcher setProperty:batchClassMap + forKey:kFetcherBatchClassMapKey]; + } + + // if there's an operation queue, then use that to schedule parsing on another + // thread + SEL parseSel = @selector(parseObjectFromDataOfFetcher:); + NSOperationQueue *queue = self.parseQueue; + if (queue) { + NSInvocationOperation *op; + op = [[[NSInvocationOperation alloc] initWithTarget:self + selector:parseSel + object:fetcher] autorelease]; + ticket.parseOperation = op; + [queue addOperation:op]; + // the fetcher now belongs to the parsing thread + } else { + // parse on the current thread, on Mac OS X 10.4 through 10.5.7 + // or when the project defines GTL_SKIP_PARSE_THREADING + [self performSelector:parseSel + withObject:fetcher]; + } +} + +- (void)parseObjectFromDataOfFetcher:(GTMBridgeFetcher *)fetcher { + // This method runs in a separate thread + + // Generally protect the fetcher properties, since canceling a ticket would + // release the fetcher properties dictionary +#if GTL_USE_SESSION_FETCHER + NSDictionary *properties = [[fetcher.properties copy] autorelease]; +#else + NSMutableDictionary *properties = [[fetcher.properties retain] autorelease]; +#endif + + // The callback thread is retaining the fetcher, so the fetcher shouldn't keep + // retaining the callback thread + NSThread *callbackThread = [properties valueForKey:kFetcherCallbackThreadKey]; + [[callbackThread retain] autorelease]; + [fetcher setProperty:nil forKey:kFetcherCallbackThreadKey]; + + GTLServiceTicket *ticket = [properties valueForKey:kFetcherTicketKey]; + [[ticket retain] autorelease]; + + NSDictionary *responseHeaders = fetcher.responseHeaders; + NSString *contentType = [responseHeaders objectForKey:@"Content-Type"]; + NSData *data = fetcher.downloadedData; + + NSOperation *parseOperation = ticket.parseOperation; + + BOOL hasData = [data length] > 0; + BOOL isJSON = [contentType hasPrefix:@"application/json"]; + GTL_DEBUG_ASSERT(isJSON || !hasData, @"Got unexpected content type '%@'", contentType); + + if (hasData && isJSON) { +#if GTL_LOG_PERFORMANCE + NSTimeInterval secs1, secs2; + secs1 = [NSDate timeIntervalSinceReferenceDate]; +#endif + + NSError *parseError = nil; + NSMutableDictionary *jsonWrapper = [GTLJSONParser objectWithData:data + error:&parseError]; + if ([parseOperation isCancelled]) return; + + if (parseError != nil) { + [fetcher setProperty:parseError forKey:kFetcherFetchErrorKey]; + } else { + NSMutableDictionary *json; + NSDictionary *batchClassMap = nil; + + // In theory, just checking for "application/json-rpc" vs + // "application/json" would work. But the JSON-RPC spec allows for + // "application/json" also so we have to carry a flag all the way in + // saying which type of result to expect and process as. + BOOL isREST = ticket.isREST; + if (isREST) { + if (isRESTDataWrapperRequired_) { + json = [jsonWrapper valueForKey:@"data"]; + } else { + json = jsonWrapper; + } + } else { + batchClassMap = [properties valueForKey:kFetcherBatchClassMapKey]; + if (batchClassMap) { + // A batch gets the whole array as it's json. + json = jsonWrapper; + } else { + json = [jsonWrapper valueForKey:@"result"]; + } + } + + if (json != nil) { + Class defaultClass = [properties valueForKey:kFetcherObjectClassKey]; + NSDictionary *surrogates = ticket.surrogates; + + GTLObject *parsedObject = [GTLObject objectForJSON:json + defaultClass:defaultClass + surrogates:surrogates + batchClassMap:batchClassMap]; + + [fetcher setProperty:parsedObject forKey:kFetcherParsedObjectKey]; + } else if (!isREST) { + NSMutableDictionary *errorJSON = [jsonWrapper valueForKey:@"error"]; + GTL_DEBUG_ASSERT(errorJSON != nil, @"no result or error in response:\n%@", + jsonWrapper); + GTLErrorObject *errorObject = [GTLErrorObject objectWithJSON:errorJSON]; + NSError *error = [errorObject foundationError]; + + // Store the error and let it go to the callback + [fetcher setProperty:error + forKey:kFetcherFetchErrorKey]; + } + } + +#if GTL_LOG_PERFORMANCE + secs2 = [NSDate timeIntervalSinceReferenceDate]; + NSLog(@"allocation of %@ took %f seconds", objectClass, secs2 - secs1); +#endif + } + + if ([parseOperation isCancelled]) return; + + SEL parseDoneSel = @selector(handleParsedObjectForFetcher:); + NSArray *runLoopModes = [properties valueForKey:kFetcherCallbackRunLoopModesKey]; + // If this callback was enqueued, then the fetcher has already released + // its delegateQueue. We'll use our own delegateQueue to determine how to + // invoke the callbacks. + NSOperationQueue *delegateQueue = self.delegateQueue; + if (delegateQueue) { + NSInvocationOperation *op; + op = [[[NSInvocationOperation alloc] initWithTarget:self + selector:parseDoneSel + object:fetcher] autorelease]; + [delegateQueue addOperation:op]; + } else if (runLoopModes) { + [self performSelector:parseDoneSel + onThread:callbackThread + withObject:fetcher + waitUntilDone:NO + modes:runLoopModes]; + } else { + // Defaults to common modes + [self performSelector:parseDoneSel + onThread:callbackThread + withObject:fetcher + waitUntilDone:NO]; + } + // the fetcher now belongs to the callback thread +} + +- (void)handleParsedObjectForFetcher:(GTMBridgeFetcher *)fetcher { + // After parsing is complete, this is invoked on the thread that the + // fetch was performed on + // + // There may not be an object due to a fetch or parsing error + + GTLServiceTicket *ticket = [fetcher propertyForKey:kFetcherTicketKey]; + ticket.parseOperation = nil; + + // unpack the callback parameters + id delegate = [fetcher propertyForKey:kFetcherDelegateKey]; + NSString *selString = [fetcher propertyForKey:kFetcherFinishedSelectorKey]; + SEL finishedSelector = NSSelectorFromString(selString); + + GTLServiceCompletionHandler completionHandler; + completionHandler = [fetcher propertyForKey:kFetcherCompletionHandlerKey]; + + GTLObject *object = [fetcher propertyForKey:kFetcherParsedObjectKey]; + NSError *error = [fetcher propertyForKey:kFetcherFetchErrorKey]; + + GTLQuery *executingQuery = (GTLQuery *)ticket.executingQuery; + + BOOL shouldFetchNextPages = ticket.shouldFetchNextPages; + GTLObject *previousObject = ticket.fetchedObject; + + if (shouldFetchNextPages + && (previousObject != nil) + && (object != nil)) { + // Accumulate new results + object = [self mergedNewResultObject:object + oldResultObject:previousObject + forQuery:executingQuery]; + } + + ticket.fetchedObject = object; + ticket.fetchError = error; + + if ([fetcher propertyForKey:kFetcherParsingNotificationKey] != nil) { + // we want to always balance the start and stop notifications + NSNotificationCenter *defaultNC = [NSNotificationCenter defaultCenter]; + [defaultNC postNotificationName:kGTLServiceTicketParsingStoppedNotification + object:ticket]; + } + + BOOL shouldCallCallbacks = YES; + + // Use the nextPageToken to fetch any later pages for non-batch queries + // + // This assumes a pagination model where objects have entries in an "items" + // field and a "nextPageToken" field, and queries support a "pageToken" + // parameter. + if (ticket.shouldFetchNextPages) { + // Determine if we should fetch more pages of results + + GTLQuery *nextPageQuery = + (GTLQuery *)[self nextPageQueryForQuery:executingQuery + result:object + ticket:ticket]; + if (nextPageQuery) { + BOOL isFetchingMore = [self fetchNextPageWithQuery:nextPageQuery + delegate:delegate + didFinishedSelector:finishedSelector + completionHandler:completionHandler + ticket:ticket]; + if (isFetchingMore) { + shouldCallCallbacks = NO; + } + } else { + // No more page tokens are present +#if DEBUG && !GTL_SKIP_PAGES_WARNING + // Each next page followed to accumulate all pages of a feed takes up to + // a few seconds. When multiple pages are being fetched, that + // usually indicates that a larger page size (that is, more items per + // feed fetched) should be requested. + // + // To avoid fetching many pages, set query.maxResults so the feed + // requested is large enough to rarely need to follow next links. + NSUInteger pageCount = ticket.pagesFetchedCounter; + if (pageCount > 2) { + NSString *queryLabel = [executingQuery isBatchQuery] ? + @"batch query" : executingQuery.methodName; + NSLog(@"Executing %@ required fetching %u pages; use a query with a" + @" larger maxResults for faster results", + queryLabel, (unsigned int) pageCount); + } +#endif + } + } + + // We no longer care about the queries for page 2 or later, so for the client + // inspecting the ticket in the callback, the executing query should be + // the original one + ticket.executingQuery = ticket.originalQuery; + + if (shouldCallCallbacks) { + // First, call query-specific callback blocks. We do this before the + // fetch callback to let applications do any final clean-up (or update + // their UI) in the fetch callback. + GTLQuery *originalQuery = (GTLQuery *)ticket.originalQuery; + if (![originalQuery isBatchQuery]) { + // Single query + GTLServiceCompletionHandler completionBlock = originalQuery.completionBlock; + if (completionBlock) { + completionBlock(ticket, object, error); + } + } else { + // Batch query + // + // We'll step through the queries of the original batch, not of the + // batch result + GTLBatchQuery *batchQuery = (GTLBatchQuery *)originalQuery; + GTLBatchResult *batchResult = (GTLBatchResult *)object; + NSDictionary *successes = batchResult.successes; + NSDictionary *failures = batchResult.failures; + + for (GTLQuery *oneQuery in batchQuery.queries) { + GTLServiceCompletionHandler completionBlock = oneQuery.completionBlock; + if (completionBlock) { + // If there was no networking error, look for a query-specific + // error or result + GTLObject *oneResult = nil; + NSError *oneError = error; + if (oneError == nil) { + NSString *requestID = [oneQuery requestID]; + GTLErrorObject *gtlError = [failures objectForKey:requestID]; + if (gtlError) { + oneError = [gtlError foundationError]; + } else { + oneResult = [successes objectForKey:requestID]; + if (oneResult == nil) { + // We found neither a success nor a failure for this + // query, unexpectedly + GTL_DEBUG_LOG(@"GTLService: Batch result missing for request %@", + requestID); + oneError = [NSError errorWithDomain:kGTLServiceErrorDomain + code:kGTLErrorQueryResultMissing + userInfo:nil]; + } + } + } + completionBlock(ticket, oneResult, oneError); + } + } + } + + // Release query callback blocks + [originalQuery executionDidStop]; + + if (finishedSelector) { + [[self class] invokeCallback:finishedSelector + target:delegate + ticket:ticket + object:object + error:error]; + } + + if (completionHandler) { + completionHandler(ticket, object, error); + } + ticket.hasCalledCallback = YES; + } + fetcher.properties = nil; + + // Tickets don't know when the fetch has completed, so the service will + // release their blocks here to avoid unintended retain loops + ticket.retryBlock = nil; + ticket.uploadProgressBlock = nil; +} + +#pragma mark - + ++ (void)invokeCallback:(SEL)callbackSel + target:(id)target + ticket:(id)ticket + object:(id)object + error:(id)error { + + // GTL fetch callbacks have no return value + NSMethodSignature *signature = [target methodSignatureForSelector:callbackSel]; + NSInvocation *retryInvocation = [NSInvocation invocationWithMethodSignature:signature]; + [retryInvocation setSelector:callbackSel]; + [retryInvocation setTarget:target]; + [retryInvocation setArgument:&ticket atIndex:2]; + [retryInvocation setArgument:&object atIndex:3]; + [retryInvocation setArgument:&error atIndex:4]; + [retryInvocation invoke]; +} + +// The object fetcher may call into this retry method; this one invokes the +// selector provided by the user. +- (BOOL)objectFetcher:(GTMBridgeFetcher *)fetcher willRetry:(BOOL)willRetry forError:(NSError *)error { + + GTLServiceTicket *ticket = [fetcher propertyForKey:kFetcherTicketKey]; + SEL retrySelector = ticket.retrySelector; + if (retrySelector) { + id delegate = [fetcher propertyForKey:kFetcherDelegateKey]; + + willRetry = [self invokeRetrySelector:retrySelector + delegate:delegate + ticket:ticket + willRetry:willRetry + error:error]; + } + + GTLServiceRetryBlock retryBlock = ticket.retryBlock; + if (retryBlock) { + willRetry = retryBlock(ticket, willRetry, error); + } + + return willRetry; +} + +- (BOOL)invokeRetrySelector:(SEL)retrySelector + delegate:(id)delegate + ticket:(GTLServiceTicket *)ticket + willRetry:(BOOL)willRetry + error:(NSError *)error { + + if ([delegate respondsToSelector:retrySelector]) { + // Unlike the retry selector invocation in GTMBridgeFetcher, this invocation + // passes the ticket rather than the fetcher as argument 2 + NSMethodSignature *signature = [delegate methodSignatureForSelector:retrySelector]; + NSInvocation *retryInvocation = [NSInvocation invocationWithMethodSignature:signature]; + [retryInvocation setSelector:retrySelector]; + [retryInvocation setTarget:delegate]; + [retryInvocation setArgument:&ticket atIndex:2]; // ticket passed + [retryInvocation setArgument:&willRetry atIndex:3]; + [retryInvocation setArgument:&error atIndex:4]; + [retryInvocation invoke]; + + [retryInvocation getReturnValue:&willRetry]; + } + return willRetry; +} + +- (BOOL)waitForTicket:(GTLServiceTicket *)ticket + timeout:(NSTimeInterval)timeoutInSeconds + fetchedObject:(GTLObject **)outObjectOrNil + error:(NSError **)outErrorOrNil { + + NSDate* giveUpDate = [NSDate dateWithTimeIntervalSinceNow:timeoutInSeconds]; + + // loop until the fetch completes with an object or an error, + // or until the timeout has expired + while (![ticket hasCalledCallback] + && [giveUpDate timeIntervalSinceNow] > 0) { + + // run the current run loop 1/1000 of a second to give the networking + // code a chance to work + NSDate *stopDate = [NSDate dateWithTimeIntervalSinceNow:0.001]; + [[NSRunLoop currentRunLoop] runUntilDate:stopDate]; + } + + NSError *fetchError = ticket.fetchError; + + if (![ticket hasCalledCallback] && fetchError == nil) { + fetchError = [NSError errorWithDomain:kGTLServiceErrorDomain + code:kGTLErrorWaitTimedOut + userInfo:nil]; + } + + if (outObjectOrNil) *outObjectOrNil = ticket.fetchedObject; + if (outErrorOrNil) *outErrorOrNil = fetchError; + + return (fetchError == nil); +} + +#pragma mark - + +// Given a single or batch query and its result, make a new query +// for the next pages, if any. Returns nil if there's no additional +// query to make. +// +// This method calls itself recursively to make the individual next page +// queries for a batch query. +- (id )nextPageQueryForQuery:(GTLQuery *)query + result:(GTLObject *)object + ticket:(GTLServiceTicket *)ticket { + if (!query.isBatchQuery) { + // This is a single query + + // Determine if we should fetch more pages of results + GTLQuery *nextPageQuery = nil; + NSString *nextPageToken = nil; + NSNumber *nextStartIndex = nil; + + if ([object respondsToSelector:@selector(nextPageToken)] + && [query respondsToSelector:@selector(pageToken)]) { + nextPageToken = [object performSelector:@selector(nextPageToken)]; + } + + if ([object respondsToSelector:@selector(nextStartIndex)] + && [query respondsToSelector:@selector(startIndex)]) { + nextStartIndex = [object performSelector:@selector(nextStartIndex)]; + } + + if (nextPageToken || nextStartIndex) { + if ([object respondsToSelector:@selector(items)]) { + // Make a query for the next page, preserving the request ID + nextPageQuery = [[query copy] autorelease]; + nextPageQuery.requestID = query.requestID; + + if (nextPageToken) { + [nextPageQuery performSelector:@selector(setPageToken:) + withObject:nextPageToken]; + } else { + // Use KVC to unwrap the scalar type instead of converting the + // NSNumber to an integer and using NSInvocation + [nextPageQuery setValue:nextStartIndex + forKey:@"startIndex"]; + } + } else { + // Object does not provide an "items" method. +#if DEBUG + NSLog(@"%@ does not support shouldFetchNextPages because it lacks an \"items\" property", + [object class]); +#endif + } + } + return nextPageQuery; + } else { + // This is a batch query + // + // Check if there's a next page to fetch for any of the success + // results by invoking this method recursively on each of those results + GTLBatchResult *batchResult = (GTLBatchResult *)object; + GTLBatchQuery *nextPageBatchQuery = nil; + NSDictionary *successes = batchResult.successes; + + for (NSString *requestID in successes) { + GTLObject *singleObject = [successes objectForKey:requestID]; + GTLQuery *singleQuery = [ticket queryForRequestID:requestID]; + + GTLQuery *newQuery = + (GTLQuery *)[self nextPageQueryForQuery:singleQuery + result:singleObject + ticket:ticket]; + if (newQuery) { + // There is another query to fetch + if (nextPageBatchQuery == nil) { + nextPageBatchQuery = [GTLBatchQuery batchQuery]; + } + [nextPageBatchQuery addQuery:newQuery]; + } + } + return nextPageBatchQuery; + } +} + +// When a ticket is set to fetch more pages for feeds, this routine +// initiates the fetch for each additional feed page +- (BOOL)fetchNextPageWithQuery:(GTLQuery *)query + delegate:(id)delegate + didFinishedSelector:(SEL)finishedSelector + completionHandler:(GTLServiceCompletionHandler)completionHandler + ticket:(GTLServiceTicket *)ticket { + // Sanity check the number of pages fetched already + NSUInteger oldPagesFetchedCounter = ticket.pagesFetchedCounter; + + if (oldPagesFetchedCounter > kMaxNumberOfNextPagesFetched) { + // Sanity check failed: way too many pages were fetched + // + // The client should be querying with a higher max results per page + // to avoid this + GTL_DEBUG_ASSERT(0, @"Fetched too many next pages for %@", + query.methodName); + return NO; + } + + ticket.pagesFetchedCounter = 1 + oldPagesFetchedCounter; + + GTLServiceTicket *newTicket; + if (query.isBatchQuery) { + newTicket = [self executeBatchQuery:(GTLBatchQuery *)query + delegate:delegate + didFinishSelector:finishedSelector + completionHandler:completionHandler + ticket:ticket]; + } else { + newTicket = [self fetchObjectWithMethodNamed:query.methodName + objectClass:query.expectedObjectClass + parameters:query.JSON + bodyObject:query.bodyObject + requestID:query.requestID + urlQueryParameters:query.urlQueryParameters + delegate:delegate + didFinishSelector:finishedSelector + completionHandler:completionHandler + executingQuery:query + ticket:ticket]; + } + + // In the bizarre case that the fetch didn't begin, newTicket will be + // nil. So long as the new ticket is the same as the ticket we're + // continuing, then we're happy. + return (newTicket == ticket); +} + +// Given a new single or batch result (meaning additional pages for a previous +// query result), merge it into the old result. +- (GTLObject *)mergedNewResultObject:(GTLObject *)newResult + oldResultObject:(GTLObject *)oldResult + forQuery:(GTLQuery *)query { + if (query.isBatchQuery) { + // Batch query result + // + // The new batch results are a subset of the old result's queries, since + // not all queries in the batch necessarily have additional pages. + // + // New success objects replace old success objects, with the old items + // prepended; new failure objects replace old success objects. + // We will update the old batch results with accumulated items, using the + // new objects, and return the old batch. + // + // We reuse the old batch results object because it may include some earlier + // results which did not have additional pages. + GTLBatchResult *newBatchResult = (GTLBatchResult *)newResult; + GTLBatchResult *oldBatchResult = (GTLBatchResult *)oldResult; + + NSMutableDictionary *newSuccesses = newBatchResult.successes; + NSMutableDictionary *newFailures = newBatchResult.failures; + NSMutableDictionary *oldSuccesses = oldBatchResult.successes; + NSMutableDictionary *oldFailures = oldBatchResult.failures; + + for (NSString *requestID in newSuccesses) { + // Prepend the old items to the new response's items + // + // We can assume the objects are collections since they're present in + // additional pages. + GTLCollectionObject *newObj = [newSuccesses objectForKey:requestID]; + GTLCollectionObject *oldObj = [oldSuccesses objectForKey:requestID]; + + NSMutableArray *items = [NSMutableArray arrayWithArray:oldObj.items]; + [items addObjectsFromArray:newObj.items]; + [newObj performSelector:@selector(setItems:) withObject:items]; + + // Replace the old object with the new one + [oldSuccesses setObject:newObj forKey:requestID]; + } + + for (NSString *requestID in newFailures) { + // Replace old successes or failures with the new failure + GTLErrorObject *newError = [newFailures objectForKey:requestID]; + [oldFailures setObject:newError forKey:requestID]; + [oldSuccesses removeObjectForKey:requestID]; + } + return oldBatchResult; + } else { + // Single query result + // + // Merge the items into the new object, and return that. + // + // We can assume the objects are collections since they're present in + // additional pages. + GTLCollectionObject *newObj = (GTLCollectionObject *)newResult; + GTLCollectionObject *oldObj = (GTLCollectionObject *)oldResult; + + NSMutableArray *items = [NSMutableArray arrayWithArray:oldObj.items]; + [items addObjectsFromArray:newObj.items]; + [newObj performSelector:@selector(setItems:) withObject:items]; + + return newObj; + } +} + +#pragma mark - + +// GTLQuery methods. + +- (GTLServiceTicket *)executeQuery:(id)queryObj + delegate:(id)delegate + didFinishSelector:(SEL)finishedSelector { + if ([queryObj isBatchQuery]) { + return [self executeBatchQuery:queryObj + delegate:delegate + didFinishSelector:finishedSelector + completionHandler:NULL + ticket:nil]; + } + + GTLQuery *query = [[(GTLQuery *)queryObj copy] autorelease]; + NSString *methodName = query.methodName; + NSDictionary *params = query.JSON; + GTLObject *bodyObject = query.bodyObject; + + return [self fetchObjectWithMethodNamed:methodName + objectClass:query.expectedObjectClass + parameters:params + bodyObject:bodyObject + requestID:query.requestID + urlQueryParameters:query.urlQueryParameters + delegate:delegate + didFinishSelector:finishedSelector + completionHandler:nil + executingQuery:query + ticket:nil]; +} + +- (GTLServiceTicket *)executeQuery:(id)queryObj + completionHandler:(void (^)(GTLServiceTicket *ticket, id object, NSError *error))handler { + if ([queryObj isBatchQuery]) { + return [self executeBatchQuery:queryObj + delegate:nil + didFinishSelector:NULL + completionHandler:handler + ticket:nil]; + } + + GTLQuery *query = [[(GTLQuery *)queryObj copy] autorelease]; + NSString *methodName = query.methodName; + NSDictionary *params = query.JSON; + GTLObject *bodyObject = query.bodyObject; + + return [self fetchObjectWithMethodNamed:methodName + objectClass:query.expectedObjectClass + parameters:params + bodyObject:bodyObject + requestID:query.requestID + urlQueryParameters:query.urlQueryParameters + delegate:nil + didFinishSelector:NULL + completionHandler:handler + executingQuery:query + ticket:nil]; +} + +#pragma mark - + +- (GTLServiceTicket *)fetchObjectWithMethodNamed:(NSString *)methodName + parameters:(NSDictionary *)parameters + objectClass:(Class)objectClass + delegate:(id)delegate + didFinishSelector:(SEL)finishedSelector { + return [self fetchObjectWithMethodNamed:methodName + objectClass:objectClass + parameters:parameters + bodyObject:nil + requestID:nil + urlQueryParameters:nil + delegate:delegate + didFinishSelector:finishedSelector + completionHandler:nil + executingQuery:nil + ticket:nil]; +} + +- (GTLServiceTicket *)fetchObjectWithMethodNamed:(NSString *)methodName + insertingObject:(GTLObject *)bodyObject + objectClass:(Class)objectClass + delegate:(id)delegate + didFinishSelector:(SEL)finishedSelector { + return [self fetchObjectWithMethodNamed:methodName + objectClass:objectClass + parameters:nil + bodyObject:bodyObject + requestID:nil + urlQueryParameters:nil + delegate:delegate + didFinishSelector:finishedSelector + completionHandler:nil + executingQuery:nil + ticket:nil]; +} + +- (GTLServiceTicket *)fetchObjectWithMethodNamed:(NSString *)methodName + parameters:(NSDictionary *)parameters + insertingObject:(GTLObject *)bodyObject + objectClass:(Class)objectClass + delegate:(id)delegate + didFinishSelector:(SEL)finishedSelector { + return [self fetchObjectWithMethodNamed:methodName + objectClass:objectClass + parameters:parameters + bodyObject:bodyObject + requestID:nil + urlQueryParameters:nil + delegate:delegate + didFinishSelector:finishedSelector + completionHandler:nil + executingQuery:nil + ticket:nil]; +} + +- (GTLServiceTicket *)fetchObjectWithMethodNamed:(NSString *)methodName + parameters:(NSDictionary *)parameters + objectClass:(Class)objectClass + completionHandler:(void (^)(GTLServiceTicket *ticket, id object, NSError *error))handler { + return [self fetchObjectWithMethodNamed:methodName + objectClass:objectClass + parameters:parameters + bodyObject:nil + requestID:nil + urlQueryParameters:nil + delegate:nil + didFinishSelector:NULL + completionHandler:handler + executingQuery:nil + ticket:nil]; +} + +- (GTLServiceTicket *)fetchObjectWithMethodNamed:(NSString *)methodName + insertingObject:(GTLObject *)bodyObject + objectClass:(Class)objectClass + completionHandler:(void (^)(GTLServiceTicket *ticket, id object, NSError *error))handler { + return [self fetchObjectWithMethodNamed:methodName + objectClass:objectClass + parameters:nil + bodyObject:bodyObject + requestID:nil + urlQueryParameters:nil + delegate:nil + didFinishSelector:NULL + completionHandler:handler + executingQuery:nil + ticket:nil]; +} + +- (GTLServiceTicket *)fetchObjectWithMethodNamed:(NSString *)methodName + parameters:(NSDictionary *)parameters + insertingObject:(GTLObject *)bodyObject + objectClass:(Class)objectClass + completionHandler:(void (^)(GTLServiceTicket *ticket, id object, NSError *error))handler { + return [self fetchObjectWithMethodNamed:methodName + objectClass:objectClass + parameters:parameters + bodyObject:bodyObject + requestID:nil + urlQueryParameters:nil + delegate:nil + didFinishSelector:NULL + completionHandler:handler + executingQuery:nil + ticket:nil]; +} + +#pragma mark - + +// These external entry points doing a REST style fetch. + +- (GTLServiceTicket *)fetchObjectWithURL:(NSURL *)feedURL + delegate:(id)delegate + didFinishSelector:(SEL)finishedSelector { + // no object class specified; use registered class + return [self fetchObjectWithURL:feedURL + objectClass:nil + bodyObject:nil + ETag:nil + httpMethod:nil + mayAuthorize:YES + delegate:delegate + didFinishSelector:finishedSelector + completionHandler:nil + ticket:nil]; +} + +- (GTLServiceTicket *)fetchPublicObjectWithURL:(NSURL *)feedURL + objectClass:(Class)objectClass + delegate:(id)delegate + didFinishSelector:(SEL)finishedSelector { + return [self fetchObjectWithURL:feedURL + objectClass:objectClass + bodyObject:nil + ETag:nil + httpMethod:nil + mayAuthorize:NO + delegate:delegate + didFinishSelector:finishedSelector + completionHandler:nil + ticket:nil]; +} + +- (GTLServiceTicket *)fetchObjectWithURL:(NSURL *)feedURL + objectClass:(Class)objectClass + delegate:(id)delegate + didFinishSelector:(SEL)finishedSelector { + return [self fetchObjectWithURL:feedURL + objectClass:objectClass + bodyObject:nil + ETag:nil + httpMethod:nil + mayAuthorize:YES + delegate:delegate + didFinishSelector:finishedSelector + completionHandler:nil + ticket:nil]; +} + + +- (GTLServiceTicket *)fetchObjectByInsertingObject:(GTLObject *)bodyToPost + forURL:(NSURL *)destinationURL + delegate:(id)delegate + didFinishSelector:(SEL)finishedSelector { + Class objClass = [bodyToPost class]; + NSString *etag = ETagIfPresent(bodyToPost); + + return [self fetchObjectWithURL:destinationURL + objectClass:objClass + bodyObject:bodyToPost + ETag:etag + httpMethod:@"POST" + mayAuthorize:YES + delegate:delegate + didFinishSelector:finishedSelector + completionHandler:nil + ticket:nil]; +} + +- (GTLServiceTicket *)fetchObjectByUpdatingObject:(GTLObject *)bodyToPut + forURL:(NSURL *)destinationURL + delegate:(id)delegate + didFinishSelector:(SEL)finishedSelector { + Class objClass = [bodyToPut class]; + NSString *etag = ETagIfPresent(bodyToPut); + + return [self fetchObjectWithURL:destinationURL + objectClass:objClass + bodyObject:bodyToPut + ETag:etag + httpMethod:@"PUT" + mayAuthorize:YES + delegate:delegate + didFinishSelector:finishedSelector + completionHandler:nil + ticket:nil]; +} + + +- (GTLServiceTicket *)deleteResourceURL:(NSURL *)destinationURL + ETag:(NSString *)etagOrNil + delegate:(id)delegate + didFinishSelector:(SEL)finishedSelector { + return [self fetchObjectWithURL:destinationURL + objectClass:nil + bodyObject:nil + ETag:etagOrNil + httpMethod:@"DELETE" + mayAuthorize:YES + delegate:delegate + didFinishSelector:finishedSelector + completionHandler:nil + ticket:nil]; +} + + +- (GTLServiceTicket *)fetchObjectWithURL:(NSURL *)objectURL + completionHandler:(void (^)(GTLServiceTicket *ticket, id object, NSError *error))handler { + return [self fetchObjectWithURL:objectURL + objectClass:nil + bodyObject:nil + ETag:nil + httpMethod:nil + mayAuthorize:YES + delegate:nil + didFinishSelector:NULL + completionHandler:handler + ticket:nil]; +} + +- (GTLServiceTicket *)fetchObjectByInsertingObject:(GTLObject *)bodyToPost + forURL:(NSURL *)destinationURL + completionHandler:(void (^)(GTLServiceTicket *ticket, id object, NSError *error))handler { + Class objClass = [bodyToPost class]; + NSString *etag = ETagIfPresent(bodyToPost); + + return [self fetchObjectWithURL:destinationURL + objectClass:objClass + bodyObject:bodyToPost + ETag:etag + httpMethod:@"POST" + mayAuthorize:YES + delegate:nil + didFinishSelector:NULL + completionHandler:handler + ticket:nil]; +} + +- (GTLServiceTicket *)fetchObjectByUpdatingObject:(GTLObject *)bodyToPut + forURL:(NSURL *)destinationURL + completionHandler:(void (^)(GTLServiceTicket *ticket, id object, NSError *error))handler { + Class objClass = [bodyToPut class]; + NSString *etag = ETagIfPresent(bodyToPut); + + return [self fetchObjectWithURL:destinationURL + objectClass:objClass + bodyObject:bodyToPut + ETag:etag + httpMethod:@"PUT" + mayAuthorize:YES + delegate:nil + didFinishSelector:NULL + completionHandler:handler + ticket:nil]; +} + +- (GTLServiceTicket *)deleteResourceURL:(NSURL *)destinationURL + ETag:(NSString *)etagOrNil + completionHandler:(void (^)(GTLServiceTicket *ticket, id object, NSError *error))handler { + return [self fetchObjectWithURL:destinationURL + objectClass:nil + bodyObject:nil + ETag:etagOrNil + httpMethod:@"DELETE" + mayAuthorize:YES + delegate:nil + didFinishSelector:NULL + completionHandler:handler + ticket:nil]; +} + +#pragma mark - + +- (NSString *)userAgent { + return userAgent_; +} + +- (void)setExactUserAgent:(NSString *)userAgent { + // internal use only + [userAgent_ release]; + userAgent_ = [userAgent copy]; +} + +- (void)setUserAgent:(NSString *)userAgent { + // remove whitespace and unfriendly characters + NSString *str = GTMBridgeCleanedUserAgentString(userAgent); + [self setExactUserAgent:str]; +} + +// +// The following methods pass through to the fetcher service object +// + +- (void)setCookieStorageMethod:(NSInteger)method { +#if !GTL_USE_SESSION_FETCHER + self.fetcherService.cookieStorageMethod = method; +#endif +} + +- (NSInteger)cookieStorageMethod { +#if !GTL_USE_SESSION_FETCHER + return self.fetcherService.cookieStorageMethod; +#else + return 1; +#endif +} + +- (void)setShouldFetchInBackground:(BOOL)flag { +#if !GTL_USE_SESSION_FETCHER + self.fetcherService.shouldFetchInBackground = flag; +#endif +} + +- (BOOL)shouldFetchInBackground { +#if !GTL_USE_SESSION_FETCHER + return self.fetcherService.shouldFetchInBackground; +#else + return YES; +#endif +} + +- (void)setDelegateQueue:(NSOperationQueue *)delegateQueue { +#if !GTL_USE_SESSION_FETCHER + self.fetcherService.delegateQueue = delegateQueue; +#endif +} + +- (NSOperationQueue *)delegateQueue { +#if !GTL_USE_SESSION_FETCHER + return self.fetcherService.delegateQueue; +#else + return nil; +#endif +} + +- (void)setRunLoopModes:(NSArray *)array { +#if !GTL_USE_SESSION_FETCHER + self.fetcherService.runLoopModes = array; +#endif +} + +- (NSArray *)runLoopModes { +#if !GTL_USE_SESSION_FETCHER + return self.fetcherService.runLoopModes; +#else + return nil; +#endif +} + +#pragma mark - + +// The service properties becomes the initial value for each future ticket's +// properties +- (void)setServiceProperties:(NSDictionary *)dict { + [serviceProperties_ autorelease]; + serviceProperties_ = [dict mutableCopy]; +} + +- (NSDictionary *)serviceProperties { + // be sure the returned pointer has the life of the autorelease pool, + // in case self is released immediately + return [[serviceProperties_ retain] autorelease]; +} + +- (void)setServiceProperty:(id)obj forKey:(NSString *)key { + + if (obj == nil) { + // user passed in nil, so delete the property + [serviceProperties_ removeObjectForKey:key]; + } else { + // be sure the property dictionary exists + if (serviceProperties_ == nil) { + [self setServiceProperties:[NSDictionary dictionary]]; + } + [serviceProperties_ setObject:obj forKey:key]; + } +} + +- (id)servicePropertyForKey:(NSString *)key { + id obj = [serviceProperties_ objectForKey:key]; + + // be sure the returned pointer has the life of the autorelease pool, + // in case self is released immediately + return [[obj retain] autorelease]; +} + +- (void)setServiceUserData:(id)userData { + [self setServiceProperty:userData forKey:kServiceUserDataPropertyKey]; +} + +- (id)serviceUserData { + return [[[self servicePropertyForKey:kServiceUserDataPropertyKey] retain] autorelease]; +} + +- (void)setAuthorizer:(id )authorizer { + self.fetcherService.authorizer = authorizer; +} + +- (id )authorizer { + return self.fetcherService.authorizer; +} + ++ (NSUInteger)defaultServiceUploadChunkSize { + // subclasses may override + return kStandardUploadChunkSize; +} + +- (NSUInteger)serviceUploadChunkSize { + return uploadChunkSize_; +} + +- (void)setServiceUploadChunkSize:(NSUInteger)val { + + if (val == kGTLStandardUploadChunkSize) { + // determine an appropriate upload chunk size for the system + +#if GTL_USE_SESSION_FETCHER + BOOL doesSupportSentDataCallback = YES; +#else + BOOL doesSupportSentDataCallback = [GTMHTTPFetcher doesSupportSentDataCallback]; +#endif + if (!doesSupportSentDataCallback) { + // for 10.4 and iPhone 2, we need a small upload chunk size so there + // are frequent intrachunk callbacks for progress monitoring + val = 75000; + } else { +#if GTL_IPHONE + val = 1000000; +#else + if (NSFoundationVersionNumber >= 751.00) { + // Mac OS X 10.6 + // + // we'll pick a huge upload chunk size, which minimizes http overhead + // and server effort, and we'll hope that NSURLConnection can finally + // handle big uploads reliably + val = 25000000; + } else { + // Mac OS X 10.5 + // + // NSURLConnection is more reliable on POSTs in 10.5 than it was in + // 10.4, but it still fails mysteriously on big uploads on some + // systems, so we'll limit the chunks to a megabyte + val = 1000000; + } +#endif + } + } + uploadChunkSize_ = val; +} + +@end + +@implementation GTLServiceTicket + +@synthesize shouldFetchNextPages = shouldFetchNextPages_, + surrogates = surrogates_, + uploadProgressSelector = uploadProgressSelector_, + retryEnabled = isRetryEnabled_, + hasCalledCallback = hasCalledCallback_, + retrySelector = retrySelector_, + maxRetryInterval = maxRetryInterval_, + objectFetcher = objectFetcher_, + postedObject = postedObject_, + fetchedObject = fetchedObject_, + executingQuery = executingQuery_, + originalQuery = originalQuery_, + fetchError = fetchError_, + pagesFetchedCounter = pagesFetchedCounter_, + APIKey = apiKey_, + parseOperation = parseOperation_, + isREST = isREST_, + retryBlock = retryBlock_; + ++ (id)ticketForService:(GTLService *)service { + return [[[self alloc] initWithService:service] autorelease]; +} + +- (id)initWithService:(GTLService *)service { + self = [super init]; + if (self) { + service_ = [service retain]; + + ticketProperties_ = [service.serviceProperties mutableCopy]; + surrogates_ = [service.surrogates retain]; + uploadProgressSelector_ = service.uploadProgressSelector; + isRetryEnabled_ = service.retryEnabled; + retrySelector_ = service.retrySelector; + maxRetryInterval_ = service.maxRetryInterval; + shouldFetchNextPages_ = service.shouldFetchNextPages; + apiKey_ = [service.APIKey copy]; + uploadProgressBlock_ = [service.uploadProgressBlock copy]; + retryBlock_ = [service.retryBlock copy]; + } + return self; +} + +- (void)dealloc { + [service_ release]; + [ticketProperties_ release]; + [surrogates_ release]; + [objectFetcher_ release]; + [uploadProgressBlock_ release]; + [retryBlock_ release]; + [postedObject_ release]; + [fetchedObject_ release]; + [executingQuery_ release]; + [originalQuery_ release]; + [fetchError_ release]; + [apiKey_ release]; + [parseOperation_ release]; + + [super dealloc]; +} + +- (NSString *)description { + NSString *devKeyInfo = @""; + if (apiKey_ != nil) { + devKeyInfo = [NSString stringWithFormat:@" devKey:%@", apiKey_]; + } + + NSString *authorizerInfo = @""; + id authorizer = self.objectFetcher.authorizer; + if (authorizer != nil) { + authorizerInfo = [NSString stringWithFormat:@" authorizer:%@", authorizer]; + } + + return [NSString stringWithFormat:@"%@ %p: {service:%@%@%@ fetcher:%@ }", + [self class], self, service_, devKeyInfo, authorizerInfo, objectFetcher_]; +} + +- (void)pauseUpload { + BOOL canPause = [objectFetcher_ respondsToSelector:@selector(pauseFetching)]; + GTL_DEBUG_ASSERT(canPause, @"unpauseable ticket"); + + if (canPause) { + [(GTLUploadFetcherClass *)objectFetcher_ pauseFetching]; + } +} + +- (void)resumeUpload { + BOOL canResume = [objectFetcher_ respondsToSelector:@selector(resumeFetching)]; + GTL_DEBUG_ASSERT(canResume, @"unresumable ticket"); + + if (canResume) { + [(GTLUploadFetcherClass *)objectFetcher_ resumeFetching]; + } +} + +- (BOOL)isUploadPaused { + BOOL isPausable = [objectFetcher_ respondsToSelector:@selector(isPaused)]; + GTL_DEBUG_ASSERT(isPausable, @"unpauseable ticket"); + + if (isPausable) { + return [(GTLUploadFetcherClass *)objectFetcher_ isPaused]; + } + return NO; +} + +- (void)cancelTicket { + NSOperation *parseOperation = self.parseOperation; + [parseOperation cancel]; + self.parseOperation = nil; + + [objectFetcher_ stopFetching]; + objectFetcher_.properties = nil; + + self.objectFetcher = nil; + self.properties = nil; + self.uploadProgressSelector = nil; + + self.uploadProgressBlock = nil; + self.retryBlock = nil; + + [self.executingQuery executionDidStop]; + self.executingQuery = self.originalQuery; + + [service_ autorelease]; + service_ = nil; +} + +- (id)service { + return service_; +} + +- (void)setUserData:(id)userData { + [self setProperty:userData forKey:kServiceUserDataPropertyKey]; +} + +- (id)userData { + // be sure the returned pointer has the life of the autorelease pool, + // in case self is released immediately + return [[[self propertyForKey:kServiceUserDataPropertyKey] retain] autorelease]; +} + +- (void)setProperties:(NSDictionary *)dict { + [ticketProperties_ autorelease]; + ticketProperties_ = [dict mutableCopy]; +} + +- (NSDictionary *)properties { + // be sure the returned pointer has the life of the autorelease pool, + // in case self is released immediately + return [[ticketProperties_ retain] autorelease]; +} + +- (void)setProperty:(id)obj forKey:(NSString *)key { + if (obj == nil) { + // user passed in nil, so delete the property + [ticketProperties_ removeObjectForKey:key]; + } else { + // be sure the property dictionary exists + if (ticketProperties_ == nil) { + // call setProperties so observers are notified + [self setProperties:[NSDictionary dictionary]]; + } + [ticketProperties_ setObject:obj forKey:key]; + } +} + +- (id)propertyForKey:(NSString *)key { + id obj = [ticketProperties_ objectForKey:key]; + + // be sure the returned pointer has the life of the autorelease pool, + // in case self is released immediately + return [[obj retain] autorelease]; +} + +- (NSDictionary *)surrogates { + return surrogates_; +} + +- (void)setSurrogates:(NSDictionary *)dict { + [surrogates_ autorelease]; + surrogates_ = [dict retain]; +} + +- (SEL)uploadProgressSelector { + return uploadProgressSelector_; +} + +- (void)setUploadProgressSelector:(SEL)progressSelector { + uploadProgressSelector_ = progressSelector; + + // if the user is turning on the progress selector in the ticket after the + // ticket's fetcher has been created, we need to give the fetcher our sentData + // callback. + // + // The progress monitor must be set in the service prior to creation of the + // ticket on 10.4 and iPhone 2.0, since on those systems the upload data must + // be wrapped with a ProgressMonitorInputStream prior to the creation of the + // fetcher. + if (progressSelector != NULL) { +#if GTL_USE_SESSION_FETCHER + __block GTMSessionFetcher *fetcher = [self objectFetcher]; + fetcher.sendProgressBlock = ^(int64_t bytesSent, int64_t totalBytesSent, + int64_t totalBytesExpectedToSend) { + [service_ objectFetcher:fetcher + didSendBytes:(NSInteger)bytesSent + totalBytesSent:(NSInteger)totalBytesSent + totalBytesExpectedToSend:(NSInteger)totalBytesExpectedToSend]; + }; +#else + SEL sentDataSel = @selector(objectFetcher:didSendBytes:totalBytesSent:totalBytesExpectedToSend:); + [[self objectFetcher] setSentDataSelector:sentDataSel]; +#endif + } +} + +- (void)setUploadProgressBlock:(GTLServiceUploadProgressBlock)block { + [uploadProgressBlock_ autorelease]; + uploadProgressBlock_ = [block copy]; + + if (uploadProgressBlock_) { + // As above, we need the fetcher to call us back when bytes are sent. +#if GTL_USE_SESSION_FETCHER + __block GTMSessionFetcher *fetcher = [self objectFetcher]; + fetcher.sendProgressBlock = ^(int64_t bytesSent, int64_t totalBytesSent, + int64_t totalBytesExpectedToSend) { + [service_ objectFetcher:fetcher + didSendBytes:(NSInteger)bytesSent + totalBytesSent:(NSInteger)totalBytesSent + totalBytesExpectedToSend:(NSInteger)totalBytesExpectedToSend]; + }; +#else + SEL sentDataSel = @selector(objectFetcher:didSendBytes:totalBytesSent:totalBytesExpectedToSend:); + [[self objectFetcher] setSentDataSelector:sentDataSel]; +#endif + } +} + +- (GTLServiceUploadProgressBlock)uploadProgressBlock { + return uploadProgressBlock_; +} + +- (NSInteger)statusCode { + return [objectFetcher_ statusCode]; +} + +- (GTLQuery *)queryForRequestID:(NSString *)requestID { + id queryObj = self.executingQuery; + if ([queryObj isBatchQuery]) { + GTLBatchQuery *batch = (GTLBatchQuery *)queryObj; + GTLQuery *result = [batch queryForRequestID:requestID]; + return result; + } else { + GTL_DEBUG_ASSERT(0, @"just use ticket.executingQuery"); + return nil; + } +} + +@end diff --git a/XCDYouTubeKit Demo/Pods/Google-API-Client/Source/Objects/GTLUploadParameters.h b/XCDYouTubeKit Demo/Pods/Google-API-Client/Source/Objects/GTLUploadParameters.h new file mode 100644 index 00000000..b436d9b0 --- /dev/null +++ b/XCDYouTubeKit Demo/Pods/Google-API-Client/Source/Objects/GTLUploadParameters.h @@ -0,0 +1,66 @@ +/* Copyright (c) 2011 Google Inc. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +// +// GTLUploadParameters.h +// + +// Uploading documentation: +// https://code.google.com/p/google-api-objectivec-client/wiki/Introduction#Uploading_Files + +#import + +#import "GTLDefines.h" + +@interface GTLUploadParameters : NSObject { + @private + NSString *MIMEType_; + NSData *data_; + NSFileHandle *fileHandle_; + NSURL *fileURL_; + NSURL *uploadLocationURL_; + NSString *slug_; + BOOL shouldSendUploadOnly_; +} + +// Uploading requires MIME type and one of +// - data to be uploaded +// - URL of file to be uploaded (preferred for large files) +// - file handle for uploading +@property (copy) NSString *MIMEType; +@property (retain) NSData *data; +@property (retain) NSFileHandle *fileHandle; +@property (retain) NSURL *fileURL; + +// Resuming an in-progress upload is done with the upload location URL, +// and requires a file handle for uploading +@property (retain) NSURL *uploadLocationURL; + +// Some services need a slug (filename) header +@property (copy) NSString *slug; + +// Uploads may be done without a JSON body in the initial request +@property (assign) BOOL shouldSendUploadOnly; + ++ (instancetype)uploadParametersWithData:(NSData *)data + MIMEType:(NSString *)mimeType GTL_NONNULL((1,2)); + ++ (instancetype)uploadParametersWithFileHandle:(NSFileHandle *)fileHandle + MIMEType:(NSString *)mimeType GTL_NONNULL((1,2)); + ++ (instancetype)uploadParametersWithFileURL:(NSURL *)fileHandle + MIMEType:(NSString *)mimeType GTL_NONNULL((1,2)); + +@end diff --git a/XCDYouTubeKit Demo/Pods/Google-API-Client/Source/Objects/GTLUploadParameters.m b/XCDYouTubeKit Demo/Pods/Google-API-Client/Source/Objects/GTLUploadParameters.m new file mode 100644 index 00000000..03db6a1b --- /dev/null +++ b/XCDYouTubeKit Demo/Pods/Google-API-Client/Source/Objects/GTLUploadParameters.m @@ -0,0 +1,123 @@ +/* Copyright (c) 2011 Google Inc. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +// +// GTLObject.m +// + +#include + +#import "GTLUploadParameters.h" + +@implementation GTLUploadParameters + +@synthesize MIMEType = MIMEType_, + data = data_, + fileHandle = fileHandle_, + uploadLocationURL = uploadLocationURL_, + fileURL = fileURL_, + slug = slug_, + shouldSendUploadOnly = shouldSendUploadOnly_; + ++ (instancetype)uploadParametersWithData:(NSData *)data + MIMEType:(NSString *)mimeType { + GTLUploadParameters *params = [[[self alloc] init] autorelease]; + params.data = data; + params.MIMEType = mimeType; + return params; +} + ++ (instancetype)uploadParametersWithFileHandle:(NSFileHandle *)fileHandle + MIMEType:(NSString *)mimeType { + GTLUploadParameters *params = [[[self alloc] init] autorelease]; + params.fileHandle = fileHandle; + params.MIMEType = mimeType; + return params; +} + ++ (instancetype)uploadParametersWithFileURL:(NSURL *)fileURL + MIMEType:(NSString *)mimeType { + GTLUploadParameters *params = [[[self alloc] init] autorelease]; + params.fileURL = fileURL; + params.MIMEType = mimeType; + return params; +} + +- (id)copyWithZone:(NSZone *)zone { + GTLUploadParameters *newParams = [[[self class] allocWithZone:zone] init]; + newParams.MIMEType = self.MIMEType; + newParams.data = self.data; + newParams.fileHandle = self.fileHandle; + newParams.fileURL = self.fileURL; + newParams.uploadLocationURL = self.uploadLocationURL; + newParams.slug = self.slug; + newParams.shouldSendUploadOnly = self.shouldSendUploadOnly; + return newParams; +} + +- (void)dealloc { + [MIMEType_ release]; + [data_ release]; + [fileHandle_ release]; + [fileURL_ release]; + [uploadLocationURL_ release]; + [slug_ release]; + + [super dealloc]; +} + +- (NSString *)description { + NSMutableArray *array = [NSMutableArray array]; + NSString *str = [NSString stringWithFormat:@"MIMEType:%@", MIMEType_]; + [array addObject:str]; + + if (data_) { + str = [NSString stringWithFormat:@"data:%llu bytes", + (unsigned long long)[data_ length]]; + [array addObject:str]; + } + + if (fileHandle_) { + str = [NSString stringWithFormat:@"fileHandle:%@", fileHandle_]; + [array addObject:str]; + } + + if (fileURL_) { + str = [NSString stringWithFormat:@"file:%@", [fileURL_ path]]; + [array addObject:str]; + } + + if (uploadLocationURL_) { + str = [NSString stringWithFormat:@"uploadLocation:%@", + [uploadLocationURL_ absoluteString]]; + [array addObject:str]; + } + + if (slug_) { + str = [NSString stringWithFormat:@"slug:%@", slug_]; + [array addObject:str]; + } + + if (shouldSendUploadOnly_) { + [array addObject:@"shouldSendUploadOnly"]; + } + + NSString *descStr = [array componentsJoinedByString:@", "]; + str = [NSString stringWithFormat:@"%@ %p: {%@}", + [self class], self, descStr]; + return str; +} + +@end diff --git a/XCDYouTubeKit Demo/Pods/Google-API-Client/Source/Services/YouTube/Generated/GTLQueryYouTube.h b/XCDYouTubeKit Demo/Pods/Google-API-Client/Source/Services/YouTube/Generated/GTLQueryYouTube.h new file mode 100644 index 00000000..34f5e046 --- /dev/null +++ b/XCDYouTubeKit Demo/Pods/Google-API-Client/Source/Services/YouTube/Generated/GTLQueryYouTube.h @@ -0,0 +1,2019 @@ +/* Copyright (c) 2014 Google Inc. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +// +// GTLQueryYouTube.h +// + +// ---------------------------------------------------------------------------- +// NOTE: This file is generated from Google APIs Discovery Service. +// Service: +// YouTube Data API (youtube/v3) +// Description: +// Programmatic access to YouTube features. +// Documentation: +// https://developers.google.com/youtube/v3 +// Classes: +// GTLQueryYouTube (45 custom class methods, 54 custom properties) + +#if GTL_BUILT_AS_FRAMEWORK + #import "GTL/GTLQuery.h" +#else + #import "GTLQuery.h" +#endif + +@class GTLYouTubeActivity; +@class GTLYouTubeChannel; +@class GTLYouTubeChannelBannerResource; +@class GTLYouTubeChannelSection; +@class GTLYouTubeInvideoBranding; +@class GTLYouTubeLiveBroadcast; +@class GTLYouTubeLiveStream; +@class GTLYouTubePlaylist; +@class GTLYouTubePlaylistItem; +@class GTLYouTubeSubscription; +@class GTLYouTubeVideo; + +@interface GTLQueryYouTube : GTLQuery + +// +// Parameters valid on all methods. +// + +// Selector specifying which fields to include in a partial response. +@property (copy) NSString *fields; + +// +// Method-specific parameters; see the comments below for more information. +// +@property (assign) BOOL autoLevels; +@property (copy) NSString *broadcastStatus; +@property (copy) NSString *categoryId; +@property (copy) NSString *channelId; +@property (copy) NSString *channelType; +@property (copy) NSString *chart; +@property (assign) BOOL displaySlate; +@property (copy) NSString *eventType; +@property (copy) NSString *forChannelId; +@property (assign) BOOL forContentOwner; +@property (assign) BOOL forMine; +@property (copy) NSString *forUsername; +@property (copy) NSString *hl; +@property (assign) BOOL home; +// identifier property maps to 'id' in JSON (to avoid Objective C's 'id'). +@property (copy) NSString *identifier; +@property (copy) NSString *locale; +@property (copy) NSString *location; +@property (copy) NSString *locationRadius; +@property (assign) BOOL managedByMe; +@property (assign) NSUInteger maxResults; +@property (assign) BOOL mine; +@property (copy) NSString *myRating; +@property (assign) BOOL mySubscribers; +@property (assign) BOOL notifySubscribers; +@property (assign) unsigned long long offsetTimeMs; +@property (copy) NSString *onBehalfOfContentOwner; +@property (copy) NSString *onBehalfOfContentOwnerChannel; +@property (copy) NSString *order; +@property (copy) NSString *pageToken; +@property (copy) NSString *part; +@property (copy) NSString *playlistId; +@property (retain) GTLDateTime *publishedAfter; +@property (retain) GTLDateTime *publishedBefore; +@property (copy) NSString *q; +@property (copy) NSString *rating; +@property (copy) NSString *regionCode; +@property (copy) NSString *relatedToVideoId; +@property (copy) NSString *safeSearch; +@property (assign) BOOL stabilize; +@property (copy) NSString *streamId; +@property (copy) NSString *topicId; +@property (copy) NSString *type; +@property (copy) NSString *videoCaption; +@property (copy) NSString *videoCategoryId; +@property (copy) NSString *videoDefinition; +@property (copy) NSString *videoDimension; +@property (copy) NSString *videoDuration; +@property (copy) NSString *videoEmbeddable; +@property (copy) NSString *videoId; +@property (copy) NSString *videoLicense; +@property (copy) NSString *videoSyndicated; +@property (copy) NSString *videoType; +@property (retain) GTLDateTime *walltime; + +#pragma mark - +#pragma mark "activities" methods +// These create a GTLQueryYouTube object. + +// Method: youtube.activities.insert +// Posts a bulletin for a specific channel. (The user submitting the request +// must be authorized to act on the channel's behalf.) +// Note: Even though an activity resource can contain information about actions +// like a user rating a video or marking a video as a favorite, you need to use +// other API methods to generate those activity resources. For example, you +// would use the API's videos.rate() method to rate a video and the +// playlistItems.insert() method to mark a video as a favorite. +// Required: +// part: The part parameter serves two purposes in this operation. It +// identifies the properties that the write operation will set as well as +// the properties that the API response will include. +// The part names that you can include in the parameter value are snippet +// and contentDetails. +// Authorization scope(s): +// kGTLAuthScopeYouTube +// Fetches a GTLYouTubeActivity. ++ (id)queryForActivitiesInsertWithObject:(GTLYouTubeActivity *)object + part:(NSString *)part; + +// Method: youtube.activities.list +// Returns a list of channel activity events that match the request criteria. +// For example, you can retrieve events associated with a particular channel, +// events associated with the user's subscriptions and Google+ friends, or the +// YouTube home page feed, which is customized for each user. +// Required: +// part: The part parameter specifies a comma-separated list of one or more +// activity resource properties that the API response will include. The part +// names that you can include in the parameter value are id, snippet, and +// contentDetails. +// If the parameter identifies a property that contains child properties, +// the child properties will be included in the response. For example, in a +// activity resource, the snippet property contains other properties that +// identify the type of activity, a display title for the activity, and so +// forth. If you set part=snippet, the API response will also contain all of +// those nested properties. +// Optional: +// channelId: The channelId parameter specifies a unique YouTube channel ID. +// The API will then return a list of that channel's activities. +// home: Set this parameter's value to true to retrieve the activity feed that +// displays on the YouTube home page for the currently authenticated user. +// maxResults: The maxResults parameter specifies the maximum number of items +// that should be returned in the result set. (0..50, default 5) +// mine: Set this parameter's value to true to retrieve a feed of the +// authenticated user's activities. +// pageToken: The pageToken parameter identifies a specific page in the result +// set that should be returned. In an API response, the nextPageToken and +// prevPageToken properties identify other pages that could be retrieved. +// publishedAfter: The publishedAfter parameter specifies the earliest date +// and time that an activity could have occurred for that activity to be +// included in the API response. If the parameter value specifies a day, but +// not a time, then any activities that occurred that day will be included +// in the result set. The value is specified in ISO 8601 +// (YYYY-MM-DDThh:mm:ss.sZ) format. +// publishedBefore: The publishedBefore parameter specifies the date and time +// before which an activity must have occurred for that activity to be +// included in the API response. If the parameter value specifies a day, but +// not a time, then any activities that occurred that day will be excluded +// from the result set. The value is specified in ISO 8601 +// (YYYY-MM-DDThh:mm:ss.sZ) format. +// regionCode: The regionCode parameter instructs the API to return results +// for the specified country. The parameter value is an ISO 3166-1 alpha-2 +// country code. YouTube uses this value when the authorized user's previous +// activity on YouTube does not provide enough information to generate the +// activity feed. +// Authorization scope(s): +// kGTLAuthScopeYouTube +// kGTLAuthScopeYouTubeReadonly +// Fetches a GTLYouTubeActivityListResponse. ++ (id)queryForActivitiesListWithPart:(NSString *)part; + +#pragma mark - +#pragma mark "channelBanners" methods +// These create a GTLQueryYouTube object. + +// Method: youtube.channelBanners.insert +// Uploads a channel banner image to YouTube. This method represents the first +// two steps in a three-step process to update the banner image for a channel: +// - Call the channelBanners.insert method to upload the binary image data to +// YouTube. The image must have a 16:9 aspect ratio and be at least 2120x1192 +// pixels. +// - Extract the url property's value from the response that the API returns for +// step 1. +// - Call the channels.update method to update the channel's branding settings. +// Set the brandingSettings.image.bannerExternalUrl property's value to the URL +// obtained in step 2. +// Optional: +// onBehalfOfContentOwner: Note: This parameter is intended exclusively for +// YouTube content partners. +// The onBehalfOfContentOwner parameter indicates that the request's +// authorization credentials identify a YouTube CMS user who is acting on +// behalf of the content owner specified in the parameter value. This +// parameter is intended for YouTube content partners that own and manage +// many different YouTube channels. It allows content owners to authenticate +// once and get access to all their video and channel data, without having +// to provide authentication credentials for each individual channel. The +// CMS account that the user authenticates with must be linked to the +// specified YouTube content owner. +// Upload Parameters: +// Maximum size: 6MB +// Accepted MIME type(s): application/octet-stream, image/jpeg, image/png +// Authorization scope(s): +// kGTLAuthScopeYouTube +// kGTLAuthScopeYouTubeUpload +// Fetches a GTLYouTubeChannelBannerResource. ++ (id)queryForChannelBannersInsertWithObject:(GTLYouTubeChannelBannerResource *)object + uploadParameters:(GTLUploadParameters *)uploadParametersOrNil; + +#pragma mark - +#pragma mark "channelSections" methods +// These create a GTLQueryYouTube object. + +// Method: youtube.channelSections.delete +// Deletes a channelSection. +// Required: +// identifier: The id parameter specifies the YouTube channelSection ID for +// the resource that is being deleted. In a channelSection resource, the id +// property specifies the YouTube channelSection ID. +// Optional: +// onBehalfOfContentOwner: Note: This parameter is intended exclusively for +// YouTube content partners. +// The onBehalfOfContentOwner parameter indicates that the request's +// authorization credentials identify a YouTube CMS user who is acting on +// behalf of the content owner specified in the parameter value. This +// parameter is intended for YouTube content partners that own and manage +// many different YouTube channels. It allows content owners to authenticate +// once and get access to all their video and channel data, without having +// to provide authentication credentials for each individual channel. The +// CMS account that the user authenticates with must be linked to the +// specified YouTube content owner. +// Authorization scope(s): +// kGTLAuthScopeYouTube +// kGTLAuthScopeYouTubeYoutubepartner ++ (id)queryForChannelSectionsDeleteWithIdentifier:(NSString *)identifier; + +// Method: youtube.channelSections.insert +// Adds a channelSection for the authenticated user's channel. +// Required: +// part: The part parameter serves two purposes in this operation. It +// identifies the properties that the write operation will set as well as +// the properties that the API response will include. +// The part names that you can include in the parameter value are snippet +// and contentDetails. +// Optional: +// onBehalfOfContentOwner: Note: This parameter is intended exclusively for +// YouTube content partners. +// The onBehalfOfContentOwner parameter indicates that the request's +// authorization credentials identify a YouTube CMS user who is acting on +// behalf of the content owner specified in the parameter value. This +// parameter is intended for YouTube content partners that own and manage +// many different YouTube channels. It allows content owners to authenticate +// once and get access to all their video and channel data, without having +// to provide authentication credentials for each individual channel. The +// CMS account that the user authenticates with must be linked to the +// specified YouTube content owner. +// onBehalfOfContentOwnerChannel: This parameter can only be used in a +// properly authorized request. Note: This parameter is intended exclusively +// for YouTube content partners. +// The onBehalfOfContentOwnerChannel parameter specifies the YouTube channel +// ID of the channel to which a video is being added. This parameter is +// required when a request specifies a value for the onBehalfOfContentOwner +// parameter, and it can only be used in conjunction with that parameter. In +// addition, the request must be authorized using a CMS account that is +// linked to the content owner that the onBehalfOfContentOwner parameter +// specifies. Finally, the channel that the onBehalfOfContentOwnerChannel +// parameter value specifies must be linked to the content owner that the +// onBehalfOfContentOwner parameter specifies. +// This parameter is intended for YouTube content partners that own and +// manage many different YouTube channels. It allows content owners to +// authenticate once and perform actions on behalf of the channel specified +// in the parameter value, without having to provide authentication +// credentials for each separate channel. +// Authorization scope(s): +// kGTLAuthScopeYouTube +// kGTLAuthScopeYouTubeYoutubepartner +// Fetches a GTLYouTubeChannelSection. ++ (id)queryForChannelSectionsInsertWithObject:(GTLYouTubeChannelSection *)object + part:(NSString *)part; + +// Method: youtube.channelSections.list +// Returns channelSection resources that match the API request criteria. +// Required: +// part: The part parameter specifies a comma-separated list of one or more +// channelSection resource properties that the API response will include. +// The part names that you can include in the parameter value are id, +// snippet, and contentDetails. +// If the parameter identifies a property that contains child properties, +// the child properties will be included in the response. For example, in a +// channelSection resource, the snippet property contains other properties, +// such as a display title for the channelSection. If you set part=snippet, +// the API response will also contain all of those nested properties. +// Optional: +// channelId: The channelId parameter specifies a YouTube channel ID. The API +// will only return that channel's channelSections. +// identifier: The id parameter specifies a comma-separated list of the +// YouTube channelSection ID(s) for the resource(s) that are being +// retrieved. In a channelSection resource, the id property specifies the +// YouTube channelSection ID. +// mine: Set this parameter's value to true to retrieve a feed of the +// authenticated user's channelSections. +// onBehalfOfContentOwner: Note: This parameter is intended exclusively for +// YouTube content partners. +// The onBehalfOfContentOwner parameter indicates that the request's +// authorization credentials identify a YouTube CMS user who is acting on +// behalf of the content owner specified in the parameter value. This +// parameter is intended for YouTube content partners that own and manage +// many different YouTube channels. It allows content owners to authenticate +// once and get access to all their video and channel data, without having +// to provide authentication credentials for each individual channel. The +// CMS account that the user authenticates with must be linked to the +// specified YouTube content owner. +// Authorization scope(s): +// kGTLAuthScopeYouTube +// kGTLAuthScopeYouTubeReadonly +// kGTLAuthScopeYouTubeYoutubepartner +// Fetches a GTLYouTubeChannelSectionListResponse. ++ (id)queryForChannelSectionsListWithPart:(NSString *)part; + +// Method: youtube.channelSections.update +// Update a channelSection. +// Required: +// part: The part parameter serves two purposes in this operation. It +// identifies the properties that the write operation will set as well as +// the properties that the API response will include. +// The part names that you can include in the parameter value are snippet +// and contentDetails. +// Optional: +// onBehalfOfContentOwner: Note: This parameter is intended exclusively for +// YouTube content partners. +// The onBehalfOfContentOwner parameter indicates that the request's +// authorization credentials identify a YouTube CMS user who is acting on +// behalf of the content owner specified in the parameter value. This +// parameter is intended for YouTube content partners that own and manage +// many different YouTube channels. It allows content owners to authenticate +// once and get access to all their video and channel data, without having +// to provide authentication credentials for each individual channel. The +// CMS account that the user authenticates with must be linked to the +// specified YouTube content owner. +// Authorization scope(s): +// kGTLAuthScopeYouTube +// kGTLAuthScopeYouTubeYoutubepartner +// Fetches a GTLYouTubeChannelSection. ++ (id)queryForChannelSectionsUpdateWithObject:(GTLYouTubeChannelSection *)object + part:(NSString *)part; + +#pragma mark - +#pragma mark "channels" methods +// These create a GTLQueryYouTube object. + +// Method: youtube.channels.list +// Returns a collection of zero or more channel resources that match the request +// criteria. +// Required: +// part: The part parameter specifies a comma-separated list of one or more +// channel resource properties that the API response will include. The part +// names that you can include in the parameter value are id, snippet, +// contentDetails, statistics, topicDetails, and invideoPromotion. +// If the parameter identifies a property that contains child properties, +// the child properties will be included in the response. For example, in a +// channel resource, the contentDetails property contains other properties, +// such as the uploads properties. As such, if you set part=contentDetails, +// the API response will also contain all of those nested properties. +// Optional: +// categoryId: The categoryId parameter specifies a YouTube guide category, +// thereby requesting YouTube channels associated with that category. +// forUsername: The forUsername parameter specifies a YouTube username, +// thereby requesting the channel associated with that username. +// identifier: The id parameter specifies a comma-separated list of the +// YouTube channel ID(s) for the resource(s) that are being retrieved. In a +// channel resource, the id property specifies the channel's YouTube channel +// ID. +// managedByMe: Set this parameter's value to true to instruct the API to only +// return channels managed by the content owner that the +// onBehalfOfContentOwner parameter specifies. The user must be +// authenticated as a CMS account linked to the specified content owner and +// onBehalfOfContentOwner must be provided. +// maxResults: The maxResults parameter specifies the maximum number of items +// that should be returned in the result set. (0..50, default 5) +// mine: Set this parameter's value to true to instruct the API to only return +// channels owned by the authenticated user. +// mySubscribers: Set this parameter's value to true to retrieve a list of +// channels that subscribed to the authenticated user's channel. +// onBehalfOfContentOwner: The onBehalfOfContentOwner parameter indicates that +// the authenticated user is acting on behalf of the content owner specified +// in the parameter value. This parameter is intended for YouTube content +// partners that own and manage many different YouTube channels. It allows +// content owners to authenticate once and get access to all their video and +// channel data, without having to provide authentication credentials for +// each individual channel. The actual CMS account that the user +// authenticates with needs to be linked to the specified YouTube content +// owner. +// pageToken: The pageToken parameter identifies a specific page in the result +// set that should be returned. In an API response, the nextPageToken and +// prevPageToken properties identify other pages that could be retrieved. +// Authorization scope(s): +// kGTLAuthScopeYouTube +// kGTLAuthScopeYouTubeReadonly +// kGTLAuthScopeYouTubeYoutubepartner +// kGTLAuthScopeYouTubeYoutubepartnerChannelAudit +// Fetches a GTLYouTubeChannelListResponse. ++ (id)queryForChannelsListWithPart:(NSString *)part; + +// Method: youtube.channels.update +// Updates a channel's metadata. +// Required: +// part: The part parameter serves two purposes in this operation. It +// identifies the properties that the write operation will set as well as +// the properties that the API response will include. +// The part names that you can include in the parameter value are id and +// invideoPromotion. +// Note that this method will override the existing values for all of the +// mutable properties that are contained in any parts that the parameter +// value specifies. +// Optional: +// onBehalfOfContentOwner: The onBehalfOfContentOwner parameter indicates that +// the authenticated user is acting on behalf of the content owner specified +// in the parameter value. This parameter is intended for YouTube content +// partners that own and manage many different YouTube channels. It allows +// content owners to authenticate once and get access to all their video and +// channel data, without having to provide authentication credentials for +// each individual channel. The actual CMS account that the user +// authenticates with needs to be linked to the specified YouTube content +// owner. +// Authorization scope(s): +// kGTLAuthScopeYouTube +// kGTLAuthScopeYouTubeYoutubepartner +// Fetches a GTLYouTubeChannel. ++ (id)queryForChannelsUpdateWithObject:(GTLYouTubeChannel *)object + part:(NSString *)part; + +#pragma mark - +#pragma mark "guideCategories" methods +// These create a GTLQueryYouTube object. + +// Method: youtube.guideCategories.list +// Returns a list of categories that can be associated with YouTube channels. +// Required: +// part: The part parameter specifies a comma-separated list of one or more +// guideCategory resource properties that the API response will include. The +// part names that you can include in the parameter value are id and +// snippet. +// If the parameter identifies a property that contains child properties, +// the child properties will be included in the response. For example, in a +// guideCategory resource, the snippet property contains other properties, +// such as the category's title. If you set part=snippet, the API response +// will also contain all of those nested properties. +// Optional: +// hl: The hl parameter specifies the language that will be used for text +// values in the API response. (Default en-US) +// identifier: The id parameter specifies a comma-separated list of the +// YouTube channel category ID(s) for the resource(s) that are being +// retrieved. In a guideCategory resource, the id property specifies the +// YouTube channel category ID. +// regionCode: The regionCode parameter instructs the API to return the list +// of guide categories available in the specified country. The parameter +// value is an ISO 3166-1 alpha-2 country code. +// Authorization scope(s): +// kGTLAuthScopeYouTube +// kGTLAuthScopeYouTubeReadonly +// kGTLAuthScopeYouTubeYoutubepartner +// Fetches a GTLYouTubeGuideCategoryListResponse. ++ (id)queryForGuideCategoriesListWithPart:(NSString *)part; + +#pragma mark - +#pragma mark "i18nLanguages" methods +// These create a GTLQueryYouTube object. + +// Method: youtube.i18nLanguages.list +// Returns a list of supported languages. +// Required: +// part: The part parameter specifies a comma-separated list of one or more +// i18nLanguage resource properties that the API response will include. The +// part names that you can include in the parameter value are id and +// snippet. +// Optional: +// hl: The hl parameter specifies the language that should be used for text +// values in the API response. (Default en_US) +// Authorization scope(s): +// kGTLAuthScopeYouTube +// kGTLAuthScopeYouTubeReadonly +// kGTLAuthScopeYouTubeYoutubepartner +// Fetches a GTLYouTubeI18nLanguageListResponse. ++ (id)queryForI18nLanguagesListWithPart:(NSString *)part; + +#pragma mark - +#pragma mark "i18nRegions" methods +// These create a GTLQueryYouTube object. + +// Method: youtube.i18nRegions.list +// Returns a list of supported regions. +// Required: +// part: The part parameter specifies a comma-separated list of one or more +// i18nRegion resource properties that the API response will include. The +// part names that you can include in the parameter value are id and +// snippet. +// Optional: +// hl: The hl parameter specifies the language that should be used for text +// values in the API response. (Default en_US) +// Authorization scope(s): +// kGTLAuthScopeYouTube +// kGTLAuthScopeYouTubeReadonly +// kGTLAuthScopeYouTubeYoutubepartner +// Fetches a GTLYouTubeI18nRegionListResponse. ++ (id)queryForI18nRegionsListWithPart:(NSString *)part; + +#pragma mark - +#pragma mark "liveBroadcasts" methods +// These create a GTLQueryYouTube object. + +// Method: youtube.liveBroadcasts.bind +// Binds a YouTube broadcast to a stream or removes an existing binding between +// a broadcast and a stream. A broadcast can only be bound to one video stream. +// Required: +// identifier: The id parameter specifies the unique ID of the broadcast that +// is being bound to a video stream. +// part: The part parameter specifies a comma-separated list of one or more +// liveBroadcast resource properties that the API response will include. The +// part names that you can include in the parameter value are id, snippet, +// contentDetails, and status. +// Optional: +// onBehalfOfContentOwner: Note: This parameter is intended exclusively for +// YouTube content partners. +// The onBehalfOfContentOwner parameter indicates that the request's +// authorization credentials identify a YouTube CMS user who is acting on +// behalf of the content owner specified in the parameter value. This +// parameter is intended for YouTube content partners that own and manage +// many different YouTube channels. It allows content owners to authenticate +// once and get access to all their video and channel data, without having +// to provide authentication credentials for each individual channel. The +// CMS account that the user authenticates with must be linked to the +// specified YouTube content owner. +// onBehalfOfContentOwnerChannel: This parameter can only be used in a +// properly authorized request. Note: This parameter is intended exclusively +// for YouTube content partners. +// The onBehalfOfContentOwnerChannel parameter specifies the YouTube channel +// ID of the channel to which a video is being added. This parameter is +// required when a request specifies a value for the onBehalfOfContentOwner +// parameter, and it can only be used in conjunction with that parameter. In +// addition, the request must be authorized using a CMS account that is +// linked to the content owner that the onBehalfOfContentOwner parameter +// specifies. Finally, the channel that the onBehalfOfContentOwnerChannel +// parameter value specifies must be linked to the content owner that the +// onBehalfOfContentOwner parameter specifies. +// This parameter is intended for YouTube content partners that own and +// manage many different YouTube channels. It allows content owners to +// authenticate once and perform actions on behalf of the channel specified +// in the parameter value, without having to provide authentication +// credentials for each separate channel. +// streamId: The streamId parameter specifies the unique ID of the video +// stream that is being bound to a broadcast. If this parameter is omitted, +// the API will remove any existing binding between the broadcast and a +// video stream. +// Authorization scope(s): +// kGTLAuthScopeYouTube +// Fetches a GTLYouTubeLiveBroadcast. ++ (id)queryForLiveBroadcastsBindWithIdentifier:(NSString *)identifier + part:(NSString *)part; + +// Method: youtube.liveBroadcasts.control +// Controls the settings for a slate that can be displayed in the broadcast +// stream. +// Required: +// identifier: The id parameter specifies the YouTube live broadcast ID that +// uniquely identifies the broadcast in which the slate is being updated. +// part: The part parameter specifies a comma-separated list of one or more +// liveBroadcast resource properties that the API response will include. The +// part names that you can include in the parameter value are id, snippet, +// contentDetails, and status. +// Optional: +// displaySlate: The displaySlate parameter specifies whether the slate is +// being enabled or disabled. +// offsetTimeMs: The offsetTimeMs parameter specifies a positive time offset +// when the specified slate change will occur. The value is measured in +// milliseconds from the beginning of the broadcast's monitor stream, which +// is the time that the testing phase for the broadcast began. Even though +// it is specified in milliseconds, the value is actually an approximation, +// and YouTube completes the requested action as closely as possible to that +// time. +// If you do not specify a value for this parameter, then YouTube performs +// the action as soon as possible. See the Getting started guide for more +// details. +// Important: You should only specify a value for this parameter if your +// broadcast stream is delayed. +// onBehalfOfContentOwner: Note: This parameter is intended exclusively for +// YouTube content partners. +// The onBehalfOfContentOwner parameter indicates that the request's +// authorization credentials identify a YouTube CMS user who is acting on +// behalf of the content owner specified in the parameter value. This +// parameter is intended for YouTube content partners that own and manage +// many different YouTube channels. It allows content owners to authenticate +// once and get access to all their video and channel data, without having +// to provide authentication credentials for each individual channel. The +// CMS account that the user authenticates with must be linked to the +// specified YouTube content owner. +// onBehalfOfContentOwnerChannel: This parameter can only be used in a +// properly authorized request. Note: This parameter is intended exclusively +// for YouTube content partners. +// The onBehalfOfContentOwnerChannel parameter specifies the YouTube channel +// ID of the channel to which a video is being added. This parameter is +// required when a request specifies a value for the onBehalfOfContentOwner +// parameter, and it can only be used in conjunction with that parameter. In +// addition, the request must be authorized using a CMS account that is +// linked to the content owner that the onBehalfOfContentOwner parameter +// specifies. Finally, the channel that the onBehalfOfContentOwnerChannel +// parameter value specifies must be linked to the content owner that the +// onBehalfOfContentOwner parameter specifies. +// This parameter is intended for YouTube content partners that own and +// manage many different YouTube channels. It allows content owners to +// authenticate once and perform actions on behalf of the channel specified +// in the parameter value, without having to provide authentication +// credentials for each separate channel. +// walltime: The walltime parameter specifies the wall clock time at which the +// specified slate change will occur. The value is specified in ISO 8601 +// (YYYY-MM-DDThh:mm:ss.sssZ) format. +// Authorization scope(s): +// kGTLAuthScopeYouTube +// Fetches a GTLYouTubeLiveBroadcast. ++ (id)queryForLiveBroadcastsControlWithIdentifier:(NSString *)identifier + part:(NSString *)part; + +// Method: youtube.liveBroadcasts.delete +// Deletes a broadcast. +// Required: +// identifier: The id parameter specifies the YouTube live broadcast ID for +// the resource that is being deleted. +// Optional: +// onBehalfOfContentOwner: Note: This parameter is intended exclusively for +// YouTube content partners. +// The onBehalfOfContentOwner parameter indicates that the request's +// authorization credentials identify a YouTube CMS user who is acting on +// behalf of the content owner specified in the parameter value. This +// parameter is intended for YouTube content partners that own and manage +// many different YouTube channels. It allows content owners to authenticate +// once and get access to all their video and channel data, without having +// to provide authentication credentials for each individual channel. The +// CMS account that the user authenticates with must be linked to the +// specified YouTube content owner. +// onBehalfOfContentOwnerChannel: This parameter can only be used in a +// properly authorized request. Note: This parameter is intended exclusively +// for YouTube content partners. +// The onBehalfOfContentOwnerChannel parameter specifies the YouTube channel +// ID of the channel to which a video is being added. This parameter is +// required when a request specifies a value for the onBehalfOfContentOwner +// parameter, and it can only be used in conjunction with that parameter. In +// addition, the request must be authorized using a CMS account that is +// linked to the content owner that the onBehalfOfContentOwner parameter +// specifies. Finally, the channel that the onBehalfOfContentOwnerChannel +// parameter value specifies must be linked to the content owner that the +// onBehalfOfContentOwner parameter specifies. +// This parameter is intended for YouTube content partners that own and +// manage many different YouTube channels. It allows content owners to +// authenticate once and perform actions on behalf of the channel specified +// in the parameter value, without having to provide authentication +// credentials for each separate channel. +// Authorization scope(s): +// kGTLAuthScopeYouTube ++ (id)queryForLiveBroadcastsDeleteWithIdentifier:(NSString *)identifier; + +// Method: youtube.liveBroadcasts.insert +// Creates a broadcast. +// Required: +// part: The part parameter serves two purposes in this operation. It +// identifies the properties that the write operation will set as well as +// the properties that the API response will include. +// The part properties that you can include in the parameter value are id, +// snippet, contentDetails, and status. +// Optional: +// onBehalfOfContentOwner: Note: This parameter is intended exclusively for +// YouTube content partners. +// The onBehalfOfContentOwner parameter indicates that the request's +// authorization credentials identify a YouTube CMS user who is acting on +// behalf of the content owner specified in the parameter value. This +// parameter is intended for YouTube content partners that own and manage +// many different YouTube channels. It allows content owners to authenticate +// once and get access to all their video and channel data, without having +// to provide authentication credentials for each individual channel. The +// CMS account that the user authenticates with must be linked to the +// specified YouTube content owner. +// onBehalfOfContentOwnerChannel: This parameter can only be used in a +// properly authorized request. Note: This parameter is intended exclusively +// for YouTube content partners. +// The onBehalfOfContentOwnerChannel parameter specifies the YouTube channel +// ID of the channel to which a video is being added. This parameter is +// required when a request specifies a value for the onBehalfOfContentOwner +// parameter, and it can only be used in conjunction with that parameter. In +// addition, the request must be authorized using a CMS account that is +// linked to the content owner that the onBehalfOfContentOwner parameter +// specifies. Finally, the channel that the onBehalfOfContentOwnerChannel +// parameter value specifies must be linked to the content owner that the +// onBehalfOfContentOwner parameter specifies. +// This parameter is intended for YouTube content partners that own and +// manage many different YouTube channels. It allows content owners to +// authenticate once and perform actions on behalf of the channel specified +// in the parameter value, without having to provide authentication +// credentials for each separate channel. +// Authorization scope(s): +// kGTLAuthScopeYouTube +// Fetches a GTLYouTubeLiveBroadcast. ++ (id)queryForLiveBroadcastsInsertWithObject:(GTLYouTubeLiveBroadcast *)object + part:(NSString *)part; + +// Method: youtube.liveBroadcasts.list +// Returns a list of YouTube broadcasts that match the API request parameters. +// Required: +// part: The part parameter specifies a comma-separated list of one or more +// liveBroadcast resource properties that the API response will include. The +// part names that you can include in the parameter value are id, snippet, +// contentDetails, and status. +// Optional: +// broadcastStatus: The broadcastStatus parameter filters the API response to +// only include broadcasts with the specified status. +// kGTLYouTubeBroadcastStatusActive: Return current live broadcasts. +// kGTLYouTubeBroadcastStatusAll: Return all broadcasts. +// kGTLYouTubeBroadcastStatusCompleted: Return broadcasts that have already +// ended. +// kGTLYouTubeBroadcastStatusUpcoming: Return broadcasts that have not yet +// started. +// identifier: The id parameter specifies a comma-separated list of YouTube +// broadcast IDs that identify the broadcasts being retrieved. In a +// liveBroadcast resource, the id property specifies the broadcast's ID. +// maxResults: The maxResults parameter specifies the maximum number of items +// that should be returned in the result set. (0..50, default 5) +// mine: The mine parameter can be used to instruct the API to only return +// broadcasts owned by the authenticated user. Set the parameter value to +// true to only retrieve your own broadcasts. +// onBehalfOfContentOwner: Note: This parameter is intended exclusively for +// YouTube content partners. +// The onBehalfOfContentOwner parameter indicates that the request's +// authorization credentials identify a YouTube CMS user who is acting on +// behalf of the content owner specified in the parameter value. This +// parameter is intended for YouTube content partners that own and manage +// many different YouTube channels. It allows content owners to authenticate +// once and get access to all their video and channel data, without having +// to provide authentication credentials for each individual channel. The +// CMS account that the user authenticates with must be linked to the +// specified YouTube content owner. +// onBehalfOfContentOwnerChannel: This parameter can only be used in a +// properly authorized request. Note: This parameter is intended exclusively +// for YouTube content partners. +// The onBehalfOfContentOwnerChannel parameter specifies the YouTube channel +// ID of the channel to which a video is being added. This parameter is +// required when a request specifies a value for the onBehalfOfContentOwner +// parameter, and it can only be used in conjunction with that parameter. In +// addition, the request must be authorized using a CMS account that is +// linked to the content owner that the onBehalfOfContentOwner parameter +// specifies. Finally, the channel that the onBehalfOfContentOwnerChannel +// parameter value specifies must be linked to the content owner that the +// onBehalfOfContentOwner parameter specifies. +// This parameter is intended for YouTube content partners that own and +// manage many different YouTube channels. It allows content owners to +// authenticate once and perform actions on behalf of the channel specified +// in the parameter value, without having to provide authentication +// credentials for each separate channel. +// pageToken: The pageToken parameter identifies a specific page in the result +// set that should be returned. In an API response, the nextPageToken and +// prevPageToken properties identify other pages that could be retrieved. +// Authorization scope(s): +// kGTLAuthScopeYouTube +// kGTLAuthScopeYouTubeReadonly +// Fetches a GTLYouTubeLiveBroadcastListResponse. ++ (id)queryForLiveBroadcastsListWithPart:(NSString *)part; + +// Method: youtube.liveBroadcasts.transition +// Changes the status of a YouTube live broadcast and initiates any processes +// associated with the new status. For example, when you transition a +// broadcast's status to testing, YouTube starts to transmit video to that +// broadcast's monitor stream. Before calling this method, you should confirm +// that the value of the status.streamStatus property for the stream bound to +// your broadcast is active. +// Required: +// broadcastStatus: The broadcastStatus parameter identifies the state to +// which the broadcast is changing. Note that to transition a broadcast to +// either the testing or live state, the status.streamStatus must be active +// for the stream that the broadcast is bound to. +// kGTLYouTubeBroadcastStatusComplete: The broadcast is over. YouTube stops +// transmitting video. +// kGTLYouTubeBroadcastStatusLive: The broadcast is visible to its +// audience. YouTube transmits video to the broadcast's monitor stream +// and its broadcast stream. +// kGTLYouTubeBroadcastStatusTesting: Start testing the broadcast. YouTube +// transmits video to the broadcast's monitor stream. Note that you can +// only transition a broadcast to the testing state if its +// contentDetails.monitorStream.enableMonitorStream property is set to +// true. +// identifier: The id parameter specifies the unique ID of the broadcast that +// is transitioning to another status. +// part: The part parameter specifies a comma-separated list of one or more +// liveBroadcast resource properties that the API response will include. The +// part names that you can include in the parameter value are id, snippet, +// contentDetails, and status. +// Optional: +// onBehalfOfContentOwner: Note: This parameter is intended exclusively for +// YouTube content partners. +// The onBehalfOfContentOwner parameter indicates that the request's +// authorization credentials identify a YouTube CMS user who is acting on +// behalf of the content owner specified in the parameter value. This +// parameter is intended for YouTube content partners that own and manage +// many different YouTube channels. It allows content owners to authenticate +// once and get access to all their video and channel data, without having +// to provide authentication credentials for each individual channel. The +// CMS account that the user authenticates with must be linked to the +// specified YouTube content owner. +// onBehalfOfContentOwnerChannel: This parameter can only be used in a +// properly authorized request. Note: This parameter is intended exclusively +// for YouTube content partners. +// The onBehalfOfContentOwnerChannel parameter specifies the YouTube channel +// ID of the channel to which a video is being added. This parameter is +// required when a request specifies a value for the onBehalfOfContentOwner +// parameter, and it can only be used in conjunction with that parameter. In +// addition, the request must be authorized using a CMS account that is +// linked to the content owner that the onBehalfOfContentOwner parameter +// specifies. Finally, the channel that the onBehalfOfContentOwnerChannel +// parameter value specifies must be linked to the content owner that the +// onBehalfOfContentOwner parameter specifies. +// This parameter is intended for YouTube content partners that own and +// manage many different YouTube channels. It allows content owners to +// authenticate once and perform actions on behalf of the channel specified +// in the parameter value, without having to provide authentication +// credentials for each separate channel. +// Authorization scope(s): +// kGTLAuthScopeYouTube +// Fetches a GTLYouTubeLiveBroadcast. ++ (id)queryForLiveBroadcastsTransitionWithBroadcastStatus:(NSString *)broadcastStatus + identifier:(NSString *)identifier + part:(NSString *)part; + +// Method: youtube.liveBroadcasts.update +// Updates a broadcast. For example, you could modify the broadcast settings +// defined in the liveBroadcast resource's contentDetails object. +// Required: +// part: The part parameter serves two purposes in this operation. It +// identifies the properties that the write operation will set as well as +// the properties that the API response will include. +// The part properties that you can include in the parameter value are id, +// snippet, contentDetails, and status. +// Note that this method will override the existing values for all of the +// mutable properties that are contained in any parts that the parameter +// value specifies. For example, a broadcast's privacy status is defined in +// the status part. As such, if your request is updating a private or +// unlisted broadcast, and the request's part parameter value includes the +// status part, the broadcast's privacy setting will be updated to whatever +// value the request body specifies. If the request body does not specify a +// value, the existing privacy setting will be removed and the broadcast +// will revert to the default privacy setting. +// Optional: +// onBehalfOfContentOwner: Note: This parameter is intended exclusively for +// YouTube content partners. +// The onBehalfOfContentOwner parameter indicates that the request's +// authorization credentials identify a YouTube CMS user who is acting on +// behalf of the content owner specified in the parameter value. This +// parameter is intended for YouTube content partners that own and manage +// many different YouTube channels. It allows content owners to authenticate +// once and get access to all their video and channel data, without having +// to provide authentication credentials for each individual channel. The +// CMS account that the user authenticates with must be linked to the +// specified YouTube content owner. +// onBehalfOfContentOwnerChannel: This parameter can only be used in a +// properly authorized request. Note: This parameter is intended exclusively +// for YouTube content partners. +// The onBehalfOfContentOwnerChannel parameter specifies the YouTube channel +// ID of the channel to which a video is being added. This parameter is +// required when a request specifies a value for the onBehalfOfContentOwner +// parameter, and it can only be used in conjunction with that parameter. In +// addition, the request must be authorized using a CMS account that is +// linked to the content owner that the onBehalfOfContentOwner parameter +// specifies. Finally, the channel that the onBehalfOfContentOwnerChannel +// parameter value specifies must be linked to the content owner that the +// onBehalfOfContentOwner parameter specifies. +// This parameter is intended for YouTube content partners that own and +// manage many different YouTube channels. It allows content owners to +// authenticate once and perform actions on behalf of the channel specified +// in the parameter value, without having to provide authentication +// credentials for each separate channel. +// Authorization scope(s): +// kGTLAuthScopeYouTube +// Fetches a GTLYouTubeLiveBroadcast. ++ (id)queryForLiveBroadcastsUpdateWithObject:(GTLYouTubeLiveBroadcast *)object + part:(NSString *)part; + +#pragma mark - +#pragma mark "liveStreams" methods +// These create a GTLQueryYouTube object. + +// Method: youtube.liveStreams.delete +// Deletes a video stream. +// Required: +// identifier: The id parameter specifies the YouTube live stream ID for the +// resource that is being deleted. +// Optional: +// onBehalfOfContentOwner: Note: This parameter is intended exclusively for +// YouTube content partners. +// The onBehalfOfContentOwner parameter indicates that the request's +// authorization credentials identify a YouTube CMS user who is acting on +// behalf of the content owner specified in the parameter value. This +// parameter is intended for YouTube content partners that own and manage +// many different YouTube channels. It allows content owners to authenticate +// once and get access to all their video and channel data, without having +// to provide authentication credentials for each individual channel. The +// CMS account that the user authenticates with must be linked to the +// specified YouTube content owner. +// onBehalfOfContentOwnerChannel: This parameter can only be used in a +// properly authorized request. Note: This parameter is intended exclusively +// for YouTube content partners. +// The onBehalfOfContentOwnerChannel parameter specifies the YouTube channel +// ID of the channel to which a video is being added. This parameter is +// required when a request specifies a value for the onBehalfOfContentOwner +// parameter, and it can only be used in conjunction with that parameter. In +// addition, the request must be authorized using a CMS account that is +// linked to the content owner that the onBehalfOfContentOwner parameter +// specifies. Finally, the channel that the onBehalfOfContentOwnerChannel +// parameter value specifies must be linked to the content owner that the +// onBehalfOfContentOwner parameter specifies. +// This parameter is intended for YouTube content partners that own and +// manage many different YouTube channels. It allows content owners to +// authenticate once and perform actions on behalf of the channel specified +// in the parameter value, without having to provide authentication +// credentials for each separate channel. +// Authorization scope(s): +// kGTLAuthScopeYouTube ++ (id)queryForLiveStreamsDeleteWithIdentifier:(NSString *)identifier; + +// Method: youtube.liveStreams.insert +// Creates a video stream. The stream enables you to send your video to YouTube, +// which can then broadcast the video to your audience. +// Required: +// part: The part parameter serves two purposes in this operation. It +// identifies the properties that the write operation will set as well as +// the properties that the API response will include. +// The part properties that you can include in the parameter value are id, +// snippet, cdn, and status. +// Optional: +// onBehalfOfContentOwner: Note: This parameter is intended exclusively for +// YouTube content partners. +// The onBehalfOfContentOwner parameter indicates that the request's +// authorization credentials identify a YouTube CMS user who is acting on +// behalf of the content owner specified in the parameter value. This +// parameter is intended for YouTube content partners that own and manage +// many different YouTube channels. It allows content owners to authenticate +// once and get access to all their video and channel data, without having +// to provide authentication credentials for each individual channel. The +// CMS account that the user authenticates with must be linked to the +// specified YouTube content owner. +// onBehalfOfContentOwnerChannel: This parameter can only be used in a +// properly authorized request. Note: This parameter is intended exclusively +// for YouTube content partners. +// The onBehalfOfContentOwnerChannel parameter specifies the YouTube channel +// ID of the channel to which a video is being added. This parameter is +// required when a request specifies a value for the onBehalfOfContentOwner +// parameter, and it can only be used in conjunction with that parameter. In +// addition, the request must be authorized using a CMS account that is +// linked to the content owner that the onBehalfOfContentOwner parameter +// specifies. Finally, the channel that the onBehalfOfContentOwnerChannel +// parameter value specifies must be linked to the content owner that the +// onBehalfOfContentOwner parameter specifies. +// This parameter is intended for YouTube content partners that own and +// manage many different YouTube channels. It allows content owners to +// authenticate once and perform actions on behalf of the channel specified +// in the parameter value, without having to provide authentication +// credentials for each separate channel. +// Authorization scope(s): +// kGTLAuthScopeYouTube +// Fetches a GTLYouTubeLiveStream. ++ (id)queryForLiveStreamsInsertWithObject:(GTLYouTubeLiveStream *)object + part:(NSString *)part; + +// Method: youtube.liveStreams.list +// Returns a list of video streams that match the API request parameters. +// Required: +// part: The part parameter specifies a comma-separated list of one or more +// liveStream resource properties that the API response will include. The +// part names that you can include in the parameter value are id, snippet, +// cdn, and status. +// Optional: +// identifier: The id parameter specifies a comma-separated list of YouTube +// stream IDs that identify the streams being retrieved. In a liveStream +// resource, the id property specifies the stream's ID. +// maxResults: The maxResults parameter specifies the maximum number of items +// that should be returned in the result set. Acceptable values are 0 to 50, +// inclusive. The default value is 5. (0..50, default 5) +// mine: The mine parameter can be used to instruct the API to only return +// streams owned by the authenticated user. Set the parameter value to true +// to only retrieve your own streams. +// onBehalfOfContentOwner: Note: This parameter is intended exclusively for +// YouTube content partners. +// The onBehalfOfContentOwner parameter indicates that the request's +// authorization credentials identify a YouTube CMS user who is acting on +// behalf of the content owner specified in the parameter value. This +// parameter is intended for YouTube content partners that own and manage +// many different YouTube channels. It allows content owners to authenticate +// once and get access to all their video and channel data, without having +// to provide authentication credentials for each individual channel. The +// CMS account that the user authenticates with must be linked to the +// specified YouTube content owner. +// onBehalfOfContentOwnerChannel: This parameter can only be used in a +// properly authorized request. Note: This parameter is intended exclusively +// for YouTube content partners. +// The onBehalfOfContentOwnerChannel parameter specifies the YouTube channel +// ID of the channel to which a video is being added. This parameter is +// required when a request specifies a value for the onBehalfOfContentOwner +// parameter, and it can only be used in conjunction with that parameter. In +// addition, the request must be authorized using a CMS account that is +// linked to the content owner that the onBehalfOfContentOwner parameter +// specifies. Finally, the channel that the onBehalfOfContentOwnerChannel +// parameter value specifies must be linked to the content owner that the +// onBehalfOfContentOwner parameter specifies. +// This parameter is intended for YouTube content partners that own and +// manage many different YouTube channels. It allows content owners to +// authenticate once and perform actions on behalf of the channel specified +// in the parameter value, without having to provide authentication +// credentials for each separate channel. +// pageToken: The pageToken parameter identifies a specific page in the result +// set that should be returned. In an API response, the nextPageToken and +// prevPageToken properties identify other pages that could be retrieved. +// Authorization scope(s): +// kGTLAuthScopeYouTube +// kGTLAuthScopeYouTubeReadonly +// Fetches a GTLYouTubeLiveStreamListResponse. ++ (id)queryForLiveStreamsListWithPart:(NSString *)part; + +// Method: youtube.liveStreams.update +// Updates a video stream. If the properties that you want to change cannot be +// updated, then you need to create a new stream with the proper settings. +// Required: +// part: The part parameter serves two purposes in this operation. It +// identifies the properties that the write operation will set as well as +// the properties that the API response will include. +// The part properties that you can include in the parameter value are id, +// snippet, cdn, and status. +// Note that this method will override the existing values for all of the +// mutable properties that are contained in any parts that the parameter +// value specifies. If the request body does not specify a value for a +// mutable property, the existing value for that property will be removed. +// Optional: +// onBehalfOfContentOwner: Note: This parameter is intended exclusively for +// YouTube content partners. +// The onBehalfOfContentOwner parameter indicates that the request's +// authorization credentials identify a YouTube CMS user who is acting on +// behalf of the content owner specified in the parameter value. This +// parameter is intended for YouTube content partners that own and manage +// many different YouTube channels. It allows content owners to authenticate +// once and get access to all their video and channel data, without having +// to provide authentication credentials for each individual channel. The +// CMS account that the user authenticates with must be linked to the +// specified YouTube content owner. +// onBehalfOfContentOwnerChannel: This parameter can only be used in a +// properly authorized request. Note: This parameter is intended exclusively +// for YouTube content partners. +// The onBehalfOfContentOwnerChannel parameter specifies the YouTube channel +// ID of the channel to which a video is being added. This parameter is +// required when a request specifies a value for the onBehalfOfContentOwner +// parameter, and it can only be used in conjunction with that parameter. In +// addition, the request must be authorized using a CMS account that is +// linked to the content owner that the onBehalfOfContentOwner parameter +// specifies. Finally, the channel that the onBehalfOfContentOwnerChannel +// parameter value specifies must be linked to the content owner that the +// onBehalfOfContentOwner parameter specifies. +// This parameter is intended for YouTube content partners that own and +// manage many different YouTube channels. It allows content owners to +// authenticate once and perform actions on behalf of the channel specified +// in the parameter value, without having to provide authentication +// credentials for each separate channel. +// Authorization scope(s): +// kGTLAuthScopeYouTube +// Fetches a GTLYouTubeLiveStream. ++ (id)queryForLiveStreamsUpdateWithObject:(GTLYouTubeLiveStream *)object + part:(NSString *)part; + +#pragma mark - +#pragma mark "playlistItems" methods +// These create a GTLQueryYouTube object. + +// Method: youtube.playlistItems.delete +// Deletes a playlist item. +// Required: +// identifier: The id parameter specifies the YouTube playlist item ID for the +// playlist item that is being deleted. In a playlistItem resource, the id +// property specifies the playlist item's ID. +// Authorization scope(s): +// kGTLAuthScopeYouTube +// kGTLAuthScopeYouTubeYoutubepartner ++ (id)queryForPlaylistItemsDeleteWithIdentifier:(NSString *)identifier; + +// Method: youtube.playlistItems.insert +// Adds a resource to a playlist. +// Required: +// part: The part parameter serves two purposes in this operation. It +// identifies the properties that the write operation will set as well as +// the properties that the API response will include. +// The part names that you can include in the parameter value are snippet, +// contentDetails, and status. +// Optional: +// onBehalfOfContentOwner: Note: This parameter is intended exclusively for +// YouTube content partners. +// The onBehalfOfContentOwner parameter indicates that the request's +// authorization credentials identify a YouTube CMS user who is acting on +// behalf of the content owner specified in the parameter value. This +// parameter is intended for YouTube content partners that own and manage +// many different YouTube channels. It allows content owners to authenticate +// once and get access to all their video and channel data, without having +// to provide authentication credentials for each individual channel. The +// CMS account that the user authenticates with must be linked to the +// specified YouTube content owner. +// Authorization scope(s): +// kGTLAuthScopeYouTube +// kGTLAuthScopeYouTubeYoutubepartner +// Fetches a GTLYouTubePlaylistItem. ++ (id)queryForPlaylistItemsInsertWithObject:(GTLYouTubePlaylistItem *)object + part:(NSString *)part; + +// Method: youtube.playlistItems.list +// Returns a collection of playlist items that match the API request parameters. +// You can retrieve all of the playlist items in a specified playlist or +// retrieve one or more playlist items by their unique IDs. +// Required: +// part: The part parameter specifies a comma-separated list of one or more +// playlistItem resource properties that the API response will include. The +// part names that you can include in the parameter value are id, snippet, +// contentDetails, and status. +// If the parameter identifies a property that contains child properties, +// the child properties will be included in the response. For example, in a +// playlistItem resource, the snippet property contains numerous fields, +// including the title, description, position, and resourceId properties. As +// such, if you set part=snippet, the API response will contain all of those +// properties. +// Optional: +// identifier: The id parameter specifies a comma-separated list of one or +// more unique playlist item IDs. +// maxResults: The maxResults parameter specifies the maximum number of items +// that should be returned in the result set. (0..50, default 5) +// onBehalfOfContentOwner: Note: This parameter is intended exclusively for +// YouTube content partners. +// The onBehalfOfContentOwner parameter indicates that the request's +// authorization credentials identify a YouTube CMS user who is acting on +// behalf of the content owner specified in the parameter value. This +// parameter is intended for YouTube content partners that own and manage +// many different YouTube channels. It allows content owners to authenticate +// once and get access to all their video and channel data, without having +// to provide authentication credentials for each individual channel. The +// CMS account that the user authenticates with must be linked to the +// specified YouTube content owner. +// pageToken: The pageToken parameter identifies a specific page in the result +// set that should be returned. In an API response, the nextPageToken and +// prevPageToken properties identify other pages that could be retrieved. +// playlistId: The playlistId parameter specifies the unique ID of the +// playlist for which you want to retrieve playlist items. Note that even +// though this is an optional parameter, every request to retrieve playlist +// items must specify a value for either the id parameter or the playlistId +// parameter. +// videoId: The videoId parameter specifies that the request should return +// only the playlist items that contain the specified video. +// Authorization scope(s): +// kGTLAuthScopeYouTube +// kGTLAuthScopeYouTubeReadonly +// kGTLAuthScopeYouTubeYoutubepartner +// Fetches a GTLYouTubePlaylistItemListResponse. ++ (id)queryForPlaylistItemsListWithPart:(NSString *)part; + +// Method: youtube.playlistItems.update +// Modifies a playlist item. For example, you could update the item's position +// in the playlist. +// Required: +// part: The part parameter serves two purposes in this operation. It +// identifies the properties that the write operation will set as well as +// the properties that the API response will include. +// The part names that you can include in the parameter value are snippet, +// contentDetails, and status. +// Note that this method will override the existing values for all of the +// mutable properties that are contained in any parts that the parameter +// value specifies. For example, a playlist item can specify a start time +// and end time, which identify the times portion of the video that should +// play when users watch the video in the playlist. If your request is +// updating a playlist item that sets these values, and the request's part +// parameter value includes the contentDetails part, the playlist item's +// start and end times will be updated to whatever value the request body +// specifies. If the request body does not specify values, the existing +// start and end times will be removed and replaced with the default +// settings. +// Authorization scope(s): +// kGTLAuthScopeYouTube +// kGTLAuthScopeYouTubeYoutubepartner +// Fetches a GTLYouTubePlaylistItem. ++ (id)queryForPlaylistItemsUpdateWithObject:(GTLYouTubePlaylistItem *)object + part:(NSString *)part; + +#pragma mark - +#pragma mark "playlists" methods +// These create a GTLQueryYouTube object. + +// Method: youtube.playlists.delete +// Deletes a playlist. +// Required: +// identifier: The id parameter specifies the YouTube playlist ID for the +// playlist that is being deleted. In a playlist resource, the id property +// specifies the playlist's ID. +// Optional: +// onBehalfOfContentOwner: Note: This parameter is intended exclusively for +// YouTube content partners. +// The onBehalfOfContentOwner parameter indicates that the request's +// authorization credentials identify a YouTube CMS user who is acting on +// behalf of the content owner specified in the parameter value. This +// parameter is intended for YouTube content partners that own and manage +// many different YouTube channels. It allows content owners to authenticate +// once and get access to all their video and channel data, without having +// to provide authentication credentials for each individual channel. The +// CMS account that the user authenticates with must be linked to the +// specified YouTube content owner. +// Authorization scope(s): +// kGTLAuthScopeYouTube +// kGTLAuthScopeYouTubeYoutubepartner ++ (id)queryForPlaylistsDeleteWithIdentifier:(NSString *)identifier; + +// Method: youtube.playlists.insert +// Creates a playlist. +// Required: +// part: The part parameter serves two purposes in this operation. It +// identifies the properties that the write operation will set as well as +// the properties that the API response will include. +// The part names that you can include in the parameter value are snippet +// and status. +// Optional: +// onBehalfOfContentOwner: Note: This parameter is intended exclusively for +// YouTube content partners. +// The onBehalfOfContentOwner parameter indicates that the request's +// authorization credentials identify a YouTube CMS user who is acting on +// behalf of the content owner specified in the parameter value. This +// parameter is intended for YouTube content partners that own and manage +// many different YouTube channels. It allows content owners to authenticate +// once and get access to all their video and channel data, without having +// to provide authentication credentials for each individual channel. The +// CMS account that the user authenticates with must be linked to the +// specified YouTube content owner. +// onBehalfOfContentOwnerChannel: This parameter can only be used in a +// properly authorized request. Note: This parameter is intended exclusively +// for YouTube content partners. +// The onBehalfOfContentOwnerChannel parameter specifies the YouTube channel +// ID of the channel to which a video is being added. This parameter is +// required when a request specifies a value for the onBehalfOfContentOwner +// parameter, and it can only be used in conjunction with that parameter. In +// addition, the request must be authorized using a CMS account that is +// linked to the content owner that the onBehalfOfContentOwner parameter +// specifies. Finally, the channel that the onBehalfOfContentOwnerChannel +// parameter value specifies must be linked to the content owner that the +// onBehalfOfContentOwner parameter specifies. +// This parameter is intended for YouTube content partners that own and +// manage many different YouTube channels. It allows content owners to +// authenticate once and perform actions on behalf of the channel specified +// in the parameter value, without having to provide authentication +// credentials for each separate channel. +// Authorization scope(s): +// kGTLAuthScopeYouTube +// kGTLAuthScopeYouTubeYoutubepartner +// Fetches a GTLYouTubePlaylist. ++ (id)queryForPlaylistsInsertWithObject:(GTLYouTubePlaylist *)object + part:(NSString *)part; + +// Method: youtube.playlists.list +// Returns a collection of playlists that match the API request parameters. For +// example, you can retrieve all playlists that the authenticated user owns, or +// you can retrieve one or more playlists by their unique IDs. +// Required: +// part: The part parameter specifies a comma-separated list of one or more +// playlist resource properties that the API response will include. The part +// names that you can include in the parameter value are id, snippet, +// status, and contentDetails. +// If the parameter identifies a property that contains child properties, +// the child properties will be included in the response. For example, in a +// playlist resource, the snippet property contains properties like author, +// title, description, tags, and timeCreated. As such, if you set +// part=snippet, the API response will contain all of those properties. +// Optional: +// channelId: This value indicates that the API should only return the +// specified channel's playlists. +// identifier: The id parameter specifies a comma-separated list of the +// YouTube playlist ID(s) for the resource(s) that are being retrieved. In a +// playlist resource, the id property specifies the playlist's YouTube +// playlist ID. +// maxResults: The maxResults parameter specifies the maximum number of items +// that should be returned in the result set. (0..50, default 5) +// mine: Set this parameter's value to true to instruct the API to only return +// playlists owned by the authenticated user. +// onBehalfOfContentOwner: Note: This parameter is intended exclusively for +// YouTube content partners. +// The onBehalfOfContentOwner parameter indicates that the request's +// authorization credentials identify a YouTube CMS user who is acting on +// behalf of the content owner specified in the parameter value. This +// parameter is intended for YouTube content partners that own and manage +// many different YouTube channels. It allows content owners to authenticate +// once and get access to all their video and channel data, without having +// to provide authentication credentials for each individual channel. The +// CMS account that the user authenticates with must be linked to the +// specified YouTube content owner. +// onBehalfOfContentOwnerChannel: This parameter can only be used in a +// properly authorized request. Note: This parameter is intended exclusively +// for YouTube content partners. +// The onBehalfOfContentOwnerChannel parameter specifies the YouTube channel +// ID of the channel to which a video is being added. This parameter is +// required when a request specifies a value for the onBehalfOfContentOwner +// parameter, and it can only be used in conjunction with that parameter. In +// addition, the request must be authorized using a CMS account that is +// linked to the content owner that the onBehalfOfContentOwner parameter +// specifies. Finally, the channel that the onBehalfOfContentOwnerChannel +// parameter value specifies must be linked to the content owner that the +// onBehalfOfContentOwner parameter specifies. +// This parameter is intended for YouTube content partners that own and +// manage many different YouTube channels. It allows content owners to +// authenticate once and perform actions on behalf of the channel specified +// in the parameter value, without having to provide authentication +// credentials for each separate channel. +// pageToken: The pageToken parameter identifies a specific page in the result +// set that should be returned. In an API response, the nextPageToken and +// prevPageToken properties identify other pages that could be retrieved. +// Authorization scope(s): +// kGTLAuthScopeYouTube +// kGTLAuthScopeYouTubeReadonly +// kGTLAuthScopeYouTubeYoutubepartner +// Fetches a GTLYouTubePlaylistListResponse. ++ (id)queryForPlaylistsListWithPart:(NSString *)part; + +// Method: youtube.playlists.update +// Modifies a playlist. For example, you could change a playlist's title, +// description, or privacy status. +// Required: +// part: The part parameter serves two purposes in this operation. It +// identifies the properties that the write operation will set as well as +// the properties that the API response will include. +// The part names that you can include in the parameter value are snippet +// and status. +// Note that this method will override the existing values for all of the +// mutable properties that are contained in any parts that the parameter +// value specifies. For example, a playlist's privacy setting is contained +// in the status part. As such, if your request is updating a private +// playlist, and the request's part parameter value includes the status +// part, the playlist's privacy setting will be updated to whatever value +// the request body specifies. If the request body does not specify a value, +// the existing privacy setting will be removed and the playlist will revert +// to the default privacy setting. +// Optional: +// onBehalfOfContentOwner: Note: This parameter is intended exclusively for +// YouTube content partners. +// The onBehalfOfContentOwner parameter indicates that the request's +// authorization credentials identify a YouTube CMS user who is acting on +// behalf of the content owner specified in the parameter value. This +// parameter is intended for YouTube content partners that own and manage +// many different YouTube channels. It allows content owners to authenticate +// once and get access to all their video and channel data, without having +// to provide authentication credentials for each individual channel. The +// CMS account that the user authenticates with must be linked to the +// specified YouTube content owner. +// Authorization scope(s): +// kGTLAuthScopeYouTube +// kGTLAuthScopeYouTubeYoutubepartner +// Fetches a GTLYouTubePlaylist. ++ (id)queryForPlaylistsUpdateWithObject:(GTLYouTubePlaylist *)object + part:(NSString *)part; + +#pragma mark - +#pragma mark "search" methods +// These create a GTLQueryYouTube object. + +// Method: youtube.search.list +// Returns a collection of search results that match the query parameters +// specified in the API request. By default, a search result set identifies +// matching video, channel, and playlist resources, but you can also configure +// queries to only retrieve a specific type of resource. +// Required: +// part: The part parameter specifies a comma-separated list of one or more +// search resource properties that the API response will include. The part +// names that you can include in the parameter value are id and snippet. +// If the parameter identifies a property that contains child properties, +// the child properties will be included in the response. For example, in a +// search result, the snippet property contains other properties that +// identify the result's title, description, and so forth. If you set +// part=snippet, the API response will also contain all of those nested +// properties. +// Optional: +// channelId: The channelId parameter indicates that the API response should +// only contain resources created by the channel +// channelType: The channelType parameter lets you restrict a search to a +// particular type of channel. +// kGTLYouTubeChannelTypeAny: Return all channels. +// kGTLYouTubeChannelTypeShow: Only retrieve shows. +// eventType: The eventType parameter restricts a search to broadcast events. +// kGTLYouTubeEventTypeCompleted: Only include completed broadcasts. +// kGTLYouTubeEventTypeLive: Only include active broadcasts. +// kGTLYouTubeEventTypeUpcoming: Only include upcoming broadcasts. +// forContentOwner: Note: This parameter is intended exclusively for YouTube +// content partners. +// The forContentOwner parameter restricts the search to only retrieve +// resources owned by the content owner specified by the +// onBehalfOfContentOwner parameter. The user must be authenticated using a +// CMS account linked to the specified content owner and +// onBehalfOfContentOwner must be provided. +// forMine: The forMine parameter restricts the search to only retrieve videos +// owned by the authenticated user. If you set this parameter to true, then +// the type parameter's value must also be set to video. +// location: The location parameter restricts a search to videos that have a +// geographical location specified in their metadata. The value is a string +// that specifies geographic latitude/longitude coordinates e.g. +// (37.42307,-122.08427) +// locationRadius: The locationRadius, in conjunction with the location +// parameter, defines a geographic area. If the geographic coordinates +// associated with a video fall within that area, then the video may be +// included in search results. This parameter value must be a floating point +// number followed by a measurement unit. Valid measurement units are m, km, +// ft, and mi. For example, valid parameter values include 1500m, 5km, +// 10000ft, and 0.75mi. The API does not support locationRadius parameter +// values larger than 1000 kilometers. +// maxResults: The maxResults parameter specifies the maximum number of items +// that should be returned in the result set. (0..50, default 5) +// onBehalfOfContentOwner: Note: This parameter is intended exclusively for +// YouTube content partners. +// The onBehalfOfContentOwner parameter indicates that the request's +// authorization credentials identify a YouTube CMS user who is acting on +// behalf of the content owner specified in the parameter value. This +// parameter is intended for YouTube content partners that own and manage +// many different YouTube channels. It allows content owners to authenticate +// once and get access to all their video and channel data, without having +// to provide authentication credentials for each individual channel. The +// CMS account that the user authenticates with must be linked to the +// specified YouTube content owner. +// order: The order parameter specifies the method that will be used to order +// resources in the API response. (Default "SEARCH_SORT_RELEVANCE") +// kGTLYouTubeOrderDate: Resources are sorted in reverse chronological +// order based on the date they were created. +// kGTLYouTubeOrderRating: Resources are sorted from highest to lowest +// rating. +// kGTLYouTubeOrderRelevance: Resources are sorted based on their relevance +// to the search query. This is the default value for this parameter. +// kGTLYouTubeOrderTitle: Resources are sorted alphabetically by title. +// kGTLYouTubeOrderVideoCount: Channels are sorted in descending order of +// their number of uploaded videos. +// kGTLYouTubeOrderViewCount: Resources are sorted from highest to lowest +// number of views. +// pageToken: The pageToken parameter identifies a specific page in the result +// set that should be returned. In an API response, the nextPageToken and +// prevPageToken properties identify other pages that could be retrieved. +// publishedAfter: The publishedAfter parameter indicates that the API +// response should only contain resources created after the specified time. +// The value is an RFC 3339 formatted date-time value +// (1970-01-01T00:00:00Z). +// publishedBefore: The publishedBefore parameter indicates that the API +// response should only contain resources created before the specified time. +// The value is an RFC 3339 formatted date-time value +// (1970-01-01T00:00:00Z). +// q: The q parameter specifies the query term to search for. +// regionCode: The regionCode parameter instructs the API to return search +// results for the specified country. The parameter value is an ISO 3166-1 +// alpha-2 country code. +// relatedToVideoId: The relatedToVideoId parameter retrieves a list of videos +// that are related to the video that the parameter value identifies. The +// parameter value must be set to a YouTube video ID and, if you are using +// this parameter, the type parameter must be set to video. +// safeSearch: The safeSearch parameter indicates whether the search results +// should include restricted content as well as standard content. +// kGTLYouTubeSafeSearchModerate: YouTube will filter some content from +// search results and, at the least, will filter content that is +// restricted in your locale. Based on their content, search results +// could be removed from search results or demoted in search results. +// This is the default parameter value. +// kGTLYouTubeSafeSearchNone: YouTube will not filter the search result +// set. +// kGTLYouTubeSafeSearchStrict: YouTube will try to exclude all restricted +// content from the search result set. Based on their content, search +// results could be removed from search results or demoted in search +// results. +// topicId: The topicId parameter indicates that the API response should only +// contain resources associated with the specified topic. The value +// identifies a Freebase topic ID. +// type: The type parameter restricts a search query to only retrieve a +// particular type of resource. The value is a comma-separated list of +// resource types. (Default video,channel,playlist) +// videoCaption: The videoCaption parameter indicates whether the API should +// filter video search results based on whether they have captions. +// kGTLYouTubeVideoCaptionAny: Do not filter results based on caption +// availability. +// kGTLYouTubeVideoCaptionClosedCaption: Only include videos that have +// captions. +// kGTLYouTubeVideoCaptionNone: Only include videos that do not have +// captions. +// videoCategoryId: The videoCategoryId parameter filters video search results +// based on their category. +// videoDefinition: The videoDefinition parameter lets you restrict a search +// to only include either high definition (HD) or standard definition (SD) +// videos. HD videos are available for playback in at least 720p, though +// higher resolutions, like 1080p, might also be available. +// kGTLYouTubeVideoDefinitionAny: Return all videos, regardless of their +// resolution. +// kGTLYouTubeVideoDefinitionHigh: Only retrieve HD videos. +// kGTLYouTubeVideoDefinitionStandard: Only retrieve videos in standard +// definition. +// videoDimension: The videoDimension parameter lets you restrict a search to +// only retrieve 2D or 3D videos. +// kGTLYouTubeVideoDimensionX2d: Restrict search results to exclude 3D +// videos. +// kGTLYouTubeVideoDimensionX3d: Restrict search results to only include 3D +// videos. +// kGTLYouTubeVideoDimensionAny: Include both 3D and non-3D videos in +// returned results. This is the default value. +// videoDuration: The videoDuration parameter filters video search results +// based on their duration. +// kGTLYouTubeVideoDurationAny: Do not filter video search results based on +// their duration. This is the default value. +// kGTLYouTubeVideoDurationLong: Only include videos longer than 20 +// minutes. +// kGTLYouTubeVideoDurationMedium: Only include videos that are between +// four and 20 minutes long (inclusive). +// kGTLYouTubeVideoDurationShort: Only include videos that are less than +// four minutes long. +// videoEmbeddable: The videoEmbeddable parameter lets you to restrict a +// search to only videos that can be embedded into a webpage. +// kGTLYouTubeVideoEmbeddableAny: Return all videos, embeddable or not. +// kGTLYouTubeVideoEmbeddableTrue: Only retrieve embeddable videos. +// videoLicense: The videoLicense parameter filters search results to only +// include videos with a particular license. YouTube lets video uploaders +// choose to attach either the Creative Commons license or the standard +// YouTube license to each of their videos. +// kGTLYouTubeVideoLicenseAny: Return all videos, regardless of which +// license they have, that match the query parameters. +// kGTLYouTubeVideoLicenseCreativeCommon: Only return videos that have a +// Creative Commons license. Users can reuse videos with this license in +// other videos that they create. Learn more. +// kGTLYouTubeVideoLicenseYoutube: Only return videos that have the +// standard YouTube license. +// videoSyndicated: The videoSyndicated parameter lets you to restrict a +// search to only videos that can be played outside youtube.com. +// kGTLYouTubeVideoSyndicatedAny: Return all videos, syndicated or not. +// kGTLYouTubeVideoSyndicatedTrue: Only retrieve syndicated videos. +// videoType: The videoType parameter lets you restrict a search to a +// particular type of videos. +// kGTLYouTubeVideoTypeAny: Return all videos. +// kGTLYouTubeVideoTypeEpisode: Only retrieve episodes of shows. +// kGTLYouTubeVideoTypeMovie: Only retrieve movies. +// Authorization scope(s): +// kGTLAuthScopeYouTube +// kGTLAuthScopeYouTubeReadonly +// kGTLAuthScopeYouTubeYoutubepartner +// Fetches a GTLYouTubeSearchListResponse. ++ (id)queryForSearchListWithPart:(NSString *)part; + +#pragma mark - +#pragma mark "subscriptions" methods +// These create a GTLQueryYouTube object. + +// Method: youtube.subscriptions.delete +// Deletes a subscription. +// Required: +// identifier: The id parameter specifies the YouTube subscription ID for the +// resource that is being deleted. In a subscription resource, the id +// property specifies the YouTube subscription ID. +// Authorization scope(s): +// kGTLAuthScopeYouTube +// kGTLAuthScopeYouTubeYoutubepartner ++ (id)queryForSubscriptionsDeleteWithIdentifier:(NSString *)identifier; + +// Method: youtube.subscriptions.insert +// Adds a subscription for the authenticated user's channel. +// Required: +// part: The part parameter serves two purposes in this operation. It +// identifies the properties that the write operation will set as well as +// the properties that the API response will include. +// The part names that you can include in the parameter value are snippet +// and contentDetails. +// Authorization scope(s): +// kGTLAuthScopeYouTube +// kGTLAuthScopeYouTubeYoutubepartner +// Fetches a GTLYouTubeSubscription. ++ (id)queryForSubscriptionsInsertWithObject:(GTLYouTubeSubscription *)object + part:(NSString *)part; + +// Method: youtube.subscriptions.list +// Returns subscription resources that match the API request criteria. +// Required: +// part: The part parameter specifies a comma-separated list of one or more +// subscription resource properties that the API response will include. The +// part names that you can include in the parameter value are id, snippet, +// and contentDetails. +// If the parameter identifies a property that contains child properties, +// the child properties will be included in the response. For example, in a +// subscription resource, the snippet property contains other properties, +// such as a display title for the subscription. If you set part=snippet, +// the API response will also contain all of those nested properties. +// Optional: +// channelId: The channelId parameter specifies a YouTube channel ID. The API +// will only return that channel's subscriptions. +// forChannelId: The forChannelId parameter specifies a comma-separated list +// of channel IDs. The API response will then only contain subscriptions +// matching those channels. +// identifier: The id parameter specifies a comma-separated list of the +// YouTube subscription ID(s) for the resource(s) that are being retrieved. +// In a subscription resource, the id property specifies the YouTube +// subscription ID. +// maxResults: The maxResults parameter specifies the maximum number of items +// that should be returned in the result set. (0..50, default 5) +// mine: Set this parameter's value to true to retrieve a feed of the +// authenticated user's subscriptions. +// mySubscribers: Set this parameter's value to true to retrieve a feed of the +// subscribers of the authenticated user. +// onBehalfOfContentOwner: Note: This parameter is intended exclusively for +// YouTube content partners. +// The onBehalfOfContentOwner parameter indicates that the request's +// authorization credentials identify a YouTube CMS user who is acting on +// behalf of the content owner specified in the parameter value. This +// parameter is intended for YouTube content partners that own and manage +// many different YouTube channels. It allows content owners to authenticate +// once and get access to all their video and channel data, without having +// to provide authentication credentials for each individual channel. The +// CMS account that the user authenticates with must be linked to the +// specified YouTube content owner. +// onBehalfOfContentOwnerChannel: This parameter can only be used in a +// properly authorized request. Note: This parameter is intended exclusively +// for YouTube content partners. +// The onBehalfOfContentOwnerChannel parameter specifies the YouTube channel +// ID of the channel to which a video is being added. This parameter is +// required when a request specifies a value for the onBehalfOfContentOwner +// parameter, and it can only be used in conjunction with that parameter. In +// addition, the request must be authorized using a CMS account that is +// linked to the content owner that the onBehalfOfContentOwner parameter +// specifies. Finally, the channel that the onBehalfOfContentOwnerChannel +// parameter value specifies must be linked to the content owner that the +// onBehalfOfContentOwner parameter specifies. +// This parameter is intended for YouTube content partners that own and +// manage many different YouTube channels. It allows content owners to +// authenticate once and perform actions on behalf of the channel specified +// in the parameter value, without having to provide authentication +// credentials for each separate channel. +// order: The order parameter specifies the method that will be used to sort +// resources in the API response. (Default "SUBSCRIPTION_ORDER_RELEVANCE") +// kGTLYouTubeOrderAlphabetical: Sort alphabetically. +// kGTLYouTubeOrderRelevance: Sort by relevance. +// kGTLYouTubeOrderUnread: Sort by order of activity. +// pageToken: The pageToken parameter identifies a specific page in the result +// set that should be returned. In an API response, the nextPageToken and +// prevPageToken properties identify other pages that could be retrieved. +// Authorization scope(s): +// kGTLAuthScopeYouTube +// kGTLAuthScopeYouTubeReadonly +// kGTLAuthScopeYouTubeYoutubepartner +// Fetches a GTLYouTubeSubscriptionListResponse. ++ (id)queryForSubscriptionsListWithPart:(NSString *)part; + +#pragma mark - +#pragma mark "thumbnails" methods +// These create a GTLQueryYouTube object. + +// Method: youtube.thumbnails.set +// Uploads a custom video thumbnail to YouTube and sets it for a video. +// Required: +// videoId: The videoId parameter specifies a YouTube video ID for which the +// custom video thumbnail is being provided. +// Optional: +// onBehalfOfContentOwner: The onBehalfOfContentOwner parameter indicates that +// the authenticated user is acting on behalf of the content owner specified +// in the parameter value. This parameter is intended for YouTube content +// partners that own and manage many different YouTube channels. It allows +// content owners to authenticate once and get access to all their video and +// channel data, without having to provide authentication credentials for +// each individual channel. The actual CMS account that the user +// authenticates with needs to be linked to the specified YouTube content +// owner. +// Upload Parameters: +// Maximum size: 2MB +// Accepted MIME type(s): application/octet-stream, image/jpeg, image/png +// Authorization scope(s): +// kGTLAuthScopeYouTube +// kGTLAuthScopeYouTubeUpload +// kGTLAuthScopeYouTubeYoutubepartner +// Fetches a GTLYouTubeThumbnailSetResponse. ++ (id)queryForThumbnailsSetWithVideoId:(NSString *)videoId + uploadParameters:(GTLUploadParameters *)uploadParametersOrNil; + +#pragma mark - +#pragma mark "videoCategories" methods +// These create a GTLQueryYouTube object. + +// Method: youtube.videoCategories.list +// Returns a list of categories that can be associated with YouTube videos. +// Required: +// part: The part parameter specifies the videoCategory resource parts that +// the API response will include. Supported values are id and snippet. +// Optional: +// hl: The hl parameter specifies the language that should be used for text +// values in the API response. (Default en_US) +// identifier: The id parameter specifies a comma-separated list of video +// category IDs for the resources that you are retrieving. +// regionCode: The regionCode parameter instructs the API to return the list +// of video categories available in the specified country. The parameter +// value is an ISO 3166-1 alpha-2 country code. +// Authorization scope(s): +// kGTLAuthScopeYouTube +// kGTLAuthScopeYouTubeReadonly +// kGTLAuthScopeYouTubeYoutubepartner +// Fetches a GTLYouTubeVideoCategoryListResponse. ++ (id)queryForVideoCategoriesListWithPart:(NSString *)part; + +#pragma mark - +#pragma mark "videos" methods +// These create a GTLQueryYouTube object. + +// Method: youtube.videos.delete +// Deletes a YouTube video. +// Required: +// identifier: The id parameter specifies the YouTube video ID for the +// resource that is being deleted. In a video resource, the id property +// specifies the video's ID. +// Optional: +// onBehalfOfContentOwner: Note: This parameter is intended exclusively for +// YouTube content partners. +// The onBehalfOfContentOwner parameter indicates that the request's +// authorization credentials identify a YouTube CMS user who is acting on +// behalf of the content owner specified in the parameter value. This +// parameter is intended for YouTube content partners that own and manage +// many different YouTube channels. It allows content owners to authenticate +// once and get access to all their video and channel data, without having +// to provide authentication credentials for each individual channel. The +// actual CMS account that the user authenticates with must be linked to the +// specified YouTube content owner. +// Authorization scope(s): +// kGTLAuthScopeYouTube +// kGTLAuthScopeYouTubeYoutubepartner ++ (id)queryForVideosDeleteWithIdentifier:(NSString *)identifier; + +// Method: youtube.videos.getRating +// Retrieves the ratings that the authorized user gave to a list of specified +// videos. +// Required: +// identifier: The id parameter specifies a comma-separated list of the +// YouTube video ID(s) for the resource(s) for which you are retrieving +// rating data. In a video resource, the id property specifies the video's +// ID. +// Optional: +// onBehalfOfContentOwner: Note: This parameter is intended exclusively for +// YouTube content partners. +// The onBehalfOfContentOwner parameter indicates that the request's +// authorization credentials identify a YouTube CMS user who is acting on +// behalf of the content owner specified in the parameter value. This +// parameter is intended for YouTube content partners that own and manage +// many different YouTube channels. It allows content owners to authenticate +// once and get access to all their video and channel data, without having +// to provide authentication credentials for each individual channel. The +// CMS account that the user authenticates with must be linked to the +// specified YouTube content owner. +// Authorization scope(s): +// kGTLAuthScopeYouTube +// kGTLAuthScopeYouTubeYoutubepartner +// Fetches a GTLYouTubeVideoGetRatingResponse. ++ (id)queryForVideosGetRatingWithIdentifier:(NSString *)identifier; + +// Method: youtube.videos.insert +// Uploads a video to YouTube and optionally sets the video's metadata. +// Required: +// part: The part parameter serves two purposes in this operation. It +// identifies the properties that the write operation will set as well as +// the properties that the API response will include. +// The part names that you can include in the parameter value are snippet, +// contentDetails, fileDetails, liveStreamingDetails, player, +// processingDetails, recordingDetails, statistics, status, suggestions, and +// topicDetails. However, not all of those parts contain properties that can +// be set when setting or updating a video's metadata. For example, the +// statistics object encapsulates statistics that YouTube calculates for a +// video and does not contain values that you can set or modify. If the +// parameter value specifies a part that does not contain mutable values, +// that part will still be included in the API response. +// Optional: +// autoLevels: The autoLevels parameter indicates whether YouTube should +// automatically enhance the video's lighting and color. +// notifySubscribers: The notifySubscribers parameter indicates whether +// YouTube should send notification to subscribers about the inserted video. +// (Default true) +// onBehalfOfContentOwner: Note: This parameter is intended exclusively for +// YouTube content partners. +// The onBehalfOfContentOwner parameter indicates that the request's +// authorization credentials identify a YouTube CMS user who is acting on +// behalf of the content owner specified in the parameter value. This +// parameter is intended for YouTube content partners that own and manage +// many different YouTube channels. It allows content owners to authenticate +// once and get access to all their video and channel data, without having +// to provide authentication credentials for each individual channel. The +// CMS account that the user authenticates with must be linked to the +// specified YouTube content owner. +// onBehalfOfContentOwnerChannel: This parameter can only be used in a +// properly authorized request. Note: This parameter is intended exclusively +// for YouTube content partners. +// The onBehalfOfContentOwnerChannel parameter specifies the YouTube channel +// ID of the channel to which a video is being added. This parameter is +// required when a request specifies a value for the onBehalfOfContentOwner +// parameter, and it can only be used in conjunction with that parameter. In +// addition, the request must be authorized using a CMS account that is +// linked to the content owner that the onBehalfOfContentOwner parameter +// specifies. Finally, the channel that the onBehalfOfContentOwnerChannel +// parameter value specifies must be linked to the content owner that the +// onBehalfOfContentOwner parameter specifies. +// This parameter is intended for YouTube content partners that own and +// manage many different YouTube channels. It allows content owners to +// authenticate once and perform actions on behalf of the channel specified +// in the parameter value, without having to provide authentication +// credentials for each separate channel. +// stabilize: The stabilize parameter indicates whether YouTube should adjust +// the video to remove shaky camera motions. +// Upload Parameters: +// Maximum size: 64GB +// Accepted MIME type(s): application/octet-stream, video/* +// Authorization scope(s): +// kGTLAuthScopeYouTube +// kGTLAuthScopeYouTubeUpload +// kGTLAuthScopeYouTubeYoutubepartner +// Fetches a GTLYouTubeVideo. ++ (id)queryForVideosInsertWithObject:(GTLYouTubeVideo *)object + part:(NSString *)part + uploadParameters:(GTLUploadParameters *)uploadParametersOrNil; + +// Method: youtube.videos.list +// Returns a list of videos that match the API request parameters. +// Required: +// part: The part parameter specifies a comma-separated list of one or more +// video resource properties that the API response will include. The part +// names that you can include in the parameter value are id, snippet, +// contentDetails, fileDetails, liveStreamingDetails, player, +// processingDetails, recordingDetails, statistics, status, suggestions, and +// topicDetails. +// If the parameter identifies a property that contains child properties, +// the child properties will be included in the response. For example, in a +// video resource, the snippet property contains the channelId, title, +// description, tags, and categoryId properties. As such, if you set +// part=snippet, the API response will contain all of those properties. +// Optional: +// chart: The chart parameter identifies the chart that you want to retrieve. +// kGTLYouTubeChartMostPopular: Return the most popular videos for the +// specified content region and video category. +// identifier: The id parameter specifies a comma-separated list of the +// YouTube video ID(s) for the resource(s) that are being retrieved. In a +// video resource, the id property specifies the video's ID. +// locale: DEPRECATED +// maxResults: The maxResults parameter specifies the maximum number of items +// that should be returned in the result set. +// Note: This parameter is supported for use in conjunction with the +// myRating parameter, but it is not supported for use in conjunction with +// the id parameter. (1..50, default 5) +// myRating: Set this parameter's value to like or dislike to instruct the API +// to only return videos liked or disliked by the authenticated user. +// kGTLYouTubeMyRatingDislike: Returns only videos disliked by the +// authenticated user. +// kGTLYouTubeMyRatingLike: Returns only video liked by the authenticated +// user. +// onBehalfOfContentOwner: Note: This parameter is intended exclusively for +// YouTube content partners. +// The onBehalfOfContentOwner parameter indicates that the request's +// authorization credentials identify a YouTube CMS user who is acting on +// behalf of the content owner specified in the parameter value. This +// parameter is intended for YouTube content partners that own and manage +// many different YouTube channels. It allows content owners to authenticate +// once and get access to all their video and channel data, without having +// to provide authentication credentials for each individual channel. The +// CMS account that the user authenticates with must be linked to the +// specified YouTube content owner. +// pageToken: The pageToken parameter identifies a specific page in the result +// set that should be returned. In an API response, the nextPageToken and +// prevPageToken properties identify other pages that could be retrieved. +// Note: This parameter is supported for use in conjunction with the +// myRating parameter, but it is not supported for use in conjunction with +// the id parameter. +// regionCode: The regionCode parameter instructs the API to select a video +// chart available in the specified region. This parameter can only be used +// in conjunction with the chart parameter. The parameter value is an ISO +// 3166-1 alpha-2 country code. +// videoCategoryId: The videoCategoryId parameter identifies the video +// category for which the chart should be retrieved. This parameter can only +// be used in conjunction with the chart parameter. By default, charts are +// not restricted to a particular category. (Default 0) +// Authorization scope(s): +// kGTLAuthScopeYouTube +// kGTLAuthScopeYouTubeReadonly +// kGTLAuthScopeYouTubeYoutubepartner +// Fetches a GTLYouTubeVideoListResponse. ++ (id)queryForVideosListWithPart:(NSString *)part; + +// Method: youtube.videos.rate +// Add a like or dislike rating to a video or remove a rating from a video. +// Required: +// identifier: The id parameter specifies the YouTube video ID of the video +// that is being rated or having its rating removed. +// rating: Specifies the rating to record. +// kGTLYouTubeRatingDislike: Records that the authenticated user disliked +// the video. +// kGTLYouTubeRatingLike: Records that the authenticated user liked the +// video. +// kGTLYouTubeRatingNone: Removes any rating that the authenticated user +// had previously set for the video. +// Optional: +// onBehalfOfContentOwner: Note: This parameter is intended exclusively for +// YouTube content partners. +// The onBehalfOfContentOwner parameter indicates that the request's +// authorization credentials identify a YouTube CMS user who is acting on +// behalf of the content owner specified in the parameter value. This +// parameter is intended for YouTube content partners that own and manage +// many different YouTube channels. It allows content owners to authenticate +// once and get access to all their video and channel data, without having +// to provide authentication credentials for each individual channel. The +// CMS account that the user authenticates with must be linked to the +// specified YouTube content owner. +// Authorization scope(s): +// kGTLAuthScopeYouTube +// kGTLAuthScopeYouTubeYoutubepartner ++ (id)queryForVideosRateWithIdentifier:(NSString *)identifier + rating:(NSString *)rating; + +// Method: youtube.videos.update +// Updates a video's metadata. +// Required: +// part: The part parameter serves two purposes in this operation. It +// identifies the properties that the write operation will set as well as +// the properties that the API response will include. +// The part names that you can include in the parameter value are snippet, +// contentDetails, fileDetails, liveStreamingDetails, player, +// processingDetails, recordingDetails, statistics, status, suggestions, and +// topicDetails. +// Note that this method will override the existing values for all of the +// mutable properties that are contained in any parts that the parameter +// value specifies. For example, a video's privacy setting is contained in +// the status part. As such, if your request is updating a private video, +// and the request's part parameter value includes the status part, the +// video's privacy setting will be updated to whatever value the request +// body specifies. If the request body does not specify a value, the +// existing privacy setting will be removed and the video will revert to the +// default privacy setting. +// In addition, not all of those parts contain properties that can be set +// when setting or updating a video's metadata. For example, the statistics +// object encapsulates statistics that YouTube calculates for a video and +// does not contain values that you can set or modify. If the parameter +// value specifies a part that does not contain mutable values, that part +// will still be included in the API response. +// Optional: +// onBehalfOfContentOwner: Note: This parameter is intended exclusively for +// YouTube content partners. +// The onBehalfOfContentOwner parameter indicates that the request's +// authorization credentials identify a YouTube CMS user who is acting on +// behalf of the content owner specified in the parameter value. This +// parameter is intended for YouTube content partners that own and manage +// many different YouTube channels. It allows content owners to authenticate +// once and get access to all their video and channel data, without having +// to provide authentication credentials for each individual channel. The +// actual CMS account that the user authenticates with must be linked to the +// specified YouTube content owner. +// Authorization scope(s): +// kGTLAuthScopeYouTube +// kGTLAuthScopeYouTubeYoutubepartner +// Fetches a GTLYouTubeVideo. ++ (id)queryForVideosUpdateWithObject:(GTLYouTubeVideo *)object + part:(NSString *)part; + +#pragma mark - +#pragma mark "watermarks" methods +// These create a GTLQueryYouTube object. + +// Method: youtube.watermarks.set +// Uploads a watermark image to YouTube and sets it for a channel. +// Required: +// channelId: The channelId parameter specifies a YouTube channel ID for which +// the watermark is being provided. +// Optional: +// onBehalfOfContentOwner: The onBehalfOfContentOwner parameter indicates that +// the authenticated user is acting on behalf of the content owner specified +// in the parameter value. This parameter is intended for YouTube content +// partners that own and manage many different YouTube channels. It allows +// content owners to authenticate once and get access to all their video and +// channel data, without having to provide authentication credentials for +// each individual channel. The actual CMS account that the user +// authenticates with needs to be linked to the specified YouTube content +// owner. +// Upload Parameters: +// Maximum size: 10MB +// Accepted MIME type(s): application/octet-stream, image/jpeg, image/png +// Authorization scope(s): +// kGTLAuthScopeYouTube +// kGTLAuthScopeYouTubeUpload +// kGTLAuthScopeYouTubeYoutubepartner ++ (id)queryForWatermarksSetWithObject:(GTLYouTubeInvideoBranding *)object + channelId:(NSString *)channelId + uploadParameters:(GTLUploadParameters *)uploadParametersOrNil; + +// Method: youtube.watermarks.unset +// Deletes a watermark. +// Required: +// channelId: The channelId parameter specifies a YouTube channel ID for which +// the watermark is being unset. +// Optional: +// onBehalfOfContentOwner: The onBehalfOfContentOwner parameter indicates that +// the authenticated user is acting on behalf of the content owner specified +// in the parameter value. This parameter is intended for YouTube content +// partners that own and manage many different YouTube channels. It allows +// content owners to authenticate once and get access to all their video and +// channel data, without having to provide authentication credentials for +// each individual channel. The actual CMS account that the user +// authenticates with needs to be linked to the specified YouTube content +// owner. +// Authorization scope(s): +// kGTLAuthScopeYouTube +// kGTLAuthScopeYouTubeYoutubepartner ++ (id)queryForWatermarksUnsetWithChannelId:(NSString *)channelId; + +@end diff --git a/XCDYouTubeKit Demo/Pods/Google-API-Client/Source/Services/YouTube/Generated/GTLQueryYouTube.m b/XCDYouTubeKit Demo/Pods/Google-API-Client/Source/Services/YouTube/Generated/GTLQueryYouTube.m new file mode 100644 index 00000000..990a7639 --- /dev/null +++ b/XCDYouTubeKit Demo/Pods/Google-API-Client/Source/Services/YouTube/Generated/GTLQueryYouTube.m @@ -0,0 +1,618 @@ +/* Copyright (c) 2014 Google Inc. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +// +// GTLQueryYouTube.m +// + +// ---------------------------------------------------------------------------- +// NOTE: This file is generated from Google APIs Discovery Service. +// Service: +// YouTube Data API (youtube/v3) +// Description: +// Programmatic access to YouTube features. +// Documentation: +// https://developers.google.com/youtube/v3 +// Classes: +// GTLQueryYouTube (45 custom class methods, 54 custom properties) + +#import "GTLQueryYouTube.h" + +#import "GTLYouTubeActivity.h" +#import "GTLYouTubeActivityListResponse.h" +#import "GTLYouTubeChannel.h" +#import "GTLYouTubeChannelBannerResource.h" +#import "GTLYouTubeChannelListResponse.h" +#import "GTLYouTubeChannelSection.h" +#import "GTLYouTubeChannelSectionListResponse.h" +#import "GTLYouTubeGuideCategoryListResponse.h" +#import "GTLYouTubeI18nLanguageListResponse.h" +#import "GTLYouTubeI18nRegionListResponse.h" +#import "GTLYouTubeInvideoBranding.h" +#import "GTLYouTubeLiveBroadcast.h" +#import "GTLYouTubeLiveBroadcastListResponse.h" +#import "GTLYouTubeLiveStream.h" +#import "GTLYouTubeLiveStreamListResponse.h" +#import "GTLYouTubePlaylist.h" +#import "GTLYouTubePlaylistItem.h" +#import "GTLYouTubePlaylistItemListResponse.h" +#import "GTLYouTubePlaylistListResponse.h" +#import "GTLYouTubeSearchListResponse.h" +#import "GTLYouTubeSubscription.h" +#import "GTLYouTubeSubscriptionListResponse.h" +#import "GTLYouTubeThumbnailSetResponse.h" +#import "GTLYouTubeVideo.h" +#import "GTLYouTubeVideoCategoryListResponse.h" +#import "GTLYouTubeVideoGetRatingResponse.h" +#import "GTLYouTubeVideoListResponse.h" + +@implementation GTLQueryYouTube + +@dynamic autoLevels, broadcastStatus, categoryId, channelId, channelType, chart, + displaySlate, eventType, fields, forChannelId, forContentOwner, + forMine, forUsername, hl, home, identifier, locale, location, + locationRadius, managedByMe, maxResults, mine, myRating, mySubscribers, + notifySubscribers, offsetTimeMs, onBehalfOfContentOwner, + onBehalfOfContentOwnerChannel, order, pageToken, part, playlistId, + publishedAfter, publishedBefore, q, rating, regionCode, + relatedToVideoId, safeSearch, stabilize, streamId, topicId, type, + videoCaption, videoCategoryId, videoDefinition, videoDimension, + videoDuration, videoEmbeddable, videoId, videoLicense, videoSyndicated, + videoType, walltime; + ++ (NSDictionary *)parameterNameMap { + NSDictionary *map = + [NSDictionary dictionaryWithObject:@"id" + forKey:@"identifier"]; + return map; +} + +#pragma mark - +#pragma mark "activities" methods +// These create a GTLQueryYouTube object. + ++ (id)queryForActivitiesInsertWithObject:(GTLYouTubeActivity *)object + part:(NSString *)part { + if (object == nil) { + GTL_DEBUG_ASSERT(object != nil, @"%@ got a nil object", NSStringFromSelector(_cmd)); + return nil; + } + NSString *methodName = @"youtube.activities.insert"; + GTLQueryYouTube *query = [self queryWithMethodName:methodName]; + query.bodyObject = object; + query.part = part; + query.expectedObjectClass = [GTLYouTubeActivity class]; + return query; +} + ++ (id)queryForActivitiesListWithPart:(NSString *)part { + NSString *methodName = @"youtube.activities.list"; + GTLQueryYouTube *query = [self queryWithMethodName:methodName]; + query.part = part; + query.expectedObjectClass = [GTLYouTubeActivityListResponse class]; + return query; +} + +#pragma mark - +#pragma mark "channelBanners" methods +// These create a GTLQueryYouTube object. + ++ (id)queryForChannelBannersInsertWithObject:(GTLYouTubeChannelBannerResource *)object + uploadParameters:(GTLUploadParameters *)uploadParametersOrNil { + if (object == nil) { + GTL_DEBUG_ASSERT(object != nil, @"%@ got a nil object", NSStringFromSelector(_cmd)); + return nil; + } + NSString *methodName = @"youtube.channelBanners.insert"; + GTLQueryYouTube *query = [self queryWithMethodName:methodName]; + query.bodyObject = object; + query.uploadParameters = uploadParametersOrNil; + query.expectedObjectClass = [GTLYouTubeChannelBannerResource class]; + return query; +} + +#pragma mark - +#pragma mark "channelSections" methods +// These create a GTLQueryYouTube object. + ++ (id)queryForChannelSectionsDeleteWithIdentifier:(NSString *)identifier { + NSString *methodName = @"youtube.channelSections.delete"; + GTLQueryYouTube *query = [self queryWithMethodName:methodName]; + query.identifier = identifier; + return query; +} + ++ (id)queryForChannelSectionsInsertWithObject:(GTLYouTubeChannelSection *)object + part:(NSString *)part { + if (object == nil) { + GTL_DEBUG_ASSERT(object != nil, @"%@ got a nil object", NSStringFromSelector(_cmd)); + return nil; + } + NSString *methodName = @"youtube.channelSections.insert"; + GTLQueryYouTube *query = [self queryWithMethodName:methodName]; + query.bodyObject = object; + query.part = part; + query.expectedObjectClass = [GTLYouTubeChannelSection class]; + return query; +} + ++ (id)queryForChannelSectionsListWithPart:(NSString *)part { + NSString *methodName = @"youtube.channelSections.list"; + GTLQueryYouTube *query = [self queryWithMethodName:methodName]; + query.part = part; + query.expectedObjectClass = [GTLYouTubeChannelSectionListResponse class]; + return query; +} + ++ (id)queryForChannelSectionsUpdateWithObject:(GTLYouTubeChannelSection *)object + part:(NSString *)part { + if (object == nil) { + GTL_DEBUG_ASSERT(object != nil, @"%@ got a nil object", NSStringFromSelector(_cmd)); + return nil; + } + NSString *methodName = @"youtube.channelSections.update"; + GTLQueryYouTube *query = [self queryWithMethodName:methodName]; + query.bodyObject = object; + query.part = part; + query.expectedObjectClass = [GTLYouTubeChannelSection class]; + return query; +} + +#pragma mark - +#pragma mark "channels" methods +// These create a GTLQueryYouTube object. + ++ (id)queryForChannelsListWithPart:(NSString *)part { + NSString *methodName = @"youtube.channels.list"; + GTLQueryYouTube *query = [self queryWithMethodName:methodName]; + query.part = part; + query.expectedObjectClass = [GTLYouTubeChannelListResponse class]; + return query; +} + ++ (id)queryForChannelsUpdateWithObject:(GTLYouTubeChannel *)object + part:(NSString *)part { + if (object == nil) { + GTL_DEBUG_ASSERT(object != nil, @"%@ got a nil object", NSStringFromSelector(_cmd)); + return nil; + } + NSString *methodName = @"youtube.channels.update"; + GTLQueryYouTube *query = [self queryWithMethodName:methodName]; + query.bodyObject = object; + query.part = part; + query.expectedObjectClass = [GTLYouTubeChannel class]; + return query; +} + +#pragma mark - +#pragma mark "guideCategories" methods +// These create a GTLQueryYouTube object. + ++ (id)queryForGuideCategoriesListWithPart:(NSString *)part { + NSString *methodName = @"youtube.guideCategories.list"; + GTLQueryYouTube *query = [self queryWithMethodName:methodName]; + query.part = part; + query.expectedObjectClass = [GTLYouTubeGuideCategoryListResponse class]; + return query; +} + +#pragma mark - +#pragma mark "i18nLanguages" methods +// These create a GTLQueryYouTube object. + ++ (id)queryForI18nLanguagesListWithPart:(NSString *)part { + NSString *methodName = @"youtube.i18nLanguages.list"; + GTLQueryYouTube *query = [self queryWithMethodName:methodName]; + query.part = part; + query.expectedObjectClass = [GTLYouTubeI18nLanguageListResponse class]; + return query; +} + +#pragma mark - +#pragma mark "i18nRegions" methods +// These create a GTLQueryYouTube object. + ++ (id)queryForI18nRegionsListWithPart:(NSString *)part { + NSString *methodName = @"youtube.i18nRegions.list"; + GTLQueryYouTube *query = [self queryWithMethodName:methodName]; + query.part = part; + query.expectedObjectClass = [GTLYouTubeI18nRegionListResponse class]; + return query; +} + +#pragma mark - +#pragma mark "liveBroadcasts" methods +// These create a GTLQueryYouTube object. + ++ (id)queryForLiveBroadcastsBindWithIdentifier:(NSString *)identifier + part:(NSString *)part { + NSString *methodName = @"youtube.liveBroadcasts.bind"; + GTLQueryYouTube *query = [self queryWithMethodName:methodName]; + query.identifier = identifier; + query.part = part; + query.expectedObjectClass = [GTLYouTubeLiveBroadcast class]; + return query; +} + ++ (id)queryForLiveBroadcastsControlWithIdentifier:(NSString *)identifier + part:(NSString *)part { + NSString *methodName = @"youtube.liveBroadcasts.control"; + GTLQueryYouTube *query = [self queryWithMethodName:methodName]; + query.identifier = identifier; + query.part = part; + query.expectedObjectClass = [GTLYouTubeLiveBroadcast class]; + return query; +} + ++ (id)queryForLiveBroadcastsDeleteWithIdentifier:(NSString *)identifier { + NSString *methodName = @"youtube.liveBroadcasts.delete"; + GTLQueryYouTube *query = [self queryWithMethodName:methodName]; + query.identifier = identifier; + return query; +} + ++ (id)queryForLiveBroadcastsInsertWithObject:(GTLYouTubeLiveBroadcast *)object + part:(NSString *)part { + if (object == nil) { + GTL_DEBUG_ASSERT(object != nil, @"%@ got a nil object", NSStringFromSelector(_cmd)); + return nil; + } + NSString *methodName = @"youtube.liveBroadcasts.insert"; + GTLQueryYouTube *query = [self queryWithMethodName:methodName]; + query.bodyObject = object; + query.part = part; + query.expectedObjectClass = [GTLYouTubeLiveBroadcast class]; + return query; +} + ++ (id)queryForLiveBroadcastsListWithPart:(NSString *)part { + NSString *methodName = @"youtube.liveBroadcasts.list"; + GTLQueryYouTube *query = [self queryWithMethodName:methodName]; + query.part = part; + query.expectedObjectClass = [GTLYouTubeLiveBroadcastListResponse class]; + return query; +} + ++ (id)queryForLiveBroadcastsTransitionWithBroadcastStatus:(NSString *)broadcastStatus + identifier:(NSString *)identifier + part:(NSString *)part { + NSString *methodName = @"youtube.liveBroadcasts.transition"; + GTLQueryYouTube *query = [self queryWithMethodName:methodName]; + query.broadcastStatus = broadcastStatus; + query.identifier = identifier; + query.part = part; + query.expectedObjectClass = [GTLYouTubeLiveBroadcast class]; + return query; +} + ++ (id)queryForLiveBroadcastsUpdateWithObject:(GTLYouTubeLiveBroadcast *)object + part:(NSString *)part { + if (object == nil) { + GTL_DEBUG_ASSERT(object != nil, @"%@ got a nil object", NSStringFromSelector(_cmd)); + return nil; + } + NSString *methodName = @"youtube.liveBroadcasts.update"; + GTLQueryYouTube *query = [self queryWithMethodName:methodName]; + query.bodyObject = object; + query.part = part; + query.expectedObjectClass = [GTLYouTubeLiveBroadcast class]; + return query; +} + +#pragma mark - +#pragma mark "liveStreams" methods +// These create a GTLQueryYouTube object. + ++ (id)queryForLiveStreamsDeleteWithIdentifier:(NSString *)identifier { + NSString *methodName = @"youtube.liveStreams.delete"; + GTLQueryYouTube *query = [self queryWithMethodName:methodName]; + query.identifier = identifier; + return query; +} + ++ (id)queryForLiveStreamsInsertWithObject:(GTLYouTubeLiveStream *)object + part:(NSString *)part { + if (object == nil) { + GTL_DEBUG_ASSERT(object != nil, @"%@ got a nil object", NSStringFromSelector(_cmd)); + return nil; + } + NSString *methodName = @"youtube.liveStreams.insert"; + GTLQueryYouTube *query = [self queryWithMethodName:methodName]; + query.bodyObject = object; + query.part = part; + query.expectedObjectClass = [GTLYouTubeLiveStream class]; + return query; +} + ++ (id)queryForLiveStreamsListWithPart:(NSString *)part { + NSString *methodName = @"youtube.liveStreams.list"; + GTLQueryYouTube *query = [self queryWithMethodName:methodName]; + query.part = part; + query.expectedObjectClass = [GTLYouTubeLiveStreamListResponse class]; + return query; +} + ++ (id)queryForLiveStreamsUpdateWithObject:(GTLYouTubeLiveStream *)object + part:(NSString *)part { + if (object == nil) { + GTL_DEBUG_ASSERT(object != nil, @"%@ got a nil object", NSStringFromSelector(_cmd)); + return nil; + } + NSString *methodName = @"youtube.liveStreams.update"; + GTLQueryYouTube *query = [self queryWithMethodName:methodName]; + query.bodyObject = object; + query.part = part; + query.expectedObjectClass = [GTLYouTubeLiveStream class]; + return query; +} + +#pragma mark - +#pragma mark "playlistItems" methods +// These create a GTLQueryYouTube object. + ++ (id)queryForPlaylistItemsDeleteWithIdentifier:(NSString *)identifier { + NSString *methodName = @"youtube.playlistItems.delete"; + GTLQueryYouTube *query = [self queryWithMethodName:methodName]; + query.identifier = identifier; + return query; +} + ++ (id)queryForPlaylistItemsInsertWithObject:(GTLYouTubePlaylistItem *)object + part:(NSString *)part { + if (object == nil) { + GTL_DEBUG_ASSERT(object != nil, @"%@ got a nil object", NSStringFromSelector(_cmd)); + return nil; + } + NSString *methodName = @"youtube.playlistItems.insert"; + GTLQueryYouTube *query = [self queryWithMethodName:methodName]; + query.bodyObject = object; + query.part = part; + query.expectedObjectClass = [GTLYouTubePlaylistItem class]; + return query; +} + ++ (id)queryForPlaylistItemsListWithPart:(NSString *)part { + NSString *methodName = @"youtube.playlistItems.list"; + GTLQueryYouTube *query = [self queryWithMethodName:methodName]; + query.part = part; + query.expectedObjectClass = [GTLYouTubePlaylistItemListResponse class]; + return query; +} + ++ (id)queryForPlaylistItemsUpdateWithObject:(GTLYouTubePlaylistItem *)object + part:(NSString *)part { + if (object == nil) { + GTL_DEBUG_ASSERT(object != nil, @"%@ got a nil object", NSStringFromSelector(_cmd)); + return nil; + } + NSString *methodName = @"youtube.playlistItems.update"; + GTLQueryYouTube *query = [self queryWithMethodName:methodName]; + query.bodyObject = object; + query.part = part; + query.expectedObjectClass = [GTLYouTubePlaylistItem class]; + return query; +} + +#pragma mark - +#pragma mark "playlists" methods +// These create a GTLQueryYouTube object. + ++ (id)queryForPlaylistsDeleteWithIdentifier:(NSString *)identifier { + NSString *methodName = @"youtube.playlists.delete"; + GTLQueryYouTube *query = [self queryWithMethodName:methodName]; + query.identifier = identifier; + return query; +} + ++ (id)queryForPlaylistsInsertWithObject:(GTLYouTubePlaylist *)object + part:(NSString *)part { + if (object == nil) { + GTL_DEBUG_ASSERT(object != nil, @"%@ got a nil object", NSStringFromSelector(_cmd)); + return nil; + } + NSString *methodName = @"youtube.playlists.insert"; + GTLQueryYouTube *query = [self queryWithMethodName:methodName]; + query.bodyObject = object; + query.part = part; + query.expectedObjectClass = [GTLYouTubePlaylist class]; + return query; +} + ++ (id)queryForPlaylistsListWithPart:(NSString *)part { + NSString *methodName = @"youtube.playlists.list"; + GTLQueryYouTube *query = [self queryWithMethodName:methodName]; + query.part = part; + query.expectedObjectClass = [GTLYouTubePlaylistListResponse class]; + return query; +} + ++ (id)queryForPlaylistsUpdateWithObject:(GTLYouTubePlaylist *)object + part:(NSString *)part { + if (object == nil) { + GTL_DEBUG_ASSERT(object != nil, @"%@ got a nil object", NSStringFromSelector(_cmd)); + return nil; + } + NSString *methodName = @"youtube.playlists.update"; + GTLQueryYouTube *query = [self queryWithMethodName:methodName]; + query.bodyObject = object; + query.part = part; + query.expectedObjectClass = [GTLYouTubePlaylist class]; + return query; +} + +#pragma mark - +#pragma mark "search" methods +// These create a GTLQueryYouTube object. + ++ (id)queryForSearchListWithPart:(NSString *)part { + NSString *methodName = @"youtube.search.list"; + GTLQueryYouTube *query = [self queryWithMethodName:methodName]; + query.part = part; + query.expectedObjectClass = [GTLYouTubeSearchListResponse class]; + return query; +} + +#pragma mark - +#pragma mark "subscriptions" methods +// These create a GTLQueryYouTube object. + ++ (id)queryForSubscriptionsDeleteWithIdentifier:(NSString *)identifier { + NSString *methodName = @"youtube.subscriptions.delete"; + GTLQueryYouTube *query = [self queryWithMethodName:methodName]; + query.identifier = identifier; + return query; +} + ++ (id)queryForSubscriptionsInsertWithObject:(GTLYouTubeSubscription *)object + part:(NSString *)part { + if (object == nil) { + GTL_DEBUG_ASSERT(object != nil, @"%@ got a nil object", NSStringFromSelector(_cmd)); + return nil; + } + NSString *methodName = @"youtube.subscriptions.insert"; + GTLQueryYouTube *query = [self queryWithMethodName:methodName]; + query.bodyObject = object; + query.part = part; + query.expectedObjectClass = [GTLYouTubeSubscription class]; + return query; +} + ++ (id)queryForSubscriptionsListWithPart:(NSString *)part { + NSString *methodName = @"youtube.subscriptions.list"; + GTLQueryYouTube *query = [self queryWithMethodName:methodName]; + query.part = part; + query.expectedObjectClass = [GTLYouTubeSubscriptionListResponse class]; + return query; +} + +#pragma mark - +#pragma mark "thumbnails" methods +// These create a GTLQueryYouTube object. + ++ (id)queryForThumbnailsSetWithVideoId:(NSString *)videoId + uploadParameters:(GTLUploadParameters *)uploadParametersOrNil { + NSString *methodName = @"youtube.thumbnails.set"; + GTLQueryYouTube *query = [self queryWithMethodName:methodName]; + query.videoId = videoId; + query.uploadParameters = uploadParametersOrNil; + query.expectedObjectClass = [GTLYouTubeThumbnailSetResponse class]; + return query; +} + +#pragma mark - +#pragma mark "videoCategories" methods +// These create a GTLQueryYouTube object. + ++ (id)queryForVideoCategoriesListWithPart:(NSString *)part { + NSString *methodName = @"youtube.videoCategories.list"; + GTLQueryYouTube *query = [self queryWithMethodName:methodName]; + query.part = part; + query.expectedObjectClass = [GTLYouTubeVideoCategoryListResponse class]; + return query; +} + +#pragma mark - +#pragma mark "videos" methods +// These create a GTLQueryYouTube object. + ++ (id)queryForVideosDeleteWithIdentifier:(NSString *)identifier { + NSString *methodName = @"youtube.videos.delete"; + GTLQueryYouTube *query = [self queryWithMethodName:methodName]; + query.identifier = identifier; + return query; +} + ++ (id)queryForVideosGetRatingWithIdentifier:(NSString *)identifier { + NSString *methodName = @"youtube.videos.getRating"; + GTLQueryYouTube *query = [self queryWithMethodName:methodName]; + query.identifier = identifier; + query.expectedObjectClass = [GTLYouTubeVideoGetRatingResponse class]; + return query; +} + ++ (id)queryForVideosInsertWithObject:(GTLYouTubeVideo *)object + part:(NSString *)part + uploadParameters:(GTLUploadParameters *)uploadParametersOrNil { + if (object == nil) { + GTL_DEBUG_ASSERT(object != nil, @"%@ got a nil object", NSStringFromSelector(_cmd)); + return nil; + } + NSString *methodName = @"youtube.videos.insert"; + GTLQueryYouTube *query = [self queryWithMethodName:methodName]; + query.bodyObject = object; + query.part = part; + query.uploadParameters = uploadParametersOrNil; + query.expectedObjectClass = [GTLYouTubeVideo class]; + return query; +} + ++ (id)queryForVideosListWithPart:(NSString *)part { + NSString *methodName = @"youtube.videos.list"; + GTLQueryYouTube *query = [self queryWithMethodName:methodName]; + query.part = part; + query.expectedObjectClass = [GTLYouTubeVideoListResponse class]; + return query; +} + ++ (id)queryForVideosRateWithIdentifier:(NSString *)identifier + rating:(NSString *)rating { + NSString *methodName = @"youtube.videos.rate"; + GTLQueryYouTube *query = [self queryWithMethodName:methodName]; + query.identifier = identifier; + query.rating = rating; + return query; +} + ++ (id)queryForVideosUpdateWithObject:(GTLYouTubeVideo *)object + part:(NSString *)part { + if (object == nil) { + GTL_DEBUG_ASSERT(object != nil, @"%@ got a nil object", NSStringFromSelector(_cmd)); + return nil; + } + NSString *methodName = @"youtube.videos.update"; + GTLQueryYouTube *query = [self queryWithMethodName:methodName]; + query.bodyObject = object; + query.part = part; + query.expectedObjectClass = [GTLYouTubeVideo class]; + return query; +} + +#pragma mark - +#pragma mark "watermarks" methods +// These create a GTLQueryYouTube object. + ++ (id)queryForWatermarksSetWithObject:(GTLYouTubeInvideoBranding *)object + channelId:(NSString *)channelId + uploadParameters:(GTLUploadParameters *)uploadParametersOrNil { + if (object == nil) { + GTL_DEBUG_ASSERT(object != nil, @"%@ got a nil object", NSStringFromSelector(_cmd)); + return nil; + } + NSString *methodName = @"youtube.watermarks.set"; + GTLQueryYouTube *query = [self queryWithMethodName:methodName]; + query.bodyObject = object; + query.channelId = channelId; + query.uploadParameters = uploadParametersOrNil; + return query; +} + ++ (id)queryForWatermarksUnsetWithChannelId:(NSString *)channelId { + NSString *methodName = @"youtube.watermarks.unset"; + GTLQueryYouTube *query = [self queryWithMethodName:methodName]; + query.channelId = channelId; + return query; +} + +@end diff --git a/XCDYouTubeKit Demo/Pods/Google-API-Client/Source/Services/YouTube/Generated/GTLServiceYouTube.h b/XCDYouTubeKit Demo/Pods/Google-API-Client/Source/Services/YouTube/Generated/GTLServiceYouTube.h new file mode 100644 index 00000000..c3cdc11d --- /dev/null +++ b/XCDYouTubeKit Demo/Pods/Google-API-Client/Source/Services/YouTube/Generated/GTLServiceYouTube.h @@ -0,0 +1,62 @@ +/* Copyright (c) 2012 Google Inc. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +// +// GTLServiceYouTube.h +// + +// ---------------------------------------------------------------------------- +// NOTE: This file is generated from Google APIs Discovery Service. +// Service: +// YouTube Data API (youtube/v3) +// Description: +// Programmatic access to YouTube features. +// Documentation: +// https://developers.google.com/youtube/v3 +// Classes: +// GTLServiceYouTube (0 custom class methods, 0 custom properties) + +#if GTL_BUILT_AS_FRAMEWORK + #import "GTL/GTLService.h" +#else + #import "GTLService.h" +#endif + +@interface GTLServiceYouTube : GTLService + +// No new methods + +// Clients should create a standard query with any of the class methods in +// GTLQueryYouTube.h. The query can the be sent with GTLService's execute +// methods, +// +// - (GTLServiceTicket *)executeQuery:(GTLQuery *)query +// completionHandler:(void (^)(GTLServiceTicket *ticket, +// id object, NSError *error))handler; +// or +// - (GTLServiceTicket *)executeQuery:(GTLQuery *)query +// delegate:(id)delegate +// didFinishSelector:(SEL)finishedSelector; +// +// where finishedSelector has a signature of: +// +// - (void)serviceTicket:(GTLServiceTicket *)ticket +// finishedWithObject:(id)object +// error:(NSError *)error; +// +// The object passed to the completion handler or delegate method +// is a subclass of GTLObject, determined by the query method executed. + +@end diff --git a/XCDYouTubeKit Demo/Pods/Google-API-Client/Source/Services/YouTube/Generated/GTLServiceYouTube.m b/XCDYouTubeKit Demo/Pods/Google-API-Client/Source/Services/YouTube/Generated/GTLServiceYouTube.m new file mode 100644 index 00000000..be6f95b7 --- /dev/null +++ b/XCDYouTubeKit Demo/Pods/Google-API-Client/Source/Services/YouTube/Generated/GTLServiceYouTube.m @@ -0,0 +1,185 @@ +/* Copyright (c) 2014 Google Inc. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +// +// GTLServiceYouTube.m +// + +// ---------------------------------------------------------------------------- +// NOTE: This file is generated from Google APIs Discovery Service. +// Service: +// YouTube Data API (youtube/v3) +// Description: +// Programmatic access to YouTube features. +// Documentation: +// https://developers.google.com/youtube/v3 +// Classes: +// GTLServiceYouTube (0 custom class methods, 0 custom properties) + +#import "GTLYouTube.h" + +@implementation GTLServiceYouTube + +#if DEBUG +// Method compiled in debug builds just to check that all the needed support +// classes are present at link time. ++ (NSArray *)checkClasses { + NSArray *classes = [NSArray arrayWithObjects: + [GTLQueryYouTube class], + [GTLYouTubeAccessPolicy class], + [GTLYouTubeActivity class], + [GTLYouTubeActivityContentDetails class], + [GTLYouTubeActivityContentDetailsBulletin class], + [GTLYouTubeActivityContentDetailsChannelItem class], + [GTLYouTubeActivityContentDetailsComment class], + [GTLYouTubeActivityContentDetailsFavorite class], + [GTLYouTubeActivityContentDetailsLike class], + [GTLYouTubeActivityContentDetailsPlaylistItem class], + [GTLYouTubeActivityContentDetailsPromotedItem class], + [GTLYouTubeActivityContentDetailsRecommendation class], + [GTLYouTubeActivityContentDetailsSocial class], + [GTLYouTubeActivityContentDetailsSubscription class], + [GTLYouTubeActivityContentDetailsUpload class], + [GTLYouTubeActivityListResponse class], + [GTLYouTubeActivitySnippet class], + [GTLYouTubeCdnSettings class], + [GTLYouTubeChannel class], + [GTLYouTubeChannelAuditDetails class], + [GTLYouTubeChannelBannerResource class], + [GTLYouTubeChannelBrandingSettings class], + [GTLYouTubeChannelContentDetails class], + [GTLYouTubeChannelContentOwnerDetails class], + [GTLYouTubeChannelConversionPing class], + [GTLYouTubeChannelConversionPings class], + [GTLYouTubeChannelListResponse class], + [GTLYouTubeChannelLocalization class], + [GTLYouTubeChannelSection class], + [GTLYouTubeChannelSectionContentDetails class], + [GTLYouTubeChannelSectionListResponse class], + [GTLYouTubeChannelSectionSnippet class], + [GTLYouTubeChannelSettings class], + [GTLYouTubeChannelSnippet class], + [GTLYouTubeChannelStatistics class], + [GTLYouTubeChannelStatus class], + [GTLYouTubeChannelTopicDetails class], + [GTLYouTubeContentRating class], + [GTLYouTubeGeoPoint class], + [GTLYouTubeGuideCategory class], + [GTLYouTubeGuideCategoryListResponse class], + [GTLYouTubeGuideCategorySnippet class], + [GTLYouTubeI18nLanguage class], + [GTLYouTubeI18nLanguageListResponse class], + [GTLYouTubeI18nLanguageSnippet class], + [GTLYouTubeI18nRegion class], + [GTLYouTubeI18nRegionListResponse class], + [GTLYouTubeI18nRegionSnippet class], + [GTLYouTubeImageSettings class], + [GTLYouTubeIngestionInfo class], + [GTLYouTubeInvideoBranding class], + [GTLYouTubeInvideoPosition class], + [GTLYouTubeInvideoPromotion class], + [GTLYouTubeInvideoTiming class], + [GTLYouTubeLanguageTag class], + [GTLYouTubeLiveBroadcast class], + [GTLYouTubeLiveBroadcastContentDetails class], + [GTLYouTubeLiveBroadcastListResponse class], + [GTLYouTubeLiveBroadcastSnippet class], + [GTLYouTubeLiveBroadcastStatus class], + [GTLYouTubeLiveStream class], + [GTLYouTubeLiveStreamContentDetails class], + [GTLYouTubeLiveStreamListResponse class], + [GTLYouTubeLiveStreamSnippet class], + [GTLYouTubeLiveStreamStatus class], + [GTLYouTubeLocalizedProperty class], + [GTLYouTubeLocalizedString class], + [GTLYouTubeMonitorStreamInfo class], + [GTLYouTubePageInfo class], + [GTLYouTubePlaylist class], + [GTLYouTubePlaylistContentDetails class], + [GTLYouTubePlaylistItem class], + [GTLYouTubePlaylistItemContentDetails class], + [GTLYouTubePlaylistItemListResponse class], + [GTLYouTubePlaylistItemSnippet class], + [GTLYouTubePlaylistItemStatus class], + [GTLYouTubePlaylistListResponse class], + [GTLYouTubePlaylistPlayer class], + [GTLYouTubePlaylistSnippet class], + [GTLYouTubePlaylistStatus class], + [GTLYouTubePromotedItem class], + [GTLYouTubePromotedItemId class], + [GTLYouTubePropertyValue class], + [GTLYouTubeResourceId class], + [GTLYouTubeSearchListResponse class], + [GTLYouTubeSearchResult class], + [GTLYouTubeSearchResultSnippet class], + [GTLYouTubeSubscription class], + [GTLYouTubeSubscriptionContentDetails class], + [GTLYouTubeSubscriptionListResponse class], + [GTLYouTubeSubscriptionSnippet class], + [GTLYouTubeSubscriptionSubscriberSnippet class], + [GTLYouTubeThumbnail class], + [GTLYouTubeThumbnailDetails class], + [GTLYouTubeThumbnailSetResponse class], + [GTLYouTubeTokenPagination class], + [GTLYouTubeVideo class], + [GTLYouTubeVideoAgeGating class], + [GTLYouTubeVideoCategory class], + [GTLYouTubeVideoCategoryListResponse class], + [GTLYouTubeVideoCategorySnippet class], + [GTLYouTubeVideoContentDetails class], + [GTLYouTubeVideoContentDetailsRegionRestriction class], + [GTLYouTubeVideoConversionPing class], + [GTLYouTubeVideoConversionPings class], + [GTLYouTubeVideoFileDetails class], + [GTLYouTubeVideoFileDetailsAudioStream class], + [GTLYouTubeVideoFileDetailsVideoStream class], + [GTLYouTubeVideoGetRatingResponse class], + [GTLYouTubeVideoListResponse class], + [GTLYouTubeVideoLiveStreamingDetails class], + [GTLYouTubeVideoMonetizationDetails class], + [GTLYouTubeVideoPlayer class], + [GTLYouTubeVideoProcessingDetails class], + [GTLYouTubeVideoProcessingDetailsProcessingProgress class], + [GTLYouTubeVideoProjectDetails class], + [GTLYouTubeVideoRating class], + [GTLYouTubeVideoRecordingDetails class], + [GTLYouTubeVideoSnippet class], + [GTLYouTubeVideoStatistics class], + [GTLYouTubeVideoStatus class], + [GTLYouTubeVideoSuggestions class], + [GTLYouTubeVideoSuggestionsTagSuggestion class], + [GTLYouTubeVideoTopicDetails class], + [GTLYouTubeWatchSettings class], + nil]; + return classes; +} +#endif // DEBUG + +- (id)init { + self = [super init]; + if (self) { + // Version from discovery. + self.apiVersion = @"v3"; + + // From discovery. Where to send JSON-RPC. + // Turn off prettyPrint for this service to save bandwidth (especially on + // mobile). The fetcher logging will pretty print. + self.rpcURL = [NSURL URLWithString:@"https://www.googleapis.com/rpc?prettyPrint=false"]; + self.rpcUploadURL = [NSURL URLWithString:@"https://www.googleapis.com/upload/rpc?uploadType=resumable&prettyPrint=false"]; + } + return self; +} + +@end diff --git a/XCDYouTubeKit Demo/Pods/Google-API-Client/Source/Services/YouTube/Generated/GTLYouTube.h b/XCDYouTubeKit Demo/Pods/Google-API-Client/Source/Services/YouTube/Generated/GTLYouTube.h new file mode 100644 index 00000000..0d9ac103 --- /dev/null +++ b/XCDYouTubeKit Demo/Pods/Google-API-Client/Source/Services/YouTube/Generated/GTLYouTube.h @@ -0,0 +1,157 @@ +/* Copyright (c) 2014 Google Inc. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +// +// GTLYouTube.h +// + +// ---------------------------------------------------------------------------- +// NOTE: This file is generated from Google APIs Discovery Service. +// Service: +// YouTube Data API (youtube/v3) +// Description: +// Programmatic access to YouTube features. +// Documentation: +// https://developers.google.com/youtube/v3 + +#import "GTLYouTubeConstants.h" + +#import "GTLYouTubeAccessPolicy.h" +#import "GTLYouTubeActivity.h" +#import "GTLYouTubeActivityContentDetails.h" +#import "GTLYouTubeActivityContentDetailsBulletin.h" +#import "GTLYouTubeActivityContentDetailsChannelItem.h" +#import "GTLYouTubeActivityContentDetailsComment.h" +#import "GTLYouTubeActivityContentDetailsFavorite.h" +#import "GTLYouTubeActivityContentDetailsLike.h" +#import "GTLYouTubeActivityContentDetailsPlaylistItem.h" +#import "GTLYouTubeActivityContentDetailsPromotedItem.h" +#import "GTLYouTubeActivityContentDetailsRecommendation.h" +#import "GTLYouTubeActivityContentDetailsSocial.h" +#import "GTLYouTubeActivityContentDetailsSubscription.h" +#import "GTLYouTubeActivityContentDetailsUpload.h" +#import "GTLYouTubeActivityListResponse.h" +#import "GTLYouTubeActivitySnippet.h" +#import "GTLYouTubeCdnSettings.h" +#import "GTLYouTubeChannel.h" +#import "GTLYouTubeChannelAuditDetails.h" +#import "GTLYouTubeChannelBannerResource.h" +#import "GTLYouTubeChannelBrandingSettings.h" +#import "GTLYouTubeChannelContentDetails.h" +#import "GTLYouTubeChannelContentOwnerDetails.h" +#import "GTLYouTubeChannelConversionPing.h" +#import "GTLYouTubeChannelConversionPings.h" +#import "GTLYouTubeChannelListResponse.h" +#import "GTLYouTubeChannelLocalization.h" +#import "GTLYouTubeChannelSection.h" +#import "GTLYouTubeChannelSectionContentDetails.h" +#import "GTLYouTubeChannelSectionListResponse.h" +#import "GTLYouTubeChannelSectionSnippet.h" +#import "GTLYouTubeChannelSettings.h" +#import "GTLYouTubeChannelSnippet.h" +#import "GTLYouTubeChannelStatistics.h" +#import "GTLYouTubeChannelStatus.h" +#import "GTLYouTubeChannelTopicDetails.h" +#import "GTLYouTubeContentRating.h" +#import "GTLYouTubeGeoPoint.h" +#import "GTLYouTubeGuideCategory.h" +#import "GTLYouTubeGuideCategoryListResponse.h" +#import "GTLYouTubeGuideCategorySnippet.h" +#import "GTLYouTubeI18nLanguage.h" +#import "GTLYouTubeI18nLanguageListResponse.h" +#import "GTLYouTubeI18nLanguageSnippet.h" +#import "GTLYouTubeI18nRegion.h" +#import "GTLYouTubeI18nRegionListResponse.h" +#import "GTLYouTubeI18nRegionSnippet.h" +#import "GTLYouTubeImageSettings.h" +#import "GTLYouTubeIngestionInfo.h" +#import "GTLYouTubeInvideoBranding.h" +#import "GTLYouTubeInvideoPosition.h" +#import "GTLYouTubeInvideoPromotion.h" +#import "GTLYouTubeInvideoTiming.h" +#import "GTLYouTubeLanguageTag.h" +#import "GTLYouTubeLiveBroadcast.h" +#import "GTLYouTubeLiveBroadcastContentDetails.h" +#import "GTLYouTubeLiveBroadcastListResponse.h" +#import "GTLYouTubeLiveBroadcastSnippet.h" +#import "GTLYouTubeLiveBroadcastStatus.h" +#import "GTLYouTubeLiveStream.h" +#import "GTLYouTubeLiveStreamContentDetails.h" +#import "GTLYouTubeLiveStreamListResponse.h" +#import "GTLYouTubeLiveStreamSnippet.h" +#import "GTLYouTubeLiveStreamStatus.h" +#import "GTLYouTubeLocalizedProperty.h" +#import "GTLYouTubeLocalizedString.h" +#import "GTLYouTubeMonitorStreamInfo.h" +#import "GTLYouTubePageInfo.h" +#import "GTLYouTubePlaylist.h" +#import "GTLYouTubePlaylistContentDetails.h" +#import "GTLYouTubePlaylistItem.h" +#import "GTLYouTubePlaylistItemContentDetails.h" +#import "GTLYouTubePlaylistItemListResponse.h" +#import "GTLYouTubePlaylistItemSnippet.h" +#import "GTLYouTubePlaylistItemStatus.h" +#import "GTLYouTubePlaylistListResponse.h" +#import "GTLYouTubePlaylistPlayer.h" +#import "GTLYouTubePlaylistSnippet.h" +#import "GTLYouTubePlaylistStatus.h" +#import "GTLYouTubePromotedItem.h" +#import "GTLYouTubePromotedItemId.h" +#import "GTLYouTubePropertyValue.h" +#import "GTLYouTubeResourceId.h" +#import "GTLYouTubeSearchListResponse.h" +#import "GTLYouTubeSearchResult.h" +#import "GTLYouTubeSearchResultSnippet.h" +#import "GTLYouTubeSubscription.h" +#import "GTLYouTubeSubscriptionContentDetails.h" +#import "GTLYouTubeSubscriptionListResponse.h" +#import "GTLYouTubeSubscriptionSnippet.h" +#import "GTLYouTubeSubscriptionSubscriberSnippet.h" +#import "GTLYouTubeThumbnail.h" +#import "GTLYouTubeThumbnailDetails.h" +#import "GTLYouTubeThumbnailSetResponse.h" +#import "GTLYouTubeTokenPagination.h" +#import "GTLYouTubeVideo.h" +#import "GTLYouTubeVideoAgeGating.h" +#import "GTLYouTubeVideoCategory.h" +#import "GTLYouTubeVideoCategoryListResponse.h" +#import "GTLYouTubeVideoCategorySnippet.h" +#import "GTLYouTubeVideoContentDetails.h" +#import "GTLYouTubeVideoContentDetailsRegionRestriction.h" +#import "GTLYouTubeVideoConversionPing.h" +#import "GTLYouTubeVideoConversionPings.h" +#import "GTLYouTubeVideoFileDetails.h" +#import "GTLYouTubeVideoFileDetailsAudioStream.h" +#import "GTLYouTubeVideoFileDetailsVideoStream.h" +#import "GTLYouTubeVideoGetRatingResponse.h" +#import "GTLYouTubeVideoListResponse.h" +#import "GTLYouTubeVideoLiveStreamingDetails.h" +#import "GTLYouTubeVideoMonetizationDetails.h" +#import "GTLYouTubeVideoPlayer.h" +#import "GTLYouTubeVideoProcessingDetails.h" +#import "GTLYouTubeVideoProcessingDetailsProcessingProgress.h" +#import "GTLYouTubeVideoProjectDetails.h" +#import "GTLYouTubeVideoRating.h" +#import "GTLYouTubeVideoRecordingDetails.h" +#import "GTLYouTubeVideoSnippet.h" +#import "GTLYouTubeVideoStatistics.h" +#import "GTLYouTubeVideoStatus.h" +#import "GTLYouTubeVideoSuggestions.h" +#import "GTLYouTubeVideoSuggestionsTagSuggestion.h" +#import "GTLYouTubeVideoTopicDetails.h" +#import "GTLYouTubeWatchSettings.h" + +#import "GTLQueryYouTube.h" +#import "GTLServiceYouTube.h" diff --git a/XCDYouTubeKit Demo/Pods/Google-API-Client/Source/Services/YouTube/Generated/GTLYouTubeAccessPolicy.h b/XCDYouTubeKit Demo/Pods/Google-API-Client/Source/Services/YouTube/Generated/GTLYouTubeAccessPolicy.h new file mode 100644 index 00000000..09eee4a3 --- /dev/null +++ b/XCDYouTubeKit Demo/Pods/Google-API-Client/Source/Services/YouTube/Generated/GTLYouTubeAccessPolicy.h @@ -0,0 +1,54 @@ +/* Copyright (c) 2013 Google Inc. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +// +// GTLYouTubeAccessPolicy.h +// + +// ---------------------------------------------------------------------------- +// NOTE: This file is generated from Google APIs Discovery Service. +// Service: +// YouTube Data API (youtube/v3) +// Description: +// Programmatic access to YouTube features. +// Documentation: +// https://developers.google.com/youtube/v3 +// Classes: +// GTLYouTubeAccessPolicy (0 custom class methods, 2 custom properties) + +#if GTL_BUILT_AS_FRAMEWORK + #import "GTL/GTLObject.h" +#else + #import "GTLObject.h" +#endif + +// ---------------------------------------------------------------------------- +// +// GTLYouTubeAccessPolicy +// + +// Rights management policy for YouTube resources. + +@interface GTLYouTubeAccessPolicy : GTLObject + +// The value of allowed indicates whether the access to the policy is allowed or +// denied by default. +@property (retain) NSNumber *allowed; // boolValue + +// A list of region codes that identify countries where the default policy do +// not apply. +@property (retain) NSArray *exception; // of NSString + +@end diff --git a/XCDYouTubeKit Demo/Pods/Google-API-Client/Source/Services/YouTube/Generated/GTLYouTubeAccessPolicy.m b/XCDYouTubeKit Demo/Pods/Google-API-Client/Source/Services/YouTube/Generated/GTLYouTubeAccessPolicy.m new file mode 100644 index 00000000..7ee2d659 --- /dev/null +++ b/XCDYouTubeKit Demo/Pods/Google-API-Client/Source/Services/YouTube/Generated/GTLYouTubeAccessPolicy.m @@ -0,0 +1,48 @@ +/* Copyright (c) 2013 Google Inc. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +// +// GTLYouTubeAccessPolicy.m +// + +// ---------------------------------------------------------------------------- +// NOTE: This file is generated from Google APIs Discovery Service. +// Service: +// YouTube Data API (youtube/v3) +// Description: +// Programmatic access to YouTube features. +// Documentation: +// https://developers.google.com/youtube/v3 +// Classes: +// GTLYouTubeAccessPolicy (0 custom class methods, 2 custom properties) + +#import "GTLYouTubeAccessPolicy.h" + +// ---------------------------------------------------------------------------- +// +// GTLYouTubeAccessPolicy +// + +@implementation GTLYouTubeAccessPolicy +@dynamic allowed, exception; + ++ (NSDictionary *)arrayPropertyToClassMap { + NSDictionary *map = + [NSDictionary dictionaryWithObject:[NSString class] + forKey:@"exception"]; + return map; +} + +@end diff --git a/XCDYouTubeKit Demo/Pods/Google-API-Client/Source/Services/YouTube/Generated/GTLYouTubeActivity.h b/XCDYouTubeKit Demo/Pods/Google-API-Client/Source/Services/YouTube/Generated/GTLYouTubeActivity.h new file mode 100644 index 00000000..f7864184 --- /dev/null +++ b/XCDYouTubeKit Demo/Pods/Google-API-Client/Source/Services/YouTube/Generated/GTLYouTubeActivity.h @@ -0,0 +1,75 @@ +/* Copyright (c) 2013 Google Inc. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +// +// GTLYouTubeActivity.h +// + +// ---------------------------------------------------------------------------- +// NOTE: This file is generated from Google APIs Discovery Service. +// Service: +// YouTube Data API (youtube/v3) +// Description: +// Programmatic access to YouTube features. +// Documentation: +// https://developers.google.com/youtube/v3 +// Classes: +// GTLYouTubeActivity (0 custom class methods, 5 custom properties) + +#if GTL_BUILT_AS_FRAMEWORK + #import "GTL/GTLObject.h" +#else + #import "GTLObject.h" +#endif + +@class GTLYouTubeActivityContentDetails; +@class GTLYouTubeActivitySnippet; + +// ---------------------------------------------------------------------------- +// +// GTLYouTubeActivity +// + +// An activity resource contains information about an action that a particular +// channel, or user, has taken on YouTube.The actions reported in activity feeds +// include rating a video, sharing a video, marking a video as a favorite, +// commenting on a video, uploading a video, and so forth. Each activity +// resource identifies the type of action, the channel associated with the +// action, and the resource(s) associated with the action, such as the video +// that was rated or uploaded. + +@interface GTLYouTubeActivity : GTLObject + +// The contentDetails object contains information about the content associated +// with the activity. For example, if the snippet.type value is videoRated, then +// the contentDetails object's content identifies the rated video. +@property (retain) GTLYouTubeActivityContentDetails *contentDetails; + +// Etag of this resource. +@property (copy) NSString *ETag; + +// The ID that YouTube uses to uniquely identify the activity. +// identifier property maps to 'id' in JSON (to avoid Objective C's 'id'). +@property (copy) NSString *identifier; + +// Identifies what kind of resource this is. Value: the fixed string +// "youtube#activity". +@property (copy) NSString *kind; + +// The snippet object contains basic details about the activity, including the +// activity's type and group ID. +@property (retain) GTLYouTubeActivitySnippet *snippet; + +@end diff --git a/XCDYouTubeKit Demo/Pods/Google-API-Client/Source/Services/YouTube/Generated/GTLYouTubeActivity.m b/XCDYouTubeKit Demo/Pods/Google-API-Client/Source/Services/YouTube/Generated/GTLYouTubeActivity.m new file mode 100644 index 00000000..43ba1ad8 --- /dev/null +++ b/XCDYouTubeKit Demo/Pods/Google-API-Client/Source/Services/YouTube/Generated/GTLYouTubeActivity.m @@ -0,0 +1,57 @@ +/* Copyright (c) 2012 Google Inc. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +// +// GTLYouTubeActivity.m +// + +// ---------------------------------------------------------------------------- +// NOTE: This file is generated from Google APIs Discovery Service. +// Service: +// YouTube Data API (youtube/v3) +// Description: +// Programmatic access to YouTube features. +// Documentation: +// https://developers.google.com/youtube/v3 +// Classes: +// GTLYouTubeActivity (0 custom class methods, 5 custom properties) + +#import "GTLYouTubeActivity.h" + +#import "GTLYouTubeActivityContentDetails.h" +#import "GTLYouTubeActivitySnippet.h" + +// ---------------------------------------------------------------------------- +// +// GTLYouTubeActivity +// + +@implementation GTLYouTubeActivity +@dynamic contentDetails, ETag, identifier, kind, snippet; + ++ (NSDictionary *)propertyToJSONKeyMap { + NSDictionary *map = + [NSDictionary dictionaryWithObjectsAndKeys: + @"etag", @"ETag", + @"id", @"identifier", + nil]; + return map; +} + ++ (void)load { + [self registerObjectClassForKind:@"youtube#activity"]; +} + +@end diff --git a/XCDYouTubeKit Demo/Pods/Google-API-Client/Source/Services/YouTube/Generated/GTLYouTubeActivityContentDetails.h b/XCDYouTubeKit Demo/Pods/Google-API-Client/Source/Services/YouTube/Generated/GTLYouTubeActivityContentDetails.h new file mode 100644 index 00000000..327b8b29 --- /dev/null +++ b/XCDYouTubeKit Demo/Pods/Google-API-Client/Source/Services/YouTube/Generated/GTLYouTubeActivityContentDetails.h @@ -0,0 +1,106 @@ +/* Copyright (c) 2013 Google Inc. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +// +// GTLYouTubeActivityContentDetails.h +// + +// ---------------------------------------------------------------------------- +// NOTE: This file is generated from Google APIs Discovery Service. +// Service: +// YouTube Data API (youtube/v3) +// Description: +// Programmatic access to YouTube features. +// Documentation: +// https://developers.google.com/youtube/v3 +// Classes: +// GTLYouTubeActivityContentDetails (0 custom class methods, 11 custom properties) + +#if GTL_BUILT_AS_FRAMEWORK + #import "GTL/GTLObject.h" +#else + #import "GTLObject.h" +#endif + +@class GTLYouTubeActivityContentDetailsBulletin; +@class GTLYouTubeActivityContentDetailsChannelItem; +@class GTLYouTubeActivityContentDetailsComment; +@class GTLYouTubeActivityContentDetailsFavorite; +@class GTLYouTubeActivityContentDetailsLike; +@class GTLYouTubeActivityContentDetailsPlaylistItem; +@class GTLYouTubeActivityContentDetailsPromotedItem; +@class GTLYouTubeActivityContentDetailsRecommendation; +@class GTLYouTubeActivityContentDetailsSocial; +@class GTLYouTubeActivityContentDetailsSubscription; +@class GTLYouTubeActivityContentDetailsUpload; + +// ---------------------------------------------------------------------------- +// +// GTLYouTubeActivityContentDetails +// + +// Details about the content of an activity: the video that was shared, the +// channel that was subscribed to, etc. + +@interface GTLYouTubeActivityContentDetails : GTLObject + +// The bulletin object contains details about a channel bulletin post. This +// object is only present if the snippet.type is bulletin. +@property (retain) GTLYouTubeActivityContentDetailsBulletin *bulletin; + +// The channelItem object contains details about a resource which was added to a +// channel. This property is only present if the snippet.type is channelItem. +@property (retain) GTLYouTubeActivityContentDetailsChannelItem *channelItem; + +// The comment object contains information about a resource that received a +// comment. This property is only present if the snippet.type is comment. +@property (retain) GTLYouTubeActivityContentDetailsComment *comment; + +// The favorite object contains information about a video that was marked as a +// favorite video. This property is only present if the snippet.type is +// favorite. +@property (retain) GTLYouTubeActivityContentDetailsFavorite *favorite; + +// The like object contains information about a resource that received a +// positive (like) rating. This property is only present if the snippet.type is +// like. +@property (retain) GTLYouTubeActivityContentDetailsLike *like; + +// The playlistItem object contains information about a new playlist item. This +// property is only present if the snippet.type is playlistItem. +@property (retain) GTLYouTubeActivityContentDetailsPlaylistItem *playlistItem; + +// The promotedItem object contains details about a resource which is being +// promoted. This property is only present if the snippet.type is promotedItem. +@property (retain) GTLYouTubeActivityContentDetailsPromotedItem *promotedItem; + +// The recommendation object contains information about a recommended resource. +// This property is only present if the snippet.type is recommendation. +@property (retain) GTLYouTubeActivityContentDetailsRecommendation *recommendation; + +// The social object contains details about a social network post. This property +// is only present if the snippet.type is social. +@property (retain) GTLYouTubeActivityContentDetailsSocial *social; + +// The subscription object contains information about a channel that a user +// subscribed to. This property is only present if the snippet.type is +// subscription. +@property (retain) GTLYouTubeActivityContentDetailsSubscription *subscription; + +// The upload object contains information about the uploaded video. This +// property is only present if the snippet.type is upload. +@property (retain) GTLYouTubeActivityContentDetailsUpload *upload; + +@end diff --git a/XCDYouTubeKit Demo/Pods/Google-API-Client/Source/Services/YouTube/Generated/GTLYouTubeActivityContentDetails.m b/XCDYouTubeKit Demo/Pods/Google-API-Client/Source/Services/YouTube/Generated/GTLYouTubeActivityContentDetails.m new file mode 100644 index 00000000..d6274339 --- /dev/null +++ b/XCDYouTubeKit Demo/Pods/Google-API-Client/Source/Services/YouTube/Generated/GTLYouTubeActivityContentDetails.m @@ -0,0 +1,53 @@ +/* Copyright (c) 2013 Google Inc. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +// +// GTLYouTubeActivityContentDetails.m +// + +// ---------------------------------------------------------------------------- +// NOTE: This file is generated from Google APIs Discovery Service. +// Service: +// YouTube Data API (youtube/v3) +// Description: +// Programmatic access to YouTube features. +// Documentation: +// https://developers.google.com/youtube/v3 +// Classes: +// GTLYouTubeActivityContentDetails (0 custom class methods, 11 custom properties) + +#import "GTLYouTubeActivityContentDetails.h" + +#import "GTLYouTubeActivityContentDetailsBulletin.h" +#import "GTLYouTubeActivityContentDetailsChannelItem.h" +#import "GTLYouTubeActivityContentDetailsComment.h" +#import "GTLYouTubeActivityContentDetailsFavorite.h" +#import "GTLYouTubeActivityContentDetailsLike.h" +#import "GTLYouTubeActivityContentDetailsPlaylistItem.h" +#import "GTLYouTubeActivityContentDetailsPromotedItem.h" +#import "GTLYouTubeActivityContentDetailsRecommendation.h" +#import "GTLYouTubeActivityContentDetailsSocial.h" +#import "GTLYouTubeActivityContentDetailsSubscription.h" +#import "GTLYouTubeActivityContentDetailsUpload.h" + +// ---------------------------------------------------------------------------- +// +// GTLYouTubeActivityContentDetails +// + +@implementation GTLYouTubeActivityContentDetails +@dynamic bulletin, channelItem, comment, favorite, like, playlistItem, + promotedItem, recommendation, social, subscription, upload; +@end diff --git a/XCDYouTubeKit Demo/Pods/Google-API-Client/Source/Services/YouTube/Generated/GTLYouTubeActivityContentDetailsBulletin.h b/XCDYouTubeKit Demo/Pods/Google-API-Client/Source/Services/YouTube/Generated/GTLYouTubeActivityContentDetailsBulletin.h new file mode 100644 index 00000000..45fe412b --- /dev/null +++ b/XCDYouTubeKit Demo/Pods/Google-API-Client/Source/Services/YouTube/Generated/GTLYouTubeActivityContentDetailsBulletin.h @@ -0,0 +1,52 @@ +/* Copyright (c) 2013 Google Inc. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +// +// GTLYouTubeActivityContentDetailsBulletin.h +// + +// ---------------------------------------------------------------------------- +// NOTE: This file is generated from Google APIs Discovery Service. +// Service: +// YouTube Data API (youtube/v3) +// Description: +// Programmatic access to YouTube features. +// Documentation: +// https://developers.google.com/youtube/v3 +// Classes: +// GTLYouTubeActivityContentDetailsBulletin (0 custom class methods, 1 custom properties) + +#if GTL_BUILT_AS_FRAMEWORK + #import "GTL/GTLObject.h" +#else + #import "GTLObject.h" +#endif + +@class GTLYouTubeResourceId; + +// ---------------------------------------------------------------------------- +// +// GTLYouTubeActivityContentDetailsBulletin +// + +// Details about a channel bulletin post. + +@interface GTLYouTubeActivityContentDetailsBulletin : GTLObject + +// The resourceId object contains information that identifies the resource +// associated with a bulletin post. +@property (retain) GTLYouTubeResourceId *resourceId; + +@end diff --git a/XCDYouTubeKit Demo/Pods/Google-API-Client/Source/Services/YouTube/Generated/GTLYouTubeActivityContentDetailsBulletin.m b/XCDYouTubeKit Demo/Pods/Google-API-Client/Source/Services/YouTube/Generated/GTLYouTubeActivityContentDetailsBulletin.m new file mode 100644 index 00000000..9f716876 --- /dev/null +++ b/XCDYouTubeKit Demo/Pods/Google-API-Client/Source/Services/YouTube/Generated/GTLYouTubeActivityContentDetailsBulletin.m @@ -0,0 +1,42 @@ +/* Copyright (c) 2013 Google Inc. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +// +// GTLYouTubeActivityContentDetailsBulletin.m +// + +// ---------------------------------------------------------------------------- +// NOTE: This file is generated from Google APIs Discovery Service. +// Service: +// YouTube Data API (youtube/v3) +// Description: +// Programmatic access to YouTube features. +// Documentation: +// https://developers.google.com/youtube/v3 +// Classes: +// GTLYouTubeActivityContentDetailsBulletin (0 custom class methods, 1 custom properties) + +#import "GTLYouTubeActivityContentDetailsBulletin.h" + +#import "GTLYouTubeResourceId.h" + +// ---------------------------------------------------------------------------- +// +// GTLYouTubeActivityContentDetailsBulletin +// + +@implementation GTLYouTubeActivityContentDetailsBulletin +@dynamic resourceId; +@end diff --git a/XCDYouTubeKit Demo/Pods/Google-API-Client/Source/Services/YouTube/Generated/GTLYouTubeActivityContentDetailsChannelItem.h b/XCDYouTubeKit Demo/Pods/Google-API-Client/Source/Services/YouTube/Generated/GTLYouTubeActivityContentDetailsChannelItem.h new file mode 100644 index 00000000..48a7e6a6 --- /dev/null +++ b/XCDYouTubeKit Demo/Pods/Google-API-Client/Source/Services/YouTube/Generated/GTLYouTubeActivityContentDetailsChannelItem.h @@ -0,0 +1,52 @@ +/* Copyright (c) 2013 Google Inc. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +// +// GTLYouTubeActivityContentDetailsChannelItem.h +// + +// ---------------------------------------------------------------------------- +// NOTE: This file is generated from Google APIs Discovery Service. +// Service: +// YouTube Data API (youtube/v3) +// Description: +// Programmatic access to YouTube features. +// Documentation: +// https://developers.google.com/youtube/v3 +// Classes: +// GTLYouTubeActivityContentDetailsChannelItem (0 custom class methods, 1 custom properties) + +#if GTL_BUILT_AS_FRAMEWORK + #import "GTL/GTLObject.h" +#else + #import "GTLObject.h" +#endif + +@class GTLYouTubeResourceId; + +// ---------------------------------------------------------------------------- +// +// GTLYouTubeActivityContentDetailsChannelItem +// + +// Details about a resource which was added to a channel. + +@interface GTLYouTubeActivityContentDetailsChannelItem : GTLObject + +// The resourceId object contains information that identifies the resource that +// was added to the channel. +@property (retain) GTLYouTubeResourceId *resourceId; + +@end diff --git a/XCDYouTubeKit Demo/Pods/Google-API-Client/Source/Services/YouTube/Generated/GTLYouTubeActivityContentDetailsChannelItem.m b/XCDYouTubeKit Demo/Pods/Google-API-Client/Source/Services/YouTube/Generated/GTLYouTubeActivityContentDetailsChannelItem.m new file mode 100644 index 00000000..947f4c94 --- /dev/null +++ b/XCDYouTubeKit Demo/Pods/Google-API-Client/Source/Services/YouTube/Generated/GTLYouTubeActivityContentDetailsChannelItem.m @@ -0,0 +1,42 @@ +/* Copyright (c) 2013 Google Inc. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +// +// GTLYouTubeActivityContentDetailsChannelItem.m +// + +// ---------------------------------------------------------------------------- +// NOTE: This file is generated from Google APIs Discovery Service. +// Service: +// YouTube Data API (youtube/v3) +// Description: +// Programmatic access to YouTube features. +// Documentation: +// https://developers.google.com/youtube/v3 +// Classes: +// GTLYouTubeActivityContentDetailsChannelItem (0 custom class methods, 1 custom properties) + +#import "GTLYouTubeActivityContentDetailsChannelItem.h" + +#import "GTLYouTubeResourceId.h" + +// ---------------------------------------------------------------------------- +// +// GTLYouTubeActivityContentDetailsChannelItem +// + +@implementation GTLYouTubeActivityContentDetailsChannelItem +@dynamic resourceId; +@end diff --git a/XCDYouTubeKit Demo/Pods/Google-API-Client/Source/Services/YouTube/Generated/GTLYouTubeActivityContentDetailsComment.h b/XCDYouTubeKit Demo/Pods/Google-API-Client/Source/Services/YouTube/Generated/GTLYouTubeActivityContentDetailsComment.h new file mode 100644 index 00000000..0e60ddd3 --- /dev/null +++ b/XCDYouTubeKit Demo/Pods/Google-API-Client/Source/Services/YouTube/Generated/GTLYouTubeActivityContentDetailsComment.h @@ -0,0 +1,52 @@ +/* Copyright (c) 2013 Google Inc. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +// +// GTLYouTubeActivityContentDetailsComment.h +// + +// ---------------------------------------------------------------------------- +// NOTE: This file is generated from Google APIs Discovery Service. +// Service: +// YouTube Data API (youtube/v3) +// Description: +// Programmatic access to YouTube features. +// Documentation: +// https://developers.google.com/youtube/v3 +// Classes: +// GTLYouTubeActivityContentDetailsComment (0 custom class methods, 1 custom properties) + +#if GTL_BUILT_AS_FRAMEWORK + #import "GTL/GTLObject.h" +#else + #import "GTLObject.h" +#endif + +@class GTLYouTubeResourceId; + +// ---------------------------------------------------------------------------- +// +// GTLYouTubeActivityContentDetailsComment +// + +// Information about a resource that received a comment. + +@interface GTLYouTubeActivityContentDetailsComment : GTLObject + +// The resourceId object contains information that identifies the resource +// associated with the comment. +@property (retain) GTLYouTubeResourceId *resourceId; + +@end diff --git a/XCDYouTubeKit Demo/Pods/Google-API-Client/Source/Services/YouTube/Generated/GTLYouTubeActivityContentDetailsComment.m b/XCDYouTubeKit Demo/Pods/Google-API-Client/Source/Services/YouTube/Generated/GTLYouTubeActivityContentDetailsComment.m new file mode 100644 index 00000000..ac52592e --- /dev/null +++ b/XCDYouTubeKit Demo/Pods/Google-API-Client/Source/Services/YouTube/Generated/GTLYouTubeActivityContentDetailsComment.m @@ -0,0 +1,42 @@ +/* Copyright (c) 2013 Google Inc. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +// +// GTLYouTubeActivityContentDetailsComment.m +// + +// ---------------------------------------------------------------------------- +// NOTE: This file is generated from Google APIs Discovery Service. +// Service: +// YouTube Data API (youtube/v3) +// Description: +// Programmatic access to YouTube features. +// Documentation: +// https://developers.google.com/youtube/v3 +// Classes: +// GTLYouTubeActivityContentDetailsComment (0 custom class methods, 1 custom properties) + +#import "GTLYouTubeActivityContentDetailsComment.h" + +#import "GTLYouTubeResourceId.h" + +// ---------------------------------------------------------------------------- +// +// GTLYouTubeActivityContentDetailsComment +// + +@implementation GTLYouTubeActivityContentDetailsComment +@dynamic resourceId; +@end diff --git a/XCDYouTubeKit Demo/Pods/Google-API-Client/Source/Services/YouTube/Generated/GTLYouTubeActivityContentDetailsFavorite.h b/XCDYouTubeKit Demo/Pods/Google-API-Client/Source/Services/YouTube/Generated/GTLYouTubeActivityContentDetailsFavorite.h new file mode 100644 index 00000000..adde23ac --- /dev/null +++ b/XCDYouTubeKit Demo/Pods/Google-API-Client/Source/Services/YouTube/Generated/GTLYouTubeActivityContentDetailsFavorite.h @@ -0,0 +1,52 @@ +/* Copyright (c) 2013 Google Inc. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +// +// GTLYouTubeActivityContentDetailsFavorite.h +// + +// ---------------------------------------------------------------------------- +// NOTE: This file is generated from Google APIs Discovery Service. +// Service: +// YouTube Data API (youtube/v3) +// Description: +// Programmatic access to YouTube features. +// Documentation: +// https://developers.google.com/youtube/v3 +// Classes: +// GTLYouTubeActivityContentDetailsFavorite (0 custom class methods, 1 custom properties) + +#if GTL_BUILT_AS_FRAMEWORK + #import "GTL/GTLObject.h" +#else + #import "GTLObject.h" +#endif + +@class GTLYouTubeResourceId; + +// ---------------------------------------------------------------------------- +// +// GTLYouTubeActivityContentDetailsFavorite +// + +// Information about a video that was marked as a favorite video. + +@interface GTLYouTubeActivityContentDetailsFavorite : GTLObject + +// The resourceId object contains information that identifies the resource that +// was marked as a favorite. +@property (retain) GTLYouTubeResourceId *resourceId; + +@end diff --git a/XCDYouTubeKit Demo/Pods/Google-API-Client/Source/Services/YouTube/Generated/GTLYouTubeActivityContentDetailsFavorite.m b/XCDYouTubeKit Demo/Pods/Google-API-Client/Source/Services/YouTube/Generated/GTLYouTubeActivityContentDetailsFavorite.m new file mode 100644 index 00000000..d91f1fdc --- /dev/null +++ b/XCDYouTubeKit Demo/Pods/Google-API-Client/Source/Services/YouTube/Generated/GTLYouTubeActivityContentDetailsFavorite.m @@ -0,0 +1,42 @@ +/* Copyright (c) 2013 Google Inc. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +// +// GTLYouTubeActivityContentDetailsFavorite.m +// + +// ---------------------------------------------------------------------------- +// NOTE: This file is generated from Google APIs Discovery Service. +// Service: +// YouTube Data API (youtube/v3) +// Description: +// Programmatic access to YouTube features. +// Documentation: +// https://developers.google.com/youtube/v3 +// Classes: +// GTLYouTubeActivityContentDetailsFavorite (0 custom class methods, 1 custom properties) + +#import "GTLYouTubeActivityContentDetailsFavorite.h" + +#import "GTLYouTubeResourceId.h" + +// ---------------------------------------------------------------------------- +// +// GTLYouTubeActivityContentDetailsFavorite +// + +@implementation GTLYouTubeActivityContentDetailsFavorite +@dynamic resourceId; +@end diff --git a/XCDYouTubeKit Demo/Pods/Google-API-Client/Source/Services/YouTube/Generated/GTLYouTubeActivityContentDetailsLike.h b/XCDYouTubeKit Demo/Pods/Google-API-Client/Source/Services/YouTube/Generated/GTLYouTubeActivityContentDetailsLike.h new file mode 100644 index 00000000..5aa16ebb --- /dev/null +++ b/XCDYouTubeKit Demo/Pods/Google-API-Client/Source/Services/YouTube/Generated/GTLYouTubeActivityContentDetailsLike.h @@ -0,0 +1,52 @@ +/* Copyright (c) 2013 Google Inc. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +// +// GTLYouTubeActivityContentDetailsLike.h +// + +// ---------------------------------------------------------------------------- +// NOTE: This file is generated from Google APIs Discovery Service. +// Service: +// YouTube Data API (youtube/v3) +// Description: +// Programmatic access to YouTube features. +// Documentation: +// https://developers.google.com/youtube/v3 +// Classes: +// GTLYouTubeActivityContentDetailsLike (0 custom class methods, 1 custom properties) + +#if GTL_BUILT_AS_FRAMEWORK + #import "GTL/GTLObject.h" +#else + #import "GTLObject.h" +#endif + +@class GTLYouTubeResourceId; + +// ---------------------------------------------------------------------------- +// +// GTLYouTubeActivityContentDetailsLike +// + +// Information about a resource that received a positive (like) rating. + +@interface GTLYouTubeActivityContentDetailsLike : GTLObject + +// The resourceId object contains information that identifies the rated +// resource. +@property (retain) GTLYouTubeResourceId *resourceId; + +@end diff --git a/XCDYouTubeKit Demo/Pods/Google-API-Client/Source/Services/YouTube/Generated/GTLYouTubeActivityContentDetailsLike.m b/XCDYouTubeKit Demo/Pods/Google-API-Client/Source/Services/YouTube/Generated/GTLYouTubeActivityContentDetailsLike.m new file mode 100644 index 00000000..eeb6a20c --- /dev/null +++ b/XCDYouTubeKit Demo/Pods/Google-API-Client/Source/Services/YouTube/Generated/GTLYouTubeActivityContentDetailsLike.m @@ -0,0 +1,42 @@ +/* Copyright (c) 2013 Google Inc. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +// +// GTLYouTubeActivityContentDetailsLike.m +// + +// ---------------------------------------------------------------------------- +// NOTE: This file is generated from Google APIs Discovery Service. +// Service: +// YouTube Data API (youtube/v3) +// Description: +// Programmatic access to YouTube features. +// Documentation: +// https://developers.google.com/youtube/v3 +// Classes: +// GTLYouTubeActivityContentDetailsLike (0 custom class methods, 1 custom properties) + +#import "GTLYouTubeActivityContentDetailsLike.h" + +#import "GTLYouTubeResourceId.h" + +// ---------------------------------------------------------------------------- +// +// GTLYouTubeActivityContentDetailsLike +// + +@implementation GTLYouTubeActivityContentDetailsLike +@dynamic resourceId; +@end diff --git a/XCDYouTubeKit Demo/Pods/Google-API-Client/Source/Services/YouTube/Generated/GTLYouTubeActivityContentDetailsPlaylistItem.h b/XCDYouTubeKit Demo/Pods/Google-API-Client/Source/Services/YouTube/Generated/GTLYouTubeActivityContentDetailsPlaylistItem.h new file mode 100644 index 00000000..f0c86e39 --- /dev/null +++ b/XCDYouTubeKit Demo/Pods/Google-API-Client/Source/Services/YouTube/Generated/GTLYouTubeActivityContentDetailsPlaylistItem.h @@ -0,0 +1,58 @@ +/* Copyright (c) 2013 Google Inc. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +// +// GTLYouTubeActivityContentDetailsPlaylistItem.h +// + +// ---------------------------------------------------------------------------- +// NOTE: This file is generated from Google APIs Discovery Service. +// Service: +// YouTube Data API (youtube/v3) +// Description: +// Programmatic access to YouTube features. +// Documentation: +// https://developers.google.com/youtube/v3 +// Classes: +// GTLYouTubeActivityContentDetailsPlaylistItem (0 custom class methods, 3 custom properties) + +#if GTL_BUILT_AS_FRAMEWORK + #import "GTL/GTLObject.h" +#else + #import "GTLObject.h" +#endif + +@class GTLYouTubeResourceId; + +// ---------------------------------------------------------------------------- +// +// GTLYouTubeActivityContentDetailsPlaylistItem +// + +// Information about a new playlist item. + +@interface GTLYouTubeActivityContentDetailsPlaylistItem : GTLObject + +// The value that YouTube uses to uniquely identify the playlist. +@property (copy) NSString *playlistId; + +// ID of the item within the playlist. +@property (copy) NSString *playlistItemId; + +// The resourceId object contains information about the resource that was added +// to the playlist. +@property (retain) GTLYouTubeResourceId *resourceId; + +@end diff --git a/XCDYouTubeKit Demo/Pods/Google-API-Client/Source/Services/YouTube/Generated/GTLYouTubeActivityContentDetailsPlaylistItem.m b/XCDYouTubeKit Demo/Pods/Google-API-Client/Source/Services/YouTube/Generated/GTLYouTubeActivityContentDetailsPlaylistItem.m new file mode 100644 index 00000000..afab6bc4 --- /dev/null +++ b/XCDYouTubeKit Demo/Pods/Google-API-Client/Source/Services/YouTube/Generated/GTLYouTubeActivityContentDetailsPlaylistItem.m @@ -0,0 +1,42 @@ +/* Copyright (c) 2013 Google Inc. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +// +// GTLYouTubeActivityContentDetailsPlaylistItem.m +// + +// ---------------------------------------------------------------------------- +// NOTE: This file is generated from Google APIs Discovery Service. +// Service: +// YouTube Data API (youtube/v3) +// Description: +// Programmatic access to YouTube features. +// Documentation: +// https://developers.google.com/youtube/v3 +// Classes: +// GTLYouTubeActivityContentDetailsPlaylistItem (0 custom class methods, 3 custom properties) + +#import "GTLYouTubeActivityContentDetailsPlaylistItem.h" + +#import "GTLYouTubeResourceId.h" + +// ---------------------------------------------------------------------------- +// +// GTLYouTubeActivityContentDetailsPlaylistItem +// + +@implementation GTLYouTubeActivityContentDetailsPlaylistItem +@dynamic playlistId, playlistItemId, resourceId; +@end diff --git a/XCDYouTubeKit Demo/Pods/Google-API-Client/Source/Services/YouTube/Generated/GTLYouTubeActivityContentDetailsPromotedItem.h b/XCDYouTubeKit Demo/Pods/Google-API-Client/Source/Services/YouTube/Generated/GTLYouTubeActivityContentDetailsPromotedItem.h new file mode 100644 index 00000000..dff255c5 --- /dev/null +++ b/XCDYouTubeKit Demo/Pods/Google-API-Client/Source/Services/YouTube/Generated/GTLYouTubeActivityContentDetailsPromotedItem.h @@ -0,0 +1,84 @@ +/* Copyright (c) 2013 Google Inc. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +// +// GTLYouTubeActivityContentDetailsPromotedItem.h +// + +// ---------------------------------------------------------------------------- +// NOTE: This file is generated from Google APIs Discovery Service. +// Service: +// YouTube Data API (youtube/v3) +// Description: +// Programmatic access to YouTube features. +// Documentation: +// https://developers.google.com/youtube/v3 +// Classes: +// GTLYouTubeActivityContentDetailsPromotedItem (0 custom class methods, 10 custom properties) + +#if GTL_BUILT_AS_FRAMEWORK + #import "GTL/GTLObject.h" +#else + #import "GTLObject.h" +#endif + +// ---------------------------------------------------------------------------- +// +// GTLYouTubeActivityContentDetailsPromotedItem +// + +// Details about a resource which is being promoted. + +@interface GTLYouTubeActivityContentDetailsPromotedItem : GTLObject + +// The URL the client should fetch to request a promoted item. +@property (copy) NSString *adTag; + +// The URL the client should ping to indicate that the user clicked through on +// this promoted item. +@property (copy) NSString *clickTrackingUrl; + +// The URL the client should ping to indicate that the user was shown this +// promoted item. +@property (copy) NSString *creativeViewUrl; + +// The type of call-to-action, a message to the user indicating action that can +// be taken. +@property (copy) NSString *ctaType; + +// The custom call-to-action button text. If specified, it will override the +// default button text for the cta_type. +@property (copy) NSString *customCtaButtonText; + +// The text description to accompany the promoted item. +@property (copy) NSString *descriptionText; + +// The URL the client should direct the user to, if the user chooses to visit +// the advertiser's website. +@property (copy) NSString *destinationUrl; + +// The list of forecasting URLs. The client should ping all of these URLs when a +// promoted item is not available, to indicate that a promoted item could have +// been shown. +@property (retain) NSArray *forecastingUrl; // of NSString + +// The list of impression URLs. The client should ping all of these URLs to +// indicate that the user was shown this promoted item. +@property (retain) NSArray *impressionUrl; // of NSString + +// The ID that YouTube uses to uniquely identify the promoted video. +@property (copy) NSString *videoId; + +@end diff --git a/XCDYouTubeKit Demo/Pods/Google-API-Client/Source/Services/YouTube/Generated/GTLYouTubeActivityContentDetailsPromotedItem.m b/XCDYouTubeKit Demo/Pods/Google-API-Client/Source/Services/YouTube/Generated/GTLYouTubeActivityContentDetailsPromotedItem.m new file mode 100644 index 00000000..0a24af27 --- /dev/null +++ b/XCDYouTubeKit Demo/Pods/Google-API-Client/Source/Services/YouTube/Generated/GTLYouTubeActivityContentDetailsPromotedItem.m @@ -0,0 +1,52 @@ +/* Copyright (c) 2013 Google Inc. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +// +// GTLYouTubeActivityContentDetailsPromotedItem.m +// + +// ---------------------------------------------------------------------------- +// NOTE: This file is generated from Google APIs Discovery Service. +// Service: +// YouTube Data API (youtube/v3) +// Description: +// Programmatic access to YouTube features. +// Documentation: +// https://developers.google.com/youtube/v3 +// Classes: +// GTLYouTubeActivityContentDetailsPromotedItem (0 custom class methods, 10 custom properties) + +#import "GTLYouTubeActivityContentDetailsPromotedItem.h" + +// ---------------------------------------------------------------------------- +// +// GTLYouTubeActivityContentDetailsPromotedItem +// + +@implementation GTLYouTubeActivityContentDetailsPromotedItem +@dynamic adTag, clickTrackingUrl, creativeViewUrl, ctaType, customCtaButtonText, + descriptionText, destinationUrl, forecastingUrl, impressionUrl, + videoId; + ++ (NSDictionary *)arrayPropertyToClassMap { + NSDictionary *map = + [NSDictionary dictionaryWithObjectsAndKeys: + [NSString class], @"forecastingUrl", + [NSString class], @"impressionUrl", + nil]; + return map; +} + +@end diff --git a/XCDYouTubeKit Demo/Pods/Google-API-Client/Source/Services/YouTube/Generated/GTLYouTubeActivityContentDetailsRecommendation.h b/XCDYouTubeKit Demo/Pods/Google-API-Client/Source/Services/YouTube/Generated/GTLYouTubeActivityContentDetailsRecommendation.h new file mode 100644 index 00000000..0b9b1927 --- /dev/null +++ b/XCDYouTubeKit Demo/Pods/Google-API-Client/Source/Services/YouTube/Generated/GTLYouTubeActivityContentDetailsRecommendation.h @@ -0,0 +1,59 @@ +/* Copyright (c) 2013 Google Inc. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +// +// GTLYouTubeActivityContentDetailsRecommendation.h +// + +// ---------------------------------------------------------------------------- +// NOTE: This file is generated from Google APIs Discovery Service. +// Service: +// YouTube Data API (youtube/v3) +// Description: +// Programmatic access to YouTube features. +// Documentation: +// https://developers.google.com/youtube/v3 +// Classes: +// GTLYouTubeActivityContentDetailsRecommendation (0 custom class methods, 3 custom properties) + +#if GTL_BUILT_AS_FRAMEWORK + #import "GTL/GTLObject.h" +#else + #import "GTLObject.h" +#endif + +@class GTLYouTubeResourceId; + +// ---------------------------------------------------------------------------- +// +// GTLYouTubeActivityContentDetailsRecommendation +// + +// Information that identifies the recommended resource. + +@interface GTLYouTubeActivityContentDetailsRecommendation : GTLObject + +// The reason that the resource is recommended to the user. +@property (copy) NSString *reason; + +// The resourceId object contains information that identifies the recommended +// resource. +@property (retain) GTLYouTubeResourceId *resourceId; + +// The seedResourceId object contains information about the resource that caused +// the recommendation. +@property (retain) GTLYouTubeResourceId *seedResourceId; + +@end diff --git a/XCDYouTubeKit Demo/Pods/Google-API-Client/Source/Services/YouTube/Generated/GTLYouTubeActivityContentDetailsRecommendation.m b/XCDYouTubeKit Demo/Pods/Google-API-Client/Source/Services/YouTube/Generated/GTLYouTubeActivityContentDetailsRecommendation.m new file mode 100644 index 00000000..7e66cd65 --- /dev/null +++ b/XCDYouTubeKit Demo/Pods/Google-API-Client/Source/Services/YouTube/Generated/GTLYouTubeActivityContentDetailsRecommendation.m @@ -0,0 +1,42 @@ +/* Copyright (c) 2013 Google Inc. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +// +// GTLYouTubeActivityContentDetailsRecommendation.m +// + +// ---------------------------------------------------------------------------- +// NOTE: This file is generated from Google APIs Discovery Service. +// Service: +// YouTube Data API (youtube/v3) +// Description: +// Programmatic access to YouTube features. +// Documentation: +// https://developers.google.com/youtube/v3 +// Classes: +// GTLYouTubeActivityContentDetailsRecommendation (0 custom class methods, 3 custom properties) + +#import "GTLYouTubeActivityContentDetailsRecommendation.h" + +#import "GTLYouTubeResourceId.h" + +// ---------------------------------------------------------------------------- +// +// GTLYouTubeActivityContentDetailsRecommendation +// + +@implementation GTLYouTubeActivityContentDetailsRecommendation +@dynamic reason, resourceId, seedResourceId; +@end diff --git a/XCDYouTubeKit Demo/Pods/Google-API-Client/Source/Services/YouTube/Generated/GTLYouTubeActivityContentDetailsSocial.h b/XCDYouTubeKit Demo/Pods/Google-API-Client/Source/Services/YouTube/Generated/GTLYouTubeActivityContentDetailsSocial.h new file mode 100644 index 00000000..5024d0e6 --- /dev/null +++ b/XCDYouTubeKit Demo/Pods/Google-API-Client/Source/Services/YouTube/Generated/GTLYouTubeActivityContentDetailsSocial.h @@ -0,0 +1,64 @@ +/* Copyright (c) 2013 Google Inc. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +// +// GTLYouTubeActivityContentDetailsSocial.h +// + +// ---------------------------------------------------------------------------- +// NOTE: This file is generated from Google APIs Discovery Service. +// Service: +// YouTube Data API (youtube/v3) +// Description: +// Programmatic access to YouTube features. +// Documentation: +// https://developers.google.com/youtube/v3 +// Classes: +// GTLYouTubeActivityContentDetailsSocial (0 custom class methods, 5 custom properties) + +#if GTL_BUILT_AS_FRAMEWORK + #import "GTL/GTLObject.h" +#else + #import "GTLObject.h" +#endif + +@class GTLYouTubeResourceId; + +// ---------------------------------------------------------------------------- +// +// GTLYouTubeActivityContentDetailsSocial +// + +// Details about a social network post. + +@interface GTLYouTubeActivityContentDetailsSocial : GTLObject + +// The author of the social network post. +@property (copy) NSString *author; + +// An image of the post's author. +@property (copy) NSString *imageUrl; + +// The URL of the social network post. +@property (copy) NSString *referenceUrl; + +// The resourceId object encapsulates information that identifies the resource +// associated with a social network post. +@property (retain) GTLYouTubeResourceId *resourceId; + +// The name of the social network. +@property (copy) NSString *type; + +@end diff --git a/XCDYouTubeKit Demo/Pods/Google-API-Client/Source/Services/YouTube/Generated/GTLYouTubeActivityContentDetailsSocial.m b/XCDYouTubeKit Demo/Pods/Google-API-Client/Source/Services/YouTube/Generated/GTLYouTubeActivityContentDetailsSocial.m new file mode 100644 index 00000000..bcdf3077 --- /dev/null +++ b/XCDYouTubeKit Demo/Pods/Google-API-Client/Source/Services/YouTube/Generated/GTLYouTubeActivityContentDetailsSocial.m @@ -0,0 +1,42 @@ +/* Copyright (c) 2013 Google Inc. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +// +// GTLYouTubeActivityContentDetailsSocial.m +// + +// ---------------------------------------------------------------------------- +// NOTE: This file is generated from Google APIs Discovery Service. +// Service: +// YouTube Data API (youtube/v3) +// Description: +// Programmatic access to YouTube features. +// Documentation: +// https://developers.google.com/youtube/v3 +// Classes: +// GTLYouTubeActivityContentDetailsSocial (0 custom class methods, 5 custom properties) + +#import "GTLYouTubeActivityContentDetailsSocial.h" + +#import "GTLYouTubeResourceId.h" + +// ---------------------------------------------------------------------------- +// +// GTLYouTubeActivityContentDetailsSocial +// + +@implementation GTLYouTubeActivityContentDetailsSocial +@dynamic author, imageUrl, referenceUrl, resourceId, type; +@end diff --git a/XCDYouTubeKit Demo/Pods/Google-API-Client/Source/Services/YouTube/Generated/GTLYouTubeActivityContentDetailsSubscription.h b/XCDYouTubeKit Demo/Pods/Google-API-Client/Source/Services/YouTube/Generated/GTLYouTubeActivityContentDetailsSubscription.h new file mode 100644 index 00000000..211cf7e0 --- /dev/null +++ b/XCDYouTubeKit Demo/Pods/Google-API-Client/Source/Services/YouTube/Generated/GTLYouTubeActivityContentDetailsSubscription.h @@ -0,0 +1,52 @@ +/* Copyright (c) 2013 Google Inc. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +// +// GTLYouTubeActivityContentDetailsSubscription.h +// + +// ---------------------------------------------------------------------------- +// NOTE: This file is generated from Google APIs Discovery Service. +// Service: +// YouTube Data API (youtube/v3) +// Description: +// Programmatic access to YouTube features. +// Documentation: +// https://developers.google.com/youtube/v3 +// Classes: +// GTLYouTubeActivityContentDetailsSubscription (0 custom class methods, 1 custom properties) + +#if GTL_BUILT_AS_FRAMEWORK + #import "GTL/GTLObject.h" +#else + #import "GTLObject.h" +#endif + +@class GTLYouTubeResourceId; + +// ---------------------------------------------------------------------------- +// +// GTLYouTubeActivityContentDetailsSubscription +// + +// Information about a channel that a user subscribed to. + +@interface GTLYouTubeActivityContentDetailsSubscription : GTLObject + +// The resourceId object contains information that identifies the resource that +// the user subscribed to. +@property (retain) GTLYouTubeResourceId *resourceId; + +@end diff --git a/XCDYouTubeKit Demo/Pods/Google-API-Client/Source/Services/YouTube/Generated/GTLYouTubeActivityContentDetailsSubscription.m b/XCDYouTubeKit Demo/Pods/Google-API-Client/Source/Services/YouTube/Generated/GTLYouTubeActivityContentDetailsSubscription.m new file mode 100644 index 00000000..c4b09974 --- /dev/null +++ b/XCDYouTubeKit Demo/Pods/Google-API-Client/Source/Services/YouTube/Generated/GTLYouTubeActivityContentDetailsSubscription.m @@ -0,0 +1,42 @@ +/* Copyright (c) 2013 Google Inc. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +// +// GTLYouTubeActivityContentDetailsSubscription.m +// + +// ---------------------------------------------------------------------------- +// NOTE: This file is generated from Google APIs Discovery Service. +// Service: +// YouTube Data API (youtube/v3) +// Description: +// Programmatic access to YouTube features. +// Documentation: +// https://developers.google.com/youtube/v3 +// Classes: +// GTLYouTubeActivityContentDetailsSubscription (0 custom class methods, 1 custom properties) + +#import "GTLYouTubeActivityContentDetailsSubscription.h" + +#import "GTLYouTubeResourceId.h" + +// ---------------------------------------------------------------------------- +// +// GTLYouTubeActivityContentDetailsSubscription +// + +@implementation GTLYouTubeActivityContentDetailsSubscription +@dynamic resourceId; +@end diff --git a/XCDYouTubeKit Demo/Pods/Google-API-Client/Source/Services/YouTube/Generated/GTLYouTubeActivityContentDetailsUpload.h b/XCDYouTubeKit Demo/Pods/Google-API-Client/Source/Services/YouTube/Generated/GTLYouTubeActivityContentDetailsUpload.h new file mode 100644 index 00000000..b64962e8 --- /dev/null +++ b/XCDYouTubeKit Demo/Pods/Google-API-Client/Source/Services/YouTube/Generated/GTLYouTubeActivityContentDetailsUpload.h @@ -0,0 +1,49 @@ +/* Copyright (c) 2013 Google Inc. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +// +// GTLYouTubeActivityContentDetailsUpload.h +// + +// ---------------------------------------------------------------------------- +// NOTE: This file is generated from Google APIs Discovery Service. +// Service: +// YouTube Data API (youtube/v3) +// Description: +// Programmatic access to YouTube features. +// Documentation: +// https://developers.google.com/youtube/v3 +// Classes: +// GTLYouTubeActivityContentDetailsUpload (0 custom class methods, 1 custom properties) + +#if GTL_BUILT_AS_FRAMEWORK + #import "GTL/GTLObject.h" +#else + #import "GTLObject.h" +#endif + +// ---------------------------------------------------------------------------- +// +// GTLYouTubeActivityContentDetailsUpload +// + +// Information about the uploaded video. + +@interface GTLYouTubeActivityContentDetailsUpload : GTLObject + +// The ID that YouTube uses to uniquely identify the uploaded video. +@property (copy) NSString *videoId; + +@end diff --git a/XCDYouTubeKit Demo/Pods/Google-API-Client/Source/Services/YouTube/Generated/GTLYouTubeActivityContentDetailsUpload.m b/XCDYouTubeKit Demo/Pods/Google-API-Client/Source/Services/YouTube/Generated/GTLYouTubeActivityContentDetailsUpload.m new file mode 100644 index 00000000..e6d32d07 --- /dev/null +++ b/XCDYouTubeKit Demo/Pods/Google-API-Client/Source/Services/YouTube/Generated/GTLYouTubeActivityContentDetailsUpload.m @@ -0,0 +1,40 @@ +/* Copyright (c) 2013 Google Inc. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +// +// GTLYouTubeActivityContentDetailsUpload.m +// + +// ---------------------------------------------------------------------------- +// NOTE: This file is generated from Google APIs Discovery Service. +// Service: +// YouTube Data API (youtube/v3) +// Description: +// Programmatic access to YouTube features. +// Documentation: +// https://developers.google.com/youtube/v3 +// Classes: +// GTLYouTubeActivityContentDetailsUpload (0 custom class methods, 1 custom properties) + +#import "GTLYouTubeActivityContentDetailsUpload.h" + +// ---------------------------------------------------------------------------- +// +// GTLYouTubeActivityContentDetailsUpload +// + +@implementation GTLYouTubeActivityContentDetailsUpload +@dynamic videoId; +@end diff --git a/XCDYouTubeKit Demo/Pods/Google-API-Client/Source/Services/YouTube/Generated/GTLYouTubeActivityListResponse.h b/XCDYouTubeKit Demo/Pods/Google-API-Client/Source/Services/YouTube/Generated/GTLYouTubeActivityListResponse.h new file mode 100644 index 00000000..65e4a092 --- /dev/null +++ b/XCDYouTubeKit Demo/Pods/Google-API-Client/Source/Services/YouTube/Generated/GTLYouTubeActivityListResponse.h @@ -0,0 +1,79 @@ +/* Copyright (c) 2013 Google Inc. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +// +// GTLYouTubeActivityListResponse.h +// + +// ---------------------------------------------------------------------------- +// NOTE: This file is generated from Google APIs Discovery Service. +// Service: +// YouTube Data API (youtube/v3) +// Description: +// Programmatic access to YouTube features. +// Documentation: +// https://developers.google.com/youtube/v3 +// Classes: +// GTLYouTubeActivityListResponse (0 custom class methods, 9 custom properties) + +#if GTL_BUILT_AS_FRAMEWORK + #import "GTL/GTLObject.h" +#else + #import "GTLObject.h" +#endif + +@class GTLYouTubeActivity; +@class GTLYouTubePageInfo; +@class GTLYouTubeTokenPagination; + +// ---------------------------------------------------------------------------- +// +// GTLYouTubeActivityListResponse +// + +// This class supports NSFastEnumeration over its "items" property. It also +// supports -itemAtIndex: to retrieve individual objects from "items". + +@interface GTLYouTubeActivityListResponse : GTLCollectionObject + +// Etag of this resource. +@property (copy) NSString *ETag; + +// Serialized EventId of the request which produced this response. +@property (copy) NSString *eventId; + +// A list of activities, or events, that match the request criteria. +@property (retain) NSArray *items; // of GTLYouTubeActivity + +// Identifies what kind of resource this is. Value: the fixed string +// "youtube#activityListResponse". +@property (copy) NSString *kind; + +// The token that can be used as the value of the pageToken parameter to +// retrieve the next page in the result set. +@property (copy) NSString *nextPageToken; + +@property (retain) GTLYouTubePageInfo *pageInfo; + +// The token that can be used as the value of the pageToken parameter to +// retrieve the previous page in the result set. +@property (copy) NSString *prevPageToken; + +@property (retain) GTLYouTubeTokenPagination *tokenPagination; + +// The visitorId identifies the visitor. +@property (copy) NSString *visitorId; + +@end diff --git a/XCDYouTubeKit Demo/Pods/Google-API-Client/Source/Services/YouTube/Generated/GTLYouTubeActivityListResponse.m b/XCDYouTubeKit Demo/Pods/Google-API-Client/Source/Services/YouTube/Generated/GTLYouTubeActivityListResponse.m new file mode 100644 index 00000000..2a20a89e --- /dev/null +++ b/XCDYouTubeKit Demo/Pods/Google-API-Client/Source/Services/YouTube/Generated/GTLYouTubeActivityListResponse.m @@ -0,0 +1,64 @@ +/* Copyright (c) 2013 Google Inc. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +// +// GTLYouTubeActivityListResponse.m +// + +// ---------------------------------------------------------------------------- +// NOTE: This file is generated from Google APIs Discovery Service. +// Service: +// YouTube Data API (youtube/v3) +// Description: +// Programmatic access to YouTube features. +// Documentation: +// https://developers.google.com/youtube/v3 +// Classes: +// GTLYouTubeActivityListResponse (0 custom class methods, 9 custom properties) + +#import "GTLYouTubeActivityListResponse.h" + +#import "GTLYouTubeActivity.h" +#import "GTLYouTubePageInfo.h" +#import "GTLYouTubeTokenPagination.h" + +// ---------------------------------------------------------------------------- +// +// GTLYouTubeActivityListResponse +// + +@implementation GTLYouTubeActivityListResponse +@dynamic ETag, eventId, items, kind, nextPageToken, pageInfo, prevPageToken, + tokenPagination, visitorId; + ++ (NSDictionary *)propertyToJSONKeyMap { + NSDictionary *map = + [NSDictionary dictionaryWithObject:@"etag" + forKey:@"ETag"]; + return map; +} + ++ (NSDictionary *)arrayPropertyToClassMap { + NSDictionary *map = + [NSDictionary dictionaryWithObject:[GTLYouTubeActivity class] + forKey:@"items"]; + return map; +} + ++ (void)load { + [self registerObjectClassForKind:@"youtube#activityListResponse"]; +} + +@end diff --git a/XCDYouTubeKit Demo/Pods/Google-API-Client/Source/Services/YouTube/Generated/GTLYouTubeActivitySnippet.h b/XCDYouTubeKit Demo/Pods/Google-API-Client/Source/Services/YouTube/Generated/GTLYouTubeActivitySnippet.h new file mode 100644 index 00000000..1615912d --- /dev/null +++ b/XCDYouTubeKit Demo/Pods/Google-API-Client/Source/Services/YouTube/Generated/GTLYouTubeActivitySnippet.h @@ -0,0 +1,84 @@ +/* Copyright (c) 2013 Google Inc. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +// +// GTLYouTubeActivitySnippet.h +// + +// ---------------------------------------------------------------------------- +// NOTE: This file is generated from Google APIs Discovery Service. +// Service: +// YouTube Data API (youtube/v3) +// Description: +// Programmatic access to YouTube features. +// Documentation: +// https://developers.google.com/youtube/v3 +// Classes: +// GTLYouTubeActivitySnippet (0 custom class methods, 8 custom properties) + +#if GTL_BUILT_AS_FRAMEWORK + #import "GTL/GTLObject.h" +#else + #import "GTLObject.h" +#endif + +@class GTLYouTubeThumbnailDetails; + +// ---------------------------------------------------------------------------- +// +// GTLYouTubeActivitySnippet +// + +// Basic details about an activity, including title, description, thumbnails, +// activity type and group. + +@interface GTLYouTubeActivitySnippet : GTLObject + +// The ID that YouTube uses to uniquely identify the channel associated with the +// activity. +@property (copy) NSString *channelId; + +// Channel title for the channel responsible for this activity +@property (copy) NSString *channelTitle; + +// The description of the resource primarily associated with the activity. +// Remapped to 'descriptionProperty' to avoid NSObject's 'description'. +@property (copy) NSString *descriptionProperty; + +// The group ID associated with the activity. A group ID identifies user events +// that are associated with the same user and resource. For example, if a user +// rates a video and marks the same video as a favorite, the entries for those +// events would have the same group ID in the user's activity feed. In your user +// interface, you can avoid repetition by grouping events with the same groupId +// value. +@property (copy) NSString *groupId; + +// The date and time that the video was uploaded. The value is specified in ISO +// 8601 (YYYY-MM-DDThh:mm:ss.sZ) format. +@property (retain) GTLDateTime *publishedAt; + +// A map of thumbnail images associated with the resource that is primarily +// associated with the activity. For each object in the map, the key is the name +// of the thumbnail image, and the value is an object that contains other +// information about the thumbnail. +@property (retain) GTLYouTubeThumbnailDetails *thumbnails; + +// The title of the resource primarily associated with the activity. +@property (copy) NSString *title; + +// The type of activity that the resource describes. +@property (copy) NSString *type; + +@end diff --git a/XCDYouTubeKit Demo/Pods/Google-API-Client/Source/Services/YouTube/Generated/GTLYouTubeActivitySnippet.m b/XCDYouTubeKit Demo/Pods/Google-API-Client/Source/Services/YouTube/Generated/GTLYouTubeActivitySnippet.m new file mode 100644 index 00000000..d54465ae --- /dev/null +++ b/XCDYouTubeKit Demo/Pods/Google-API-Client/Source/Services/YouTube/Generated/GTLYouTubeActivitySnippet.m @@ -0,0 +1,51 @@ +/* Copyright (c) 2013 Google Inc. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +// +// GTLYouTubeActivitySnippet.m +// + +// ---------------------------------------------------------------------------- +// NOTE: This file is generated from Google APIs Discovery Service. +// Service: +// YouTube Data API (youtube/v3) +// Description: +// Programmatic access to YouTube features. +// Documentation: +// https://developers.google.com/youtube/v3 +// Classes: +// GTLYouTubeActivitySnippet (0 custom class methods, 8 custom properties) + +#import "GTLYouTubeActivitySnippet.h" + +#import "GTLYouTubeThumbnailDetails.h" + +// ---------------------------------------------------------------------------- +// +// GTLYouTubeActivitySnippet +// + +@implementation GTLYouTubeActivitySnippet +@dynamic channelId, channelTitle, descriptionProperty, groupId, publishedAt, + thumbnails, title, type; + ++ (NSDictionary *)propertyToJSONKeyMap { + NSDictionary *map = + [NSDictionary dictionaryWithObject:@"description" + forKey:@"descriptionProperty"]; + return map; +} + +@end diff --git a/XCDYouTubeKit Demo/Pods/Google-API-Client/Source/Services/YouTube/Generated/GTLYouTubeCdnSettings.h b/XCDYouTubeKit Demo/Pods/Google-API-Client/Source/Services/YouTube/Generated/GTLYouTubeCdnSettings.h new file mode 100644 index 00000000..6b5010ff --- /dev/null +++ b/XCDYouTubeKit Demo/Pods/Google-API-Client/Source/Services/YouTube/Generated/GTLYouTubeCdnSettings.h @@ -0,0 +1,58 @@ +/* Copyright (c) 2013 Google Inc. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +// +// GTLYouTubeCdnSettings.h +// + +// ---------------------------------------------------------------------------- +// NOTE: This file is generated from Google APIs Discovery Service. +// Service: +// YouTube Data API (youtube/v3) +// Description: +// Programmatic access to YouTube features. +// Documentation: +// https://developers.google.com/youtube/v3 +// Classes: +// GTLYouTubeCdnSettings (0 custom class methods, 3 custom properties) + +#if GTL_BUILT_AS_FRAMEWORK + #import "GTL/GTLObject.h" +#else + #import "GTLObject.h" +#endif + +@class GTLYouTubeIngestionInfo; + +// ---------------------------------------------------------------------------- +// +// GTLYouTubeCdnSettings +// + +// Brief description of the live stream cdn settings. + +@interface GTLYouTubeCdnSettings : GTLObject + +// The format of the video stream that you are sending to Youtube. +@property (copy) NSString *format; + +// The ingestionInfo object contains information that YouTube provides that you +// need to transmit your RTMP or HTTP stream to YouTube. +@property (retain) GTLYouTubeIngestionInfo *ingestionInfo; + +// The method or protocol used to transmit the video stream. +@property (copy) NSString *ingestionType; + +@end diff --git a/XCDYouTubeKit Demo/Pods/Google-API-Client/Source/Services/YouTube/Generated/GTLYouTubeCdnSettings.m b/XCDYouTubeKit Demo/Pods/Google-API-Client/Source/Services/YouTube/Generated/GTLYouTubeCdnSettings.m new file mode 100644 index 00000000..63763666 --- /dev/null +++ b/XCDYouTubeKit Demo/Pods/Google-API-Client/Source/Services/YouTube/Generated/GTLYouTubeCdnSettings.m @@ -0,0 +1,42 @@ +/* Copyright (c) 2013 Google Inc. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +// +// GTLYouTubeCdnSettings.m +// + +// ---------------------------------------------------------------------------- +// NOTE: This file is generated from Google APIs Discovery Service. +// Service: +// YouTube Data API (youtube/v3) +// Description: +// Programmatic access to YouTube features. +// Documentation: +// https://developers.google.com/youtube/v3 +// Classes: +// GTLYouTubeCdnSettings (0 custom class methods, 3 custom properties) + +#import "GTLYouTubeCdnSettings.h" + +#import "GTLYouTubeIngestionInfo.h" + +// ---------------------------------------------------------------------------- +// +// GTLYouTubeCdnSettings +// + +@implementation GTLYouTubeCdnSettings +@dynamic format, ingestionInfo, ingestionType; +@end diff --git a/XCDYouTubeKit Demo/Pods/Google-API-Client/Source/Services/YouTube/Generated/GTLYouTubeChannel.h b/XCDYouTubeKit Demo/Pods/Google-API-Client/Source/Services/YouTube/Generated/GTLYouTubeChannel.h new file mode 100644 index 00000000..3708527c --- /dev/null +++ b/XCDYouTubeKit Demo/Pods/Google-API-Client/Source/Services/YouTube/Generated/GTLYouTubeChannel.h @@ -0,0 +1,126 @@ +/* Copyright (c) 2014 Google Inc. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +// +// GTLYouTubeChannel.h +// + +// ---------------------------------------------------------------------------- +// NOTE: This file is generated from Google APIs Discovery Service. +// Service: +// YouTube Data API (youtube/v3) +// Description: +// Programmatic access to YouTube features. +// Documentation: +// https://developers.google.com/youtube/v3 +// Classes: +// GTLYouTubeChannel (0 custom class methods, 14 custom properties) +// GTLYouTubeChannelLocalizations (0 custom class methods, 0 custom properties) + +#if GTL_BUILT_AS_FRAMEWORK + #import "GTL/GTLObject.h" +#else + #import "GTLObject.h" +#endif + +@class GTLYouTubeChannelAuditDetails; +@class GTLYouTubeChannelBrandingSettings; +@class GTLYouTubeChannelContentDetails; +@class GTLYouTubeChannelContentOwnerDetails; +@class GTLYouTubeChannelConversionPings; +@class GTLYouTubeChannelLocalization; +@class GTLYouTubeChannelLocalizations; +@class GTLYouTubeChannelSnippet; +@class GTLYouTubeChannelStatistics; +@class GTLYouTubeChannelStatus; +@class GTLYouTubeChannelTopicDetails; +@class GTLYouTubeInvideoPromotion; + +// ---------------------------------------------------------------------------- +// +// GTLYouTubeChannel +// + +// A channel resource contains information about a YouTube channel. + +@interface GTLYouTubeChannel : GTLObject + +// The auditionDetails object encapsulates channel data that is relevant for +// YouTube Partners during the audition process. +@property (retain) GTLYouTubeChannelAuditDetails *auditDetails; + +// The brandingSettings object encapsulates information about the branding of +// the channel. +@property (retain) GTLYouTubeChannelBrandingSettings *brandingSettings; + +// The contentDetails object encapsulates information about the channel's +// content. +@property (retain) GTLYouTubeChannelContentDetails *contentDetails; + +// The contentOwnerDetails object encapsulates channel data that is relevant for +// YouTube Partners linked with the channel. +@property (retain) GTLYouTubeChannelContentOwnerDetails *contentOwnerDetails; + +// The conversionPings object encapsulates information about conversion pings +// that need to be respected by the channel. +@property (retain) GTLYouTubeChannelConversionPings *conversionPings; + +// Etag of this resource. +@property (copy) NSString *ETag; + +// The ID that YouTube uses to uniquely identify the channel. +// identifier property maps to 'id' in JSON (to avoid Objective C's 'id'). +@property (copy) NSString *identifier; + +// The invideoPromotion object encapsulates information about promotion campaign +// associated with the channel. +@property (retain) GTLYouTubeInvideoPromotion *invideoPromotion; + +// Identifies what kind of resource this is. Value: the fixed string +// "youtube#channel". +@property (copy) NSString *kind; + +// Localizations for different languages +@property (retain) GTLYouTubeChannelLocalizations *localizations; + +// The snippet object contains basic details about the channel, such as its +// title, description, and thumbnail images. +@property (retain) GTLYouTubeChannelSnippet *snippet; + +// The statistics object encapsulates statistics for the channel. +@property (retain) GTLYouTubeChannelStatistics *statistics; + +// The status object encapsulates information about the privacy status of the +// channel. +@property (retain) GTLYouTubeChannelStatus *status; + +// The topicDetails object encapsulates information about Freebase topics +// associated with the channel. +@property (retain) GTLYouTubeChannelTopicDetails *topicDetails; + +@end + + +// ---------------------------------------------------------------------------- +// +// GTLYouTubeChannelLocalizations +// + +@interface GTLYouTubeChannelLocalizations : GTLObject +// This object is documented as having more properties that are +// GTLYouTubeChannelLocalization. Use -additionalJSONKeys and +// -additionalPropertyForName: to get the list of properties and then fetch +// them; or -additionalProperties to fetch them all at once. +@end diff --git a/XCDYouTubeKit Demo/Pods/Google-API-Client/Source/Services/YouTube/Generated/GTLYouTubeChannel.m b/XCDYouTubeKit Demo/Pods/Google-API-Client/Source/Services/YouTube/Generated/GTLYouTubeChannel.m new file mode 100644 index 00000000..a1b6173b --- /dev/null +++ b/XCDYouTubeKit Demo/Pods/Google-API-Client/Source/Services/YouTube/Generated/GTLYouTubeChannel.m @@ -0,0 +1,83 @@ +/* Copyright (c) 2014 Google Inc. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +// +// GTLYouTubeChannel.m +// + +// ---------------------------------------------------------------------------- +// NOTE: This file is generated from Google APIs Discovery Service. +// Service: +// YouTube Data API (youtube/v3) +// Description: +// Programmatic access to YouTube features. +// Documentation: +// https://developers.google.com/youtube/v3 +// Classes: +// GTLYouTubeChannel (0 custom class methods, 14 custom properties) +// GTLYouTubeChannelLocalizations (0 custom class methods, 0 custom properties) + +#import "GTLYouTubeChannel.h" + +#import "GTLYouTubeChannelAuditDetails.h" +#import "GTLYouTubeChannelBrandingSettings.h" +#import "GTLYouTubeChannelContentDetails.h" +#import "GTLYouTubeChannelContentOwnerDetails.h" +#import "GTLYouTubeChannelConversionPings.h" +#import "GTLYouTubeChannelLocalization.h" +#import "GTLYouTubeChannelSnippet.h" +#import "GTLYouTubeChannelStatistics.h" +#import "GTLYouTubeChannelStatus.h" +#import "GTLYouTubeChannelTopicDetails.h" +#import "GTLYouTubeInvideoPromotion.h" + +// ---------------------------------------------------------------------------- +// +// GTLYouTubeChannel +// + +@implementation GTLYouTubeChannel +@dynamic auditDetails, brandingSettings, contentDetails, contentOwnerDetails, + conversionPings, ETag, identifier, invideoPromotion, kind, + localizations, snippet, statistics, status, topicDetails; + ++ (NSDictionary *)propertyToJSONKeyMap { + NSDictionary *map = + [NSDictionary dictionaryWithObjectsAndKeys: + @"etag", @"ETag", + @"id", @"identifier", + nil]; + return map; +} + ++ (void)load { + [self registerObjectClassForKind:@"youtube#channel"]; +} + +@end + + +// ---------------------------------------------------------------------------- +// +// GTLYouTubeChannelLocalizations +// + +@implementation GTLYouTubeChannelLocalizations + ++ (Class)classForAdditionalProperties { + return [GTLYouTubeChannelLocalization class]; +} + +@end diff --git a/XCDYouTubeKit Demo/Pods/Google-API-Client/Source/Services/YouTube/Generated/GTLYouTubeChannelAuditDetails.h b/XCDYouTubeKit Demo/Pods/Google-API-Client/Source/Services/YouTube/Generated/GTLYouTubeChannelAuditDetails.h new file mode 100644 index 00000000..6d32f002 --- /dev/null +++ b/XCDYouTubeKit Demo/Pods/Google-API-Client/Source/Services/YouTube/Generated/GTLYouTubeChannelAuditDetails.h @@ -0,0 +1,63 @@ +/* Copyright (c) 2013 Google Inc. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +// +// GTLYouTubeChannelAuditDetails.h +// + +// ---------------------------------------------------------------------------- +// NOTE: This file is generated from Google APIs Discovery Service. +// Service: +// YouTube Data API (youtube/v3) +// Description: +// Programmatic access to YouTube features. +// Documentation: +// https://developers.google.com/youtube/v3 +// Classes: +// GTLYouTubeChannelAuditDetails (0 custom class methods, 4 custom properties) + +#if GTL_BUILT_AS_FRAMEWORK + #import "GTL/GTLObject.h" +#else + #import "GTLObject.h" +#endif + +// ---------------------------------------------------------------------------- +// +// GTLYouTubeChannelAuditDetails +// + +// The auditDetails object encapsulates channel data that is relevant for +// YouTube Partners during the audit process. + +@interface GTLYouTubeChannelAuditDetails : GTLObject + +// Whether or not the channel respects the community guidelines. +@property (retain) NSNumber *communityGuidelinesGoodStanding; // boolValue + +// Whether or not the channel has any unresolved claims. +@property (retain) NSNumber *contentIdClaimsGoodStanding; // boolValue + +// Whether or not the channel has any copyright strikes. +@property (retain) NSNumber *copyrightStrikesGoodStanding; // boolValue + +// Describes the general state of the channel. This field will always show if +// there are any issues whatsoever with the channel. Currently this field +// represents the result of the logical and operation over the community +// guidelines good standing, the copyright strikes good standing and the content +// ID claims good standing, but this may change in the future. +@property (retain) NSNumber *overallGoodStanding; // boolValue + +@end diff --git a/XCDYouTubeKit Demo/Pods/Google-API-Client/Source/Services/YouTube/Generated/GTLYouTubeChannelAuditDetails.m b/XCDYouTubeKit Demo/Pods/Google-API-Client/Source/Services/YouTube/Generated/GTLYouTubeChannelAuditDetails.m new file mode 100644 index 00000000..b7fdb5d7 --- /dev/null +++ b/XCDYouTubeKit Demo/Pods/Google-API-Client/Source/Services/YouTube/Generated/GTLYouTubeChannelAuditDetails.m @@ -0,0 +1,41 @@ +/* Copyright (c) 2013 Google Inc. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +// +// GTLYouTubeChannelAuditDetails.m +// + +// ---------------------------------------------------------------------------- +// NOTE: This file is generated from Google APIs Discovery Service. +// Service: +// YouTube Data API (youtube/v3) +// Description: +// Programmatic access to YouTube features. +// Documentation: +// https://developers.google.com/youtube/v3 +// Classes: +// GTLYouTubeChannelAuditDetails (0 custom class methods, 4 custom properties) + +#import "GTLYouTubeChannelAuditDetails.h" + +// ---------------------------------------------------------------------------- +// +// GTLYouTubeChannelAuditDetails +// + +@implementation GTLYouTubeChannelAuditDetails +@dynamic communityGuidelinesGoodStanding, contentIdClaimsGoodStanding, + copyrightStrikesGoodStanding, overallGoodStanding; +@end diff --git a/XCDYouTubeKit Demo/Pods/Google-API-Client/Source/Services/YouTube/Generated/GTLYouTubeChannelBannerResource.h b/XCDYouTubeKit Demo/Pods/Google-API-Client/Source/Services/YouTube/Generated/GTLYouTubeChannelBannerResource.h new file mode 100644 index 00000000..15817dd0 --- /dev/null +++ b/XCDYouTubeKit Demo/Pods/Google-API-Client/Source/Services/YouTube/Generated/GTLYouTubeChannelBannerResource.h @@ -0,0 +1,56 @@ +/* Copyright (c) 2013 Google Inc. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +// +// GTLYouTubeChannelBannerResource.h +// + +// ---------------------------------------------------------------------------- +// NOTE: This file is generated from Google APIs Discovery Service. +// Service: +// YouTube Data API (youtube/v3) +// Description: +// Programmatic access to YouTube features. +// Documentation: +// https://developers.google.com/youtube/v3 +// Classes: +// GTLYouTubeChannelBannerResource (0 custom class methods, 3 custom properties) + +#if GTL_BUILT_AS_FRAMEWORK + #import "GTL/GTLObject.h" +#else + #import "GTLObject.h" +#endif + +// ---------------------------------------------------------------------------- +// +// GTLYouTubeChannelBannerResource +// + +// A channel banner returned as the response to a channel_banner.insert call. + +@interface GTLYouTubeChannelBannerResource : GTLObject + +// Etag of this resource. +@property (copy) NSString *ETag; + +// Identifies what kind of resource this is. Value: the fixed string +// "youtube#channelBannerResource". +@property (copy) NSString *kind; + +// The URL of this banner image. +@property (copy) NSString *url; + +@end diff --git a/XCDYouTubeKit Demo/Pods/Google-API-Client/Source/Services/YouTube/Generated/GTLYouTubeChannelBannerResource.m b/XCDYouTubeKit Demo/Pods/Google-API-Client/Source/Services/YouTube/Generated/GTLYouTubeChannelBannerResource.m new file mode 100644 index 00000000..76f2b79e --- /dev/null +++ b/XCDYouTubeKit Demo/Pods/Google-API-Client/Source/Services/YouTube/Generated/GTLYouTubeChannelBannerResource.m @@ -0,0 +1,52 @@ +/* Copyright (c) 2013 Google Inc. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +// +// GTLYouTubeChannelBannerResource.m +// + +// ---------------------------------------------------------------------------- +// NOTE: This file is generated from Google APIs Discovery Service. +// Service: +// YouTube Data API (youtube/v3) +// Description: +// Programmatic access to YouTube features. +// Documentation: +// https://developers.google.com/youtube/v3 +// Classes: +// GTLYouTubeChannelBannerResource (0 custom class methods, 3 custom properties) + +#import "GTLYouTubeChannelBannerResource.h" + +// ---------------------------------------------------------------------------- +// +// GTLYouTubeChannelBannerResource +// + +@implementation GTLYouTubeChannelBannerResource +@dynamic ETag, kind, url; + ++ (NSDictionary *)propertyToJSONKeyMap { + NSDictionary *map = + [NSDictionary dictionaryWithObject:@"etag" + forKey:@"ETag"]; + return map; +} + ++ (void)load { + [self registerObjectClassForKind:@"youtube#channelBannerResource"]; +} + +@end diff --git a/XCDYouTubeKit Demo/Pods/Google-API-Client/Source/Services/YouTube/Generated/GTLYouTubeChannelBrandingSettings.h b/XCDYouTubeKit Demo/Pods/Google-API-Client/Source/Services/YouTube/Generated/GTLYouTubeChannelBrandingSettings.h new file mode 100644 index 00000000..4f84af18 --- /dev/null +++ b/XCDYouTubeKit Demo/Pods/Google-API-Client/Source/Services/YouTube/Generated/GTLYouTubeChannelBrandingSettings.h @@ -0,0 +1,63 @@ +/* Copyright (c) 2013 Google Inc. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +// +// GTLYouTubeChannelBrandingSettings.h +// + +// ---------------------------------------------------------------------------- +// NOTE: This file is generated from Google APIs Discovery Service. +// Service: +// YouTube Data API (youtube/v3) +// Description: +// Programmatic access to YouTube features. +// Documentation: +// https://developers.google.com/youtube/v3 +// Classes: +// GTLYouTubeChannelBrandingSettings (0 custom class methods, 4 custom properties) + +#if GTL_BUILT_AS_FRAMEWORK + #import "GTL/GTLObject.h" +#else + #import "GTLObject.h" +#endif + +@class GTLYouTubeChannelSettings; +@class GTLYouTubeImageSettings; +@class GTLYouTubePropertyValue; +@class GTLYouTubeWatchSettings; + +// ---------------------------------------------------------------------------- +// +// GTLYouTubeChannelBrandingSettings +// + +// Branding properties of a YouTube channel. + +@interface GTLYouTubeChannelBrandingSettings : GTLObject + +// Branding properties for the channel view. +@property (retain) GTLYouTubeChannelSettings *channel; + +// Additional experimental branding properties. +@property (retain) NSArray *hints; // of GTLYouTubePropertyValue + +// Branding properties for branding images. +@property (retain) GTLYouTubeImageSettings *image; + +// Branding properties for the watch page. +@property (retain) GTLYouTubeWatchSettings *watch; + +@end diff --git a/XCDYouTubeKit Demo/Pods/Google-API-Client/Source/Services/YouTube/Generated/GTLYouTubeChannelBrandingSettings.m b/XCDYouTubeKit Demo/Pods/Google-API-Client/Source/Services/YouTube/Generated/GTLYouTubeChannelBrandingSettings.m new file mode 100644 index 00000000..7069edf9 --- /dev/null +++ b/XCDYouTubeKit Demo/Pods/Google-API-Client/Source/Services/YouTube/Generated/GTLYouTubeChannelBrandingSettings.m @@ -0,0 +1,53 @@ +/* Copyright (c) 2013 Google Inc. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +// +// GTLYouTubeChannelBrandingSettings.m +// + +// ---------------------------------------------------------------------------- +// NOTE: This file is generated from Google APIs Discovery Service. +// Service: +// YouTube Data API (youtube/v3) +// Description: +// Programmatic access to YouTube features. +// Documentation: +// https://developers.google.com/youtube/v3 +// Classes: +// GTLYouTubeChannelBrandingSettings (0 custom class methods, 4 custom properties) + +#import "GTLYouTubeChannelBrandingSettings.h" + +#import "GTLYouTubeChannelSettings.h" +#import "GTLYouTubeImageSettings.h" +#import "GTLYouTubePropertyValue.h" +#import "GTLYouTubeWatchSettings.h" + +// ---------------------------------------------------------------------------- +// +// GTLYouTubeChannelBrandingSettings +// + +@implementation GTLYouTubeChannelBrandingSettings +@dynamic channel, hints, image, watch; + ++ (NSDictionary *)arrayPropertyToClassMap { + NSDictionary *map = + [NSDictionary dictionaryWithObject:[GTLYouTubePropertyValue class] + forKey:@"hints"]; + return map; +} + +@end diff --git a/XCDYouTubeKit Demo/Pods/Google-API-Client/Source/Services/YouTube/Generated/GTLYouTubeChannelContentDetails.h b/XCDYouTubeKit Demo/Pods/Google-API-Client/Source/Services/YouTube/Generated/GTLYouTubeChannelContentDetails.h new file mode 100644 index 00000000..4a9ff343 --- /dev/null +++ b/XCDYouTubeKit Demo/Pods/Google-API-Client/Source/Services/YouTube/Generated/GTLYouTubeChannelContentDetails.h @@ -0,0 +1,89 @@ +/* Copyright (c) 2013 Google Inc. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +// +// GTLYouTubeChannelContentDetails.h +// + +// ---------------------------------------------------------------------------- +// NOTE: This file is generated from Google APIs Discovery Service. +// Service: +// YouTube Data API (youtube/v3) +// Description: +// Programmatic access to YouTube features. +// Documentation: +// https://developers.google.com/youtube/v3 +// Classes: +// GTLYouTubeChannelContentDetails (0 custom class methods, 2 custom properties) +// GTLYouTubeChannelContentDetailsRelatedPlaylists (0 custom class methods, 5 custom properties) + +#if GTL_BUILT_AS_FRAMEWORK + #import "GTL/GTLObject.h" +#else + #import "GTLObject.h" +#endif + +@class GTLYouTubeChannelContentDetailsRelatedPlaylists; + +// ---------------------------------------------------------------------------- +// +// GTLYouTubeChannelContentDetails +// + +// Details about the content of a channel. + +@interface GTLYouTubeChannelContentDetails : GTLObject + +// The googlePlusUserId object identifies the Google+ profile ID associated with +// this channel. +@property (copy) NSString *googlePlusUserId; + +@property (retain) GTLYouTubeChannelContentDetailsRelatedPlaylists *relatedPlaylists; +@end + + +// ---------------------------------------------------------------------------- +// +// GTLYouTubeChannelContentDetailsRelatedPlaylists +// + +@interface GTLYouTubeChannelContentDetailsRelatedPlaylists : GTLObject + +// The ID of the playlist that contains the channel"s favorite videos. Use the +// playlistItems.insert and playlistItems.delete to add or remove items from +// that list. +@property (copy) NSString *favorites; + +// The ID of the playlist that contains the channel"s liked videos. Use the +// playlistItems.insert and playlistItems.delete to add or remove items from +// that list. +@property (copy) NSString *likes; + +// The ID of the playlist that contains the channel"s uploaded videos. Use the +// videos.insert method to upload new videos and the videos.delete method to +// delete previously uploaded videos. +@property (copy) NSString *uploads; + +// The ID of the playlist that contains the channel"s watch history. Use the +// playlistItems.insert and playlistItems.delete to add or remove items from +// that list. +@property (copy) NSString *watchHistory; + +// The ID of the playlist that contains the channel"s watch later playlist. Use +// the playlistItems.insert and playlistItems.delete to add or remove items from +// that list. +@property (copy) NSString *watchLater; + +@end diff --git a/XCDYouTubeKit Demo/Pods/Google-API-Client/Source/Services/YouTube/Generated/GTLYouTubeChannelContentDetails.m b/XCDYouTubeKit Demo/Pods/Google-API-Client/Source/Services/YouTube/Generated/GTLYouTubeChannelContentDetails.m new file mode 100644 index 00000000..98ad80be --- /dev/null +++ b/XCDYouTubeKit Demo/Pods/Google-API-Client/Source/Services/YouTube/Generated/GTLYouTubeChannelContentDetails.m @@ -0,0 +1,51 @@ +/* Copyright (c) 2013 Google Inc. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +// +// GTLYouTubeChannelContentDetails.m +// + +// ---------------------------------------------------------------------------- +// NOTE: This file is generated from Google APIs Discovery Service. +// Service: +// YouTube Data API (youtube/v3) +// Description: +// Programmatic access to YouTube features. +// Documentation: +// https://developers.google.com/youtube/v3 +// Classes: +// GTLYouTubeChannelContentDetails (0 custom class methods, 2 custom properties) +// GTLYouTubeChannelContentDetailsRelatedPlaylists (0 custom class methods, 5 custom properties) + +#import "GTLYouTubeChannelContentDetails.h" + +// ---------------------------------------------------------------------------- +// +// GTLYouTubeChannelContentDetails +// + +@implementation GTLYouTubeChannelContentDetails +@dynamic googlePlusUserId, relatedPlaylists; +@end + + +// ---------------------------------------------------------------------------- +// +// GTLYouTubeChannelContentDetailsRelatedPlaylists +// + +@implementation GTLYouTubeChannelContentDetailsRelatedPlaylists +@dynamic favorites, likes, uploads, watchHistory, watchLater; +@end diff --git a/XCDYouTubeKit Demo/Pods/Google-API-Client/Source/Services/YouTube/Generated/GTLYouTubeChannelContentOwnerDetails.h b/XCDYouTubeKit Demo/Pods/Google-API-Client/Source/Services/YouTube/Generated/GTLYouTubeChannelContentOwnerDetails.h new file mode 100644 index 00000000..d46f6f0b --- /dev/null +++ b/XCDYouTubeKit Demo/Pods/Google-API-Client/Source/Services/YouTube/Generated/GTLYouTubeChannelContentOwnerDetails.h @@ -0,0 +1,54 @@ +/* Copyright (c) 2014 Google Inc. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +// +// GTLYouTubeChannelContentOwnerDetails.h +// + +// ---------------------------------------------------------------------------- +// NOTE: This file is generated from Google APIs Discovery Service. +// Service: +// YouTube Data API (youtube/v3) +// Description: +// Programmatic access to YouTube features. +// Documentation: +// https://developers.google.com/youtube/v3 +// Classes: +// GTLYouTubeChannelContentOwnerDetails (0 custom class methods, 2 custom properties) + +#if GTL_BUILT_AS_FRAMEWORK + #import "GTL/GTLObject.h" +#else + #import "GTLObject.h" +#endif + +// ---------------------------------------------------------------------------- +// +// GTLYouTubeChannelContentOwnerDetails +// + +// The contentOwnerDetails object encapsulates channel data that is relevant for +// YouTube Partners linked with the channel. + +@interface GTLYouTubeChannelContentOwnerDetails : GTLObject + +// The ID of the content owner linked to the channel. +@property (copy) NSString *contentOwner; + +// The date and time of when the channel was linked to the content owner. The +// value is specified in ISO 8601 (YYYY-MM-DDThh:mm:ss.sZ) format. +@property (retain) GTLDateTime *timeLinked; + +@end diff --git a/XCDYouTubeKit Demo/Pods/Google-API-Client/Source/Services/YouTube/Generated/GTLYouTubeChannelContentOwnerDetails.m b/XCDYouTubeKit Demo/Pods/Google-API-Client/Source/Services/YouTube/Generated/GTLYouTubeChannelContentOwnerDetails.m new file mode 100644 index 00000000..0f528de8 --- /dev/null +++ b/XCDYouTubeKit Demo/Pods/Google-API-Client/Source/Services/YouTube/Generated/GTLYouTubeChannelContentOwnerDetails.m @@ -0,0 +1,40 @@ +/* Copyright (c) 2014 Google Inc. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +// +// GTLYouTubeChannelContentOwnerDetails.m +// + +// ---------------------------------------------------------------------------- +// NOTE: This file is generated from Google APIs Discovery Service. +// Service: +// YouTube Data API (youtube/v3) +// Description: +// Programmatic access to YouTube features. +// Documentation: +// https://developers.google.com/youtube/v3 +// Classes: +// GTLYouTubeChannelContentOwnerDetails (0 custom class methods, 2 custom properties) + +#import "GTLYouTubeChannelContentOwnerDetails.h" + +// ---------------------------------------------------------------------------- +// +// GTLYouTubeChannelContentOwnerDetails +// + +@implementation GTLYouTubeChannelContentOwnerDetails +@dynamic contentOwner, timeLinked; +@end diff --git a/XCDYouTubeKit Demo/Pods/Google-API-Client/Source/Services/YouTube/Generated/GTLYouTubeChannelConversionPing.h b/XCDYouTubeKit Demo/Pods/Google-API-Client/Source/Services/YouTube/Generated/GTLYouTubeChannelConversionPing.h new file mode 100644 index 00000000..8b8e4d73 --- /dev/null +++ b/XCDYouTubeKit Demo/Pods/Google-API-Client/Source/Services/YouTube/Generated/GTLYouTubeChannelConversionPing.h @@ -0,0 +1,60 @@ +/* Copyright (c) 2013 Google Inc. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +// +// GTLYouTubeChannelConversionPing.h +// + +// ---------------------------------------------------------------------------- +// NOTE: This file is generated from Google APIs Discovery Service. +// Service: +// YouTube Data API (youtube/v3) +// Description: +// Programmatic access to YouTube features. +// Documentation: +// https://developers.google.com/youtube/v3 +// Classes: +// GTLYouTubeChannelConversionPing (0 custom class methods, 2 custom properties) + +#if GTL_BUILT_AS_FRAMEWORK + #import "GTL/GTLObject.h" +#else + #import "GTLObject.h" +#endif + +// ---------------------------------------------------------------------------- +// +// GTLYouTubeChannelConversionPing +// + +// Pings that the app shall fire (authenticated by biscotti cookie). Each ping +// has a context, in which the app must fire the ping, and a url identifying the +// ping. + +@interface GTLYouTubeChannelConversionPing : GTLObject + +// Defines the context of the ping. +@property (copy) NSString *context; + +// The url (without the schema) that the player shall send the ping to. It's at +// caller's descretion to decide which schema to use (http vs https) Example of +// a returned url: //googleads.g.doubleclick.net/pagead/ +// viewthroughconversion/962985656/?data=path%3DtHe_path%3Btype%3D +// cview%3Butuid%3DGISQtTNGYqaYl4sKxoVvKA&labe=default The caller must append +// biscotti authentication (ms param in case of mobile, for example) to this +// ping. +@property (copy) NSString *conversionUrl; + +@end diff --git a/XCDYouTubeKit Demo/Pods/Google-API-Client/Source/Services/YouTube/Generated/GTLYouTubeChannelConversionPing.m b/XCDYouTubeKit Demo/Pods/Google-API-Client/Source/Services/YouTube/Generated/GTLYouTubeChannelConversionPing.m new file mode 100644 index 00000000..d18a654e --- /dev/null +++ b/XCDYouTubeKit Demo/Pods/Google-API-Client/Source/Services/YouTube/Generated/GTLYouTubeChannelConversionPing.m @@ -0,0 +1,40 @@ +/* Copyright (c) 2013 Google Inc. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +// +// GTLYouTubeChannelConversionPing.m +// + +// ---------------------------------------------------------------------------- +// NOTE: This file is generated from Google APIs Discovery Service. +// Service: +// YouTube Data API (youtube/v3) +// Description: +// Programmatic access to YouTube features. +// Documentation: +// https://developers.google.com/youtube/v3 +// Classes: +// GTLYouTubeChannelConversionPing (0 custom class methods, 2 custom properties) + +#import "GTLYouTubeChannelConversionPing.h" + +// ---------------------------------------------------------------------------- +// +// GTLYouTubeChannelConversionPing +// + +@implementation GTLYouTubeChannelConversionPing +@dynamic context, conversionUrl; +@end diff --git a/XCDYouTubeKit Demo/Pods/Google-API-Client/Source/Services/YouTube/Generated/GTLYouTubeChannelConversionPings.h b/XCDYouTubeKit Demo/Pods/Google-API-Client/Source/Services/YouTube/Generated/GTLYouTubeChannelConversionPings.h new file mode 100644 index 00000000..d9e0330a --- /dev/null +++ b/XCDYouTubeKit Demo/Pods/Google-API-Client/Source/Services/YouTube/Generated/GTLYouTubeChannelConversionPings.h @@ -0,0 +1,54 @@ +/* Copyright (c) 2013 Google Inc. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +// +// GTLYouTubeChannelConversionPings.h +// + +// ---------------------------------------------------------------------------- +// NOTE: This file is generated from Google APIs Discovery Service. +// Service: +// YouTube Data API (youtube/v3) +// Description: +// Programmatic access to YouTube features. +// Documentation: +// https://developers.google.com/youtube/v3 +// Classes: +// GTLYouTubeChannelConversionPings (0 custom class methods, 1 custom properties) + +#if GTL_BUILT_AS_FRAMEWORK + #import "GTL/GTLObject.h" +#else + #import "GTLObject.h" +#endif + +@class GTLYouTubeChannelConversionPing; + +// ---------------------------------------------------------------------------- +// +// GTLYouTubeChannelConversionPings +// + +// The conversionPings object encapsulates information about conversion pings +// that need to be respected by the channel. + +@interface GTLYouTubeChannelConversionPings : GTLObject + +// Pings that the app shall fire (authenticated by biscotti cookie). Each ping +// has a context, in which the app must fire the ping, and a url identifying the +// ping. +@property (retain) NSArray *pings; // of GTLYouTubeChannelConversionPing + +@end diff --git a/XCDYouTubeKit Demo/Pods/Google-API-Client/Source/Services/YouTube/Generated/GTLYouTubeChannelConversionPings.m b/XCDYouTubeKit Demo/Pods/Google-API-Client/Source/Services/YouTube/Generated/GTLYouTubeChannelConversionPings.m new file mode 100644 index 00000000..f25cf9d8 --- /dev/null +++ b/XCDYouTubeKit Demo/Pods/Google-API-Client/Source/Services/YouTube/Generated/GTLYouTubeChannelConversionPings.m @@ -0,0 +1,50 @@ +/* Copyright (c) 2013 Google Inc. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +// +// GTLYouTubeChannelConversionPings.m +// + +// ---------------------------------------------------------------------------- +// NOTE: This file is generated from Google APIs Discovery Service. +// Service: +// YouTube Data API (youtube/v3) +// Description: +// Programmatic access to YouTube features. +// Documentation: +// https://developers.google.com/youtube/v3 +// Classes: +// GTLYouTubeChannelConversionPings (0 custom class methods, 1 custom properties) + +#import "GTLYouTubeChannelConversionPings.h" + +#import "GTLYouTubeChannelConversionPing.h" + +// ---------------------------------------------------------------------------- +// +// GTLYouTubeChannelConversionPings +// + +@implementation GTLYouTubeChannelConversionPings +@dynamic pings; + ++ (NSDictionary *)arrayPropertyToClassMap { + NSDictionary *map = + [NSDictionary dictionaryWithObject:[GTLYouTubeChannelConversionPing class] + forKey:@"pings"]; + return map; +} + +@end diff --git a/XCDYouTubeKit Demo/Pods/Google-API-Client/Source/Services/YouTube/Generated/GTLYouTubeChannelListResponse.h b/XCDYouTubeKit Demo/Pods/Google-API-Client/Source/Services/YouTube/Generated/GTLYouTubeChannelListResponse.h new file mode 100644 index 00000000..5a7354c6 --- /dev/null +++ b/XCDYouTubeKit Demo/Pods/Google-API-Client/Source/Services/YouTube/Generated/GTLYouTubeChannelListResponse.h @@ -0,0 +1,79 @@ +/* Copyright (c) 2013 Google Inc. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +// +// GTLYouTubeChannelListResponse.h +// + +// ---------------------------------------------------------------------------- +// NOTE: This file is generated from Google APIs Discovery Service. +// Service: +// YouTube Data API (youtube/v3) +// Description: +// Programmatic access to YouTube features. +// Documentation: +// https://developers.google.com/youtube/v3 +// Classes: +// GTLYouTubeChannelListResponse (0 custom class methods, 9 custom properties) + +#if GTL_BUILT_AS_FRAMEWORK + #import "GTL/GTLObject.h" +#else + #import "GTLObject.h" +#endif + +@class GTLYouTubeChannel; +@class GTLYouTubePageInfo; +@class GTLYouTubeTokenPagination; + +// ---------------------------------------------------------------------------- +// +// GTLYouTubeChannelListResponse +// + +// This class supports NSFastEnumeration over its "items" property. It also +// supports -itemAtIndex: to retrieve individual objects from "items". + +@interface GTLYouTubeChannelListResponse : GTLCollectionObject + +// Etag of this resource. +@property (copy) NSString *ETag; + +// Serialized EventId of the request which produced this response. +@property (copy) NSString *eventId; + +// A list of channels that match the request criteria. +@property (retain) NSArray *items; // of GTLYouTubeChannel + +// Identifies what kind of resource this is. Value: the fixed string +// "youtube#channelListResponse". +@property (copy) NSString *kind; + +// The token that can be used as the value of the pageToken parameter to +// retrieve the next page in the result set. +@property (copy) NSString *nextPageToken; + +@property (retain) GTLYouTubePageInfo *pageInfo; + +// The token that can be used as the value of the pageToken parameter to +// retrieve the previous page in the result set. +@property (copy) NSString *prevPageToken; + +@property (retain) GTLYouTubeTokenPagination *tokenPagination; + +// The visitorId identifies the visitor. +@property (copy) NSString *visitorId; + +@end diff --git a/XCDYouTubeKit Demo/Pods/Google-API-Client/Source/Services/YouTube/Generated/GTLYouTubeChannelListResponse.m b/XCDYouTubeKit Demo/Pods/Google-API-Client/Source/Services/YouTube/Generated/GTLYouTubeChannelListResponse.m new file mode 100644 index 00000000..f72dcd9b --- /dev/null +++ b/XCDYouTubeKit Demo/Pods/Google-API-Client/Source/Services/YouTube/Generated/GTLYouTubeChannelListResponse.m @@ -0,0 +1,64 @@ +/* Copyright (c) 2013 Google Inc. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +// +// GTLYouTubeChannelListResponse.m +// + +// ---------------------------------------------------------------------------- +// NOTE: This file is generated from Google APIs Discovery Service. +// Service: +// YouTube Data API (youtube/v3) +// Description: +// Programmatic access to YouTube features. +// Documentation: +// https://developers.google.com/youtube/v3 +// Classes: +// GTLYouTubeChannelListResponse (0 custom class methods, 9 custom properties) + +#import "GTLYouTubeChannelListResponse.h" + +#import "GTLYouTubeChannel.h" +#import "GTLYouTubePageInfo.h" +#import "GTLYouTubeTokenPagination.h" + +// ---------------------------------------------------------------------------- +// +// GTLYouTubeChannelListResponse +// + +@implementation GTLYouTubeChannelListResponse +@dynamic ETag, eventId, items, kind, nextPageToken, pageInfo, prevPageToken, + tokenPagination, visitorId; + ++ (NSDictionary *)propertyToJSONKeyMap { + NSDictionary *map = + [NSDictionary dictionaryWithObject:@"etag" + forKey:@"ETag"]; + return map; +} + ++ (NSDictionary *)arrayPropertyToClassMap { + NSDictionary *map = + [NSDictionary dictionaryWithObject:[GTLYouTubeChannel class] + forKey:@"items"]; + return map; +} + ++ (void)load { + [self registerObjectClassForKind:@"youtube#channelListResponse"]; +} + +@end diff --git a/XCDYouTubeKit Demo/Pods/Google-API-Client/Source/Services/YouTube/Generated/GTLYouTubeChannelLocalization.h b/XCDYouTubeKit Demo/Pods/Google-API-Client/Source/Services/YouTube/Generated/GTLYouTubeChannelLocalization.h new file mode 100644 index 00000000..c6cbb258 --- /dev/null +++ b/XCDYouTubeKit Demo/Pods/Google-API-Client/Source/Services/YouTube/Generated/GTLYouTubeChannelLocalization.h @@ -0,0 +1,53 @@ +/* Copyright (c) 2014 Google Inc. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +// +// GTLYouTubeChannelLocalization.h +// + +// ---------------------------------------------------------------------------- +// NOTE: This file is generated from Google APIs Discovery Service. +// Service: +// YouTube Data API (youtube/v3) +// Description: +// Programmatic access to YouTube features. +// Documentation: +// https://developers.google.com/youtube/v3 +// Classes: +// GTLYouTubeChannelLocalization (0 custom class methods, 2 custom properties) + +#if GTL_BUILT_AS_FRAMEWORK + #import "GTL/GTLObject.h" +#else + #import "GTLObject.h" +#endif + +// ---------------------------------------------------------------------------- +// +// GTLYouTubeChannelLocalization +// + +// Channel localization setting + +@interface GTLYouTubeChannelLocalization : GTLObject + +// The localized strings for channel's description. +// Remapped to 'descriptionProperty' to avoid NSObject's 'description'. +@property (copy) NSString *descriptionProperty; + +// The localized strings for channel's title, read-only. +@property (copy) NSString *title; + +@end diff --git a/XCDYouTubeKit Demo/Pods/Google-API-Client/Source/Services/YouTube/Generated/GTLYouTubeChannelLocalization.m b/XCDYouTubeKit Demo/Pods/Google-API-Client/Source/Services/YouTube/Generated/GTLYouTubeChannelLocalization.m new file mode 100644 index 00000000..6757758f --- /dev/null +++ b/XCDYouTubeKit Demo/Pods/Google-API-Client/Source/Services/YouTube/Generated/GTLYouTubeChannelLocalization.m @@ -0,0 +1,48 @@ +/* Copyright (c) 2014 Google Inc. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +// +// GTLYouTubeChannelLocalization.m +// + +// ---------------------------------------------------------------------------- +// NOTE: This file is generated from Google APIs Discovery Service. +// Service: +// YouTube Data API (youtube/v3) +// Description: +// Programmatic access to YouTube features. +// Documentation: +// https://developers.google.com/youtube/v3 +// Classes: +// GTLYouTubeChannelLocalization (0 custom class methods, 2 custom properties) + +#import "GTLYouTubeChannelLocalization.h" + +// ---------------------------------------------------------------------------- +// +// GTLYouTubeChannelLocalization +// + +@implementation GTLYouTubeChannelLocalization +@dynamic descriptionProperty, title; + ++ (NSDictionary *)propertyToJSONKeyMap { + NSDictionary *map = + [NSDictionary dictionaryWithObject:@"description" + forKey:@"descriptionProperty"]; + return map; +} + +@end diff --git a/XCDYouTubeKit Demo/Pods/Google-API-Client/Source/Services/YouTube/Generated/GTLYouTubeChannelSection.h b/XCDYouTubeKit Demo/Pods/Google-API-Client/Source/Services/YouTube/Generated/GTLYouTubeChannelSection.h new file mode 100644 index 00000000..8222b64f --- /dev/null +++ b/XCDYouTubeKit Demo/Pods/Google-API-Client/Source/Services/YouTube/Generated/GTLYouTubeChannelSection.h @@ -0,0 +1,68 @@ +/* Copyright (c) 2014 Google Inc. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +// +// GTLYouTubeChannelSection.h +// + +// ---------------------------------------------------------------------------- +// NOTE: This file is generated from Google APIs Discovery Service. +// Service: +// YouTube Data API (youtube/v3) +// Description: +// Programmatic access to YouTube features. +// Documentation: +// https://developers.google.com/youtube/v3 +// Classes: +// GTLYouTubeChannelSection (0 custom class methods, 5 custom properties) + +#if GTL_BUILT_AS_FRAMEWORK + #import "GTL/GTLObject.h" +#else + #import "GTLObject.h" +#endif + +@class GTLYouTubeChannelSectionContentDetails; +@class GTLYouTubeChannelSectionSnippet; + +// ---------------------------------------------------------------------------- +// +// GTLYouTubeChannelSection +// + +// TODO(lxz) follow up with adiamondstein@ to fullfill the doc before deploying + +@interface GTLYouTubeChannelSection : GTLObject + +// The contentDetails object contains details about the ChannelSection content, +// such as playlists and channels. +@property (retain) GTLYouTubeChannelSectionContentDetails *contentDetails; + +// Etag of this resource. +@property (copy) NSString *ETag; + +// The ID that YouTube uses to uniquely identify the ChannelSection. +// identifier property maps to 'id' in JSON (to avoid Objective C's 'id'). +@property (copy) NSString *identifier; + +// Identifies what kind of resource this is. Value: the fixed string +// "youtube#channelSection". +@property (copy) NSString *kind; + +// The snippet object contains basic details about the ChannelSection, such as +// its type, style and title. +@property (retain) GTLYouTubeChannelSectionSnippet *snippet; + +@end diff --git a/XCDYouTubeKit Demo/Pods/Google-API-Client/Source/Services/YouTube/Generated/GTLYouTubeChannelSection.m b/XCDYouTubeKit Demo/Pods/Google-API-Client/Source/Services/YouTube/Generated/GTLYouTubeChannelSection.m new file mode 100644 index 00000000..d2f3bd67 --- /dev/null +++ b/XCDYouTubeKit Demo/Pods/Google-API-Client/Source/Services/YouTube/Generated/GTLYouTubeChannelSection.m @@ -0,0 +1,57 @@ +/* Copyright (c) 2014 Google Inc. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +// +// GTLYouTubeChannelSection.m +// + +// ---------------------------------------------------------------------------- +// NOTE: This file is generated from Google APIs Discovery Service. +// Service: +// YouTube Data API (youtube/v3) +// Description: +// Programmatic access to YouTube features. +// Documentation: +// https://developers.google.com/youtube/v3 +// Classes: +// GTLYouTubeChannelSection (0 custom class methods, 5 custom properties) + +#import "GTLYouTubeChannelSection.h" + +#import "GTLYouTubeChannelSectionContentDetails.h" +#import "GTLYouTubeChannelSectionSnippet.h" + +// ---------------------------------------------------------------------------- +// +// GTLYouTubeChannelSection +// + +@implementation GTLYouTubeChannelSection +@dynamic contentDetails, ETag, identifier, kind, snippet; + ++ (NSDictionary *)propertyToJSONKeyMap { + NSDictionary *map = + [NSDictionary dictionaryWithObjectsAndKeys: + @"etag", @"ETag", + @"id", @"identifier", + nil]; + return map; +} + ++ (void)load { + [self registerObjectClassForKind:@"youtube#channelSection"]; +} + +@end diff --git a/XCDYouTubeKit Demo/Pods/Google-API-Client/Source/Services/YouTube/Generated/GTLYouTubeChannelSectionContentDetails.h b/XCDYouTubeKit Demo/Pods/Google-API-Client/Source/Services/YouTube/Generated/GTLYouTubeChannelSectionContentDetails.h new file mode 100644 index 00000000..d7d2cc94 --- /dev/null +++ b/XCDYouTubeKit Demo/Pods/Google-API-Client/Source/Services/YouTube/Generated/GTLYouTubeChannelSectionContentDetails.h @@ -0,0 +1,53 @@ +/* Copyright (c) 2014 Google Inc. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +// +// GTLYouTubeChannelSectionContentDetails.h +// + +// ---------------------------------------------------------------------------- +// NOTE: This file is generated from Google APIs Discovery Service. +// Service: +// YouTube Data API (youtube/v3) +// Description: +// Programmatic access to YouTube features. +// Documentation: +// https://developers.google.com/youtube/v3 +// Classes: +// GTLYouTubeChannelSectionContentDetails (0 custom class methods, 2 custom properties) + +#if GTL_BUILT_AS_FRAMEWORK + #import "GTL/GTLObject.h" +#else + #import "GTLObject.h" +#endif + +// ---------------------------------------------------------------------------- +// +// GTLYouTubeChannelSectionContentDetails +// + +// Details about a channelsection, including playlists and channels. + +@interface GTLYouTubeChannelSectionContentDetails : GTLObject + +// The channel ids for type multiple_channels. +@property (retain) NSArray *channels; // of NSString + +// The playlist ids for type single_playlist and multiple_playlists. For +// singlePlaylist, only one playlistId is allowed. +@property (retain) NSArray *playlists; // of NSString + +@end diff --git a/XCDYouTubeKit Demo/Pods/Google-API-Client/Source/Services/YouTube/Generated/GTLYouTubeChannelSectionContentDetails.m b/XCDYouTubeKit Demo/Pods/Google-API-Client/Source/Services/YouTube/Generated/GTLYouTubeChannelSectionContentDetails.m new file mode 100644 index 00000000..650321ee --- /dev/null +++ b/XCDYouTubeKit Demo/Pods/Google-API-Client/Source/Services/YouTube/Generated/GTLYouTubeChannelSectionContentDetails.m @@ -0,0 +1,50 @@ +/* Copyright (c) 2014 Google Inc. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +// +// GTLYouTubeChannelSectionContentDetails.m +// + +// ---------------------------------------------------------------------------- +// NOTE: This file is generated from Google APIs Discovery Service. +// Service: +// YouTube Data API (youtube/v3) +// Description: +// Programmatic access to YouTube features. +// Documentation: +// https://developers.google.com/youtube/v3 +// Classes: +// GTLYouTubeChannelSectionContentDetails (0 custom class methods, 2 custom properties) + +#import "GTLYouTubeChannelSectionContentDetails.h" + +// ---------------------------------------------------------------------------- +// +// GTLYouTubeChannelSectionContentDetails +// + +@implementation GTLYouTubeChannelSectionContentDetails +@dynamic channels, playlists; + ++ (NSDictionary *)arrayPropertyToClassMap { + NSDictionary *map = + [NSDictionary dictionaryWithObjectsAndKeys: + [NSString class], @"channels", + [NSString class], @"playlists", + nil]; + return map; +} + +@end diff --git a/XCDYouTubeKit Demo/Pods/Google-API-Client/Source/Services/YouTube/Generated/GTLYouTubeChannelSectionListResponse.h b/XCDYouTubeKit Demo/Pods/Google-API-Client/Source/Services/YouTube/Generated/GTLYouTubeChannelSectionListResponse.h new file mode 100644 index 00000000..5565383e --- /dev/null +++ b/XCDYouTubeKit Demo/Pods/Google-API-Client/Source/Services/YouTube/Generated/GTLYouTubeChannelSectionListResponse.h @@ -0,0 +1,65 @@ +/* Copyright (c) 2014 Google Inc. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +// +// GTLYouTubeChannelSectionListResponse.h +// + +// ---------------------------------------------------------------------------- +// NOTE: This file is generated from Google APIs Discovery Service. +// Service: +// YouTube Data API (youtube/v3) +// Description: +// Programmatic access to YouTube features. +// Documentation: +// https://developers.google.com/youtube/v3 +// Classes: +// GTLYouTubeChannelSectionListResponse (0 custom class methods, 5 custom properties) + +#if GTL_BUILT_AS_FRAMEWORK + #import "GTL/GTLObject.h" +#else + #import "GTLObject.h" +#endif + +@class GTLYouTubeChannelSection; + +// ---------------------------------------------------------------------------- +// +// GTLYouTubeChannelSectionListResponse +// + +// This class supports NSFastEnumeration over its "items" property. It also +// supports -itemAtIndex: to retrieve individual objects from "items". + +@interface GTLYouTubeChannelSectionListResponse : GTLCollectionObject + +// Etag of this resource. +@property (copy) NSString *ETag; + +// Serialized EventId of the request which produced this response. +@property (copy) NSString *eventId; + +// A list of ChannelSections that match the request criteria. +@property (retain) NSArray *items; // of GTLYouTubeChannelSection + +// Identifies what kind of resource this is. Value: the fixed string +// "youtube#channelSectionListResponse". +@property (copy) NSString *kind; + +// The visitorId identifies the visitor. +@property (copy) NSString *visitorId; + +@end diff --git a/XCDYouTubeKit Demo/Pods/Google-API-Client/Source/Services/YouTube/Generated/GTLYouTubeChannelSectionListResponse.m b/XCDYouTubeKit Demo/Pods/Google-API-Client/Source/Services/YouTube/Generated/GTLYouTubeChannelSectionListResponse.m new file mode 100644 index 00000000..545a93c3 --- /dev/null +++ b/XCDYouTubeKit Demo/Pods/Google-API-Client/Source/Services/YouTube/Generated/GTLYouTubeChannelSectionListResponse.m @@ -0,0 +1,61 @@ +/* Copyright (c) 2014 Google Inc. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +// +// GTLYouTubeChannelSectionListResponse.m +// + +// ---------------------------------------------------------------------------- +// NOTE: This file is generated from Google APIs Discovery Service. +// Service: +// YouTube Data API (youtube/v3) +// Description: +// Programmatic access to YouTube features. +// Documentation: +// https://developers.google.com/youtube/v3 +// Classes: +// GTLYouTubeChannelSectionListResponse (0 custom class methods, 5 custom properties) + +#import "GTLYouTubeChannelSectionListResponse.h" + +#import "GTLYouTubeChannelSection.h" + +// ---------------------------------------------------------------------------- +// +// GTLYouTubeChannelSectionListResponse +// + +@implementation GTLYouTubeChannelSectionListResponse +@dynamic ETag, eventId, items, kind, visitorId; + ++ (NSDictionary *)propertyToJSONKeyMap { + NSDictionary *map = + [NSDictionary dictionaryWithObject:@"etag" + forKey:@"ETag"]; + return map; +} + ++ (NSDictionary *)arrayPropertyToClassMap { + NSDictionary *map = + [NSDictionary dictionaryWithObject:[GTLYouTubeChannelSection class] + forKey:@"items"]; + return map; +} + ++ (void)load { + [self registerObjectClassForKind:@"youtube#channelSectionListResponse"]; +} + +@end diff --git a/XCDYouTubeKit Demo/Pods/Google-API-Client/Source/Services/YouTube/Generated/GTLYouTubeChannelSectionSnippet.h b/XCDYouTubeKit Demo/Pods/Google-API-Client/Source/Services/YouTube/Generated/GTLYouTubeChannelSectionSnippet.h new file mode 100644 index 00000000..7c1c123a --- /dev/null +++ b/XCDYouTubeKit Demo/Pods/Google-API-Client/Source/Services/YouTube/Generated/GTLYouTubeChannelSectionSnippet.h @@ -0,0 +1,62 @@ +/* Copyright (c) 2014 Google Inc. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +// +// GTLYouTubeChannelSectionSnippet.h +// + +// ---------------------------------------------------------------------------- +// NOTE: This file is generated from Google APIs Discovery Service. +// Service: +// YouTube Data API (youtube/v3) +// Description: +// Programmatic access to YouTube features. +// Documentation: +// https://developers.google.com/youtube/v3 +// Classes: +// GTLYouTubeChannelSectionSnippet (0 custom class methods, 5 custom properties) + +#if GTL_BUILT_AS_FRAMEWORK + #import "GTL/GTLObject.h" +#else + #import "GTLObject.h" +#endif + +// ---------------------------------------------------------------------------- +// +// GTLYouTubeChannelSectionSnippet +// + +// Basic details about a channelsection, including title, style and position. + +@interface GTLYouTubeChannelSectionSnippet : GTLObject + +// The ID that YouTube uses to uniquely identify the channel that published the +// channelSection. +@property (copy) NSString *channelId; + +// The position of the channelSection in the channel. +@property (retain) NSNumber *position; // unsignedIntValue + +// The style of the channelSection. +@property (copy) NSString *style; + +// The channelSection's title for multiple_playlists and multiple_channels. +@property (copy) NSString *title; + +// The type of the channelSection. +@property (copy) NSString *type; + +@end diff --git a/XCDYouTubeKit Demo/Pods/Google-API-Client/Source/Services/YouTube/Generated/GTLYouTubeChannelSectionSnippet.m b/XCDYouTubeKit Demo/Pods/Google-API-Client/Source/Services/YouTube/Generated/GTLYouTubeChannelSectionSnippet.m new file mode 100644 index 00000000..57bfd500 --- /dev/null +++ b/XCDYouTubeKit Demo/Pods/Google-API-Client/Source/Services/YouTube/Generated/GTLYouTubeChannelSectionSnippet.m @@ -0,0 +1,40 @@ +/* Copyright (c) 2014 Google Inc. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +// +// GTLYouTubeChannelSectionSnippet.m +// + +// ---------------------------------------------------------------------------- +// NOTE: This file is generated from Google APIs Discovery Service. +// Service: +// YouTube Data API (youtube/v3) +// Description: +// Programmatic access to YouTube features. +// Documentation: +// https://developers.google.com/youtube/v3 +// Classes: +// GTLYouTubeChannelSectionSnippet (0 custom class methods, 5 custom properties) + +#import "GTLYouTubeChannelSectionSnippet.h" + +// ---------------------------------------------------------------------------- +// +// GTLYouTubeChannelSectionSnippet +// + +@implementation GTLYouTubeChannelSectionSnippet +@dynamic channelId, position, style, title, type; +@end diff --git a/XCDYouTubeKit Demo/Pods/Google-API-Client/Source/Services/YouTube/Generated/GTLYouTubeChannelSettings.h b/XCDYouTubeKit Demo/Pods/Google-API-Client/Source/Services/YouTube/Generated/GTLYouTubeChannelSettings.h new file mode 100644 index 00000000..6865edce --- /dev/null +++ b/XCDYouTubeKit Demo/Pods/Google-API-Client/Source/Services/YouTube/Generated/GTLYouTubeChannelSettings.h @@ -0,0 +1,86 @@ +/* Copyright (c) 2014 Google Inc. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +// +// GTLYouTubeChannelSettings.h +// + +// ---------------------------------------------------------------------------- +// NOTE: This file is generated from Google APIs Discovery Service. +// Service: +// YouTube Data API (youtube/v3) +// Description: +// Programmatic access to YouTube features. +// Documentation: +// https://developers.google.com/youtube/v3 +// Classes: +// GTLYouTubeChannelSettings (0 custom class methods, 13 custom properties) + +#if GTL_BUILT_AS_FRAMEWORK + #import "GTL/GTLObject.h" +#else + #import "GTLObject.h" +#endif + +// ---------------------------------------------------------------------------- +// +// GTLYouTubeChannelSettings +// + +// Branding properties for the channel view. + +@interface GTLYouTubeChannelSettings : GTLObject +@property (copy) NSString *defaultLanguage; + +// Which content tab users should see when viewing the channel. +@property (copy) NSString *defaultTab; + +// Specifies the channel description. +// Remapped to 'descriptionProperty' to avoid NSObject's 'description'. +@property (copy) NSString *descriptionProperty; + +// Title for the featured channels tab. +@property (copy) NSString *featuredChannelsTitle; + +// The list of featured channels. +@property (retain) NSArray *featuredChannelsUrls; // of NSString + +// Lists keywords associated with the channel, comma-separated. +@property (copy) NSString *keywords; + +// Whether user-submitted comments left on the channel page need to be approved +// by the channel owner to be publicly visible. +@property (retain) NSNumber *moderateComments; // boolValue + +// A prominent color that can be rendered on this channel page. +@property (copy) NSString *profileColor; + +// Whether the tab to browse the videos should be displayed. +@property (retain) NSNumber *showBrowseView; // boolValue + +// Whether related channels should be proposed. +@property (retain) NSNumber *showRelatedChannels; // boolValue + +// Specifies the channel title. +@property (copy) NSString *title; + +// The ID for a Google Analytics account to track and measure traffic to the +// channels. +@property (copy) NSString *trackingAnalyticsAccountId; + +// The trailer of the channel, for users that are not subscribers. +@property (copy) NSString *unsubscribedTrailer; + +@end diff --git a/XCDYouTubeKit Demo/Pods/Google-API-Client/Source/Services/YouTube/Generated/GTLYouTubeChannelSettings.m b/XCDYouTubeKit Demo/Pods/Google-API-Client/Source/Services/YouTube/Generated/GTLYouTubeChannelSettings.m new file mode 100644 index 00000000..bb9ff839 --- /dev/null +++ b/XCDYouTubeKit Demo/Pods/Google-API-Client/Source/Services/YouTube/Generated/GTLYouTubeChannelSettings.m @@ -0,0 +1,58 @@ +/* Copyright (c) 2014 Google Inc. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +// +// GTLYouTubeChannelSettings.m +// + +// ---------------------------------------------------------------------------- +// NOTE: This file is generated from Google APIs Discovery Service. +// Service: +// YouTube Data API (youtube/v3) +// Description: +// Programmatic access to YouTube features. +// Documentation: +// https://developers.google.com/youtube/v3 +// Classes: +// GTLYouTubeChannelSettings (0 custom class methods, 13 custom properties) + +#import "GTLYouTubeChannelSettings.h" + +// ---------------------------------------------------------------------------- +// +// GTLYouTubeChannelSettings +// + +@implementation GTLYouTubeChannelSettings +@dynamic defaultLanguage, defaultTab, descriptionProperty, + featuredChannelsTitle, featuredChannelsUrls, keywords, + moderateComments, profileColor, showBrowseView, showRelatedChannels, + title, trackingAnalyticsAccountId, unsubscribedTrailer; + ++ (NSDictionary *)propertyToJSONKeyMap { + NSDictionary *map = + [NSDictionary dictionaryWithObject:@"description" + forKey:@"descriptionProperty"]; + return map; +} + ++ (NSDictionary *)arrayPropertyToClassMap { + NSDictionary *map = + [NSDictionary dictionaryWithObject:[NSString class] + forKey:@"featuredChannelsUrls"]; + return map; +} + +@end diff --git a/XCDYouTubeKit Demo/Pods/Google-API-Client/Source/Services/YouTube/Generated/GTLYouTubeChannelSnippet.h b/XCDYouTubeKit Demo/Pods/Google-API-Client/Source/Services/YouTube/Generated/GTLYouTubeChannelSnippet.h new file mode 100644 index 00000000..04d7d956 --- /dev/null +++ b/XCDYouTubeKit Demo/Pods/Google-API-Client/Source/Services/YouTube/Generated/GTLYouTubeChannelSnippet.h @@ -0,0 +1,71 @@ +/* Copyright (c) 2014 Google Inc. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +// +// GTLYouTubeChannelSnippet.h +// + +// ---------------------------------------------------------------------------- +// NOTE: This file is generated from Google APIs Discovery Service. +// Service: +// YouTube Data API (youtube/v3) +// Description: +// Programmatic access to YouTube features. +// Documentation: +// https://developers.google.com/youtube/v3 +// Classes: +// GTLYouTubeChannelSnippet (0 custom class methods, 6 custom properties) + +#if GTL_BUILT_AS_FRAMEWORK + #import "GTL/GTLObject.h" +#else + #import "GTLObject.h" +#endif + +@class GTLYouTubeChannelLocalization; +@class GTLYouTubeThumbnailDetails; + +// ---------------------------------------------------------------------------- +// +// GTLYouTubeChannelSnippet +// + +// Basic details about a channel, including title, description and thumbnails. + +@interface GTLYouTubeChannelSnippet : GTLObject + +// The language of the channel's default title and description. +@property (copy) NSString *defaultLanguage; + +// The description of the channel. +// Remapped to 'descriptionProperty' to avoid NSObject's 'description'. +@property (copy) NSString *descriptionProperty; + +// Localized title and description, read-only. +@property (retain) GTLYouTubeChannelLocalization *localized; + +// The date and time that the channel was created. The value is specified in ISO +// 8601 (YYYY-MM-DDThh:mm:ss.sZ) format. +@property (retain) GTLDateTime *publishedAt; + +// A map of thumbnail images associated with the channel. For each object in the +// map, the key is the name of the thumbnail image, and the value is an object +// that contains other information about the thumbnail. +@property (retain) GTLYouTubeThumbnailDetails *thumbnails; + +// The channel's title. +@property (copy) NSString *title; + +@end diff --git a/XCDYouTubeKit Demo/Pods/Google-API-Client/Source/Services/YouTube/Generated/GTLYouTubeChannelSnippet.m b/XCDYouTubeKit Demo/Pods/Google-API-Client/Source/Services/YouTube/Generated/GTLYouTubeChannelSnippet.m new file mode 100644 index 00000000..e7062f24 --- /dev/null +++ b/XCDYouTubeKit Demo/Pods/Google-API-Client/Source/Services/YouTube/Generated/GTLYouTubeChannelSnippet.m @@ -0,0 +1,52 @@ +/* Copyright (c) 2014 Google Inc. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +// +// GTLYouTubeChannelSnippet.m +// + +// ---------------------------------------------------------------------------- +// NOTE: This file is generated from Google APIs Discovery Service. +// Service: +// YouTube Data API (youtube/v3) +// Description: +// Programmatic access to YouTube features. +// Documentation: +// https://developers.google.com/youtube/v3 +// Classes: +// GTLYouTubeChannelSnippet (0 custom class methods, 6 custom properties) + +#import "GTLYouTubeChannelSnippet.h" + +#import "GTLYouTubeChannelLocalization.h" +#import "GTLYouTubeThumbnailDetails.h" + +// ---------------------------------------------------------------------------- +// +// GTLYouTubeChannelSnippet +// + +@implementation GTLYouTubeChannelSnippet +@dynamic defaultLanguage, descriptionProperty, localized, publishedAt, + thumbnails, title; + ++ (NSDictionary *)propertyToJSONKeyMap { + NSDictionary *map = + [NSDictionary dictionaryWithObject:@"description" + forKey:@"descriptionProperty"]; + return map; +} + +@end diff --git a/XCDYouTubeKit Demo/Pods/Google-API-Client/Source/Services/YouTube/Generated/GTLYouTubeChannelStatistics.h b/XCDYouTubeKit Demo/Pods/Google-API-Client/Source/Services/YouTube/Generated/GTLYouTubeChannelStatistics.h new file mode 100644 index 00000000..117850ee --- /dev/null +++ b/XCDYouTubeKit Demo/Pods/Google-API-Client/Source/Services/YouTube/Generated/GTLYouTubeChannelStatistics.h @@ -0,0 +1,62 @@ +/* Copyright (c) 2013 Google Inc. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +// +// GTLYouTubeChannelStatistics.h +// + +// ---------------------------------------------------------------------------- +// NOTE: This file is generated from Google APIs Discovery Service. +// Service: +// YouTube Data API (youtube/v3) +// Description: +// Programmatic access to YouTube features. +// Documentation: +// https://developers.google.com/youtube/v3 +// Classes: +// GTLYouTubeChannelStatistics (0 custom class methods, 5 custom properties) + +#if GTL_BUILT_AS_FRAMEWORK + #import "GTL/GTLObject.h" +#else + #import "GTLObject.h" +#endif + +// ---------------------------------------------------------------------------- +// +// GTLYouTubeChannelStatistics +// + +// Statistics about a channel: number of subscribers, number of videos in the +// channel, etc. + +@interface GTLYouTubeChannelStatistics : GTLObject + +// The number of comments for the channel. +@property (retain) NSNumber *commentCount; // unsignedLongLongValue + +// Whether or not the number of subscribers is shown for this user. +@property (retain) NSNumber *hiddenSubscriberCount; // boolValue + +// The number of subscribers that the channel has. +@property (retain) NSNumber *subscriberCount; // unsignedLongLongValue + +// The number of videos uploaded to the channel. +@property (retain) NSNumber *videoCount; // unsignedLongLongValue + +// The number of times the channel has been viewed. +@property (retain) NSNumber *viewCount; // unsignedLongLongValue + +@end diff --git a/XCDYouTubeKit Demo/Pods/Google-API-Client/Source/Services/YouTube/Generated/GTLYouTubeChannelStatistics.m b/XCDYouTubeKit Demo/Pods/Google-API-Client/Source/Services/YouTube/Generated/GTLYouTubeChannelStatistics.m new file mode 100644 index 00000000..7e7467b7 --- /dev/null +++ b/XCDYouTubeKit Demo/Pods/Google-API-Client/Source/Services/YouTube/Generated/GTLYouTubeChannelStatistics.m @@ -0,0 +1,41 @@ +/* Copyright (c) 2013 Google Inc. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +// +// GTLYouTubeChannelStatistics.m +// + +// ---------------------------------------------------------------------------- +// NOTE: This file is generated from Google APIs Discovery Service. +// Service: +// YouTube Data API (youtube/v3) +// Description: +// Programmatic access to YouTube features. +// Documentation: +// https://developers.google.com/youtube/v3 +// Classes: +// GTLYouTubeChannelStatistics (0 custom class methods, 5 custom properties) + +#import "GTLYouTubeChannelStatistics.h" + +// ---------------------------------------------------------------------------- +// +// GTLYouTubeChannelStatistics +// + +@implementation GTLYouTubeChannelStatistics +@dynamic commentCount, hiddenSubscriberCount, subscriberCount, videoCount, + viewCount; +@end diff --git a/XCDYouTubeKit Demo/Pods/Google-API-Client/Source/Services/YouTube/Generated/GTLYouTubeChannelStatus.h b/XCDYouTubeKit Demo/Pods/Google-API-Client/Source/Services/YouTube/Generated/GTLYouTubeChannelStatus.h new file mode 100644 index 00000000..7853e0fd --- /dev/null +++ b/XCDYouTubeKit Demo/Pods/Google-API-Client/Source/Services/YouTube/Generated/GTLYouTubeChannelStatus.h @@ -0,0 +1,56 @@ +/* Copyright (c) 2014 Google Inc. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +// +// GTLYouTubeChannelStatus.h +// + +// ---------------------------------------------------------------------------- +// NOTE: This file is generated from Google APIs Discovery Service. +// Service: +// YouTube Data API (youtube/v3) +// Description: +// Programmatic access to YouTube features. +// Documentation: +// https://developers.google.com/youtube/v3 +// Classes: +// GTLYouTubeChannelStatus (0 custom class methods, 3 custom properties) + +#if GTL_BUILT_AS_FRAMEWORK + #import "GTL/GTLObject.h" +#else + #import "GTLObject.h" +#endif + +// ---------------------------------------------------------------------------- +// +// GTLYouTubeChannelStatus +// + +// JSON template for the status part of a channel. + +@interface GTLYouTubeChannelStatus : GTLObject + +// If true, then the user is linked to either a YouTube username or G+ account. +// Otherwise, the user doesn't have a public YouTube identity. +@property (retain) NSNumber *isLinked; // boolValue + +// The long uploads status of this channel. See +@property (copy) NSString *longUploadsStatus; + +// Privacy status of the channel. +@property (copy) NSString *privacyStatus; + +@end diff --git a/XCDYouTubeKit Demo/Pods/Google-API-Client/Source/Services/YouTube/Generated/GTLYouTubeChannelStatus.m b/XCDYouTubeKit Demo/Pods/Google-API-Client/Source/Services/YouTube/Generated/GTLYouTubeChannelStatus.m new file mode 100644 index 00000000..7536d07e --- /dev/null +++ b/XCDYouTubeKit Demo/Pods/Google-API-Client/Source/Services/YouTube/Generated/GTLYouTubeChannelStatus.m @@ -0,0 +1,40 @@ +/* Copyright (c) 2014 Google Inc. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +// +// GTLYouTubeChannelStatus.m +// + +// ---------------------------------------------------------------------------- +// NOTE: This file is generated from Google APIs Discovery Service. +// Service: +// YouTube Data API (youtube/v3) +// Description: +// Programmatic access to YouTube features. +// Documentation: +// https://developers.google.com/youtube/v3 +// Classes: +// GTLYouTubeChannelStatus (0 custom class methods, 3 custom properties) + +#import "GTLYouTubeChannelStatus.h" + +// ---------------------------------------------------------------------------- +// +// GTLYouTubeChannelStatus +// + +@implementation GTLYouTubeChannelStatus +@dynamic isLinked, longUploadsStatus, privacyStatus; +@end diff --git a/XCDYouTubeKit Demo/Pods/Google-API-Client/Source/Services/YouTube/Generated/GTLYouTubeChannelTopicDetails.h b/XCDYouTubeKit Demo/Pods/Google-API-Client/Source/Services/YouTube/Generated/GTLYouTubeChannelTopicDetails.h new file mode 100644 index 00000000..2747937c --- /dev/null +++ b/XCDYouTubeKit Demo/Pods/Google-API-Client/Source/Services/YouTube/Generated/GTLYouTubeChannelTopicDetails.h @@ -0,0 +1,50 @@ +/* Copyright (c) 2012 Google Inc. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +// +// GTLYouTubeChannelTopicDetails.h +// + +// ---------------------------------------------------------------------------- +// NOTE: This file is generated from Google APIs Discovery Service. +// Service: +// YouTube Data API (youtube/v3) +// Description: +// Programmatic access to YouTube features. +// Documentation: +// https://developers.google.com/youtube/v3 +// Classes: +// GTLYouTubeChannelTopicDetails (0 custom class methods, 1 custom properties) + +#if GTL_BUILT_AS_FRAMEWORK + #import "GTL/GTLObject.h" +#else + #import "GTLObject.h" +#endif + +// ---------------------------------------------------------------------------- +// +// GTLYouTubeChannelTopicDetails +// + +// Freebase topic information related to the channel. + +@interface GTLYouTubeChannelTopicDetails : GTLObject + +// A list of Freebase topic IDs associated with the channel. You can retrieve +// information about each topic using the Freebase Topic API. +@property (retain) NSArray *topicIds; // of NSString + +@end diff --git a/XCDYouTubeKit Demo/Pods/Google-API-Client/Source/Services/YouTube/Generated/GTLYouTubeChannelTopicDetails.m b/XCDYouTubeKit Demo/Pods/Google-API-Client/Source/Services/YouTube/Generated/GTLYouTubeChannelTopicDetails.m new file mode 100644 index 00000000..003f036a --- /dev/null +++ b/XCDYouTubeKit Demo/Pods/Google-API-Client/Source/Services/YouTube/Generated/GTLYouTubeChannelTopicDetails.m @@ -0,0 +1,48 @@ +/* Copyright (c) 2012 Google Inc. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +// +// GTLYouTubeChannelTopicDetails.m +// + +// ---------------------------------------------------------------------------- +// NOTE: This file is generated from Google APIs Discovery Service. +// Service: +// YouTube Data API (youtube/v3) +// Description: +// Programmatic access to YouTube features. +// Documentation: +// https://developers.google.com/youtube/v3 +// Classes: +// GTLYouTubeChannelTopicDetails (0 custom class methods, 1 custom properties) + +#import "GTLYouTubeChannelTopicDetails.h" + +// ---------------------------------------------------------------------------- +// +// GTLYouTubeChannelTopicDetails +// + +@implementation GTLYouTubeChannelTopicDetails +@dynamic topicIds; + ++ (NSDictionary *)arrayPropertyToClassMap { + NSDictionary *map = + [NSDictionary dictionaryWithObject:[NSString class] + forKey:@"topicIds"]; + return map; +} + +@end diff --git a/XCDYouTubeKit Demo/Pods/Google-API-Client/Source/Services/YouTube/Generated/GTLYouTubeConstants.h b/XCDYouTubeKit Demo/Pods/Google-API-Client/Source/Services/YouTube/Generated/GTLYouTubeConstants.h new file mode 100644 index 00000000..6a447c35 --- /dev/null +++ b/XCDYouTubeKit Demo/Pods/Google-API-Client/Source/Services/YouTube/Generated/GTLYouTubeConstants.h @@ -0,0 +1,939 @@ +/* Copyright (c) 2014 Google Inc. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +// +// GTLYouTubeConstants.h +// + +// ---------------------------------------------------------------------------- +// NOTE: This file is generated from Google APIs Discovery Service. +// Service: +// YouTube Data API (youtube/v3) +// Description: +// Programmatic access to YouTube features. +// Documentation: +// https://developers.google.com/youtube/v3 + +#import + +#if GTL_BUILT_AS_FRAMEWORK + #import "GTL/GTLDefines.h" +#else + #import "GTLDefines.h" +#endif + +// Authorization scope +// Manage your YouTube account +GTL_EXTERN NSString * const kGTLAuthScopeYouTube; // "https://www.googleapis.com/auth/youtube" +// View your YouTube account +GTL_EXTERN NSString * const kGTLAuthScopeYouTubeReadonly; // "https://www.googleapis.com/auth/youtube.readonly" +// Manage your YouTube videos +GTL_EXTERN NSString * const kGTLAuthScopeYouTubeUpload; // "https://www.googleapis.com/auth/youtube.upload" +// View and manage your assets and associated content on YouTube +GTL_EXTERN NSString * const kGTLAuthScopeYouTubeYoutubepartner; // "https://www.googleapis.com/auth/youtubepartner" +// View private information of your YouTube channel relevant during the audit +// process with a YouTube partner +GTL_EXTERN NSString * const kGTLAuthScopeYouTubeYoutubepartnerChannelAudit; // "https://www.googleapis.com/auth/youtubepartner-channel-audit" + +// GTLQueryYouTube - BroadcastStatus +GTL_EXTERN NSString * const kGTLYouTubeBroadcastStatusActive; // "active" +GTL_EXTERN NSString * const kGTLYouTubeBroadcastStatusAll; // "all" +GTL_EXTERN NSString * const kGTLYouTubeBroadcastStatusComplete; // "complete" +GTL_EXTERN NSString * const kGTLYouTubeBroadcastStatusCompleted; // "completed" +GTL_EXTERN NSString * const kGTLYouTubeBroadcastStatusLive; // "live" +GTL_EXTERN NSString * const kGTLYouTubeBroadcastStatusTesting; // "testing" +GTL_EXTERN NSString * const kGTLYouTubeBroadcastStatusUpcoming; // "upcoming" + +// GTLQueryYouTube - ChannelType +GTL_EXTERN NSString * const kGTLYouTubeChannelTypeAny; // "any" +GTL_EXTERN NSString * const kGTLYouTubeChannelTypeShow; // "show" + +// GTLQueryYouTube - Chart +GTL_EXTERN NSString * const kGTLYouTubeChartMostPopular; // "mostPopular" + +// GTLQueryYouTube - EventType +GTL_EXTERN NSString * const kGTLYouTubeEventTypeCompleted; // "completed" +GTL_EXTERN NSString * const kGTLYouTubeEventTypeLive; // "live" +GTL_EXTERN NSString * const kGTLYouTubeEventTypeUpcoming; // "upcoming" + +// GTLQueryYouTube - MyRating +GTL_EXTERN NSString * const kGTLYouTubeMyRatingDislike; // "dislike" +GTL_EXTERN NSString * const kGTLYouTubeMyRatingLike; // "like" + +// GTLQueryYouTube - Order +GTL_EXTERN NSString * const kGTLYouTubeOrderAlphabetical; // "alphabetical" +GTL_EXTERN NSString * const kGTLYouTubeOrderDate; // "date" +GTL_EXTERN NSString * const kGTLYouTubeOrderRating; // "rating" +GTL_EXTERN NSString * const kGTLYouTubeOrderRelevance; // "relevance" +GTL_EXTERN NSString * const kGTLYouTubeOrderTitle; // "title" +GTL_EXTERN NSString * const kGTLYouTubeOrderUnread; // "unread" +GTL_EXTERN NSString * const kGTLYouTubeOrderVideoCount; // "videoCount" +GTL_EXTERN NSString * const kGTLYouTubeOrderViewCount; // "viewCount" + +// GTLQueryYouTube - Rating +GTL_EXTERN NSString * const kGTLYouTubeRatingDislike; // "dislike" +GTL_EXTERN NSString * const kGTLYouTubeRatingLike; // "like" +GTL_EXTERN NSString * const kGTLYouTubeRatingNone; // "none" + +// GTLQueryYouTube - SafeSearch +GTL_EXTERN NSString * const kGTLYouTubeSafeSearchModerate; // "moderate" +GTL_EXTERN NSString * const kGTLYouTubeSafeSearchNone; // "none" +GTL_EXTERN NSString * const kGTLYouTubeSafeSearchStrict; // "strict" + +// GTLQueryYouTube - VideoCaption +GTL_EXTERN NSString * const kGTLYouTubeVideoCaptionAny; // "any" +GTL_EXTERN NSString * const kGTLYouTubeVideoCaptionClosedCaption; // "closedCaption" +GTL_EXTERN NSString * const kGTLYouTubeVideoCaptionNone; // "none" + +// GTLQueryYouTube - VideoDefinition +GTL_EXTERN NSString * const kGTLYouTubeVideoDefinitionAny; // "any" +GTL_EXTERN NSString * const kGTLYouTubeVideoDefinitionHigh; // "high" +GTL_EXTERN NSString * const kGTLYouTubeVideoDefinitionStandard; // "standard" + +// GTLQueryYouTube - VideoDimension +GTL_EXTERN NSString * const kGTLYouTubeVideoDimensionAny; // "any" +GTL_EXTERN NSString * const kGTLYouTubeVideoDimensionX2d; // "2d" +GTL_EXTERN NSString * const kGTLYouTubeVideoDimensionX3d; // "3d" + +// GTLQueryYouTube - VideoDuration +GTL_EXTERN NSString * const kGTLYouTubeVideoDurationAny; // "any" +GTL_EXTERN NSString * const kGTLYouTubeVideoDurationLong; // "long" +GTL_EXTERN NSString * const kGTLYouTubeVideoDurationMedium; // "medium" +GTL_EXTERN NSString * const kGTLYouTubeVideoDurationShort; // "short" + +// GTLQueryYouTube - VideoEmbeddable +GTL_EXTERN NSString * const kGTLYouTubeVideoEmbeddableAny; // "any" +GTL_EXTERN NSString * const kGTLYouTubeVideoEmbeddableTrue; // "true" + +// GTLQueryYouTube - VideoLicense +GTL_EXTERN NSString * const kGTLYouTubeVideoLicenseAny; // "any" +GTL_EXTERN NSString * const kGTLYouTubeVideoLicenseCreativeCommon; // "creativeCommon" +GTL_EXTERN NSString * const kGTLYouTubeVideoLicenseYoutube; // "youtube" + +// GTLQueryYouTube - VideoSyndicated +GTL_EXTERN NSString * const kGTLYouTubeVideoSyndicatedAny; // "any" +GTL_EXTERN NSString * const kGTLYouTubeVideoSyndicatedTrue; // "true" + +// GTLQueryYouTube - VideoType +GTL_EXTERN NSString * const kGTLYouTubeVideoTypeAny; // "any" +GTL_EXTERN NSString * const kGTLYouTubeVideoTypeEpisode; // "episode" +GTL_EXTERN NSString * const kGTLYouTubeVideoTypeMovie; // "movie" + +// GTLYouTubeActivityContentDetailsPromotedItem - CtaType +GTL_EXTERN NSString * const kGTLYouTubeActivityContentDetailsPromotedItem_CtaType_Unspecified; // "unspecified" +GTL_EXTERN NSString * const kGTLYouTubeActivityContentDetailsPromotedItem_CtaType_VisitAdvertiserSite; // "visitAdvertiserSite" + +// GTLYouTubeActivityContentDetailsRecommendation - Reason +GTL_EXTERN NSString * const kGTLYouTubeActivityContentDetailsRecommendation_Reason_Unspecified; // "unspecified" +GTL_EXTERN NSString * const kGTLYouTubeActivityContentDetailsRecommendation_Reason_VideoFavorited; // "videoFavorited" +GTL_EXTERN NSString * const kGTLYouTubeActivityContentDetailsRecommendation_Reason_VideoLiked; // "videoLiked" +GTL_EXTERN NSString * const kGTLYouTubeActivityContentDetailsRecommendation_Reason_VideoWatched; // "videoWatched" + +// GTLYouTubeActivityContentDetailsSocial - Type +GTL_EXTERN NSString * const kGTLYouTubeActivityContentDetailsSocial_Type_Facebook; // "facebook" +GTL_EXTERN NSString * const kGTLYouTubeActivityContentDetailsSocial_Type_GooglePlus; // "googlePlus" +GTL_EXTERN NSString * const kGTLYouTubeActivityContentDetailsSocial_Type_Twitter; // "twitter" +GTL_EXTERN NSString * const kGTLYouTubeActivityContentDetailsSocial_Type_Unspecified; // "unspecified" + +// GTLYouTubeActivitySnippet - Type +GTL_EXTERN NSString * const kGTLYouTubeActivitySnippet_Type_Bulletin; // "bulletin" +GTL_EXTERN NSString * const kGTLYouTubeActivitySnippet_Type_ChannelItem; // "channelItem" +GTL_EXTERN NSString * const kGTLYouTubeActivitySnippet_Type_Comment; // "comment" +GTL_EXTERN NSString * const kGTLYouTubeActivitySnippet_Type_Favorite; // "favorite" +GTL_EXTERN NSString * const kGTLYouTubeActivitySnippet_Type_Like; // "like" +GTL_EXTERN NSString * const kGTLYouTubeActivitySnippet_Type_PlaylistItem; // "playlistItem" +GTL_EXTERN NSString * const kGTLYouTubeActivitySnippet_Type_PromotedItem; // "promotedItem" +GTL_EXTERN NSString * const kGTLYouTubeActivitySnippet_Type_Recommendation; // "recommendation" +GTL_EXTERN NSString * const kGTLYouTubeActivitySnippet_Type_Social; // "social" +GTL_EXTERN NSString * const kGTLYouTubeActivitySnippet_Type_Subscription; // "subscription" +GTL_EXTERN NSString * const kGTLYouTubeActivitySnippet_Type_Upload; // "upload" + +// GTLYouTubeCdnSettings - IngestionType +GTL_EXTERN NSString * const kGTLYouTubeCdnSettings_IngestionType_Dash; // "dash" +GTL_EXTERN NSString * const kGTLYouTubeCdnSettings_IngestionType_Rtmp; // "rtmp" + +// GTLYouTubeChannelConversionPing - Context +GTL_EXTERN NSString * const kGTLYouTubeChannelConversionPing_Context_Cview; // "cview" +GTL_EXTERN NSString * const kGTLYouTubeChannelConversionPing_Context_Subscribe; // "subscribe" +GTL_EXTERN NSString * const kGTLYouTubeChannelConversionPing_Context_Unsubscribe; // "unsubscribe" + +// GTLYouTubeChannelSectionSnippet - Style +GTL_EXTERN NSString * const kGTLYouTubeChannelSectionSnippet_Style_ChannelsectionStyleUndefined; // "channelsectionStyleUndefined" +GTL_EXTERN NSString * const kGTLYouTubeChannelSectionSnippet_Style_HorizontalRow; // "horizontalRow" +GTL_EXTERN NSString * const kGTLYouTubeChannelSectionSnippet_Style_VerticalList; // "verticalList" + +// GTLYouTubeChannelSectionSnippet - Type +GTL_EXTERN NSString * const kGTLYouTubeChannelSectionSnippet_Type_AllPlaylists; // "allPlaylists" +GTL_EXTERN NSString * const kGTLYouTubeChannelSectionSnippet_Type_ChannelsectionTypeUndefined; // "channelsectionTypeUndefined" +GTL_EXTERN NSString * const kGTLYouTubeChannelSectionSnippet_Type_CompletedEvents; // "completedEvents" +GTL_EXTERN NSString * const kGTLYouTubeChannelSectionSnippet_Type_LikedPlaylists; // "likedPlaylists" +GTL_EXTERN NSString * const kGTLYouTubeChannelSectionSnippet_Type_Likes; // "likes" +GTL_EXTERN NSString * const kGTLYouTubeChannelSectionSnippet_Type_LiveEvents; // "liveEvents" +GTL_EXTERN NSString * const kGTLYouTubeChannelSectionSnippet_Type_MultipleChannels; // "multipleChannels" +GTL_EXTERN NSString * const kGTLYouTubeChannelSectionSnippet_Type_MultiplePlaylists; // "multiplePlaylists" +GTL_EXTERN NSString * const kGTLYouTubeChannelSectionSnippet_Type_PopularUploads; // "popularUploads" +GTL_EXTERN NSString * const kGTLYouTubeChannelSectionSnippet_Type_PostedPlaylists; // "postedPlaylists" +GTL_EXTERN NSString * const kGTLYouTubeChannelSectionSnippet_Type_PostedVideos; // "postedVideos" +GTL_EXTERN NSString * const kGTLYouTubeChannelSectionSnippet_Type_RecentActivity; // "recentActivity" +GTL_EXTERN NSString * const kGTLYouTubeChannelSectionSnippet_Type_RecentPosts; // "recentPosts" +GTL_EXTERN NSString * const kGTLYouTubeChannelSectionSnippet_Type_RecentUploads; // "recentUploads" +GTL_EXTERN NSString * const kGTLYouTubeChannelSectionSnippet_Type_SinglePlaylist; // "singlePlaylist" +GTL_EXTERN NSString * const kGTLYouTubeChannelSectionSnippet_Type_Subscriptions; // "subscriptions" +GTL_EXTERN NSString * const kGTLYouTubeChannelSectionSnippet_Type_UpcomingEvents; // "upcomingEvents" + +// GTLYouTubeChannelStatus - LongUploadsStatus +GTL_EXTERN NSString * const kGTLYouTubeChannelStatus_LongUploadsStatus_Allowed; // "allowed" +GTL_EXTERN NSString * const kGTLYouTubeChannelStatus_LongUploadsStatus_Disallowed; // "disallowed" +GTL_EXTERN NSString * const kGTLYouTubeChannelStatus_LongUploadsStatus_Eligible; // "eligible" +GTL_EXTERN NSString * const kGTLYouTubeChannelStatus_LongUploadsStatus_LongUploadsUnspecified; // "longUploadsUnspecified" + +// GTLYouTubeChannelStatus - PrivacyStatus +GTL_EXTERN NSString * const kGTLYouTubeChannelStatus_PrivacyStatus_Private; // "private" +GTL_EXTERN NSString * const kGTLYouTubeChannelStatus_PrivacyStatus_Public; // "public" +GTL_EXTERN NSString * const kGTLYouTubeChannelStatus_PrivacyStatus_Unlisted; // "unlisted" + +// GTLYouTubeContentRating - AcbRating +GTL_EXTERN NSString * const kGTLYouTubeContentRating_AcbRating_AcbC; // "acbC" +GTL_EXTERN NSString * const kGTLYouTubeContentRating_AcbRating_AcbE; // "acbE" +GTL_EXTERN NSString * const kGTLYouTubeContentRating_AcbRating_AcbG; // "acbG" +GTL_EXTERN NSString * const kGTLYouTubeContentRating_AcbRating_AcbM; // "acbM" +GTL_EXTERN NSString * const kGTLYouTubeContentRating_AcbRating_AcbMa15plus; // "acbMa15plus" +GTL_EXTERN NSString * const kGTLYouTubeContentRating_AcbRating_AcbP; // "acbP" +GTL_EXTERN NSString * const kGTLYouTubeContentRating_AcbRating_AcbPg; // "acbPg" +GTL_EXTERN NSString * const kGTLYouTubeContentRating_AcbRating_AcbR18plus; // "acbR18plus" +GTL_EXTERN NSString * const kGTLYouTubeContentRating_AcbRating_AcbUnrated; // "acbUnrated" + +// GTLYouTubeContentRating - AgcomRating +GTL_EXTERN NSString * const kGTLYouTubeContentRating_AgcomRating_AgcomT; // "agcomT" +GTL_EXTERN NSString * const kGTLYouTubeContentRating_AgcomRating_AgcomUnrated; // "agcomUnrated" +GTL_EXTERN NSString * const kGTLYouTubeContentRating_AgcomRating_AgcomVm14; // "agcomVm14" +GTL_EXTERN NSString * const kGTLYouTubeContentRating_AgcomRating_AgcomVm18; // "agcomVm18" + +// GTLYouTubeContentRating - AnatelRating +GTL_EXTERN NSString * const kGTLYouTubeContentRating_AnatelRating_AnatelA; // "anatelA" +GTL_EXTERN NSString * const kGTLYouTubeContentRating_AnatelRating_AnatelF; // "anatelF" +GTL_EXTERN NSString * const kGTLYouTubeContentRating_AnatelRating_AnatelI; // "anatelI" +GTL_EXTERN NSString * const kGTLYouTubeContentRating_AnatelRating_AnatelI10; // "anatelI10" +GTL_EXTERN NSString * const kGTLYouTubeContentRating_AnatelRating_AnatelI12; // "anatelI12" +GTL_EXTERN NSString * const kGTLYouTubeContentRating_AnatelRating_AnatelI7; // "anatelI7" +GTL_EXTERN NSString * const kGTLYouTubeContentRating_AnatelRating_AnatelR; // "anatelR" +GTL_EXTERN NSString * const kGTLYouTubeContentRating_AnatelRating_AnatelUnrated; // "anatelUnrated" + +// GTLYouTubeContentRating - BbfcRating +GTL_EXTERN NSString * const kGTLYouTubeContentRating_BbfcRating_Bbfc12; // "bbfc12" +GTL_EXTERN NSString * const kGTLYouTubeContentRating_BbfcRating_Bbfc12a; // "bbfc12a" +GTL_EXTERN NSString * const kGTLYouTubeContentRating_BbfcRating_Bbfc15; // "bbfc15" +GTL_EXTERN NSString * const kGTLYouTubeContentRating_BbfcRating_Bbfc18; // "bbfc18" +GTL_EXTERN NSString * const kGTLYouTubeContentRating_BbfcRating_BbfcPg; // "bbfcPg" +GTL_EXTERN NSString * const kGTLYouTubeContentRating_BbfcRating_BbfcR18; // "bbfcR18" +GTL_EXTERN NSString * const kGTLYouTubeContentRating_BbfcRating_BbfcU; // "bbfcU" +GTL_EXTERN NSString * const kGTLYouTubeContentRating_BbfcRating_BbfcUnrated; // "bbfcUnrated" + +// GTLYouTubeContentRating - BfvcRating +GTL_EXTERN NSString * const kGTLYouTubeContentRating_BfvcRating_Bfvc13; // "bfvc13" +GTL_EXTERN NSString * const kGTLYouTubeContentRating_BfvcRating_Bfvc15; // "bfvc15" +GTL_EXTERN NSString * const kGTLYouTubeContentRating_BfvcRating_Bfvc18; // "bfvc18" +GTL_EXTERN NSString * const kGTLYouTubeContentRating_BfvcRating_Bfvc20; // "bfvc20" +GTL_EXTERN NSString * const kGTLYouTubeContentRating_BfvcRating_BfvcB; // "bfvcB" +GTL_EXTERN NSString * const kGTLYouTubeContentRating_BfvcRating_BfvcE; // "bfvcE" +GTL_EXTERN NSString * const kGTLYouTubeContentRating_BfvcRating_BfvcG; // "bfvcG" +GTL_EXTERN NSString * const kGTLYouTubeContentRating_BfvcRating_BfvcUnrated; // "bfvcUnrated" + +// GTLYouTubeContentRating - BmukkRating +GTL_EXTERN NSString * const kGTLYouTubeContentRating_BmukkRating_Bmukk10; // "bmukk10" +GTL_EXTERN NSString * const kGTLYouTubeContentRating_BmukkRating_Bmukk12; // "bmukk12" +GTL_EXTERN NSString * const kGTLYouTubeContentRating_BmukkRating_Bmukk14; // "bmukk14" +GTL_EXTERN NSString * const kGTLYouTubeContentRating_BmukkRating_Bmukk16; // "bmukk16" +GTL_EXTERN NSString * const kGTLYouTubeContentRating_BmukkRating_Bmukk6; // "bmukk6" +GTL_EXTERN NSString * const kGTLYouTubeContentRating_BmukkRating_Bmukk8; // "bmukk8" +GTL_EXTERN NSString * const kGTLYouTubeContentRating_BmukkRating_BmukkAa; // "bmukkAa" +GTL_EXTERN NSString * const kGTLYouTubeContentRating_BmukkRating_BmukkUnrated; // "bmukkUnrated" + +// GTLYouTubeContentRating - CatvfrRating +GTL_EXTERN NSString * const kGTLYouTubeContentRating_CatvfrRating_Catvfr13plus; // "catvfr13plus" +GTL_EXTERN NSString * const kGTLYouTubeContentRating_CatvfrRating_Catvfr16plus; // "catvfr16plus" +GTL_EXTERN NSString * const kGTLYouTubeContentRating_CatvfrRating_Catvfr18plus; // "catvfr18plus" +GTL_EXTERN NSString * const kGTLYouTubeContentRating_CatvfrRating_Catvfr8plus; // "catvfr8plus" +GTL_EXTERN NSString * const kGTLYouTubeContentRating_CatvfrRating_CatvfrG; // "catvfrG" +GTL_EXTERN NSString * const kGTLYouTubeContentRating_CatvfrRating_CatvfrUnrated; // "catvfrUnrated" + +// GTLYouTubeContentRating - CatvRating +GTL_EXTERN NSString * const kGTLYouTubeContentRating_CatvRating_Catv14plus; // "catv14plus" +GTL_EXTERN NSString * const kGTLYouTubeContentRating_CatvRating_Catv18plus; // "catv18plus" +GTL_EXTERN NSString * const kGTLYouTubeContentRating_CatvRating_CatvC; // "catvC" +GTL_EXTERN NSString * const kGTLYouTubeContentRating_CatvRating_CatvC8; // "catvC8" +GTL_EXTERN NSString * const kGTLYouTubeContentRating_CatvRating_CatvG; // "catvG" +GTL_EXTERN NSString * const kGTLYouTubeContentRating_CatvRating_CatvPg; // "catvPg" +GTL_EXTERN NSString * const kGTLYouTubeContentRating_CatvRating_CatvUnrated; // "catvUnrated" + +// GTLYouTubeContentRating - CbfcRating +GTL_EXTERN NSString * const kGTLYouTubeContentRating_CbfcRating_CbfcA; // "cbfcA" +GTL_EXTERN NSString * const kGTLYouTubeContentRating_CbfcRating_CbfcS; // "cbfcS" +GTL_EXTERN NSString * const kGTLYouTubeContentRating_CbfcRating_CbfcU; // "cbfcU" +GTL_EXTERN NSString * const kGTLYouTubeContentRating_CbfcRating_CbfcUA; // "cbfcUA" +GTL_EXTERN NSString * const kGTLYouTubeContentRating_CbfcRating_CbfcUnrated; // "cbfcUnrated" + +// GTLYouTubeContentRating - CccRating +GTL_EXTERN NSString * const kGTLYouTubeContentRating_CccRating_Ccc14; // "ccc14" +GTL_EXTERN NSString * const kGTLYouTubeContentRating_CccRating_Ccc18; // "ccc18" +GTL_EXTERN NSString * const kGTLYouTubeContentRating_CccRating_Ccc18s; // "ccc18s" +GTL_EXTERN NSString * const kGTLYouTubeContentRating_CccRating_Ccc18v; // "ccc18v" +GTL_EXTERN NSString * const kGTLYouTubeContentRating_CccRating_Ccc6; // "ccc6" +GTL_EXTERN NSString * const kGTLYouTubeContentRating_CccRating_CccTe; // "cccTe" +GTL_EXTERN NSString * const kGTLYouTubeContentRating_CccRating_CccUnrated; // "cccUnrated" + +// GTLYouTubeContentRating - CceRating +GTL_EXTERN NSString * const kGTLYouTubeContentRating_CceRating_CceM12; // "cceM12" +GTL_EXTERN NSString * const kGTLYouTubeContentRating_CceRating_CceM16; // "cceM16" +GTL_EXTERN NSString * const kGTLYouTubeContentRating_CceRating_CceM18; // "cceM18" +GTL_EXTERN NSString * const kGTLYouTubeContentRating_CceRating_CceM4; // "cceM4" +GTL_EXTERN NSString * const kGTLYouTubeContentRating_CceRating_CceM6; // "cceM6" +GTL_EXTERN NSString * const kGTLYouTubeContentRating_CceRating_CceUnrated; // "cceUnrated" + +// GTLYouTubeContentRating - ChfilmRating +GTL_EXTERN NSString * const kGTLYouTubeContentRating_ChfilmRating_Chfilm0; // "chfilm0" +GTL_EXTERN NSString * const kGTLYouTubeContentRating_ChfilmRating_Chfilm12; // "chfilm12" +GTL_EXTERN NSString * const kGTLYouTubeContentRating_ChfilmRating_Chfilm16; // "chfilm16" +GTL_EXTERN NSString * const kGTLYouTubeContentRating_ChfilmRating_Chfilm18; // "chfilm18" +GTL_EXTERN NSString * const kGTLYouTubeContentRating_ChfilmRating_Chfilm6; // "chfilm6" +GTL_EXTERN NSString * const kGTLYouTubeContentRating_ChfilmRating_ChfilmUnrated; // "chfilmUnrated" + +// GTLYouTubeContentRating - ChvrsRating +GTL_EXTERN NSString * const kGTLYouTubeContentRating_ChvrsRating_Chvrs14a; // "chvrs14a" +GTL_EXTERN NSString * const kGTLYouTubeContentRating_ChvrsRating_Chvrs18a; // "chvrs18a" +GTL_EXTERN NSString * const kGTLYouTubeContentRating_ChvrsRating_ChvrsE; // "chvrsE" +GTL_EXTERN NSString * const kGTLYouTubeContentRating_ChvrsRating_ChvrsG; // "chvrsG" +GTL_EXTERN NSString * const kGTLYouTubeContentRating_ChvrsRating_ChvrsPg; // "chvrsPg" +GTL_EXTERN NSString * const kGTLYouTubeContentRating_ChvrsRating_ChvrsR; // "chvrsR" +GTL_EXTERN NSString * const kGTLYouTubeContentRating_ChvrsRating_ChvrsUnrated; // "chvrsUnrated" + +// GTLYouTubeContentRating - CicfRating +GTL_EXTERN NSString * const kGTLYouTubeContentRating_CicfRating_CicfE; // "cicfE" +GTL_EXTERN NSString * const kGTLYouTubeContentRating_CicfRating_CicfKntEna; // "cicfKntEna" +GTL_EXTERN NSString * const kGTLYouTubeContentRating_CicfRating_CicfKtEa; // "cicfKtEa" +GTL_EXTERN NSString * const kGTLYouTubeContentRating_CicfRating_CicfUnrated; // "cicfUnrated" + +// GTLYouTubeContentRating - CnaRating +GTL_EXTERN NSString * const kGTLYouTubeContentRating_CnaRating_Cna12; // "cna12" +GTL_EXTERN NSString * const kGTLYouTubeContentRating_CnaRating_Cna15; // "cna15" +GTL_EXTERN NSString * const kGTLYouTubeContentRating_CnaRating_Cna18; // "cna18" +GTL_EXTERN NSString * const kGTLYouTubeContentRating_CnaRating_Cna18plus; // "cna18plus" +GTL_EXTERN NSString * const kGTLYouTubeContentRating_CnaRating_CnaAp; // "cnaAp" +GTL_EXTERN NSString * const kGTLYouTubeContentRating_CnaRating_CnaUnrated; // "cnaUnrated" + +// GTLYouTubeContentRating - CsaRating +GTL_EXTERN NSString * const kGTLYouTubeContentRating_CsaRating_Csa10; // "csa10" +GTL_EXTERN NSString * const kGTLYouTubeContentRating_CsaRating_Csa12; // "csa12" +GTL_EXTERN NSString * const kGTLYouTubeContentRating_CsaRating_Csa16; // "csa16" +GTL_EXTERN NSString * const kGTLYouTubeContentRating_CsaRating_Csa18; // "csa18" +GTL_EXTERN NSString * const kGTLYouTubeContentRating_CsaRating_CsaInterdiction; // "csaInterdiction" +GTL_EXTERN NSString * const kGTLYouTubeContentRating_CsaRating_CsaUnrated; // "csaUnrated" + +// GTLYouTubeContentRating - CscfRating +GTL_EXTERN NSString * const kGTLYouTubeContentRating_CscfRating_Cscf12; // "cscf12" +GTL_EXTERN NSString * const kGTLYouTubeContentRating_CscfRating_Cscf16; // "cscf16" +GTL_EXTERN NSString * const kGTLYouTubeContentRating_CscfRating_Cscf18; // "cscf18" +GTL_EXTERN NSString * const kGTLYouTubeContentRating_CscfRating_Cscf6; // "cscf6" +GTL_EXTERN NSString * const kGTLYouTubeContentRating_CscfRating_CscfA; // "cscfA" +GTL_EXTERN NSString * const kGTLYouTubeContentRating_CscfRating_CscfUnrated; // "cscfUnrated" + +// GTLYouTubeContentRating - CzfilmRating +GTL_EXTERN NSString * const kGTLYouTubeContentRating_CzfilmRating_Czfilm12; // "czfilm12" +GTL_EXTERN NSString * const kGTLYouTubeContentRating_CzfilmRating_Czfilm14; // "czfilm14" +GTL_EXTERN NSString * const kGTLYouTubeContentRating_CzfilmRating_Czfilm18; // "czfilm18" +GTL_EXTERN NSString * const kGTLYouTubeContentRating_CzfilmRating_CzfilmU; // "czfilmU" +GTL_EXTERN NSString * const kGTLYouTubeContentRating_CzfilmRating_CzfilmUnrated; // "czfilmUnrated" + +// GTLYouTubeContentRating - DjctqRating +GTL_EXTERN NSString * const kGTLYouTubeContentRating_DjctqRating_Djctq10; // "djctq10" +GTL_EXTERN NSString * const kGTLYouTubeContentRating_DjctqRating_Djctq12; // "djctq12" +GTL_EXTERN NSString * const kGTLYouTubeContentRating_DjctqRating_Djctq14; // "djctq14" +GTL_EXTERN NSString * const kGTLYouTubeContentRating_DjctqRating_Djctq16; // "djctq16" +GTL_EXTERN NSString * const kGTLYouTubeContentRating_DjctqRating_Djctq18; // "djctq18" +GTL_EXTERN NSString * const kGTLYouTubeContentRating_DjctqRating_DjctqL; // "djctqL" +GTL_EXTERN NSString * const kGTLYouTubeContentRating_DjctqRating_DjctqUnrated; // "djctqUnrated" + +// GTLYouTubeContentRating - DjctqRatingReasons +GTL_EXTERN NSString * const kGTLYouTubeContentRating_DjctqRatingReasons_DjctqCriminalActs; // "djctqCriminalActs" +GTL_EXTERN NSString * const kGTLYouTubeContentRating_DjctqRatingReasons_DjctqDrugs; // "djctqDrugs" +GTL_EXTERN NSString * const kGTLYouTubeContentRating_DjctqRatingReasons_DjctqExplicitSex; // "djctqExplicitSex" +GTL_EXTERN NSString * const kGTLYouTubeContentRating_DjctqRatingReasons_DjctqExtremeViolence; // "djctqExtremeViolence" +GTL_EXTERN NSString * const kGTLYouTubeContentRating_DjctqRatingReasons_DjctqIllegalDrugs; // "djctqIllegalDrugs" +GTL_EXTERN NSString * const kGTLYouTubeContentRating_DjctqRatingReasons_DjctqImpactingContent; // "djctqImpactingContent" +GTL_EXTERN NSString * const kGTLYouTubeContentRating_DjctqRatingReasons_DjctqInappropriateLanguage; // "djctqInappropriateLanguage" +GTL_EXTERN NSString * const kGTLYouTubeContentRating_DjctqRatingReasons_DjctqLegalDrugs; // "djctqLegalDrugs" +GTL_EXTERN NSString * const kGTLYouTubeContentRating_DjctqRatingReasons_DjctqNudity; // "djctqNudity" +GTL_EXTERN NSString * const kGTLYouTubeContentRating_DjctqRatingReasons_DjctqSex; // "djctqSex" +GTL_EXTERN NSString * const kGTLYouTubeContentRating_DjctqRatingReasons_DjctqSexualContent; // "djctqSexualContent" +GTL_EXTERN NSString * const kGTLYouTubeContentRating_DjctqRatingReasons_DjctqViolence; // "djctqViolence" + +// GTLYouTubeContentRating - EefilmRating +GTL_EXTERN NSString * const kGTLYouTubeContentRating_EefilmRating_EefilmK12; // "eefilmK12" +GTL_EXTERN NSString * const kGTLYouTubeContentRating_EefilmRating_EefilmK14; // "eefilmK14" +GTL_EXTERN NSString * const kGTLYouTubeContentRating_EefilmRating_EefilmK16; // "eefilmK16" +GTL_EXTERN NSString * const kGTLYouTubeContentRating_EefilmRating_EefilmK6; // "eefilmK6" +GTL_EXTERN NSString * const kGTLYouTubeContentRating_EefilmRating_EefilmL; // "eefilmL" +GTL_EXTERN NSString * const kGTLYouTubeContentRating_EefilmRating_EefilmMs12; // "eefilmMs12" +GTL_EXTERN NSString * const kGTLYouTubeContentRating_EefilmRating_EefilmMs6; // "eefilmMs6" +GTL_EXTERN NSString * const kGTLYouTubeContentRating_EefilmRating_EefilmPere; // "eefilmPere" +GTL_EXTERN NSString * const kGTLYouTubeContentRating_EefilmRating_EefilmUnrated; // "eefilmUnrated" + +// GTLYouTubeContentRating - EgfilmRating +GTL_EXTERN NSString * const kGTLYouTubeContentRating_EgfilmRating_Egfilm18; // "egfilm18" +GTL_EXTERN NSString * const kGTLYouTubeContentRating_EgfilmRating_EgfilmBn; // "egfilmBn" +GTL_EXTERN NSString * const kGTLYouTubeContentRating_EgfilmRating_EgfilmGn; // "egfilmGn" +GTL_EXTERN NSString * const kGTLYouTubeContentRating_EgfilmRating_EgfilmUnrated; // "egfilmUnrated" + +// GTLYouTubeContentRating - EirinRating +GTL_EXTERN NSString * const kGTLYouTubeContentRating_EirinRating_EirinG; // "eirinG" +GTL_EXTERN NSString * const kGTLYouTubeContentRating_EirinRating_EirinPg12; // "eirinPg12" +GTL_EXTERN NSString * const kGTLYouTubeContentRating_EirinRating_EirinR15plus; // "eirinR15plus" +GTL_EXTERN NSString * const kGTLYouTubeContentRating_EirinRating_EirinR18plus; // "eirinR18plus" +GTL_EXTERN NSString * const kGTLYouTubeContentRating_EirinRating_EirinUnrated; // "eirinUnrated" + +// GTLYouTubeContentRating - FcbmRating +GTL_EXTERN NSString * const kGTLYouTubeContentRating_FcbmRating_Fcbm18; // "fcbm18" +GTL_EXTERN NSString * const kGTLYouTubeContentRating_FcbmRating_Fcbm18pa; // "fcbm18pa" +GTL_EXTERN NSString * const kGTLYouTubeContentRating_FcbmRating_Fcbm18pl; // "fcbm18pl" +GTL_EXTERN NSString * const kGTLYouTubeContentRating_FcbmRating_Fcbm18sg; // "fcbm18sg" +GTL_EXTERN NSString * const kGTLYouTubeContentRating_FcbmRating_Fcbm18sx; // "fcbm18sx" +GTL_EXTERN NSString * const kGTLYouTubeContentRating_FcbmRating_FcbmP13; // "fcbmP13" +GTL_EXTERN NSString * const kGTLYouTubeContentRating_FcbmRating_FcbmU; // "fcbmU" +GTL_EXTERN NSString * const kGTLYouTubeContentRating_FcbmRating_FcbmUnrated; // "fcbmUnrated" + +// GTLYouTubeContentRating - FcoRating +GTL_EXTERN NSString * const kGTLYouTubeContentRating_FcoRating_FcoI; // "fcoI" +GTL_EXTERN NSString * const kGTLYouTubeContentRating_FcoRating_FcoIia; // "fcoIia" +GTL_EXTERN NSString * const kGTLYouTubeContentRating_FcoRating_FcoIib; // "fcoIib" +GTL_EXTERN NSString * const kGTLYouTubeContentRating_FcoRating_FcoIii; // "fcoIii" +GTL_EXTERN NSString * const kGTLYouTubeContentRating_FcoRating_FcoUnrated; // "fcoUnrated" + +// GTLYouTubeContentRating - FmocRating +GTL_EXTERN NSString * const kGTLYouTubeContentRating_FmocRating_Fmoc10; // "fmoc10" +GTL_EXTERN NSString * const kGTLYouTubeContentRating_FmocRating_Fmoc12; // "fmoc12" +GTL_EXTERN NSString * const kGTLYouTubeContentRating_FmocRating_Fmoc16; // "fmoc16" +GTL_EXTERN NSString * const kGTLYouTubeContentRating_FmocRating_Fmoc18; // "fmoc18" +GTL_EXTERN NSString * const kGTLYouTubeContentRating_FmocRating_FmocE; // "fmocE" +GTL_EXTERN NSString * const kGTLYouTubeContentRating_FmocRating_FmocU; // "fmocU" +GTL_EXTERN NSString * const kGTLYouTubeContentRating_FmocRating_FmocUnrated; // "fmocUnrated" + +// GTLYouTubeContentRating - FpbRating +GTL_EXTERN NSString * const kGTLYouTubeContentRating_FpbRating_Fpb1012Pg; // "fpb1012Pg" +GTL_EXTERN NSString * const kGTLYouTubeContentRating_FpbRating_Fpb13; // "fpb13" +GTL_EXTERN NSString * const kGTLYouTubeContentRating_FpbRating_Fpb16; // "fpb16" +GTL_EXTERN NSString * const kGTLYouTubeContentRating_FpbRating_Fpb18; // "fpb18" +GTL_EXTERN NSString * const kGTLYouTubeContentRating_FpbRating_Fpb79Pg; // "fpb79Pg" +GTL_EXTERN NSString * const kGTLYouTubeContentRating_FpbRating_FpbA; // "fpbA" +GTL_EXTERN NSString * const kGTLYouTubeContentRating_FpbRating_FpbPg; // "fpbPg" +GTL_EXTERN NSString * const kGTLYouTubeContentRating_FpbRating_FpbUnrated; // "fpbUnrated" +GTL_EXTERN NSString * const kGTLYouTubeContentRating_FpbRating_FpbX18; // "fpbX18" +GTL_EXTERN NSString * const kGTLYouTubeContentRating_FpbRating_FpbXx; // "fpbXx" + +// GTLYouTubeContentRating - FskRating +GTL_EXTERN NSString * const kGTLYouTubeContentRating_FskRating_Fsk0; // "fsk0" +GTL_EXTERN NSString * const kGTLYouTubeContentRating_FskRating_Fsk12; // "fsk12" +GTL_EXTERN NSString * const kGTLYouTubeContentRating_FskRating_Fsk16; // "fsk16" +GTL_EXTERN NSString * const kGTLYouTubeContentRating_FskRating_Fsk18; // "fsk18" +GTL_EXTERN NSString * const kGTLYouTubeContentRating_FskRating_Fsk6; // "fsk6" +GTL_EXTERN NSString * const kGTLYouTubeContentRating_FskRating_FskUnrated; // "fskUnrated" + +// GTLYouTubeContentRating - GrfilmRating +GTL_EXTERN NSString * const kGTLYouTubeContentRating_GrfilmRating_GrfilmE; // "grfilmE" +GTL_EXTERN NSString * const kGTLYouTubeContentRating_GrfilmRating_GrfilmK; // "grfilmK" +GTL_EXTERN NSString * const kGTLYouTubeContentRating_GrfilmRating_GrfilmK13; // "grfilmK13" +GTL_EXTERN NSString * const kGTLYouTubeContentRating_GrfilmRating_GrfilmK17; // "grfilmK17" +GTL_EXTERN NSString * const kGTLYouTubeContentRating_GrfilmRating_GrfilmUnrated; // "grfilmUnrated" + +// GTLYouTubeContentRating - IcaaRating +GTL_EXTERN NSString * const kGTLYouTubeContentRating_IcaaRating_Icaa12; // "icaa12" +GTL_EXTERN NSString * const kGTLYouTubeContentRating_IcaaRating_Icaa13; // "icaa13" +GTL_EXTERN NSString * const kGTLYouTubeContentRating_IcaaRating_Icaa16; // "icaa16" +GTL_EXTERN NSString * const kGTLYouTubeContentRating_IcaaRating_Icaa18; // "icaa18" +GTL_EXTERN NSString * const kGTLYouTubeContentRating_IcaaRating_Icaa7; // "icaa7" +GTL_EXTERN NSString * const kGTLYouTubeContentRating_IcaaRating_IcaaApta; // "icaaApta" +GTL_EXTERN NSString * const kGTLYouTubeContentRating_IcaaRating_IcaaUnrated; // "icaaUnrated" +GTL_EXTERN NSString * const kGTLYouTubeContentRating_IcaaRating_IcaaX; // "icaaX" + +// GTLYouTubeContentRating - IfcoRating +GTL_EXTERN NSString * const kGTLYouTubeContentRating_IfcoRating_Ifco12; // "ifco12" +GTL_EXTERN NSString * const kGTLYouTubeContentRating_IfcoRating_Ifco15; // "ifco15" +GTL_EXTERN NSString * const kGTLYouTubeContentRating_IfcoRating_Ifco18; // "ifco18" +GTL_EXTERN NSString * const kGTLYouTubeContentRating_IfcoRating_IfcoG; // "ifcoG" +GTL_EXTERN NSString * const kGTLYouTubeContentRating_IfcoRating_IfcoPg; // "ifcoPg" +GTL_EXTERN NSString * const kGTLYouTubeContentRating_IfcoRating_IfcoUnrated; // "ifcoUnrated" + +// GTLYouTubeContentRating - IlfilmRating +GTL_EXTERN NSString * const kGTLYouTubeContentRating_IlfilmRating_Ilfilm12; // "ilfilm12" +GTL_EXTERN NSString * const kGTLYouTubeContentRating_IlfilmRating_Ilfilm16; // "ilfilm16" +GTL_EXTERN NSString * const kGTLYouTubeContentRating_IlfilmRating_Ilfilm18; // "ilfilm18" +GTL_EXTERN NSString * const kGTLYouTubeContentRating_IlfilmRating_IlfilmAa; // "ilfilmAa" +GTL_EXTERN NSString * const kGTLYouTubeContentRating_IlfilmRating_IlfilmUnrated; // "ilfilmUnrated" + +// GTLYouTubeContentRating - IncaaRating +GTL_EXTERN NSString * const kGTLYouTubeContentRating_IncaaRating_IncaaAtp; // "incaaAtp" +GTL_EXTERN NSString * const kGTLYouTubeContentRating_IncaaRating_IncaaC; // "incaaC" +GTL_EXTERN NSString * const kGTLYouTubeContentRating_IncaaRating_IncaaSam13; // "incaaSam13" +GTL_EXTERN NSString * const kGTLYouTubeContentRating_IncaaRating_IncaaSam16; // "incaaSam16" +GTL_EXTERN NSString * const kGTLYouTubeContentRating_IncaaRating_IncaaSam18; // "incaaSam18" +GTL_EXTERN NSString * const kGTLYouTubeContentRating_IncaaRating_IncaaUnrated; // "incaaUnrated" + +// GTLYouTubeContentRating - KfcbRating +GTL_EXTERN NSString * const kGTLYouTubeContentRating_KfcbRating_Kfcb16plus; // "kfcb16plus" +GTL_EXTERN NSString * const kGTLYouTubeContentRating_KfcbRating_KfcbG; // "kfcbG" +GTL_EXTERN NSString * const kGTLYouTubeContentRating_KfcbRating_KfcbPg; // "kfcbPg" +GTL_EXTERN NSString * const kGTLYouTubeContentRating_KfcbRating_KfcbR; // "kfcbR" +GTL_EXTERN NSString * const kGTLYouTubeContentRating_KfcbRating_KfcbUnrated; // "kfcbUnrated" + +// GTLYouTubeContentRating - KijkwijzerRating +GTL_EXTERN NSString * const kGTLYouTubeContentRating_KijkwijzerRating_Kijkwijzer12; // "kijkwijzer12" +GTL_EXTERN NSString * const kGTLYouTubeContentRating_KijkwijzerRating_Kijkwijzer16; // "kijkwijzer16" +GTL_EXTERN NSString * const kGTLYouTubeContentRating_KijkwijzerRating_Kijkwijzer6; // "kijkwijzer6" +GTL_EXTERN NSString * const kGTLYouTubeContentRating_KijkwijzerRating_Kijkwijzer9; // "kijkwijzer9" +GTL_EXTERN NSString * const kGTLYouTubeContentRating_KijkwijzerRating_KijkwijzerAl; // "kijkwijzerAl" +GTL_EXTERN NSString * const kGTLYouTubeContentRating_KijkwijzerRating_KijkwijzerUnrated; // "kijkwijzerUnrated" + +// GTLYouTubeContentRating - KmrbRating +GTL_EXTERN NSString * const kGTLYouTubeContentRating_KmrbRating_Kmrb12plus; // "kmrb12plus" +GTL_EXTERN NSString * const kGTLYouTubeContentRating_KmrbRating_Kmrb15plus; // "kmrb15plus" +GTL_EXTERN NSString * const kGTLYouTubeContentRating_KmrbRating_KmrbAll; // "kmrbAll" +GTL_EXTERN NSString * const kGTLYouTubeContentRating_KmrbRating_KmrbR; // "kmrbR" +GTL_EXTERN NSString * const kGTLYouTubeContentRating_KmrbRating_KmrbTeenr; // "kmrbTeenr" +GTL_EXTERN NSString * const kGTLYouTubeContentRating_KmrbRating_KmrbUnrated; // "kmrbUnrated" + +// GTLYouTubeContentRating - LsfRating +GTL_EXTERN NSString * const kGTLYouTubeContentRating_LsfRating_LsfA; // "lsfA" +GTL_EXTERN NSString * const kGTLYouTubeContentRating_LsfRating_LsfBo; // "lsfBo" +GTL_EXTERN NSString * const kGTLYouTubeContentRating_LsfRating_LsfD; // "lsfD" +GTL_EXTERN NSString * const kGTLYouTubeContentRating_LsfRating_LsfR; // "lsfR" +GTL_EXTERN NSString * const kGTLYouTubeContentRating_LsfRating_LsfSu; // "lsfSu" +GTL_EXTERN NSString * const kGTLYouTubeContentRating_LsfRating_LsfUnrated; // "lsfUnrated" + +// GTLYouTubeContentRating - MccaaRating +GTL_EXTERN NSString * const kGTLYouTubeContentRating_MccaaRating_Mccaa12; // "mccaa12" +GTL_EXTERN NSString * const kGTLYouTubeContentRating_MccaaRating_Mccaa12a; // "mccaa12a" +GTL_EXTERN NSString * const kGTLYouTubeContentRating_MccaaRating_Mccaa14; // "mccaa14" +GTL_EXTERN NSString * const kGTLYouTubeContentRating_MccaaRating_Mccaa15; // "mccaa15" +GTL_EXTERN NSString * const kGTLYouTubeContentRating_MccaaRating_Mccaa16; // "mccaa16" +GTL_EXTERN NSString * const kGTLYouTubeContentRating_MccaaRating_Mccaa18; // "mccaa18" +GTL_EXTERN NSString * const kGTLYouTubeContentRating_MccaaRating_MccaaPg; // "mccaaPg" +GTL_EXTERN NSString * const kGTLYouTubeContentRating_MccaaRating_MccaaU; // "mccaaU" +GTL_EXTERN NSString * const kGTLYouTubeContentRating_MccaaRating_MccaaUnrated; // "mccaaUnrated" + +// GTLYouTubeContentRating - MccypRating +GTL_EXTERN NSString * const kGTLYouTubeContentRating_MccypRating_Mccyp11; // "mccyp11" +GTL_EXTERN NSString * const kGTLYouTubeContentRating_MccypRating_Mccyp15; // "mccyp15" +GTL_EXTERN NSString * const kGTLYouTubeContentRating_MccypRating_Mccyp7; // "mccyp7" +GTL_EXTERN NSString * const kGTLYouTubeContentRating_MccypRating_MccypA; // "mccypA" +GTL_EXTERN NSString * const kGTLYouTubeContentRating_MccypRating_MccypUnrated; // "mccypUnrated" + +// GTLYouTubeContentRating - MdaRating +GTL_EXTERN NSString * const kGTLYouTubeContentRating_MdaRating_MdaG; // "mdaG" +GTL_EXTERN NSString * const kGTLYouTubeContentRating_MdaRating_MdaM18; // "mdaM18" +GTL_EXTERN NSString * const kGTLYouTubeContentRating_MdaRating_MdaNc16; // "mdaNc16" +GTL_EXTERN NSString * const kGTLYouTubeContentRating_MdaRating_MdaPg; // "mdaPg" +GTL_EXTERN NSString * const kGTLYouTubeContentRating_MdaRating_MdaPg13; // "mdaPg13" +GTL_EXTERN NSString * const kGTLYouTubeContentRating_MdaRating_MdaR21; // "mdaR21" +GTL_EXTERN NSString * const kGTLYouTubeContentRating_MdaRating_MdaUnrated; // "mdaUnrated" + +// GTLYouTubeContentRating - MedietilsynetRating +GTL_EXTERN NSString * const kGTLYouTubeContentRating_MedietilsynetRating_Medietilsynet11; // "medietilsynet11" +GTL_EXTERN NSString * const kGTLYouTubeContentRating_MedietilsynetRating_Medietilsynet15; // "medietilsynet15" +GTL_EXTERN NSString * const kGTLYouTubeContentRating_MedietilsynetRating_Medietilsynet18; // "medietilsynet18" +GTL_EXTERN NSString * const kGTLYouTubeContentRating_MedietilsynetRating_Medietilsynet7; // "medietilsynet7" +GTL_EXTERN NSString * const kGTLYouTubeContentRating_MedietilsynetRating_MedietilsynetA; // "medietilsynetA" +GTL_EXTERN NSString * const kGTLYouTubeContentRating_MedietilsynetRating_MedietilsynetUnrated; // "medietilsynetUnrated" + +// GTLYouTubeContentRating - MekuRating +GTL_EXTERN NSString * const kGTLYouTubeContentRating_MekuRating_Meku12; // "meku12" +GTL_EXTERN NSString * const kGTLYouTubeContentRating_MekuRating_Meku16; // "meku16" +GTL_EXTERN NSString * const kGTLYouTubeContentRating_MekuRating_Meku18; // "meku18" +GTL_EXTERN NSString * const kGTLYouTubeContentRating_MekuRating_Meku7; // "meku7" +GTL_EXTERN NSString * const kGTLYouTubeContentRating_MekuRating_MekuS; // "mekuS" +GTL_EXTERN NSString * const kGTLYouTubeContentRating_MekuRating_MekuUnrated; // "mekuUnrated" + +// GTLYouTubeContentRating - MibacRating +GTL_EXTERN NSString * const kGTLYouTubeContentRating_MibacRating_MibacT; // "mibacT" +GTL_EXTERN NSString * const kGTLYouTubeContentRating_MibacRating_MibacUnrated; // "mibacUnrated" +GTL_EXTERN NSString * const kGTLYouTubeContentRating_MibacRating_MibacVap; // "mibacVap" +GTL_EXTERN NSString * const kGTLYouTubeContentRating_MibacRating_MibacVm12; // "mibacVm12" +GTL_EXTERN NSString * const kGTLYouTubeContentRating_MibacRating_MibacVm14; // "mibacVm14" +GTL_EXTERN NSString * const kGTLYouTubeContentRating_MibacRating_MibacVm18; // "mibacVm18" + +// GTLYouTubeContentRating - MocRating +GTL_EXTERN NSString * const kGTLYouTubeContentRating_MocRating_Moc12; // "moc12" +GTL_EXTERN NSString * const kGTLYouTubeContentRating_MocRating_Moc15; // "moc15" +GTL_EXTERN NSString * const kGTLYouTubeContentRating_MocRating_Moc18; // "moc18" +GTL_EXTERN NSString * const kGTLYouTubeContentRating_MocRating_Moc7; // "moc7" +GTL_EXTERN NSString * const kGTLYouTubeContentRating_MocRating_MocBanned; // "mocBanned" +GTL_EXTERN NSString * const kGTLYouTubeContentRating_MocRating_MocE; // "mocE" +GTL_EXTERN NSString * const kGTLYouTubeContentRating_MocRating_MocT; // "mocT" +GTL_EXTERN NSString * const kGTLYouTubeContentRating_MocRating_MocUnrated; // "mocUnrated" +GTL_EXTERN NSString * const kGTLYouTubeContentRating_MocRating_MocX; // "mocX" + +// GTLYouTubeContentRating - MoctwRating +GTL_EXTERN NSString * const kGTLYouTubeContentRating_MoctwRating_MoctwG; // "moctwG" +GTL_EXTERN NSString * const kGTLYouTubeContentRating_MoctwRating_MoctwP; // "moctwP" +GTL_EXTERN NSString * const kGTLYouTubeContentRating_MoctwRating_MoctwPg; // "moctwPg" +GTL_EXTERN NSString * const kGTLYouTubeContentRating_MoctwRating_MoctwR; // "moctwR" +GTL_EXTERN NSString * const kGTLYouTubeContentRating_MoctwRating_MoctwUnrated; // "moctwUnrated" + +// GTLYouTubeContentRating - MpaaRating +GTL_EXTERN NSString * const kGTLYouTubeContentRating_MpaaRating_MpaaG; // "mpaaG" +GTL_EXTERN NSString * const kGTLYouTubeContentRating_MpaaRating_MpaaNc17; // "mpaaNc17" +GTL_EXTERN NSString * const kGTLYouTubeContentRating_MpaaRating_MpaaPg; // "mpaaPg" +GTL_EXTERN NSString * const kGTLYouTubeContentRating_MpaaRating_MpaaPg13; // "mpaaPg13" +GTL_EXTERN NSString * const kGTLYouTubeContentRating_MpaaRating_MpaaR; // "mpaaR" +GTL_EXTERN NSString * const kGTLYouTubeContentRating_MpaaRating_MpaaUnrated; // "mpaaUnrated" + +// GTLYouTubeContentRating - MtrcbRating +GTL_EXTERN NSString * const kGTLYouTubeContentRating_MtrcbRating_MtrcbG; // "mtrcbG" +GTL_EXTERN NSString * const kGTLYouTubeContentRating_MtrcbRating_MtrcbPg; // "mtrcbPg" +GTL_EXTERN NSString * const kGTLYouTubeContentRating_MtrcbRating_MtrcbR13; // "mtrcbR13" +GTL_EXTERN NSString * const kGTLYouTubeContentRating_MtrcbRating_MtrcbR16; // "mtrcbR16" +GTL_EXTERN NSString * const kGTLYouTubeContentRating_MtrcbRating_MtrcbR18; // "mtrcbR18" +GTL_EXTERN NSString * const kGTLYouTubeContentRating_MtrcbRating_MtrcbUnrated; // "mtrcbUnrated" +GTL_EXTERN NSString * const kGTLYouTubeContentRating_MtrcbRating_MtrcbX; // "mtrcbX" + +// GTLYouTubeContentRating - NbcplRating +GTL_EXTERN NSString * const kGTLYouTubeContentRating_NbcplRating_Nbcpl18plus; // "nbcpl18plus" +GTL_EXTERN NSString * const kGTLYouTubeContentRating_NbcplRating_NbcplI; // "nbcplI" +GTL_EXTERN NSString * const kGTLYouTubeContentRating_NbcplRating_NbcplIi; // "nbcplIi" +GTL_EXTERN NSString * const kGTLYouTubeContentRating_NbcplRating_NbcplIii; // "nbcplIii" +GTL_EXTERN NSString * const kGTLYouTubeContentRating_NbcplRating_NbcplIv; // "nbcplIv" +GTL_EXTERN NSString * const kGTLYouTubeContentRating_NbcplRating_NbcplUnrated; // "nbcplUnrated" + +// GTLYouTubeContentRating - NbcRating +GTL_EXTERN NSString * const kGTLYouTubeContentRating_NbcRating_Nbc12plus; // "nbc12plus" +GTL_EXTERN NSString * const kGTLYouTubeContentRating_NbcRating_Nbc15plus; // "nbc15plus" +GTL_EXTERN NSString * const kGTLYouTubeContentRating_NbcRating_Nbc18plus; // "nbc18plus" +GTL_EXTERN NSString * const kGTLYouTubeContentRating_NbcRating_Nbc18plusr; // "nbc18plusr" +GTL_EXTERN NSString * const kGTLYouTubeContentRating_NbcRating_NbcG; // "nbcG" +GTL_EXTERN NSString * const kGTLYouTubeContentRating_NbcRating_NbcPg; // "nbcPg" +GTL_EXTERN NSString * const kGTLYouTubeContentRating_NbcRating_NbcPu; // "nbcPu" +GTL_EXTERN NSString * const kGTLYouTubeContentRating_NbcRating_NbcUnrated; // "nbcUnrated" + +// GTLYouTubeContentRating - NfrcRating +GTL_EXTERN NSString * const kGTLYouTubeContentRating_NfrcRating_NfrcA; // "nfrcA" +GTL_EXTERN NSString * const kGTLYouTubeContentRating_NfrcRating_NfrcB; // "nfrcB" +GTL_EXTERN NSString * const kGTLYouTubeContentRating_NfrcRating_NfrcC; // "nfrcC" +GTL_EXTERN NSString * const kGTLYouTubeContentRating_NfrcRating_NfrcD; // "nfrcD" +GTL_EXTERN NSString * const kGTLYouTubeContentRating_NfrcRating_NfrcUnrated; // "nfrcUnrated" +GTL_EXTERN NSString * const kGTLYouTubeContentRating_NfrcRating_NfrcX; // "nfrcX" + +// GTLYouTubeContentRating - NfvcbRating +GTL_EXTERN NSString * const kGTLYouTubeContentRating_NfvcbRating_Nfvcb12; // "nfvcb12" +GTL_EXTERN NSString * const kGTLYouTubeContentRating_NfvcbRating_Nfvcb12a; // "nfvcb12a" +GTL_EXTERN NSString * const kGTLYouTubeContentRating_NfvcbRating_Nfvcb15; // "nfvcb15" +GTL_EXTERN NSString * const kGTLYouTubeContentRating_NfvcbRating_Nfvcb18; // "nfvcb18" +GTL_EXTERN NSString * const kGTLYouTubeContentRating_NfvcbRating_NfvcbG; // "nfvcbG" +GTL_EXTERN NSString * const kGTLYouTubeContentRating_NfvcbRating_NfvcbPg; // "nfvcbPg" +GTL_EXTERN NSString * const kGTLYouTubeContentRating_NfvcbRating_NfvcbRe; // "nfvcbRe" +GTL_EXTERN NSString * const kGTLYouTubeContentRating_NfvcbRating_NfvcbUnrated; // "nfvcbUnrated" + +// GTLYouTubeContentRating - NkclvRating +GTL_EXTERN NSString * const kGTLYouTubeContentRating_NkclvRating_Nkclv12plus; // "nkclv12plus" +GTL_EXTERN NSString * const kGTLYouTubeContentRating_NkclvRating_Nkclv18plus; // "nkclv18plus" +GTL_EXTERN NSString * const kGTLYouTubeContentRating_NkclvRating_Nkclv7plus; // "nkclv7plus" +GTL_EXTERN NSString * const kGTLYouTubeContentRating_NkclvRating_NkclvU; // "nkclvU" +GTL_EXTERN NSString * const kGTLYouTubeContentRating_NkclvRating_NkclvUnrated; // "nkclvUnrated" + +// GTLYouTubeContentRating - OflcRating +GTL_EXTERN NSString * const kGTLYouTubeContentRating_OflcRating_OflcG; // "oflcG" +GTL_EXTERN NSString * const kGTLYouTubeContentRating_OflcRating_OflcM; // "oflcM" +GTL_EXTERN NSString * const kGTLYouTubeContentRating_OflcRating_OflcPg; // "oflcPg" +GTL_EXTERN NSString * const kGTLYouTubeContentRating_OflcRating_OflcR13; // "oflcR13" +GTL_EXTERN NSString * const kGTLYouTubeContentRating_OflcRating_OflcR15; // "oflcR15" +GTL_EXTERN NSString * const kGTLYouTubeContentRating_OflcRating_OflcR16; // "oflcR16" +GTL_EXTERN NSString * const kGTLYouTubeContentRating_OflcRating_OflcR18; // "oflcR18" +GTL_EXTERN NSString * const kGTLYouTubeContentRating_OflcRating_OflcRp13; // "oflcRp13" +GTL_EXTERN NSString * const kGTLYouTubeContentRating_OflcRating_OflcRp16; // "oflcRp16" +GTL_EXTERN NSString * const kGTLYouTubeContentRating_OflcRating_OflcUnrated; // "oflcUnrated" + +// GTLYouTubeContentRating - PefilmRating +GTL_EXTERN NSString * const kGTLYouTubeContentRating_PefilmRating_Pefilm14; // "pefilm14" +GTL_EXTERN NSString * const kGTLYouTubeContentRating_PefilmRating_Pefilm18; // "pefilm18" +GTL_EXTERN NSString * const kGTLYouTubeContentRating_PefilmRating_PefilmPg; // "pefilmPg" +GTL_EXTERN NSString * const kGTLYouTubeContentRating_PefilmRating_PefilmPt; // "pefilmPt" +GTL_EXTERN NSString * const kGTLYouTubeContentRating_PefilmRating_PefilmUnrated; // "pefilmUnrated" + +// GTLYouTubeContentRating - RcnofRating +GTL_EXTERN NSString * const kGTLYouTubeContentRating_RcnofRating_RcnofI; // "rcnofI" +GTL_EXTERN NSString * const kGTLYouTubeContentRating_RcnofRating_RcnofIi; // "rcnofIi" +GTL_EXTERN NSString * const kGTLYouTubeContentRating_RcnofRating_RcnofIii; // "rcnofIii" +GTL_EXTERN NSString * const kGTLYouTubeContentRating_RcnofRating_RcnofIv; // "rcnofIv" +GTL_EXTERN NSString * const kGTLYouTubeContentRating_RcnofRating_RcnofUnrated; // "rcnofUnrated" +GTL_EXTERN NSString * const kGTLYouTubeContentRating_RcnofRating_RcnofV; // "rcnofV" +GTL_EXTERN NSString * const kGTLYouTubeContentRating_RcnofRating_RcnofVi; // "rcnofVi" + +// GTLYouTubeContentRating - ResorteviolenciaRating +GTL_EXTERN NSString * const kGTLYouTubeContentRating_ResorteviolenciaRating_ResorteviolenciaA; // "resorteviolenciaA" +GTL_EXTERN NSString * const kGTLYouTubeContentRating_ResorteviolenciaRating_ResorteviolenciaB; // "resorteviolenciaB" +GTL_EXTERN NSString * const kGTLYouTubeContentRating_ResorteviolenciaRating_ResorteviolenciaC; // "resorteviolenciaC" +GTL_EXTERN NSString * const kGTLYouTubeContentRating_ResorteviolenciaRating_ResorteviolenciaD; // "resorteviolenciaD" +GTL_EXTERN NSString * const kGTLYouTubeContentRating_ResorteviolenciaRating_ResorteviolenciaE; // "resorteviolenciaE" +GTL_EXTERN NSString * const kGTLYouTubeContentRating_ResorteviolenciaRating_ResorteviolenciaUnrated; // "resorteviolenciaUnrated" + +// GTLYouTubeContentRating - RtcRating +GTL_EXTERN NSString * const kGTLYouTubeContentRating_RtcRating_RtcA; // "rtcA" +GTL_EXTERN NSString * const kGTLYouTubeContentRating_RtcRating_RtcAa; // "rtcAa" +GTL_EXTERN NSString * const kGTLYouTubeContentRating_RtcRating_RtcB; // "rtcB" +GTL_EXTERN NSString * const kGTLYouTubeContentRating_RtcRating_RtcB15; // "rtcB15" +GTL_EXTERN NSString * const kGTLYouTubeContentRating_RtcRating_RtcC; // "rtcC" +GTL_EXTERN NSString * const kGTLYouTubeContentRating_RtcRating_RtcD; // "rtcD" +GTL_EXTERN NSString * const kGTLYouTubeContentRating_RtcRating_RtcUnrated; // "rtcUnrated" + +// GTLYouTubeContentRating - RteRating +GTL_EXTERN NSString * const kGTLYouTubeContentRating_RteRating_RteCh; // "rteCh" +GTL_EXTERN NSString * const kGTLYouTubeContentRating_RteRating_RteGa; // "rteGa" +GTL_EXTERN NSString * const kGTLYouTubeContentRating_RteRating_RteMa; // "rteMa" +GTL_EXTERN NSString * const kGTLYouTubeContentRating_RteRating_RtePs; // "rtePs" +GTL_EXTERN NSString * const kGTLYouTubeContentRating_RteRating_RteUnrated; // "rteUnrated" + +// GTLYouTubeContentRating - RussiaRating +GTL_EXTERN NSString * const kGTLYouTubeContentRating_RussiaRating_Russia0; // "russia0" +GTL_EXTERN NSString * const kGTLYouTubeContentRating_RussiaRating_Russia12; // "russia12" +GTL_EXTERN NSString * const kGTLYouTubeContentRating_RussiaRating_Russia16; // "russia16" +GTL_EXTERN NSString * const kGTLYouTubeContentRating_RussiaRating_Russia18; // "russia18" +GTL_EXTERN NSString * const kGTLYouTubeContentRating_RussiaRating_Russia6; // "russia6" +GTL_EXTERN NSString * const kGTLYouTubeContentRating_RussiaRating_RussiaUnrated; // "russiaUnrated" + +// GTLYouTubeContentRating - SkfilmRating +GTL_EXTERN NSString * const kGTLYouTubeContentRating_SkfilmRating_SkfilmG; // "skfilmG" +GTL_EXTERN NSString * const kGTLYouTubeContentRating_SkfilmRating_SkfilmP2; // "skfilmP2" +GTL_EXTERN NSString * const kGTLYouTubeContentRating_SkfilmRating_SkfilmP5; // "skfilmP5" +GTL_EXTERN NSString * const kGTLYouTubeContentRating_SkfilmRating_SkfilmP8; // "skfilmP8" +GTL_EXTERN NSString * const kGTLYouTubeContentRating_SkfilmRating_SkfilmUnrated; // "skfilmUnrated" + +// GTLYouTubeContentRating - SmaisRating +GTL_EXTERN NSString * const kGTLYouTubeContentRating_SmaisRating_Smais12; // "smais12" +GTL_EXTERN NSString * const kGTLYouTubeContentRating_SmaisRating_Smais14; // "smais14" +GTL_EXTERN NSString * const kGTLYouTubeContentRating_SmaisRating_Smais16; // "smais16" +GTL_EXTERN NSString * const kGTLYouTubeContentRating_SmaisRating_Smais18; // "smais18" +GTL_EXTERN NSString * const kGTLYouTubeContentRating_SmaisRating_Smais7; // "smais7" +GTL_EXTERN NSString * const kGTLYouTubeContentRating_SmaisRating_SmaisL; // "smaisL" +GTL_EXTERN NSString * const kGTLYouTubeContentRating_SmaisRating_SmaisUnrated; // "smaisUnrated" + +// GTLYouTubeContentRating - SmsaRating +GTL_EXTERN NSString * const kGTLYouTubeContentRating_SmsaRating_Smsa11; // "smsa11" +GTL_EXTERN NSString * const kGTLYouTubeContentRating_SmsaRating_Smsa15; // "smsa15" +GTL_EXTERN NSString * const kGTLYouTubeContentRating_SmsaRating_Smsa7; // "smsa7" +GTL_EXTERN NSString * const kGTLYouTubeContentRating_SmsaRating_SmsaA; // "smsaA" +GTL_EXTERN NSString * const kGTLYouTubeContentRating_SmsaRating_SmsaUnrated; // "smsaUnrated" + +// GTLYouTubeContentRating - TvpgRating +GTL_EXTERN NSString * const kGTLYouTubeContentRating_TvpgRating_Pg14; // "pg14" +GTL_EXTERN NSString * const kGTLYouTubeContentRating_TvpgRating_TvpgG; // "tvpgG" +GTL_EXTERN NSString * const kGTLYouTubeContentRating_TvpgRating_TvpgMa; // "tvpgMa" +GTL_EXTERN NSString * const kGTLYouTubeContentRating_TvpgRating_TvpgPg; // "tvpgPg" +GTL_EXTERN NSString * const kGTLYouTubeContentRating_TvpgRating_TvpgUnrated; // "tvpgUnrated" +GTL_EXTERN NSString * const kGTLYouTubeContentRating_TvpgRating_TvpgY; // "tvpgY" +GTL_EXTERN NSString * const kGTLYouTubeContentRating_TvpgRating_TvpgY7; // "tvpgY7" +GTL_EXTERN NSString * const kGTLYouTubeContentRating_TvpgRating_TvpgY7Fv; // "tvpgY7Fv" + +// GTLYouTubeContentRating - YtRating +GTL_EXTERN NSString * const kGTLYouTubeContentRating_YtRating_YtAgeRestricted; // "ytAgeRestricted" + +// GTLYouTubeInvideoPosition - CornerPosition +GTL_EXTERN NSString * const kGTLYouTubeInvideoPosition_CornerPosition_BottomLeft; // "bottomLeft" +GTL_EXTERN NSString * const kGTLYouTubeInvideoPosition_CornerPosition_BottomRight; // "bottomRight" +GTL_EXTERN NSString * const kGTLYouTubeInvideoPosition_CornerPosition_TopLeft; // "topLeft" +GTL_EXTERN NSString * const kGTLYouTubeInvideoPosition_CornerPosition_TopRight; // "topRight" + +// GTLYouTubeInvideoPosition - Type +GTL_EXTERN NSString * const kGTLYouTubeInvideoPosition_Type_Corner; // "corner" + +// GTLYouTubeInvideoTiming - Type +GTL_EXTERN NSString * const kGTLYouTubeInvideoTiming_Type_OffsetFromEnd; // "offsetFromEnd" +GTL_EXTERN NSString * const kGTLYouTubeInvideoTiming_Type_OffsetFromStart; // "offsetFromStart" + +// GTLYouTubeLiveBroadcastStatus - LifeCycleStatus +GTL_EXTERN NSString * const kGTLYouTubeLiveBroadcastStatus_LifeCycleStatus_Abandoned; // "abandoned" +GTL_EXTERN NSString * const kGTLYouTubeLiveBroadcastStatus_LifeCycleStatus_Complete; // "complete" +GTL_EXTERN NSString * const kGTLYouTubeLiveBroadcastStatus_LifeCycleStatus_CompleteStarting; // "completeStarting" +GTL_EXTERN NSString * const kGTLYouTubeLiveBroadcastStatus_LifeCycleStatus_Created; // "created" +GTL_EXTERN NSString * const kGTLYouTubeLiveBroadcastStatus_LifeCycleStatus_Live; // "live" +GTL_EXTERN NSString * const kGTLYouTubeLiveBroadcastStatus_LifeCycleStatus_LiveStarting; // "liveStarting" +GTL_EXTERN NSString * const kGTLYouTubeLiveBroadcastStatus_LifeCycleStatus_Ready; // "ready" +GTL_EXTERN NSString * const kGTLYouTubeLiveBroadcastStatus_LifeCycleStatus_Reclaimed; // "reclaimed" +GTL_EXTERN NSString * const kGTLYouTubeLiveBroadcastStatus_LifeCycleStatus_Revoked; // "revoked" +GTL_EXTERN NSString * const kGTLYouTubeLiveBroadcastStatus_LifeCycleStatus_Testing; // "testing" +GTL_EXTERN NSString * const kGTLYouTubeLiveBroadcastStatus_LifeCycleStatus_TestStarting; // "testStarting" + +// GTLYouTubeLiveBroadcastStatus - LiveBroadcastPriority +GTL_EXTERN NSString * const kGTLYouTubeLiveBroadcastStatus_LiveBroadcastPriority_High; // "high" +GTL_EXTERN NSString * const kGTLYouTubeLiveBroadcastStatus_LiveBroadcastPriority_Low; // "low" +GTL_EXTERN NSString * const kGTLYouTubeLiveBroadcastStatus_LiveBroadcastPriority_Normal; // "normal" + +// GTLYouTubeLiveBroadcastStatus - PrivacyStatus +GTL_EXTERN NSString * const kGTLYouTubeLiveBroadcastStatus_PrivacyStatus_Private; // "private" +GTL_EXTERN NSString * const kGTLYouTubeLiveBroadcastStatus_PrivacyStatus_Public; // "public" +GTL_EXTERN NSString * const kGTLYouTubeLiveBroadcastStatus_PrivacyStatus_Unlisted; // "unlisted" + +// GTLYouTubeLiveBroadcastStatus - RecordingStatus +GTL_EXTERN NSString * const kGTLYouTubeLiveBroadcastStatus_RecordingStatus_NotRecording; // "notRecording" +GTL_EXTERN NSString * const kGTLYouTubeLiveBroadcastStatus_RecordingStatus_Recorded; // "recorded" +GTL_EXTERN NSString * const kGTLYouTubeLiveBroadcastStatus_RecordingStatus_Recording; // "recording" + +// GTLYouTubeLiveStreamStatus - StreamStatus +GTL_EXTERN NSString * const kGTLYouTubeLiveStreamStatus_StreamStatus_Active; // "active" +GTL_EXTERN NSString * const kGTLYouTubeLiveStreamStatus_StreamStatus_Created; // "created" +GTL_EXTERN NSString * const kGTLYouTubeLiveStreamStatus_StreamStatus_Error; // "error" +GTL_EXTERN NSString * const kGTLYouTubeLiveStreamStatus_StreamStatus_Inactive; // "inactive" +GTL_EXTERN NSString * const kGTLYouTubeLiveStreamStatus_StreamStatus_Ready; // "ready" + +// GTLYouTubePlaylistItemStatus - PrivacyStatus +GTL_EXTERN NSString * const kGTLYouTubePlaylistItemStatus_PrivacyStatus_Private; // "private" +GTL_EXTERN NSString * const kGTLYouTubePlaylistItemStatus_PrivacyStatus_Public; // "public" +GTL_EXTERN NSString * const kGTLYouTubePlaylistItemStatus_PrivacyStatus_Unlisted; // "unlisted" + +// GTLYouTubePlaylistStatus - PrivacyStatus +GTL_EXTERN NSString * const kGTLYouTubePlaylistStatus_PrivacyStatus_Private; // "private" +GTL_EXTERN NSString * const kGTLYouTubePlaylistStatus_PrivacyStatus_Public; // "public" +GTL_EXTERN NSString * const kGTLYouTubePlaylistStatus_PrivacyStatus_Unlisted; // "unlisted" + +// GTLYouTubePromotedItemId - Type +GTL_EXTERN NSString * const kGTLYouTubePromotedItemId_Type_RecentUpload; // "recentUpload" +GTL_EXTERN NSString * const kGTLYouTubePromotedItemId_Type_Video; // "video" +GTL_EXTERN NSString * const kGTLYouTubePromotedItemId_Type_Website; // "website" + +// GTLYouTubeSearchResultSnippet - LiveBroadcastContent +GTL_EXTERN NSString * const kGTLYouTubeSearchResultSnippet_LiveBroadcastContent_Live; // "live" +GTL_EXTERN NSString * const kGTLYouTubeSearchResultSnippet_LiveBroadcastContent_None; // "none" +GTL_EXTERN NSString * const kGTLYouTubeSearchResultSnippet_LiveBroadcastContent_Upcoming; // "upcoming" + +// GTLYouTubeSubscriptionContentDetails - ActivityType +GTL_EXTERN NSString * const kGTLYouTubeSubscriptionContentDetails_ActivityType_All; // "all" +GTL_EXTERN NSString * const kGTLYouTubeSubscriptionContentDetails_ActivityType_Uploads; // "uploads" + +// GTLYouTubeVideoAgeGating - VideoGameRating +GTL_EXTERN NSString * const kGTLYouTubeVideoAgeGating_VideoGameRating_Anyone; // "anyone" +GTL_EXTERN NSString * const kGTLYouTubeVideoAgeGating_VideoGameRating_M15Plus; // "m15Plus" +GTL_EXTERN NSString * const kGTLYouTubeVideoAgeGating_VideoGameRating_M16Plus; // "m16Plus" +GTL_EXTERN NSString * const kGTLYouTubeVideoAgeGating_VideoGameRating_M17Plus; // "m17Plus" + +// GTLYouTubeVideoContentDetails - Caption +GTL_EXTERN NSString * const kGTLYouTubeVideoContentDetails_Caption_False; // "false" +GTL_EXTERN NSString * const kGTLYouTubeVideoContentDetails_Caption_True; // "true" + +// GTLYouTubeVideoContentDetails - Definition +GTL_EXTERN NSString * const kGTLYouTubeVideoContentDetails_Definition_Hd; // "hd" +GTL_EXTERN NSString * const kGTLYouTubeVideoContentDetails_Definition_Sd; // "sd" + +// GTLYouTubeVideoConversionPing - Context +GTL_EXTERN NSString * const kGTLYouTubeVideoConversionPing_Context_Comment; // "comment" +GTL_EXTERN NSString * const kGTLYouTubeVideoConversionPing_Context_Dislike; // "dislike" +GTL_EXTERN NSString * const kGTLYouTubeVideoConversionPing_Context_Like; // "like" +GTL_EXTERN NSString * const kGTLYouTubeVideoConversionPing_Context_Share; // "share" + +// GTLYouTubeVideoFileDetails - FileType +GTL_EXTERN NSString * const kGTLYouTubeVideoFileDetails_FileType_Archive; // "archive" +GTL_EXTERN NSString * const kGTLYouTubeVideoFileDetails_FileType_Audio; // "audio" +GTL_EXTERN NSString * const kGTLYouTubeVideoFileDetails_FileType_Document; // "document" +GTL_EXTERN NSString * const kGTLYouTubeVideoFileDetails_FileType_Image; // "image" +GTL_EXTERN NSString * const kGTLYouTubeVideoFileDetails_FileType_Other; // "other" +GTL_EXTERN NSString * const kGTLYouTubeVideoFileDetails_FileType_Project; // "project" +GTL_EXTERN NSString * const kGTLYouTubeVideoFileDetails_FileType_Video; // "video" + +// GTLYouTubeVideoFileDetailsVideoStream - Rotation +GTL_EXTERN NSString * const kGTLYouTubeVideoFileDetailsVideoStream_Rotation_Clockwise; // "clockwise" +GTL_EXTERN NSString * const kGTLYouTubeVideoFileDetailsVideoStream_Rotation_CounterClockwise; // "counterClockwise" +GTL_EXTERN NSString * const kGTLYouTubeVideoFileDetailsVideoStream_Rotation_None; // "none" +GTL_EXTERN NSString * const kGTLYouTubeVideoFileDetailsVideoStream_Rotation_Other; // "other" +GTL_EXTERN NSString * const kGTLYouTubeVideoFileDetailsVideoStream_Rotation_UpsideDown; // "upsideDown" + +// GTLYouTubeVideoProcessingDetails - ProcessingFailureReason +GTL_EXTERN NSString * const kGTLYouTubeVideoProcessingDetails_ProcessingFailureReason_Other; // "other" +GTL_EXTERN NSString * const kGTLYouTubeVideoProcessingDetails_ProcessingFailureReason_StreamingFailed; // "streamingFailed" +GTL_EXTERN NSString * const kGTLYouTubeVideoProcessingDetails_ProcessingFailureReason_TranscodeFailed; // "transcodeFailed" +GTL_EXTERN NSString * const kGTLYouTubeVideoProcessingDetails_ProcessingFailureReason_UploadFailed; // "uploadFailed" + +// GTLYouTubeVideoProcessingDetails - ProcessingStatus +GTL_EXTERN NSString * const kGTLYouTubeVideoProcessingDetails_ProcessingStatus_Failed; // "failed" +GTL_EXTERN NSString * const kGTLYouTubeVideoProcessingDetails_ProcessingStatus_Processing; // "processing" +GTL_EXTERN NSString * const kGTLYouTubeVideoProcessingDetails_ProcessingStatus_Succeeded; // "succeeded" +GTL_EXTERN NSString * const kGTLYouTubeVideoProcessingDetails_ProcessingStatus_Terminated; // "terminated" + +// GTLYouTubeVideoRating - Rating +GTL_EXTERN NSString * const kGTLYouTubeVideoRating_Rating_Dislike; // "dislike" +GTL_EXTERN NSString * const kGTLYouTubeVideoRating_Rating_Like; // "like" +GTL_EXTERN NSString * const kGTLYouTubeVideoRating_Rating_None; // "none" +GTL_EXTERN NSString * const kGTLYouTubeVideoRating_Rating_Unspecified; // "unspecified" + +// GTLYouTubeVideoSnippet - LiveBroadcastContent +GTL_EXTERN NSString * const kGTLYouTubeVideoSnippet_LiveBroadcastContent_Live; // "live" +GTL_EXTERN NSString * const kGTLYouTubeVideoSnippet_LiveBroadcastContent_None; // "none" +GTL_EXTERN NSString * const kGTLYouTubeVideoSnippet_LiveBroadcastContent_Upcoming; // "upcoming" + +// GTLYouTubeVideoStatus - FailureReason +GTL_EXTERN NSString * const kGTLYouTubeVideoStatus_FailureReason_Codec; // "codec" +GTL_EXTERN NSString * const kGTLYouTubeVideoStatus_FailureReason_Conversion; // "conversion" +GTL_EXTERN NSString * const kGTLYouTubeVideoStatus_FailureReason_EmptyFile; // "emptyFile" +GTL_EXTERN NSString * const kGTLYouTubeVideoStatus_FailureReason_InvalidFile; // "invalidFile" +GTL_EXTERN NSString * const kGTLYouTubeVideoStatus_FailureReason_TooSmall; // "tooSmall" +GTL_EXTERN NSString * const kGTLYouTubeVideoStatus_FailureReason_UploadAborted; // "uploadAborted" + +// GTLYouTubeVideoStatus - License +GTL_EXTERN NSString * const kGTLYouTubeVideoStatus_License_CreativeCommon; // "creativeCommon" +GTL_EXTERN NSString * const kGTLYouTubeVideoStatus_License_Youtube; // "youtube" + +// GTLYouTubeVideoStatus - PrivacyStatus +GTL_EXTERN NSString * const kGTLYouTubeVideoStatus_PrivacyStatus_Private; // "private" +GTL_EXTERN NSString * const kGTLYouTubeVideoStatus_PrivacyStatus_Public; // "public" +GTL_EXTERN NSString * const kGTLYouTubeVideoStatus_PrivacyStatus_Unlisted; // "unlisted" + +// GTLYouTubeVideoStatus - RejectionReason +GTL_EXTERN NSString * const kGTLYouTubeVideoStatus_RejectionReason_Claim; // "claim" +GTL_EXTERN NSString * const kGTLYouTubeVideoStatus_RejectionReason_Copyright; // "copyright" +GTL_EXTERN NSString * const kGTLYouTubeVideoStatus_RejectionReason_Duplicate; // "duplicate" +GTL_EXTERN NSString * const kGTLYouTubeVideoStatus_RejectionReason_Inappropriate; // "inappropriate" +GTL_EXTERN NSString * const kGTLYouTubeVideoStatus_RejectionReason_Length; // "length" +GTL_EXTERN NSString * const kGTLYouTubeVideoStatus_RejectionReason_TermsOfUse; // "termsOfUse" +GTL_EXTERN NSString * const kGTLYouTubeVideoStatus_RejectionReason_Trademark; // "trademark" +GTL_EXTERN NSString * const kGTLYouTubeVideoStatus_RejectionReason_UploaderAccountClosed; // "uploaderAccountClosed" +GTL_EXTERN NSString * const kGTLYouTubeVideoStatus_RejectionReason_UploaderAccountSuspended; // "uploaderAccountSuspended" + +// GTLYouTubeVideoStatus - UploadStatus +GTL_EXTERN NSString * const kGTLYouTubeVideoStatus_UploadStatus_Deleted; // "deleted" +GTL_EXTERN NSString * const kGTLYouTubeVideoStatus_UploadStatus_Failed; // "failed" +GTL_EXTERN NSString * const kGTLYouTubeVideoStatus_UploadStatus_Processed; // "processed" +GTL_EXTERN NSString * const kGTLYouTubeVideoStatus_UploadStatus_Rejected; // "rejected" +GTL_EXTERN NSString * const kGTLYouTubeVideoStatus_UploadStatus_Uploaded; // "uploaded" + +// GTLYouTubeVideoSuggestions - EditorSuggestions +GTL_EXTERN NSString * const kGTLYouTubeVideoSuggestions_EditorSuggestions_AudioQuietAudioSwap; // "audioQuietAudioSwap" +GTL_EXTERN NSString * const kGTLYouTubeVideoSuggestions_EditorSuggestions_VideoAutoLevels; // "videoAutoLevels" +GTL_EXTERN NSString * const kGTLYouTubeVideoSuggestions_EditorSuggestions_VideoCrop; // "videoCrop" +GTL_EXTERN NSString * const kGTLYouTubeVideoSuggestions_EditorSuggestions_VideoStabilize; // "videoStabilize" + +// GTLYouTubeVideoSuggestions - ProcessingErrors +GTL_EXTERN NSString * const kGTLYouTubeVideoSuggestions_ProcessingErrors_ArchiveFile; // "archiveFile" +GTL_EXTERN NSString * const kGTLYouTubeVideoSuggestions_ProcessingErrors_AudioFile; // "audioFile" +GTL_EXTERN NSString * const kGTLYouTubeVideoSuggestions_ProcessingErrors_DocFile; // "docFile" +GTL_EXTERN NSString * const kGTLYouTubeVideoSuggestions_ProcessingErrors_ImageFile; // "imageFile" +GTL_EXTERN NSString * const kGTLYouTubeVideoSuggestions_ProcessingErrors_NotAVideoFile; // "notAVideoFile" +GTL_EXTERN NSString * const kGTLYouTubeVideoSuggestions_ProcessingErrors_ProjectFile; // "projectFile" + +// GTLYouTubeVideoSuggestions - ProcessingHints +GTL_EXTERN NSString * const kGTLYouTubeVideoSuggestions_ProcessingHints_NonStreamableMov; // "nonStreamableMov" +GTL_EXTERN NSString * const kGTLYouTubeVideoSuggestions_ProcessingHints_SendBestQualityVideo; // "sendBestQualityVideo" + +// GTLYouTubeVideoSuggestions - ProcessingWarnings +GTL_EXTERN NSString * const kGTLYouTubeVideoSuggestions_ProcessingWarnings_HasEditlist; // "hasEditlist" +GTL_EXTERN NSString * const kGTLYouTubeVideoSuggestions_ProcessingWarnings_InconsistentResolution; // "inconsistentResolution" +GTL_EXTERN NSString * const kGTLYouTubeVideoSuggestions_ProcessingWarnings_ProblematicAudioCodec; // "problematicAudioCodec" +GTL_EXTERN NSString * const kGTLYouTubeVideoSuggestions_ProcessingWarnings_ProblematicVideoCodec; // "problematicVideoCodec" +GTL_EXTERN NSString * const kGTLYouTubeVideoSuggestions_ProcessingWarnings_UnknownAudioCodec; // "unknownAudioCodec" +GTL_EXTERN NSString * const kGTLYouTubeVideoSuggestions_ProcessingWarnings_UnknownContainer; // "unknownContainer" +GTL_EXTERN NSString * const kGTLYouTubeVideoSuggestions_ProcessingWarnings_UnknownVideoCodec; // "unknownVideoCodec" diff --git a/XCDYouTubeKit Demo/Pods/Google-API-Client/Source/Services/YouTube/Generated/GTLYouTubeConstants.m b/XCDYouTubeKit Demo/Pods/Google-API-Client/Source/Services/YouTube/Generated/GTLYouTubeConstants.m new file mode 100644 index 00000000..008b086e --- /dev/null +++ b/XCDYouTubeKit Demo/Pods/Google-API-Client/Source/Services/YouTube/Generated/GTLYouTubeConstants.m @@ -0,0 +1,927 @@ +/* Copyright (c) 2014 Google Inc. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +// +// GTLYouTubeConstants.m +// + +// ---------------------------------------------------------------------------- +// NOTE: This file is generated from Google APIs Discovery Service. +// Service: +// YouTube Data API (youtube/v3) +// Description: +// Programmatic access to YouTube features. +// Documentation: +// https://developers.google.com/youtube/v3 + +#import "GTLYouTubeConstants.h" + +// Authorization scope +NSString * const kGTLAuthScopeYouTube = @"https://www.googleapis.com/auth/youtube"; +NSString * const kGTLAuthScopeYouTubeReadonly = @"https://www.googleapis.com/auth/youtube.readonly"; +NSString * const kGTLAuthScopeYouTubeUpload = @"https://www.googleapis.com/auth/youtube.upload"; +NSString * const kGTLAuthScopeYouTubeYoutubepartner = @"https://www.googleapis.com/auth/youtubepartner"; +NSString * const kGTLAuthScopeYouTubeYoutubepartnerChannelAudit = @"https://www.googleapis.com/auth/youtubepartner-channel-audit"; + +// GTLQueryYouTube - BroadcastStatus +NSString * const kGTLYouTubeBroadcastStatusActive = @"active"; +NSString * const kGTLYouTubeBroadcastStatusAll = @"all"; +NSString * const kGTLYouTubeBroadcastStatusComplete = @"complete"; +NSString * const kGTLYouTubeBroadcastStatusCompleted = @"completed"; +NSString * const kGTLYouTubeBroadcastStatusLive = @"live"; +NSString * const kGTLYouTubeBroadcastStatusTesting = @"testing"; +NSString * const kGTLYouTubeBroadcastStatusUpcoming = @"upcoming"; + +// GTLQueryYouTube - ChannelType +NSString * const kGTLYouTubeChannelTypeAny = @"any"; +NSString * const kGTLYouTubeChannelTypeShow = @"show"; + +// GTLQueryYouTube - Chart +NSString * const kGTLYouTubeChartMostPopular = @"mostPopular"; + +// GTLQueryYouTube - EventType +NSString * const kGTLYouTubeEventTypeCompleted = @"completed"; +NSString * const kGTLYouTubeEventTypeLive = @"live"; +NSString * const kGTLYouTubeEventTypeUpcoming = @"upcoming"; + +// GTLQueryYouTube - MyRating +NSString * const kGTLYouTubeMyRatingDislike = @"dislike"; +NSString * const kGTLYouTubeMyRatingLike = @"like"; + +// GTLQueryYouTube - Order +NSString * const kGTLYouTubeOrderAlphabetical = @"alphabetical"; +NSString * const kGTLYouTubeOrderDate = @"date"; +NSString * const kGTLYouTubeOrderRating = @"rating"; +NSString * const kGTLYouTubeOrderRelevance = @"relevance"; +NSString * const kGTLYouTubeOrderTitle = @"title"; +NSString * const kGTLYouTubeOrderUnread = @"unread"; +NSString * const kGTLYouTubeOrderVideoCount = @"videoCount"; +NSString * const kGTLYouTubeOrderViewCount = @"viewCount"; + +// GTLQueryYouTube - Rating +NSString * const kGTLYouTubeRatingDislike = @"dislike"; +NSString * const kGTLYouTubeRatingLike = @"like"; +NSString * const kGTLYouTubeRatingNone = @"none"; + +// GTLQueryYouTube - SafeSearch +NSString * const kGTLYouTubeSafeSearchModerate = @"moderate"; +NSString * const kGTLYouTubeSafeSearchNone = @"none"; +NSString * const kGTLYouTubeSafeSearchStrict = @"strict"; + +// GTLQueryYouTube - VideoCaption +NSString * const kGTLYouTubeVideoCaptionAny = @"any"; +NSString * const kGTLYouTubeVideoCaptionClosedCaption = @"closedCaption"; +NSString * const kGTLYouTubeVideoCaptionNone = @"none"; + +// GTLQueryYouTube - VideoDefinition +NSString * const kGTLYouTubeVideoDefinitionAny = @"any"; +NSString * const kGTLYouTubeVideoDefinitionHigh = @"high"; +NSString * const kGTLYouTubeVideoDefinitionStandard = @"standard"; + +// GTLQueryYouTube - VideoDimension +NSString * const kGTLYouTubeVideoDimensionAny = @"any"; +NSString * const kGTLYouTubeVideoDimensionX2d = @"2d"; +NSString * const kGTLYouTubeVideoDimensionX3d = @"3d"; + +// GTLQueryYouTube - VideoDuration +NSString * const kGTLYouTubeVideoDurationAny = @"any"; +NSString * const kGTLYouTubeVideoDurationLong = @"long"; +NSString * const kGTLYouTubeVideoDurationMedium = @"medium"; +NSString * const kGTLYouTubeVideoDurationShort = @"short"; + +// GTLQueryYouTube - VideoEmbeddable +NSString * const kGTLYouTubeVideoEmbeddableAny = @"any"; +NSString * const kGTLYouTubeVideoEmbeddableTrue = @"true"; + +// GTLQueryYouTube - VideoLicense +NSString * const kGTLYouTubeVideoLicenseAny = @"any"; +NSString * const kGTLYouTubeVideoLicenseCreativeCommon = @"creativeCommon"; +NSString * const kGTLYouTubeVideoLicenseYoutube = @"youtube"; + +// GTLQueryYouTube - VideoSyndicated +NSString * const kGTLYouTubeVideoSyndicatedAny = @"any"; +NSString * const kGTLYouTubeVideoSyndicatedTrue = @"true"; + +// GTLQueryYouTube - VideoType +NSString * const kGTLYouTubeVideoTypeAny = @"any"; +NSString * const kGTLYouTubeVideoTypeEpisode = @"episode"; +NSString * const kGTLYouTubeVideoTypeMovie = @"movie"; + +// GTLYouTubeActivityContentDetailsPromotedItem - CtaType +NSString * const kGTLYouTubeActivityContentDetailsPromotedItem_CtaType_Unspecified = @"unspecified"; +NSString * const kGTLYouTubeActivityContentDetailsPromotedItem_CtaType_VisitAdvertiserSite = @"visitAdvertiserSite"; + +// GTLYouTubeActivityContentDetailsRecommendation - Reason +NSString * const kGTLYouTubeActivityContentDetailsRecommendation_Reason_Unspecified = @"unspecified"; +NSString * const kGTLYouTubeActivityContentDetailsRecommendation_Reason_VideoFavorited = @"videoFavorited"; +NSString * const kGTLYouTubeActivityContentDetailsRecommendation_Reason_VideoLiked = @"videoLiked"; +NSString * const kGTLYouTubeActivityContentDetailsRecommendation_Reason_VideoWatched = @"videoWatched"; + +// GTLYouTubeActivityContentDetailsSocial - Type +NSString * const kGTLYouTubeActivityContentDetailsSocial_Type_Facebook = @"facebook"; +NSString * const kGTLYouTubeActivityContentDetailsSocial_Type_GooglePlus = @"googlePlus"; +NSString * const kGTLYouTubeActivityContentDetailsSocial_Type_Twitter = @"twitter"; +NSString * const kGTLYouTubeActivityContentDetailsSocial_Type_Unspecified = @"unspecified"; + +// GTLYouTubeActivitySnippet - Type +NSString * const kGTLYouTubeActivitySnippet_Type_Bulletin = @"bulletin"; +NSString * const kGTLYouTubeActivitySnippet_Type_ChannelItem = @"channelItem"; +NSString * const kGTLYouTubeActivitySnippet_Type_Comment = @"comment"; +NSString * const kGTLYouTubeActivitySnippet_Type_Favorite = @"favorite"; +NSString * const kGTLYouTubeActivitySnippet_Type_Like = @"like"; +NSString * const kGTLYouTubeActivitySnippet_Type_PlaylistItem = @"playlistItem"; +NSString * const kGTLYouTubeActivitySnippet_Type_PromotedItem = @"promotedItem"; +NSString * const kGTLYouTubeActivitySnippet_Type_Recommendation = @"recommendation"; +NSString * const kGTLYouTubeActivitySnippet_Type_Social = @"social"; +NSString * const kGTLYouTubeActivitySnippet_Type_Subscription = @"subscription"; +NSString * const kGTLYouTubeActivitySnippet_Type_Upload = @"upload"; + +// GTLYouTubeCdnSettings - IngestionType +NSString * const kGTLYouTubeCdnSettings_IngestionType_Dash = @"dash"; +NSString * const kGTLYouTubeCdnSettings_IngestionType_Rtmp = @"rtmp"; + +// GTLYouTubeChannelConversionPing - Context +NSString * const kGTLYouTubeChannelConversionPing_Context_Cview = @"cview"; +NSString * const kGTLYouTubeChannelConversionPing_Context_Subscribe = @"subscribe"; +NSString * const kGTLYouTubeChannelConversionPing_Context_Unsubscribe = @"unsubscribe"; + +// GTLYouTubeChannelSectionSnippet - Style +NSString * const kGTLYouTubeChannelSectionSnippet_Style_ChannelsectionStyleUndefined = @"channelsectionStyleUndefined"; +NSString * const kGTLYouTubeChannelSectionSnippet_Style_HorizontalRow = @"horizontalRow"; +NSString * const kGTLYouTubeChannelSectionSnippet_Style_VerticalList = @"verticalList"; + +// GTLYouTubeChannelSectionSnippet - Type +NSString * const kGTLYouTubeChannelSectionSnippet_Type_AllPlaylists = @"allPlaylists"; +NSString * const kGTLYouTubeChannelSectionSnippet_Type_ChannelsectionTypeUndefined = @"channelsectionTypeUndefined"; +NSString * const kGTLYouTubeChannelSectionSnippet_Type_CompletedEvents = @"completedEvents"; +NSString * const kGTLYouTubeChannelSectionSnippet_Type_LikedPlaylists = @"likedPlaylists"; +NSString * const kGTLYouTubeChannelSectionSnippet_Type_Likes = @"likes"; +NSString * const kGTLYouTubeChannelSectionSnippet_Type_LiveEvents = @"liveEvents"; +NSString * const kGTLYouTubeChannelSectionSnippet_Type_MultipleChannels = @"multipleChannels"; +NSString * const kGTLYouTubeChannelSectionSnippet_Type_MultiplePlaylists = @"multiplePlaylists"; +NSString * const kGTLYouTubeChannelSectionSnippet_Type_PopularUploads = @"popularUploads"; +NSString * const kGTLYouTubeChannelSectionSnippet_Type_PostedPlaylists = @"postedPlaylists"; +NSString * const kGTLYouTubeChannelSectionSnippet_Type_PostedVideos = @"postedVideos"; +NSString * const kGTLYouTubeChannelSectionSnippet_Type_RecentActivity = @"recentActivity"; +NSString * const kGTLYouTubeChannelSectionSnippet_Type_RecentPosts = @"recentPosts"; +NSString * const kGTLYouTubeChannelSectionSnippet_Type_RecentUploads = @"recentUploads"; +NSString * const kGTLYouTubeChannelSectionSnippet_Type_SinglePlaylist = @"singlePlaylist"; +NSString * const kGTLYouTubeChannelSectionSnippet_Type_Subscriptions = @"subscriptions"; +NSString * const kGTLYouTubeChannelSectionSnippet_Type_UpcomingEvents = @"upcomingEvents"; + +// GTLYouTubeChannelStatus - LongUploadsStatus +NSString * const kGTLYouTubeChannelStatus_LongUploadsStatus_Allowed = @"allowed"; +NSString * const kGTLYouTubeChannelStatus_LongUploadsStatus_Disallowed = @"disallowed"; +NSString * const kGTLYouTubeChannelStatus_LongUploadsStatus_Eligible = @"eligible"; +NSString * const kGTLYouTubeChannelStatus_LongUploadsStatus_LongUploadsUnspecified = @"longUploadsUnspecified"; + +// GTLYouTubeChannelStatus - PrivacyStatus +NSString * const kGTLYouTubeChannelStatus_PrivacyStatus_Private = @"private"; +NSString * const kGTLYouTubeChannelStatus_PrivacyStatus_Public = @"public"; +NSString * const kGTLYouTubeChannelStatus_PrivacyStatus_Unlisted = @"unlisted"; + +// GTLYouTubeContentRating - AcbRating +NSString * const kGTLYouTubeContentRating_AcbRating_AcbC = @"acbC"; +NSString * const kGTLYouTubeContentRating_AcbRating_AcbE = @"acbE"; +NSString * const kGTLYouTubeContentRating_AcbRating_AcbG = @"acbG"; +NSString * const kGTLYouTubeContentRating_AcbRating_AcbM = @"acbM"; +NSString * const kGTLYouTubeContentRating_AcbRating_AcbMa15plus = @"acbMa15plus"; +NSString * const kGTLYouTubeContentRating_AcbRating_AcbP = @"acbP"; +NSString * const kGTLYouTubeContentRating_AcbRating_AcbPg = @"acbPg"; +NSString * const kGTLYouTubeContentRating_AcbRating_AcbR18plus = @"acbR18plus"; +NSString * const kGTLYouTubeContentRating_AcbRating_AcbUnrated = @"acbUnrated"; + +// GTLYouTubeContentRating - AgcomRating +NSString * const kGTLYouTubeContentRating_AgcomRating_AgcomT = @"agcomT"; +NSString * const kGTLYouTubeContentRating_AgcomRating_AgcomUnrated = @"agcomUnrated"; +NSString * const kGTLYouTubeContentRating_AgcomRating_AgcomVm14 = @"agcomVm14"; +NSString * const kGTLYouTubeContentRating_AgcomRating_AgcomVm18 = @"agcomVm18"; + +// GTLYouTubeContentRating - AnatelRating +NSString * const kGTLYouTubeContentRating_AnatelRating_AnatelA = @"anatelA"; +NSString * const kGTLYouTubeContentRating_AnatelRating_AnatelF = @"anatelF"; +NSString * const kGTLYouTubeContentRating_AnatelRating_AnatelI = @"anatelI"; +NSString * const kGTLYouTubeContentRating_AnatelRating_AnatelI10 = @"anatelI10"; +NSString * const kGTLYouTubeContentRating_AnatelRating_AnatelI12 = @"anatelI12"; +NSString * const kGTLYouTubeContentRating_AnatelRating_AnatelI7 = @"anatelI7"; +NSString * const kGTLYouTubeContentRating_AnatelRating_AnatelR = @"anatelR"; +NSString * const kGTLYouTubeContentRating_AnatelRating_AnatelUnrated = @"anatelUnrated"; + +// GTLYouTubeContentRating - BbfcRating +NSString * const kGTLYouTubeContentRating_BbfcRating_Bbfc12 = @"bbfc12"; +NSString * const kGTLYouTubeContentRating_BbfcRating_Bbfc12a = @"bbfc12a"; +NSString * const kGTLYouTubeContentRating_BbfcRating_Bbfc15 = @"bbfc15"; +NSString * const kGTLYouTubeContentRating_BbfcRating_Bbfc18 = @"bbfc18"; +NSString * const kGTLYouTubeContentRating_BbfcRating_BbfcPg = @"bbfcPg"; +NSString * const kGTLYouTubeContentRating_BbfcRating_BbfcR18 = @"bbfcR18"; +NSString * const kGTLYouTubeContentRating_BbfcRating_BbfcU = @"bbfcU"; +NSString * const kGTLYouTubeContentRating_BbfcRating_BbfcUnrated = @"bbfcUnrated"; + +// GTLYouTubeContentRating - BfvcRating +NSString * const kGTLYouTubeContentRating_BfvcRating_Bfvc13 = @"bfvc13"; +NSString * const kGTLYouTubeContentRating_BfvcRating_Bfvc15 = @"bfvc15"; +NSString * const kGTLYouTubeContentRating_BfvcRating_Bfvc18 = @"bfvc18"; +NSString * const kGTLYouTubeContentRating_BfvcRating_Bfvc20 = @"bfvc20"; +NSString * const kGTLYouTubeContentRating_BfvcRating_BfvcB = @"bfvcB"; +NSString * const kGTLYouTubeContentRating_BfvcRating_BfvcE = @"bfvcE"; +NSString * const kGTLYouTubeContentRating_BfvcRating_BfvcG = @"bfvcG"; +NSString * const kGTLYouTubeContentRating_BfvcRating_BfvcUnrated = @"bfvcUnrated"; + +// GTLYouTubeContentRating - BmukkRating +NSString * const kGTLYouTubeContentRating_BmukkRating_Bmukk10 = @"bmukk10"; +NSString * const kGTLYouTubeContentRating_BmukkRating_Bmukk12 = @"bmukk12"; +NSString * const kGTLYouTubeContentRating_BmukkRating_Bmukk14 = @"bmukk14"; +NSString * const kGTLYouTubeContentRating_BmukkRating_Bmukk16 = @"bmukk16"; +NSString * const kGTLYouTubeContentRating_BmukkRating_Bmukk6 = @"bmukk6"; +NSString * const kGTLYouTubeContentRating_BmukkRating_Bmukk8 = @"bmukk8"; +NSString * const kGTLYouTubeContentRating_BmukkRating_BmukkAa = @"bmukkAa"; +NSString * const kGTLYouTubeContentRating_BmukkRating_BmukkUnrated = @"bmukkUnrated"; + +// GTLYouTubeContentRating - CatvfrRating +NSString * const kGTLYouTubeContentRating_CatvfrRating_Catvfr13plus = @"catvfr13plus"; +NSString * const kGTLYouTubeContentRating_CatvfrRating_Catvfr16plus = @"catvfr16plus"; +NSString * const kGTLYouTubeContentRating_CatvfrRating_Catvfr18plus = @"catvfr18plus"; +NSString * const kGTLYouTubeContentRating_CatvfrRating_Catvfr8plus = @"catvfr8plus"; +NSString * const kGTLYouTubeContentRating_CatvfrRating_CatvfrG = @"catvfrG"; +NSString * const kGTLYouTubeContentRating_CatvfrRating_CatvfrUnrated = @"catvfrUnrated"; + +// GTLYouTubeContentRating - CatvRating +NSString * const kGTLYouTubeContentRating_CatvRating_Catv14plus = @"catv14plus"; +NSString * const kGTLYouTubeContentRating_CatvRating_Catv18plus = @"catv18plus"; +NSString * const kGTLYouTubeContentRating_CatvRating_CatvC = @"catvC"; +NSString * const kGTLYouTubeContentRating_CatvRating_CatvC8 = @"catvC8"; +NSString * const kGTLYouTubeContentRating_CatvRating_CatvG = @"catvG"; +NSString * const kGTLYouTubeContentRating_CatvRating_CatvPg = @"catvPg"; +NSString * const kGTLYouTubeContentRating_CatvRating_CatvUnrated = @"catvUnrated"; + +// GTLYouTubeContentRating - CbfcRating +NSString * const kGTLYouTubeContentRating_CbfcRating_CbfcA = @"cbfcA"; +NSString * const kGTLYouTubeContentRating_CbfcRating_CbfcS = @"cbfcS"; +NSString * const kGTLYouTubeContentRating_CbfcRating_CbfcU = @"cbfcU"; +NSString * const kGTLYouTubeContentRating_CbfcRating_CbfcUA = @"cbfcUA"; +NSString * const kGTLYouTubeContentRating_CbfcRating_CbfcUnrated = @"cbfcUnrated"; + +// GTLYouTubeContentRating - CccRating +NSString * const kGTLYouTubeContentRating_CccRating_Ccc14 = @"ccc14"; +NSString * const kGTLYouTubeContentRating_CccRating_Ccc18 = @"ccc18"; +NSString * const kGTLYouTubeContentRating_CccRating_Ccc18s = @"ccc18s"; +NSString * const kGTLYouTubeContentRating_CccRating_Ccc18v = @"ccc18v"; +NSString * const kGTLYouTubeContentRating_CccRating_Ccc6 = @"ccc6"; +NSString * const kGTLYouTubeContentRating_CccRating_CccTe = @"cccTe"; +NSString * const kGTLYouTubeContentRating_CccRating_CccUnrated = @"cccUnrated"; + +// GTLYouTubeContentRating - CceRating +NSString * const kGTLYouTubeContentRating_CceRating_CceM12 = @"cceM12"; +NSString * const kGTLYouTubeContentRating_CceRating_CceM16 = @"cceM16"; +NSString * const kGTLYouTubeContentRating_CceRating_CceM18 = @"cceM18"; +NSString * const kGTLYouTubeContentRating_CceRating_CceM4 = @"cceM4"; +NSString * const kGTLYouTubeContentRating_CceRating_CceM6 = @"cceM6"; +NSString * const kGTLYouTubeContentRating_CceRating_CceUnrated = @"cceUnrated"; + +// GTLYouTubeContentRating - ChfilmRating +NSString * const kGTLYouTubeContentRating_ChfilmRating_Chfilm0 = @"chfilm0"; +NSString * const kGTLYouTubeContentRating_ChfilmRating_Chfilm12 = @"chfilm12"; +NSString * const kGTLYouTubeContentRating_ChfilmRating_Chfilm16 = @"chfilm16"; +NSString * const kGTLYouTubeContentRating_ChfilmRating_Chfilm18 = @"chfilm18"; +NSString * const kGTLYouTubeContentRating_ChfilmRating_Chfilm6 = @"chfilm6"; +NSString * const kGTLYouTubeContentRating_ChfilmRating_ChfilmUnrated = @"chfilmUnrated"; + +// GTLYouTubeContentRating - ChvrsRating +NSString * const kGTLYouTubeContentRating_ChvrsRating_Chvrs14a = @"chvrs14a"; +NSString * const kGTLYouTubeContentRating_ChvrsRating_Chvrs18a = @"chvrs18a"; +NSString * const kGTLYouTubeContentRating_ChvrsRating_ChvrsE = @"chvrsE"; +NSString * const kGTLYouTubeContentRating_ChvrsRating_ChvrsG = @"chvrsG"; +NSString * const kGTLYouTubeContentRating_ChvrsRating_ChvrsPg = @"chvrsPg"; +NSString * const kGTLYouTubeContentRating_ChvrsRating_ChvrsR = @"chvrsR"; +NSString * const kGTLYouTubeContentRating_ChvrsRating_ChvrsUnrated = @"chvrsUnrated"; + +// GTLYouTubeContentRating - CicfRating +NSString * const kGTLYouTubeContentRating_CicfRating_CicfE = @"cicfE"; +NSString * const kGTLYouTubeContentRating_CicfRating_CicfKntEna = @"cicfKntEna"; +NSString * const kGTLYouTubeContentRating_CicfRating_CicfKtEa = @"cicfKtEa"; +NSString * const kGTLYouTubeContentRating_CicfRating_CicfUnrated = @"cicfUnrated"; + +// GTLYouTubeContentRating - CnaRating +NSString * const kGTLYouTubeContentRating_CnaRating_Cna12 = @"cna12"; +NSString * const kGTLYouTubeContentRating_CnaRating_Cna15 = @"cna15"; +NSString * const kGTLYouTubeContentRating_CnaRating_Cna18 = @"cna18"; +NSString * const kGTLYouTubeContentRating_CnaRating_Cna18plus = @"cna18plus"; +NSString * const kGTLYouTubeContentRating_CnaRating_CnaAp = @"cnaAp"; +NSString * const kGTLYouTubeContentRating_CnaRating_CnaUnrated = @"cnaUnrated"; + +// GTLYouTubeContentRating - CsaRating +NSString * const kGTLYouTubeContentRating_CsaRating_Csa10 = @"csa10"; +NSString * const kGTLYouTubeContentRating_CsaRating_Csa12 = @"csa12"; +NSString * const kGTLYouTubeContentRating_CsaRating_Csa16 = @"csa16"; +NSString * const kGTLYouTubeContentRating_CsaRating_Csa18 = @"csa18"; +NSString * const kGTLYouTubeContentRating_CsaRating_CsaInterdiction = @"csaInterdiction"; +NSString * const kGTLYouTubeContentRating_CsaRating_CsaUnrated = @"csaUnrated"; + +// GTLYouTubeContentRating - CscfRating +NSString * const kGTLYouTubeContentRating_CscfRating_Cscf12 = @"cscf12"; +NSString * const kGTLYouTubeContentRating_CscfRating_Cscf16 = @"cscf16"; +NSString * const kGTLYouTubeContentRating_CscfRating_Cscf18 = @"cscf18"; +NSString * const kGTLYouTubeContentRating_CscfRating_Cscf6 = @"cscf6"; +NSString * const kGTLYouTubeContentRating_CscfRating_CscfA = @"cscfA"; +NSString * const kGTLYouTubeContentRating_CscfRating_CscfUnrated = @"cscfUnrated"; + +// GTLYouTubeContentRating - CzfilmRating +NSString * const kGTLYouTubeContentRating_CzfilmRating_Czfilm12 = @"czfilm12"; +NSString * const kGTLYouTubeContentRating_CzfilmRating_Czfilm14 = @"czfilm14"; +NSString * const kGTLYouTubeContentRating_CzfilmRating_Czfilm18 = @"czfilm18"; +NSString * const kGTLYouTubeContentRating_CzfilmRating_CzfilmU = @"czfilmU"; +NSString * const kGTLYouTubeContentRating_CzfilmRating_CzfilmUnrated = @"czfilmUnrated"; + +// GTLYouTubeContentRating - DjctqRating +NSString * const kGTLYouTubeContentRating_DjctqRating_Djctq10 = @"djctq10"; +NSString * const kGTLYouTubeContentRating_DjctqRating_Djctq12 = @"djctq12"; +NSString * const kGTLYouTubeContentRating_DjctqRating_Djctq14 = @"djctq14"; +NSString * const kGTLYouTubeContentRating_DjctqRating_Djctq16 = @"djctq16"; +NSString * const kGTLYouTubeContentRating_DjctqRating_Djctq18 = @"djctq18"; +NSString * const kGTLYouTubeContentRating_DjctqRating_DjctqL = @"djctqL"; +NSString * const kGTLYouTubeContentRating_DjctqRating_DjctqUnrated = @"djctqUnrated"; + +// GTLYouTubeContentRating - DjctqRatingReasons +NSString * const kGTLYouTubeContentRating_DjctqRatingReasons_DjctqCriminalActs = @"djctqCriminalActs"; +NSString * const kGTLYouTubeContentRating_DjctqRatingReasons_DjctqDrugs = @"djctqDrugs"; +NSString * const kGTLYouTubeContentRating_DjctqRatingReasons_DjctqExplicitSex = @"djctqExplicitSex"; +NSString * const kGTLYouTubeContentRating_DjctqRatingReasons_DjctqExtremeViolence = @"djctqExtremeViolence"; +NSString * const kGTLYouTubeContentRating_DjctqRatingReasons_DjctqIllegalDrugs = @"djctqIllegalDrugs"; +NSString * const kGTLYouTubeContentRating_DjctqRatingReasons_DjctqImpactingContent = @"djctqImpactingContent"; +NSString * const kGTLYouTubeContentRating_DjctqRatingReasons_DjctqInappropriateLanguage = @"djctqInappropriateLanguage"; +NSString * const kGTLYouTubeContentRating_DjctqRatingReasons_DjctqLegalDrugs = @"djctqLegalDrugs"; +NSString * const kGTLYouTubeContentRating_DjctqRatingReasons_DjctqNudity = @"djctqNudity"; +NSString * const kGTLYouTubeContentRating_DjctqRatingReasons_DjctqSex = @"djctqSex"; +NSString * const kGTLYouTubeContentRating_DjctqRatingReasons_DjctqSexualContent = @"djctqSexualContent"; +NSString * const kGTLYouTubeContentRating_DjctqRatingReasons_DjctqViolence = @"djctqViolence"; + +// GTLYouTubeContentRating - EefilmRating +NSString * const kGTLYouTubeContentRating_EefilmRating_EefilmK12 = @"eefilmK12"; +NSString * const kGTLYouTubeContentRating_EefilmRating_EefilmK14 = @"eefilmK14"; +NSString * const kGTLYouTubeContentRating_EefilmRating_EefilmK16 = @"eefilmK16"; +NSString * const kGTLYouTubeContentRating_EefilmRating_EefilmK6 = @"eefilmK6"; +NSString * const kGTLYouTubeContentRating_EefilmRating_EefilmL = @"eefilmL"; +NSString * const kGTLYouTubeContentRating_EefilmRating_EefilmMs12 = @"eefilmMs12"; +NSString * const kGTLYouTubeContentRating_EefilmRating_EefilmMs6 = @"eefilmMs6"; +NSString * const kGTLYouTubeContentRating_EefilmRating_EefilmPere = @"eefilmPere"; +NSString * const kGTLYouTubeContentRating_EefilmRating_EefilmUnrated = @"eefilmUnrated"; + +// GTLYouTubeContentRating - EgfilmRating +NSString * const kGTLYouTubeContentRating_EgfilmRating_Egfilm18 = @"egfilm18"; +NSString * const kGTLYouTubeContentRating_EgfilmRating_EgfilmBn = @"egfilmBn"; +NSString * const kGTLYouTubeContentRating_EgfilmRating_EgfilmGn = @"egfilmGn"; +NSString * const kGTLYouTubeContentRating_EgfilmRating_EgfilmUnrated = @"egfilmUnrated"; + +// GTLYouTubeContentRating - EirinRating +NSString * const kGTLYouTubeContentRating_EirinRating_EirinG = @"eirinG"; +NSString * const kGTLYouTubeContentRating_EirinRating_EirinPg12 = @"eirinPg12"; +NSString * const kGTLYouTubeContentRating_EirinRating_EirinR15plus = @"eirinR15plus"; +NSString * const kGTLYouTubeContentRating_EirinRating_EirinR18plus = @"eirinR18plus"; +NSString * const kGTLYouTubeContentRating_EirinRating_EirinUnrated = @"eirinUnrated"; + +// GTLYouTubeContentRating - FcbmRating +NSString * const kGTLYouTubeContentRating_FcbmRating_Fcbm18 = @"fcbm18"; +NSString * const kGTLYouTubeContentRating_FcbmRating_Fcbm18pa = @"fcbm18pa"; +NSString * const kGTLYouTubeContentRating_FcbmRating_Fcbm18pl = @"fcbm18pl"; +NSString * const kGTLYouTubeContentRating_FcbmRating_Fcbm18sg = @"fcbm18sg"; +NSString * const kGTLYouTubeContentRating_FcbmRating_Fcbm18sx = @"fcbm18sx"; +NSString * const kGTLYouTubeContentRating_FcbmRating_FcbmP13 = @"fcbmP13"; +NSString * const kGTLYouTubeContentRating_FcbmRating_FcbmU = @"fcbmU"; +NSString * const kGTLYouTubeContentRating_FcbmRating_FcbmUnrated = @"fcbmUnrated"; + +// GTLYouTubeContentRating - FcoRating +NSString * const kGTLYouTubeContentRating_FcoRating_FcoI = @"fcoI"; +NSString * const kGTLYouTubeContentRating_FcoRating_FcoIia = @"fcoIia"; +NSString * const kGTLYouTubeContentRating_FcoRating_FcoIib = @"fcoIib"; +NSString * const kGTLYouTubeContentRating_FcoRating_FcoIii = @"fcoIii"; +NSString * const kGTLYouTubeContentRating_FcoRating_FcoUnrated = @"fcoUnrated"; + +// GTLYouTubeContentRating - FmocRating +NSString * const kGTLYouTubeContentRating_FmocRating_Fmoc10 = @"fmoc10"; +NSString * const kGTLYouTubeContentRating_FmocRating_Fmoc12 = @"fmoc12"; +NSString * const kGTLYouTubeContentRating_FmocRating_Fmoc16 = @"fmoc16"; +NSString * const kGTLYouTubeContentRating_FmocRating_Fmoc18 = @"fmoc18"; +NSString * const kGTLYouTubeContentRating_FmocRating_FmocE = @"fmocE"; +NSString * const kGTLYouTubeContentRating_FmocRating_FmocU = @"fmocU"; +NSString * const kGTLYouTubeContentRating_FmocRating_FmocUnrated = @"fmocUnrated"; + +// GTLYouTubeContentRating - FpbRating +NSString * const kGTLYouTubeContentRating_FpbRating_Fpb1012Pg = @"fpb1012Pg"; +NSString * const kGTLYouTubeContentRating_FpbRating_Fpb13 = @"fpb13"; +NSString * const kGTLYouTubeContentRating_FpbRating_Fpb16 = @"fpb16"; +NSString * const kGTLYouTubeContentRating_FpbRating_Fpb18 = @"fpb18"; +NSString * const kGTLYouTubeContentRating_FpbRating_Fpb79Pg = @"fpb79Pg"; +NSString * const kGTLYouTubeContentRating_FpbRating_FpbA = @"fpbA"; +NSString * const kGTLYouTubeContentRating_FpbRating_FpbPg = @"fpbPg"; +NSString * const kGTLYouTubeContentRating_FpbRating_FpbUnrated = @"fpbUnrated"; +NSString * const kGTLYouTubeContentRating_FpbRating_FpbX18 = @"fpbX18"; +NSString * const kGTLYouTubeContentRating_FpbRating_FpbXx = @"fpbXx"; + +// GTLYouTubeContentRating - FskRating +NSString * const kGTLYouTubeContentRating_FskRating_Fsk0 = @"fsk0"; +NSString * const kGTLYouTubeContentRating_FskRating_Fsk12 = @"fsk12"; +NSString * const kGTLYouTubeContentRating_FskRating_Fsk16 = @"fsk16"; +NSString * const kGTLYouTubeContentRating_FskRating_Fsk18 = @"fsk18"; +NSString * const kGTLYouTubeContentRating_FskRating_Fsk6 = @"fsk6"; +NSString * const kGTLYouTubeContentRating_FskRating_FskUnrated = @"fskUnrated"; + +// GTLYouTubeContentRating - GrfilmRating +NSString * const kGTLYouTubeContentRating_GrfilmRating_GrfilmE = @"grfilmE"; +NSString * const kGTLYouTubeContentRating_GrfilmRating_GrfilmK = @"grfilmK"; +NSString * const kGTLYouTubeContentRating_GrfilmRating_GrfilmK13 = @"grfilmK13"; +NSString * const kGTLYouTubeContentRating_GrfilmRating_GrfilmK17 = @"grfilmK17"; +NSString * const kGTLYouTubeContentRating_GrfilmRating_GrfilmUnrated = @"grfilmUnrated"; + +// GTLYouTubeContentRating - IcaaRating +NSString * const kGTLYouTubeContentRating_IcaaRating_Icaa12 = @"icaa12"; +NSString * const kGTLYouTubeContentRating_IcaaRating_Icaa13 = @"icaa13"; +NSString * const kGTLYouTubeContentRating_IcaaRating_Icaa16 = @"icaa16"; +NSString * const kGTLYouTubeContentRating_IcaaRating_Icaa18 = @"icaa18"; +NSString * const kGTLYouTubeContentRating_IcaaRating_Icaa7 = @"icaa7"; +NSString * const kGTLYouTubeContentRating_IcaaRating_IcaaApta = @"icaaApta"; +NSString * const kGTLYouTubeContentRating_IcaaRating_IcaaUnrated = @"icaaUnrated"; +NSString * const kGTLYouTubeContentRating_IcaaRating_IcaaX = @"icaaX"; + +// GTLYouTubeContentRating - IfcoRating +NSString * const kGTLYouTubeContentRating_IfcoRating_Ifco12 = @"ifco12"; +NSString * const kGTLYouTubeContentRating_IfcoRating_Ifco15 = @"ifco15"; +NSString * const kGTLYouTubeContentRating_IfcoRating_Ifco18 = @"ifco18"; +NSString * const kGTLYouTubeContentRating_IfcoRating_IfcoG = @"ifcoG"; +NSString * const kGTLYouTubeContentRating_IfcoRating_IfcoPg = @"ifcoPg"; +NSString * const kGTLYouTubeContentRating_IfcoRating_IfcoUnrated = @"ifcoUnrated"; + +// GTLYouTubeContentRating - IlfilmRating +NSString * const kGTLYouTubeContentRating_IlfilmRating_Ilfilm12 = @"ilfilm12"; +NSString * const kGTLYouTubeContentRating_IlfilmRating_Ilfilm16 = @"ilfilm16"; +NSString * const kGTLYouTubeContentRating_IlfilmRating_Ilfilm18 = @"ilfilm18"; +NSString * const kGTLYouTubeContentRating_IlfilmRating_IlfilmAa = @"ilfilmAa"; +NSString * const kGTLYouTubeContentRating_IlfilmRating_IlfilmUnrated = @"ilfilmUnrated"; + +// GTLYouTubeContentRating - IncaaRating +NSString * const kGTLYouTubeContentRating_IncaaRating_IncaaAtp = @"incaaAtp"; +NSString * const kGTLYouTubeContentRating_IncaaRating_IncaaC = @"incaaC"; +NSString * const kGTLYouTubeContentRating_IncaaRating_IncaaSam13 = @"incaaSam13"; +NSString * const kGTLYouTubeContentRating_IncaaRating_IncaaSam16 = @"incaaSam16"; +NSString * const kGTLYouTubeContentRating_IncaaRating_IncaaSam18 = @"incaaSam18"; +NSString * const kGTLYouTubeContentRating_IncaaRating_IncaaUnrated = @"incaaUnrated"; + +// GTLYouTubeContentRating - KfcbRating +NSString * const kGTLYouTubeContentRating_KfcbRating_Kfcb16plus = @"kfcb16plus"; +NSString * const kGTLYouTubeContentRating_KfcbRating_KfcbG = @"kfcbG"; +NSString * const kGTLYouTubeContentRating_KfcbRating_KfcbPg = @"kfcbPg"; +NSString * const kGTLYouTubeContentRating_KfcbRating_KfcbR = @"kfcbR"; +NSString * const kGTLYouTubeContentRating_KfcbRating_KfcbUnrated = @"kfcbUnrated"; + +// GTLYouTubeContentRating - KijkwijzerRating +NSString * const kGTLYouTubeContentRating_KijkwijzerRating_Kijkwijzer12 = @"kijkwijzer12"; +NSString * const kGTLYouTubeContentRating_KijkwijzerRating_Kijkwijzer16 = @"kijkwijzer16"; +NSString * const kGTLYouTubeContentRating_KijkwijzerRating_Kijkwijzer6 = @"kijkwijzer6"; +NSString * const kGTLYouTubeContentRating_KijkwijzerRating_Kijkwijzer9 = @"kijkwijzer9"; +NSString * const kGTLYouTubeContentRating_KijkwijzerRating_KijkwijzerAl = @"kijkwijzerAl"; +NSString * const kGTLYouTubeContentRating_KijkwijzerRating_KijkwijzerUnrated = @"kijkwijzerUnrated"; + +// GTLYouTubeContentRating - KmrbRating +NSString * const kGTLYouTubeContentRating_KmrbRating_Kmrb12plus = @"kmrb12plus"; +NSString * const kGTLYouTubeContentRating_KmrbRating_Kmrb15plus = @"kmrb15plus"; +NSString * const kGTLYouTubeContentRating_KmrbRating_KmrbAll = @"kmrbAll"; +NSString * const kGTLYouTubeContentRating_KmrbRating_KmrbR = @"kmrbR"; +NSString * const kGTLYouTubeContentRating_KmrbRating_KmrbTeenr = @"kmrbTeenr"; +NSString * const kGTLYouTubeContentRating_KmrbRating_KmrbUnrated = @"kmrbUnrated"; + +// GTLYouTubeContentRating - LsfRating +NSString * const kGTLYouTubeContentRating_LsfRating_LsfA = @"lsfA"; +NSString * const kGTLYouTubeContentRating_LsfRating_LsfBo = @"lsfBo"; +NSString * const kGTLYouTubeContentRating_LsfRating_LsfD = @"lsfD"; +NSString * const kGTLYouTubeContentRating_LsfRating_LsfR = @"lsfR"; +NSString * const kGTLYouTubeContentRating_LsfRating_LsfSu = @"lsfSu"; +NSString * const kGTLYouTubeContentRating_LsfRating_LsfUnrated = @"lsfUnrated"; + +// GTLYouTubeContentRating - MccaaRating +NSString * const kGTLYouTubeContentRating_MccaaRating_Mccaa12 = @"mccaa12"; +NSString * const kGTLYouTubeContentRating_MccaaRating_Mccaa12a = @"mccaa12a"; +NSString * const kGTLYouTubeContentRating_MccaaRating_Mccaa14 = @"mccaa14"; +NSString * const kGTLYouTubeContentRating_MccaaRating_Mccaa15 = @"mccaa15"; +NSString * const kGTLYouTubeContentRating_MccaaRating_Mccaa16 = @"mccaa16"; +NSString * const kGTLYouTubeContentRating_MccaaRating_Mccaa18 = @"mccaa18"; +NSString * const kGTLYouTubeContentRating_MccaaRating_MccaaPg = @"mccaaPg"; +NSString * const kGTLYouTubeContentRating_MccaaRating_MccaaU = @"mccaaU"; +NSString * const kGTLYouTubeContentRating_MccaaRating_MccaaUnrated = @"mccaaUnrated"; + +// GTLYouTubeContentRating - MccypRating +NSString * const kGTLYouTubeContentRating_MccypRating_Mccyp11 = @"mccyp11"; +NSString * const kGTLYouTubeContentRating_MccypRating_Mccyp15 = @"mccyp15"; +NSString * const kGTLYouTubeContentRating_MccypRating_Mccyp7 = @"mccyp7"; +NSString * const kGTLYouTubeContentRating_MccypRating_MccypA = @"mccypA"; +NSString * const kGTLYouTubeContentRating_MccypRating_MccypUnrated = @"mccypUnrated"; + +// GTLYouTubeContentRating - MdaRating +NSString * const kGTLYouTubeContentRating_MdaRating_MdaG = @"mdaG"; +NSString * const kGTLYouTubeContentRating_MdaRating_MdaM18 = @"mdaM18"; +NSString * const kGTLYouTubeContentRating_MdaRating_MdaNc16 = @"mdaNc16"; +NSString * const kGTLYouTubeContentRating_MdaRating_MdaPg = @"mdaPg"; +NSString * const kGTLYouTubeContentRating_MdaRating_MdaPg13 = @"mdaPg13"; +NSString * const kGTLYouTubeContentRating_MdaRating_MdaR21 = @"mdaR21"; +NSString * const kGTLYouTubeContentRating_MdaRating_MdaUnrated = @"mdaUnrated"; + +// GTLYouTubeContentRating - MedietilsynetRating +NSString * const kGTLYouTubeContentRating_MedietilsynetRating_Medietilsynet11 = @"medietilsynet11"; +NSString * const kGTLYouTubeContentRating_MedietilsynetRating_Medietilsynet15 = @"medietilsynet15"; +NSString * const kGTLYouTubeContentRating_MedietilsynetRating_Medietilsynet18 = @"medietilsynet18"; +NSString * const kGTLYouTubeContentRating_MedietilsynetRating_Medietilsynet7 = @"medietilsynet7"; +NSString * const kGTLYouTubeContentRating_MedietilsynetRating_MedietilsynetA = @"medietilsynetA"; +NSString * const kGTLYouTubeContentRating_MedietilsynetRating_MedietilsynetUnrated = @"medietilsynetUnrated"; + +// GTLYouTubeContentRating - MekuRating +NSString * const kGTLYouTubeContentRating_MekuRating_Meku12 = @"meku12"; +NSString * const kGTLYouTubeContentRating_MekuRating_Meku16 = @"meku16"; +NSString * const kGTLYouTubeContentRating_MekuRating_Meku18 = @"meku18"; +NSString * const kGTLYouTubeContentRating_MekuRating_Meku7 = @"meku7"; +NSString * const kGTLYouTubeContentRating_MekuRating_MekuS = @"mekuS"; +NSString * const kGTLYouTubeContentRating_MekuRating_MekuUnrated = @"mekuUnrated"; + +// GTLYouTubeContentRating - MibacRating +NSString * const kGTLYouTubeContentRating_MibacRating_MibacT = @"mibacT"; +NSString * const kGTLYouTubeContentRating_MibacRating_MibacUnrated = @"mibacUnrated"; +NSString * const kGTLYouTubeContentRating_MibacRating_MibacVap = @"mibacVap"; +NSString * const kGTLYouTubeContentRating_MibacRating_MibacVm12 = @"mibacVm12"; +NSString * const kGTLYouTubeContentRating_MibacRating_MibacVm14 = @"mibacVm14"; +NSString * const kGTLYouTubeContentRating_MibacRating_MibacVm18 = @"mibacVm18"; + +// GTLYouTubeContentRating - MocRating +NSString * const kGTLYouTubeContentRating_MocRating_Moc12 = @"moc12"; +NSString * const kGTLYouTubeContentRating_MocRating_Moc15 = @"moc15"; +NSString * const kGTLYouTubeContentRating_MocRating_Moc18 = @"moc18"; +NSString * const kGTLYouTubeContentRating_MocRating_Moc7 = @"moc7"; +NSString * const kGTLYouTubeContentRating_MocRating_MocBanned = @"mocBanned"; +NSString * const kGTLYouTubeContentRating_MocRating_MocE = @"mocE"; +NSString * const kGTLYouTubeContentRating_MocRating_MocT = @"mocT"; +NSString * const kGTLYouTubeContentRating_MocRating_MocUnrated = @"mocUnrated"; +NSString * const kGTLYouTubeContentRating_MocRating_MocX = @"mocX"; + +// GTLYouTubeContentRating - MoctwRating +NSString * const kGTLYouTubeContentRating_MoctwRating_MoctwG = @"moctwG"; +NSString * const kGTLYouTubeContentRating_MoctwRating_MoctwP = @"moctwP"; +NSString * const kGTLYouTubeContentRating_MoctwRating_MoctwPg = @"moctwPg"; +NSString * const kGTLYouTubeContentRating_MoctwRating_MoctwR = @"moctwR"; +NSString * const kGTLYouTubeContentRating_MoctwRating_MoctwUnrated = @"moctwUnrated"; + +// GTLYouTubeContentRating - MpaaRating +NSString * const kGTLYouTubeContentRating_MpaaRating_MpaaG = @"mpaaG"; +NSString * const kGTLYouTubeContentRating_MpaaRating_MpaaNc17 = @"mpaaNc17"; +NSString * const kGTLYouTubeContentRating_MpaaRating_MpaaPg = @"mpaaPg"; +NSString * const kGTLYouTubeContentRating_MpaaRating_MpaaPg13 = @"mpaaPg13"; +NSString * const kGTLYouTubeContentRating_MpaaRating_MpaaR = @"mpaaR"; +NSString * const kGTLYouTubeContentRating_MpaaRating_MpaaUnrated = @"mpaaUnrated"; + +// GTLYouTubeContentRating - MtrcbRating +NSString * const kGTLYouTubeContentRating_MtrcbRating_MtrcbG = @"mtrcbG"; +NSString * const kGTLYouTubeContentRating_MtrcbRating_MtrcbPg = @"mtrcbPg"; +NSString * const kGTLYouTubeContentRating_MtrcbRating_MtrcbR13 = @"mtrcbR13"; +NSString * const kGTLYouTubeContentRating_MtrcbRating_MtrcbR16 = @"mtrcbR16"; +NSString * const kGTLYouTubeContentRating_MtrcbRating_MtrcbR18 = @"mtrcbR18"; +NSString * const kGTLYouTubeContentRating_MtrcbRating_MtrcbUnrated = @"mtrcbUnrated"; +NSString * const kGTLYouTubeContentRating_MtrcbRating_MtrcbX = @"mtrcbX"; + +// GTLYouTubeContentRating - NbcplRating +NSString * const kGTLYouTubeContentRating_NbcplRating_Nbcpl18plus = @"nbcpl18plus"; +NSString * const kGTLYouTubeContentRating_NbcplRating_NbcplI = @"nbcplI"; +NSString * const kGTLYouTubeContentRating_NbcplRating_NbcplIi = @"nbcplIi"; +NSString * const kGTLYouTubeContentRating_NbcplRating_NbcplIii = @"nbcplIii"; +NSString * const kGTLYouTubeContentRating_NbcplRating_NbcplIv = @"nbcplIv"; +NSString * const kGTLYouTubeContentRating_NbcplRating_NbcplUnrated = @"nbcplUnrated"; + +// GTLYouTubeContentRating - NbcRating +NSString * const kGTLYouTubeContentRating_NbcRating_Nbc12plus = @"nbc12plus"; +NSString * const kGTLYouTubeContentRating_NbcRating_Nbc15plus = @"nbc15plus"; +NSString * const kGTLYouTubeContentRating_NbcRating_Nbc18plus = @"nbc18plus"; +NSString * const kGTLYouTubeContentRating_NbcRating_Nbc18plusr = @"nbc18plusr"; +NSString * const kGTLYouTubeContentRating_NbcRating_NbcG = @"nbcG"; +NSString * const kGTLYouTubeContentRating_NbcRating_NbcPg = @"nbcPg"; +NSString * const kGTLYouTubeContentRating_NbcRating_NbcPu = @"nbcPu"; +NSString * const kGTLYouTubeContentRating_NbcRating_NbcUnrated = @"nbcUnrated"; + +// GTLYouTubeContentRating - NfrcRating +NSString * const kGTLYouTubeContentRating_NfrcRating_NfrcA = @"nfrcA"; +NSString * const kGTLYouTubeContentRating_NfrcRating_NfrcB = @"nfrcB"; +NSString * const kGTLYouTubeContentRating_NfrcRating_NfrcC = @"nfrcC"; +NSString * const kGTLYouTubeContentRating_NfrcRating_NfrcD = @"nfrcD"; +NSString * const kGTLYouTubeContentRating_NfrcRating_NfrcUnrated = @"nfrcUnrated"; +NSString * const kGTLYouTubeContentRating_NfrcRating_NfrcX = @"nfrcX"; + +// GTLYouTubeContentRating - NfvcbRating +NSString * const kGTLYouTubeContentRating_NfvcbRating_Nfvcb12 = @"nfvcb12"; +NSString * const kGTLYouTubeContentRating_NfvcbRating_Nfvcb12a = @"nfvcb12a"; +NSString * const kGTLYouTubeContentRating_NfvcbRating_Nfvcb15 = @"nfvcb15"; +NSString * const kGTLYouTubeContentRating_NfvcbRating_Nfvcb18 = @"nfvcb18"; +NSString * const kGTLYouTubeContentRating_NfvcbRating_NfvcbG = @"nfvcbG"; +NSString * const kGTLYouTubeContentRating_NfvcbRating_NfvcbPg = @"nfvcbPg"; +NSString * const kGTLYouTubeContentRating_NfvcbRating_NfvcbRe = @"nfvcbRe"; +NSString * const kGTLYouTubeContentRating_NfvcbRating_NfvcbUnrated = @"nfvcbUnrated"; + +// GTLYouTubeContentRating - NkclvRating +NSString * const kGTLYouTubeContentRating_NkclvRating_Nkclv12plus = @"nkclv12plus"; +NSString * const kGTLYouTubeContentRating_NkclvRating_Nkclv18plus = @"nkclv18plus"; +NSString * const kGTLYouTubeContentRating_NkclvRating_Nkclv7plus = @"nkclv7plus"; +NSString * const kGTLYouTubeContentRating_NkclvRating_NkclvU = @"nkclvU"; +NSString * const kGTLYouTubeContentRating_NkclvRating_NkclvUnrated = @"nkclvUnrated"; + +// GTLYouTubeContentRating - OflcRating +NSString * const kGTLYouTubeContentRating_OflcRating_OflcG = @"oflcG"; +NSString * const kGTLYouTubeContentRating_OflcRating_OflcM = @"oflcM"; +NSString * const kGTLYouTubeContentRating_OflcRating_OflcPg = @"oflcPg"; +NSString * const kGTLYouTubeContentRating_OflcRating_OflcR13 = @"oflcR13"; +NSString * const kGTLYouTubeContentRating_OflcRating_OflcR15 = @"oflcR15"; +NSString * const kGTLYouTubeContentRating_OflcRating_OflcR16 = @"oflcR16"; +NSString * const kGTLYouTubeContentRating_OflcRating_OflcR18 = @"oflcR18"; +NSString * const kGTLYouTubeContentRating_OflcRating_OflcRp13 = @"oflcRp13"; +NSString * const kGTLYouTubeContentRating_OflcRating_OflcRp16 = @"oflcRp16"; +NSString * const kGTLYouTubeContentRating_OflcRating_OflcUnrated = @"oflcUnrated"; + +// GTLYouTubeContentRating - PefilmRating +NSString * const kGTLYouTubeContentRating_PefilmRating_Pefilm14 = @"pefilm14"; +NSString * const kGTLYouTubeContentRating_PefilmRating_Pefilm18 = @"pefilm18"; +NSString * const kGTLYouTubeContentRating_PefilmRating_PefilmPg = @"pefilmPg"; +NSString * const kGTLYouTubeContentRating_PefilmRating_PefilmPt = @"pefilmPt"; +NSString * const kGTLYouTubeContentRating_PefilmRating_PefilmUnrated = @"pefilmUnrated"; + +// GTLYouTubeContentRating - RcnofRating +NSString * const kGTLYouTubeContentRating_RcnofRating_RcnofI = @"rcnofI"; +NSString * const kGTLYouTubeContentRating_RcnofRating_RcnofIi = @"rcnofIi"; +NSString * const kGTLYouTubeContentRating_RcnofRating_RcnofIii = @"rcnofIii"; +NSString * const kGTLYouTubeContentRating_RcnofRating_RcnofIv = @"rcnofIv"; +NSString * const kGTLYouTubeContentRating_RcnofRating_RcnofUnrated = @"rcnofUnrated"; +NSString * const kGTLYouTubeContentRating_RcnofRating_RcnofV = @"rcnofV"; +NSString * const kGTLYouTubeContentRating_RcnofRating_RcnofVi = @"rcnofVi"; + +// GTLYouTubeContentRating - ResorteviolenciaRating +NSString * const kGTLYouTubeContentRating_ResorteviolenciaRating_ResorteviolenciaA = @"resorteviolenciaA"; +NSString * const kGTLYouTubeContentRating_ResorteviolenciaRating_ResorteviolenciaB = @"resorteviolenciaB"; +NSString * const kGTLYouTubeContentRating_ResorteviolenciaRating_ResorteviolenciaC = @"resorteviolenciaC"; +NSString * const kGTLYouTubeContentRating_ResorteviolenciaRating_ResorteviolenciaD = @"resorteviolenciaD"; +NSString * const kGTLYouTubeContentRating_ResorteviolenciaRating_ResorteviolenciaE = @"resorteviolenciaE"; +NSString * const kGTLYouTubeContentRating_ResorteviolenciaRating_ResorteviolenciaUnrated = @"resorteviolenciaUnrated"; + +// GTLYouTubeContentRating - RtcRating +NSString * const kGTLYouTubeContentRating_RtcRating_RtcA = @"rtcA"; +NSString * const kGTLYouTubeContentRating_RtcRating_RtcAa = @"rtcAa"; +NSString * const kGTLYouTubeContentRating_RtcRating_RtcB = @"rtcB"; +NSString * const kGTLYouTubeContentRating_RtcRating_RtcB15 = @"rtcB15"; +NSString * const kGTLYouTubeContentRating_RtcRating_RtcC = @"rtcC"; +NSString * const kGTLYouTubeContentRating_RtcRating_RtcD = @"rtcD"; +NSString * const kGTLYouTubeContentRating_RtcRating_RtcUnrated = @"rtcUnrated"; + +// GTLYouTubeContentRating - RteRating +NSString * const kGTLYouTubeContentRating_RteRating_RteCh = @"rteCh"; +NSString * const kGTLYouTubeContentRating_RteRating_RteGa = @"rteGa"; +NSString * const kGTLYouTubeContentRating_RteRating_RteMa = @"rteMa"; +NSString * const kGTLYouTubeContentRating_RteRating_RtePs = @"rtePs"; +NSString * const kGTLYouTubeContentRating_RteRating_RteUnrated = @"rteUnrated"; + +// GTLYouTubeContentRating - RussiaRating +NSString * const kGTLYouTubeContentRating_RussiaRating_Russia0 = @"russia0"; +NSString * const kGTLYouTubeContentRating_RussiaRating_Russia12 = @"russia12"; +NSString * const kGTLYouTubeContentRating_RussiaRating_Russia16 = @"russia16"; +NSString * const kGTLYouTubeContentRating_RussiaRating_Russia18 = @"russia18"; +NSString * const kGTLYouTubeContentRating_RussiaRating_Russia6 = @"russia6"; +NSString * const kGTLYouTubeContentRating_RussiaRating_RussiaUnrated = @"russiaUnrated"; + +// GTLYouTubeContentRating - SkfilmRating +NSString * const kGTLYouTubeContentRating_SkfilmRating_SkfilmG = @"skfilmG"; +NSString * const kGTLYouTubeContentRating_SkfilmRating_SkfilmP2 = @"skfilmP2"; +NSString * const kGTLYouTubeContentRating_SkfilmRating_SkfilmP5 = @"skfilmP5"; +NSString * const kGTLYouTubeContentRating_SkfilmRating_SkfilmP8 = @"skfilmP8"; +NSString * const kGTLYouTubeContentRating_SkfilmRating_SkfilmUnrated = @"skfilmUnrated"; + +// GTLYouTubeContentRating - SmaisRating +NSString * const kGTLYouTubeContentRating_SmaisRating_Smais12 = @"smais12"; +NSString * const kGTLYouTubeContentRating_SmaisRating_Smais14 = @"smais14"; +NSString * const kGTLYouTubeContentRating_SmaisRating_Smais16 = @"smais16"; +NSString * const kGTLYouTubeContentRating_SmaisRating_Smais18 = @"smais18"; +NSString * const kGTLYouTubeContentRating_SmaisRating_Smais7 = @"smais7"; +NSString * const kGTLYouTubeContentRating_SmaisRating_SmaisL = @"smaisL"; +NSString * const kGTLYouTubeContentRating_SmaisRating_SmaisUnrated = @"smaisUnrated"; + +// GTLYouTubeContentRating - SmsaRating +NSString * const kGTLYouTubeContentRating_SmsaRating_Smsa11 = @"smsa11"; +NSString * const kGTLYouTubeContentRating_SmsaRating_Smsa15 = @"smsa15"; +NSString * const kGTLYouTubeContentRating_SmsaRating_Smsa7 = @"smsa7"; +NSString * const kGTLYouTubeContentRating_SmsaRating_SmsaA = @"smsaA"; +NSString * const kGTLYouTubeContentRating_SmsaRating_SmsaUnrated = @"smsaUnrated"; + +// GTLYouTubeContentRating - TvpgRating +NSString * const kGTLYouTubeContentRating_TvpgRating_Pg14 = @"pg14"; +NSString * const kGTLYouTubeContentRating_TvpgRating_TvpgG = @"tvpgG"; +NSString * const kGTLYouTubeContentRating_TvpgRating_TvpgMa = @"tvpgMa"; +NSString * const kGTLYouTubeContentRating_TvpgRating_TvpgPg = @"tvpgPg"; +NSString * const kGTLYouTubeContentRating_TvpgRating_TvpgUnrated = @"tvpgUnrated"; +NSString * const kGTLYouTubeContentRating_TvpgRating_TvpgY = @"tvpgY"; +NSString * const kGTLYouTubeContentRating_TvpgRating_TvpgY7 = @"tvpgY7"; +NSString * const kGTLYouTubeContentRating_TvpgRating_TvpgY7Fv = @"tvpgY7Fv"; + +// GTLYouTubeContentRating - YtRating +NSString * const kGTLYouTubeContentRating_YtRating_YtAgeRestricted = @"ytAgeRestricted"; + +// GTLYouTubeInvideoPosition - CornerPosition +NSString * const kGTLYouTubeInvideoPosition_CornerPosition_BottomLeft = @"bottomLeft"; +NSString * const kGTLYouTubeInvideoPosition_CornerPosition_BottomRight = @"bottomRight"; +NSString * const kGTLYouTubeInvideoPosition_CornerPosition_TopLeft = @"topLeft"; +NSString * const kGTLYouTubeInvideoPosition_CornerPosition_TopRight = @"topRight"; + +// GTLYouTubeInvideoPosition - Type +NSString * const kGTLYouTubeInvideoPosition_Type_Corner = @"corner"; + +// GTLYouTubeInvideoTiming - Type +NSString * const kGTLYouTubeInvideoTiming_Type_OffsetFromEnd = @"offsetFromEnd"; +NSString * const kGTLYouTubeInvideoTiming_Type_OffsetFromStart = @"offsetFromStart"; + +// GTLYouTubeLiveBroadcastStatus - LifeCycleStatus +NSString * const kGTLYouTubeLiveBroadcastStatus_LifeCycleStatus_Abandoned = @"abandoned"; +NSString * const kGTLYouTubeLiveBroadcastStatus_LifeCycleStatus_Complete = @"complete"; +NSString * const kGTLYouTubeLiveBroadcastStatus_LifeCycleStatus_CompleteStarting = @"completeStarting"; +NSString * const kGTLYouTubeLiveBroadcastStatus_LifeCycleStatus_Created = @"created"; +NSString * const kGTLYouTubeLiveBroadcastStatus_LifeCycleStatus_Live = @"live"; +NSString * const kGTLYouTubeLiveBroadcastStatus_LifeCycleStatus_LiveStarting = @"liveStarting"; +NSString * const kGTLYouTubeLiveBroadcastStatus_LifeCycleStatus_Ready = @"ready"; +NSString * const kGTLYouTubeLiveBroadcastStatus_LifeCycleStatus_Reclaimed = @"reclaimed"; +NSString * const kGTLYouTubeLiveBroadcastStatus_LifeCycleStatus_Revoked = @"revoked"; +NSString * const kGTLYouTubeLiveBroadcastStatus_LifeCycleStatus_Testing = @"testing"; +NSString * const kGTLYouTubeLiveBroadcastStatus_LifeCycleStatus_TestStarting = @"testStarting"; + +// GTLYouTubeLiveBroadcastStatus - LiveBroadcastPriority +NSString * const kGTLYouTubeLiveBroadcastStatus_LiveBroadcastPriority_High = @"high"; +NSString * const kGTLYouTubeLiveBroadcastStatus_LiveBroadcastPriority_Low = @"low"; +NSString * const kGTLYouTubeLiveBroadcastStatus_LiveBroadcastPriority_Normal = @"normal"; + +// GTLYouTubeLiveBroadcastStatus - PrivacyStatus +NSString * const kGTLYouTubeLiveBroadcastStatus_PrivacyStatus_Private = @"private"; +NSString * const kGTLYouTubeLiveBroadcastStatus_PrivacyStatus_Public = @"public"; +NSString * const kGTLYouTubeLiveBroadcastStatus_PrivacyStatus_Unlisted = @"unlisted"; + +// GTLYouTubeLiveBroadcastStatus - RecordingStatus +NSString * const kGTLYouTubeLiveBroadcastStatus_RecordingStatus_NotRecording = @"notRecording"; +NSString * const kGTLYouTubeLiveBroadcastStatus_RecordingStatus_Recorded = @"recorded"; +NSString * const kGTLYouTubeLiveBroadcastStatus_RecordingStatus_Recording = @"recording"; + +// GTLYouTubeLiveStreamStatus - StreamStatus +NSString * const kGTLYouTubeLiveStreamStatus_StreamStatus_Active = @"active"; +NSString * const kGTLYouTubeLiveStreamStatus_StreamStatus_Created = @"created"; +NSString * const kGTLYouTubeLiveStreamStatus_StreamStatus_Error = @"error"; +NSString * const kGTLYouTubeLiveStreamStatus_StreamStatus_Inactive = @"inactive"; +NSString * const kGTLYouTubeLiveStreamStatus_StreamStatus_Ready = @"ready"; + +// GTLYouTubePlaylistItemStatus - PrivacyStatus +NSString * const kGTLYouTubePlaylistItemStatus_PrivacyStatus_Private = @"private"; +NSString * const kGTLYouTubePlaylistItemStatus_PrivacyStatus_Public = @"public"; +NSString * const kGTLYouTubePlaylistItemStatus_PrivacyStatus_Unlisted = @"unlisted"; + +// GTLYouTubePlaylistStatus - PrivacyStatus +NSString * const kGTLYouTubePlaylistStatus_PrivacyStatus_Private = @"private"; +NSString * const kGTLYouTubePlaylistStatus_PrivacyStatus_Public = @"public"; +NSString * const kGTLYouTubePlaylistStatus_PrivacyStatus_Unlisted = @"unlisted"; + +// GTLYouTubePromotedItemId - Type +NSString * const kGTLYouTubePromotedItemId_Type_RecentUpload = @"recentUpload"; +NSString * const kGTLYouTubePromotedItemId_Type_Video = @"video"; +NSString * const kGTLYouTubePromotedItemId_Type_Website = @"website"; + +// GTLYouTubeSearchResultSnippet - LiveBroadcastContent +NSString * const kGTLYouTubeSearchResultSnippet_LiveBroadcastContent_Live = @"live"; +NSString * const kGTLYouTubeSearchResultSnippet_LiveBroadcastContent_None = @"none"; +NSString * const kGTLYouTubeSearchResultSnippet_LiveBroadcastContent_Upcoming = @"upcoming"; + +// GTLYouTubeSubscriptionContentDetails - ActivityType +NSString * const kGTLYouTubeSubscriptionContentDetails_ActivityType_All = @"all"; +NSString * const kGTLYouTubeSubscriptionContentDetails_ActivityType_Uploads = @"uploads"; + +// GTLYouTubeVideoAgeGating - VideoGameRating +NSString * const kGTLYouTubeVideoAgeGating_VideoGameRating_Anyone = @"anyone"; +NSString * const kGTLYouTubeVideoAgeGating_VideoGameRating_M15Plus = @"m15Plus"; +NSString * const kGTLYouTubeVideoAgeGating_VideoGameRating_M16Plus = @"m16Plus"; +NSString * const kGTLYouTubeVideoAgeGating_VideoGameRating_M17Plus = @"m17Plus"; + +// GTLYouTubeVideoContentDetails - Caption +NSString * const kGTLYouTubeVideoContentDetails_Caption_False = @"false"; +NSString * const kGTLYouTubeVideoContentDetails_Caption_True = @"true"; + +// GTLYouTubeVideoContentDetails - Definition +NSString * const kGTLYouTubeVideoContentDetails_Definition_Hd = @"hd"; +NSString * const kGTLYouTubeVideoContentDetails_Definition_Sd = @"sd"; + +// GTLYouTubeVideoConversionPing - Context +NSString * const kGTLYouTubeVideoConversionPing_Context_Comment = @"comment"; +NSString * const kGTLYouTubeVideoConversionPing_Context_Dislike = @"dislike"; +NSString * const kGTLYouTubeVideoConversionPing_Context_Like = @"like"; +NSString * const kGTLYouTubeVideoConversionPing_Context_Share = @"share"; + +// GTLYouTubeVideoFileDetails - FileType +NSString * const kGTLYouTubeVideoFileDetails_FileType_Archive = @"archive"; +NSString * const kGTLYouTubeVideoFileDetails_FileType_Audio = @"audio"; +NSString * const kGTLYouTubeVideoFileDetails_FileType_Document = @"document"; +NSString * const kGTLYouTubeVideoFileDetails_FileType_Image = @"image"; +NSString * const kGTLYouTubeVideoFileDetails_FileType_Other = @"other"; +NSString * const kGTLYouTubeVideoFileDetails_FileType_Project = @"project"; +NSString * const kGTLYouTubeVideoFileDetails_FileType_Video = @"video"; + +// GTLYouTubeVideoFileDetailsVideoStream - Rotation +NSString * const kGTLYouTubeVideoFileDetailsVideoStream_Rotation_Clockwise = @"clockwise"; +NSString * const kGTLYouTubeVideoFileDetailsVideoStream_Rotation_CounterClockwise = @"counterClockwise"; +NSString * const kGTLYouTubeVideoFileDetailsVideoStream_Rotation_None = @"none"; +NSString * const kGTLYouTubeVideoFileDetailsVideoStream_Rotation_Other = @"other"; +NSString * const kGTLYouTubeVideoFileDetailsVideoStream_Rotation_UpsideDown = @"upsideDown"; + +// GTLYouTubeVideoProcessingDetails - ProcessingFailureReason +NSString * const kGTLYouTubeVideoProcessingDetails_ProcessingFailureReason_Other = @"other"; +NSString * const kGTLYouTubeVideoProcessingDetails_ProcessingFailureReason_StreamingFailed = @"streamingFailed"; +NSString * const kGTLYouTubeVideoProcessingDetails_ProcessingFailureReason_TranscodeFailed = @"transcodeFailed"; +NSString * const kGTLYouTubeVideoProcessingDetails_ProcessingFailureReason_UploadFailed = @"uploadFailed"; + +// GTLYouTubeVideoProcessingDetails - ProcessingStatus +NSString * const kGTLYouTubeVideoProcessingDetails_ProcessingStatus_Failed = @"failed"; +NSString * const kGTLYouTubeVideoProcessingDetails_ProcessingStatus_Processing = @"processing"; +NSString * const kGTLYouTubeVideoProcessingDetails_ProcessingStatus_Succeeded = @"succeeded"; +NSString * const kGTLYouTubeVideoProcessingDetails_ProcessingStatus_Terminated = @"terminated"; + +// GTLYouTubeVideoRating - Rating +NSString * const kGTLYouTubeVideoRating_Rating_Dislike = @"dislike"; +NSString * const kGTLYouTubeVideoRating_Rating_Like = @"like"; +NSString * const kGTLYouTubeVideoRating_Rating_None = @"none"; +NSString * const kGTLYouTubeVideoRating_Rating_Unspecified = @"unspecified"; + +// GTLYouTubeVideoSnippet - LiveBroadcastContent +NSString * const kGTLYouTubeVideoSnippet_LiveBroadcastContent_Live = @"live"; +NSString * const kGTLYouTubeVideoSnippet_LiveBroadcastContent_None = @"none"; +NSString * const kGTLYouTubeVideoSnippet_LiveBroadcastContent_Upcoming = @"upcoming"; + +// GTLYouTubeVideoStatus - FailureReason +NSString * const kGTLYouTubeVideoStatus_FailureReason_Codec = @"codec"; +NSString * const kGTLYouTubeVideoStatus_FailureReason_Conversion = @"conversion"; +NSString * const kGTLYouTubeVideoStatus_FailureReason_EmptyFile = @"emptyFile"; +NSString * const kGTLYouTubeVideoStatus_FailureReason_InvalidFile = @"invalidFile"; +NSString * const kGTLYouTubeVideoStatus_FailureReason_TooSmall = @"tooSmall"; +NSString * const kGTLYouTubeVideoStatus_FailureReason_UploadAborted = @"uploadAborted"; + +// GTLYouTubeVideoStatus - License +NSString * const kGTLYouTubeVideoStatus_License_CreativeCommon = @"creativeCommon"; +NSString * const kGTLYouTubeVideoStatus_License_Youtube = @"youtube"; + +// GTLYouTubeVideoStatus - PrivacyStatus +NSString * const kGTLYouTubeVideoStatus_PrivacyStatus_Private = @"private"; +NSString * const kGTLYouTubeVideoStatus_PrivacyStatus_Public = @"public"; +NSString * const kGTLYouTubeVideoStatus_PrivacyStatus_Unlisted = @"unlisted"; + +// GTLYouTubeVideoStatus - RejectionReason +NSString * const kGTLYouTubeVideoStatus_RejectionReason_Claim = @"claim"; +NSString * const kGTLYouTubeVideoStatus_RejectionReason_Copyright = @"copyright"; +NSString * const kGTLYouTubeVideoStatus_RejectionReason_Duplicate = @"duplicate"; +NSString * const kGTLYouTubeVideoStatus_RejectionReason_Inappropriate = @"inappropriate"; +NSString * const kGTLYouTubeVideoStatus_RejectionReason_Length = @"length"; +NSString * const kGTLYouTubeVideoStatus_RejectionReason_TermsOfUse = @"termsOfUse"; +NSString * const kGTLYouTubeVideoStatus_RejectionReason_Trademark = @"trademark"; +NSString * const kGTLYouTubeVideoStatus_RejectionReason_UploaderAccountClosed = @"uploaderAccountClosed"; +NSString * const kGTLYouTubeVideoStatus_RejectionReason_UploaderAccountSuspended = @"uploaderAccountSuspended"; + +// GTLYouTubeVideoStatus - UploadStatus +NSString * const kGTLYouTubeVideoStatus_UploadStatus_Deleted = @"deleted"; +NSString * const kGTLYouTubeVideoStatus_UploadStatus_Failed = @"failed"; +NSString * const kGTLYouTubeVideoStatus_UploadStatus_Processed = @"processed"; +NSString * const kGTLYouTubeVideoStatus_UploadStatus_Rejected = @"rejected"; +NSString * const kGTLYouTubeVideoStatus_UploadStatus_Uploaded = @"uploaded"; + +// GTLYouTubeVideoSuggestions - EditorSuggestions +NSString * const kGTLYouTubeVideoSuggestions_EditorSuggestions_AudioQuietAudioSwap = @"audioQuietAudioSwap"; +NSString * const kGTLYouTubeVideoSuggestions_EditorSuggestions_VideoAutoLevels = @"videoAutoLevels"; +NSString * const kGTLYouTubeVideoSuggestions_EditorSuggestions_VideoCrop = @"videoCrop"; +NSString * const kGTLYouTubeVideoSuggestions_EditorSuggestions_VideoStabilize = @"videoStabilize"; + +// GTLYouTubeVideoSuggestions - ProcessingErrors +NSString * const kGTLYouTubeVideoSuggestions_ProcessingErrors_ArchiveFile = @"archiveFile"; +NSString * const kGTLYouTubeVideoSuggestions_ProcessingErrors_AudioFile = @"audioFile"; +NSString * const kGTLYouTubeVideoSuggestions_ProcessingErrors_DocFile = @"docFile"; +NSString * const kGTLYouTubeVideoSuggestions_ProcessingErrors_ImageFile = @"imageFile"; +NSString * const kGTLYouTubeVideoSuggestions_ProcessingErrors_NotAVideoFile = @"notAVideoFile"; +NSString * const kGTLYouTubeVideoSuggestions_ProcessingErrors_ProjectFile = @"projectFile"; + +// GTLYouTubeVideoSuggestions - ProcessingHints +NSString * const kGTLYouTubeVideoSuggestions_ProcessingHints_NonStreamableMov = @"nonStreamableMov"; +NSString * const kGTLYouTubeVideoSuggestions_ProcessingHints_SendBestQualityVideo = @"sendBestQualityVideo"; + +// GTLYouTubeVideoSuggestions - ProcessingWarnings +NSString * const kGTLYouTubeVideoSuggestions_ProcessingWarnings_HasEditlist = @"hasEditlist"; +NSString * const kGTLYouTubeVideoSuggestions_ProcessingWarnings_InconsistentResolution = @"inconsistentResolution"; +NSString * const kGTLYouTubeVideoSuggestions_ProcessingWarnings_ProblematicAudioCodec = @"problematicAudioCodec"; +NSString * const kGTLYouTubeVideoSuggestions_ProcessingWarnings_ProblematicVideoCodec = @"problematicVideoCodec"; +NSString * const kGTLYouTubeVideoSuggestions_ProcessingWarnings_UnknownAudioCodec = @"unknownAudioCodec"; +NSString * const kGTLYouTubeVideoSuggestions_ProcessingWarnings_UnknownContainer = @"unknownContainer"; +NSString * const kGTLYouTubeVideoSuggestions_ProcessingWarnings_UnknownVideoCodec = @"unknownVideoCodec"; diff --git a/XCDYouTubeKit Demo/Pods/Google-API-Client/Source/Services/YouTube/Generated/GTLYouTubeContentRating.h b/XCDYouTubeKit Demo/Pods/Google-API-Client/Source/Services/YouTube/Generated/GTLYouTubeContentRating.h new file mode 100644 index 00000000..7bc7fff3 --- /dev/null +++ b/XCDYouTubeKit Demo/Pods/Google-API-Client/Source/Services/YouTube/Generated/GTLYouTubeContentRating.h @@ -0,0 +1,249 @@ +/* Copyright (c) 2014 Google Inc. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +// +// GTLYouTubeContentRating.h +// + +// ---------------------------------------------------------------------------- +// NOTE: This file is generated from Google APIs Discovery Service. +// Service: +// YouTube Data API (youtube/v3) +// Description: +// Programmatic access to YouTube features. +// Documentation: +// https://developers.google.com/youtube/v3 +// Classes: +// GTLYouTubeContentRating (0 custom class methods, 64 custom properties) + +#if GTL_BUILT_AS_FRAMEWORK + #import "GTL/GTLObject.h" +#else + #import "GTLObject.h" +#endif + +// ---------------------------------------------------------------------------- +// +// GTLYouTubeContentRating +// + +// Ratings schemes. The country-specific ratings are mostly for movies and +// shows. NEXT_ID: 65 + +@interface GTLYouTubeContentRating : GTLObject + +// Rating system in Australia - Australian Classification Board +@property (copy) NSString *acbRating; + +// Rating system for Italy - Autorit� per le Garanzie nelle Comunicazioni +@property (copy) NSString *agcomRating; + +// Rating system for Chile - Asociaci�n Nacional de Televisi�n +@property (copy) NSString *anatelRating; + +// British Board of Film Classification +@property (copy) NSString *bbfcRating; + +// Rating system for Thailand - Board of Filmand Video Censors +@property (copy) NSString *bfvcRating; + +// Rating system for Austria - Bundesministeriums f�r Unterricht, Kunst und +// Kultur! +@property (copy) NSString *bmukkRating; + +// Rating system for French Canadian TV - Regie du cinema +@property (copy) NSString *catvfrRating; + +// Rating system for Canadian TV - Canadian TV Classification System +@property (copy) NSString *catvRating; + +// Rating system in India - Central Board of Film Certification +@property (copy) NSString *cbfcRating; + +// Rating system for Chile - Consejo de Calificaci�n Cinematogr�fica +@property (copy) NSString *cccRating; + +// Rating system for Portugal - Comiss�o de Classifica��o de Espect�culos +@property (copy) NSString *cceRating; + +// Rating system for Switzerland - Switzerland Rating System +@property (copy) NSString *chfilmRating; + +// Canadian Home Video Rating System +@property (copy) NSString *chvrsRating; + +// Rating system for Belgium - Belgium Rating System +@property (copy) NSString *cicfRating; + +// Rating system for Romania - CONSILIUL NATIONAL AL AUDIOVIZUALULUI - CNA +@property (copy) NSString *cnaRating; + +// Rating system for France - Conseil sup�rieur de l?audiovisuel +@property (copy) NSString *csaRating; + +// Rating system for Luxembourg - Commission de surveillance de la +// classification des films +@property (copy) NSString *cscfRating; + +// Rating system for Czech republic - Czech republic Rating System +@property (copy) NSString *czfilmRating; + +// Rating system in Brazil - Department of Justice, Rating, Titles and +// Qualification +@property (copy) NSString *djctqRating; + +@property (retain) NSArray *djctqRatingReasons; // of NSString + +// Rating system for Estonia - Estonia Rating System +@property (copy) NSString *eefilmRating; + +// Rating system for Egypt - Egypt Rating System +@property (copy) NSString *egfilmRating; + +// Rating system in Japan - Eiga Rinri Kanri Iinkai +@property (copy) NSString *eirinRating; + +// Rating system for Malaysia - Film Censorship Board of Malaysia +@property (copy) NSString *fcbmRating; + +// Rating system for Hong kong - Office for Film, Newspaper and Article +// Administration +@property (copy) NSString *fcoRating; + +// Rating system in France - French Minister of Culture +@property (copy) NSString *fmocRating; + +// Rating system for South africa - Film & Publication Board +@property (copy) NSString *fpbRating; + +// Rating system in Germany - Voluntary Self Regulation of the Movie Industry +@property (copy) NSString *fskRating; + +// Rating system for Greece - Greece Rating System +@property (copy) NSString *grfilmRating; + +// Rating system in Spain - Instituto de Cinematografia y de las Artes +// Audiovisuales +@property (copy) NSString *icaaRating; + +// Rating system in Ireland - Irish Film Classification Office +@property (copy) NSString *ifcoRating; + +// Rating system for Israel - Israel Rating System +@property (copy) NSString *ilfilmRating; + +// Rating system for Argentina - Instituto Nacional de Cine y Artes +// Audiovisuales +@property (copy) NSString *incaaRating; + +// Rating system for Kenya - Kenya Film Classification Board +@property (copy) NSString *kfcbRating; + +// Rating system for Netherlands - Nederlands Instituut voor de Classificatie +// van Audiovisuele Media +@property (copy) NSString *kijkwijzerRating; + +// Rating system in South Korea - Korea Media Rating Board +@property (copy) NSString *kmrbRating; + +// Rating system for Indonesia - Lembaga Sensor Film +@property (copy) NSString *lsfRating; + +// Rating system for Malta - Film Age-Classification Board +@property (copy) NSString *mccaaRating; + +// Rating system for Denmark - The Media Council for Children and Young People +@property (copy) NSString *mccypRating; + +// Rating system for Singapore - Media Development Authority +@property (copy) NSString *mdaRating; + +// Rating system for Norway - Medietilsynet +@property (copy) NSString *medietilsynetRating; + +// Rating system for Finland - Finnish Centre for Media Education and +// Audiovisual Media +@property (copy) NSString *mekuRating; + +// Rating system in Italy - Ministero dei Beni e delle Attivita Culturali e del +// Turismo +@property (copy) NSString *mibacRating; + +// Rating system for Colombia - MoC +@property (copy) NSString *mocRating; + +// Rating system for Taiwan - Ministry of Culture - Tawan +@property (copy) NSString *moctwRating; + +// Motion Picture Association of America rating for the content. +@property (copy) NSString *mpaaRating; + +// Rating system for Philippines - MOVIE AND TELEVISION REVIEW AND +// CLASSIFICATION BOARD +@property (copy) NSString *mtrcbRating; + +// Rating system for Poland - National Broadcasting Council +@property (copy) NSString *nbcplRating; + +// Rating system for Maldives - National Bureau of Classification +@property (copy) NSString *nbcRating; + +// Rating system for Bulgaria - National Film Centre +@property (copy) NSString *nfrcRating; + +// Rating system for Nigeria - National Film and Video Censors Board +@property (copy) NSString *nfvcbRating; + +// Rating system for Latvia - National Film Center of Latvia +@property (copy) NSString *nkclvRating; + +// Rating system in New Zealand - Office of Film and Literature Classification +@property (copy) NSString *oflcRating; + +// Rating system for Peru - Peru Rating System +@property (copy) NSString *pefilmRating; + +// Rating system for Hungary - Rating Committee of the National Office of Film +@property (copy) NSString *rcnofRating; + +// Rating system for Venezuela - SiBCI +@property (copy) NSString *resorteviolenciaRating; + +// Rating system in Mexico - General Directorate of Radio, Television and +// Cinematography +@property (copy) NSString *rtcRating; + +// Rating system for Ireland - Raidi� Teilif�s �ireann +@property (copy) NSString *rteRating; + +// Rating system in Russia +@property (copy) NSString *russiaRating; + +// Rating system for Slovakia - Slovakia Rating System +@property (copy) NSString *skfilmRating; + +// Rating system for Iceland - SMAIS +@property (copy) NSString *smaisRating; + +// Rating system for Sweden - Statens medier�d (National Media Council) +@property (copy) NSString *smsaRating; + +// TV Parental Guidelines rating of the content. +@property (copy) NSString *tvpgRating; + +// Internal YouTube rating. +@property (copy) NSString *ytRating; + +@end diff --git a/XCDYouTubeKit Demo/Pods/Google-API-Client/Source/Services/YouTube/Generated/GTLYouTubeContentRating.m b/XCDYouTubeKit Demo/Pods/Google-API-Client/Source/Services/YouTube/Generated/GTLYouTubeContentRating.m new file mode 100644 index 00000000..18cfa4a4 --- /dev/null +++ b/XCDYouTubeKit Demo/Pods/Google-API-Client/Source/Services/YouTube/Generated/GTLYouTubeContentRating.m @@ -0,0 +1,60 @@ +/* Copyright (c) 2014 Google Inc. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +// +// GTLYouTubeContentRating.m +// + +// ---------------------------------------------------------------------------- +// NOTE: This file is generated from Google APIs Discovery Service. +// Service: +// YouTube Data API (youtube/v3) +// Description: +// Programmatic access to YouTube features. +// Documentation: +// https://developers.google.com/youtube/v3 +// Classes: +// GTLYouTubeContentRating (0 custom class methods, 64 custom properties) + +#import "GTLYouTubeContentRating.h" + +// ---------------------------------------------------------------------------- +// +// GTLYouTubeContentRating +// + +@implementation GTLYouTubeContentRating +@dynamic acbRating, agcomRating, anatelRating, bbfcRating, bfvcRating, + bmukkRating, catvfrRating, catvRating, cbfcRating, cccRating, + cceRating, chfilmRating, chvrsRating, cicfRating, cnaRating, csaRating, + cscfRating, czfilmRating, djctqRating, djctqRatingReasons, + eefilmRating, egfilmRating, eirinRating, fcbmRating, fcoRating, + fmocRating, fpbRating, fskRating, grfilmRating, icaaRating, ifcoRating, + ilfilmRating, incaaRating, kfcbRating, kijkwijzerRating, kmrbRating, + lsfRating, mccaaRating, mccypRating, mdaRating, medietilsynetRating, + mekuRating, mibacRating, mocRating, moctwRating, mpaaRating, + mtrcbRating, nbcplRating, nbcRating, nfrcRating, nfvcbRating, + nkclvRating, oflcRating, pefilmRating, rcnofRating, + resorteviolenciaRating, rtcRating, rteRating, russiaRating, + skfilmRating, smaisRating, smsaRating, tvpgRating, ytRating; + ++ (NSDictionary *)arrayPropertyToClassMap { + NSDictionary *map = + [NSDictionary dictionaryWithObject:[NSString class] + forKey:@"djctqRatingReasons"]; + return map; +} + +@end diff --git a/XCDYouTubeKit Demo/Pods/Google-API-Client/Source/Services/YouTube/Generated/GTLYouTubeGeoPoint.h b/XCDYouTubeKit Demo/Pods/Google-API-Client/Source/Services/YouTube/Generated/GTLYouTubeGeoPoint.h new file mode 100644 index 00000000..045a1768 --- /dev/null +++ b/XCDYouTubeKit Demo/Pods/Google-API-Client/Source/Services/YouTube/Generated/GTLYouTubeGeoPoint.h @@ -0,0 +1,55 @@ +/* Copyright (c) 2013 Google Inc. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +// +// GTLYouTubeGeoPoint.h +// + +// ---------------------------------------------------------------------------- +// NOTE: This file is generated from Google APIs Discovery Service. +// Service: +// YouTube Data API (youtube/v3) +// Description: +// Programmatic access to YouTube features. +// Documentation: +// https://developers.google.com/youtube/v3 +// Classes: +// GTLYouTubeGeoPoint (0 custom class methods, 3 custom properties) + +#if GTL_BUILT_AS_FRAMEWORK + #import "GTL/GTLObject.h" +#else + #import "GTLObject.h" +#endif + +// ---------------------------------------------------------------------------- +// +// GTLYouTubeGeoPoint +// + +// Geographical coordinates of a point, in WGS84. + +@interface GTLYouTubeGeoPoint : GTLObject + +// Altitude above the reference ellipsoid, in meters. +@property (retain) NSNumber *altitude; // doubleValue + +// Latitude in degrees. +@property (retain) NSNumber *latitude; // doubleValue + +// Longitude in degrees. +@property (retain) NSNumber *longitude; // doubleValue + +@end diff --git a/XCDYouTubeKit Demo/Pods/Google-API-Client/Source/Services/YouTube/Generated/GTLYouTubeGeoPoint.m b/XCDYouTubeKit Demo/Pods/Google-API-Client/Source/Services/YouTube/Generated/GTLYouTubeGeoPoint.m new file mode 100644 index 00000000..80a2db88 --- /dev/null +++ b/XCDYouTubeKit Demo/Pods/Google-API-Client/Source/Services/YouTube/Generated/GTLYouTubeGeoPoint.m @@ -0,0 +1,40 @@ +/* Copyright (c) 2013 Google Inc. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +// +// GTLYouTubeGeoPoint.m +// + +// ---------------------------------------------------------------------------- +// NOTE: This file is generated from Google APIs Discovery Service. +// Service: +// YouTube Data API (youtube/v3) +// Description: +// Programmatic access to YouTube features. +// Documentation: +// https://developers.google.com/youtube/v3 +// Classes: +// GTLYouTubeGeoPoint (0 custom class methods, 3 custom properties) + +#import "GTLYouTubeGeoPoint.h" + +// ---------------------------------------------------------------------------- +// +// GTLYouTubeGeoPoint +// + +@implementation GTLYouTubeGeoPoint +@dynamic altitude, latitude, longitude; +@end diff --git a/XCDYouTubeKit Demo/Pods/Google-API-Client/Source/Services/YouTube/Generated/GTLYouTubeGuideCategory.h b/XCDYouTubeKit Demo/Pods/Google-API-Client/Source/Services/YouTube/Generated/GTLYouTubeGuideCategory.h new file mode 100644 index 00000000..1084c90b --- /dev/null +++ b/XCDYouTubeKit Demo/Pods/Google-API-Client/Source/Services/YouTube/Generated/GTLYouTubeGuideCategory.h @@ -0,0 +1,67 @@ +/* Copyright (c) 2013 Google Inc. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +// +// GTLYouTubeGuideCategory.h +// + +// ---------------------------------------------------------------------------- +// NOTE: This file is generated from Google APIs Discovery Service. +// Service: +// YouTube Data API (youtube/v3) +// Description: +// Programmatic access to YouTube features. +// Documentation: +// https://developers.google.com/youtube/v3 +// Classes: +// GTLYouTubeGuideCategory (0 custom class methods, 4 custom properties) + +#if GTL_BUILT_AS_FRAMEWORK + #import "GTL/GTLObject.h" +#else + #import "GTLObject.h" +#endif + +@class GTLYouTubeGuideCategorySnippet; + +// ---------------------------------------------------------------------------- +// +// GTLYouTubeGuideCategory +// + +// A guideCategory resource identifies a category that YouTube algorithmically +// assigns based on a channel's content or other indicators, such as the +// channel's popularity. The list is similar to video categories, with the +// difference being that a video's uploader can assign a video category but only +// YouTube can assign a channel category. + +@interface GTLYouTubeGuideCategory : GTLObject + +// Etag of this resource. +@property (copy) NSString *ETag; + +// The ID that YouTube uses to uniquely identify the guide category. +// identifier property maps to 'id' in JSON (to avoid Objective C's 'id'). +@property (copy) NSString *identifier; + +// Identifies what kind of resource this is. Value: the fixed string +// "youtube#guideCategory". +@property (copy) NSString *kind; + +// The snippet object contains basic details about the category, such as its +// title. +@property (retain) GTLYouTubeGuideCategorySnippet *snippet; + +@end diff --git a/XCDYouTubeKit Demo/Pods/Google-API-Client/Source/Services/YouTube/Generated/GTLYouTubeGuideCategory.m b/XCDYouTubeKit Demo/Pods/Google-API-Client/Source/Services/YouTube/Generated/GTLYouTubeGuideCategory.m new file mode 100644 index 00000000..872adc27 --- /dev/null +++ b/XCDYouTubeKit Demo/Pods/Google-API-Client/Source/Services/YouTube/Generated/GTLYouTubeGuideCategory.m @@ -0,0 +1,56 @@ +/* Copyright (c) 2012 Google Inc. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +// +// GTLYouTubeGuideCategory.m +// + +// ---------------------------------------------------------------------------- +// NOTE: This file is generated from Google APIs Discovery Service. +// Service: +// YouTube Data API (youtube/v3) +// Description: +// Programmatic access to YouTube features. +// Documentation: +// https://developers.google.com/youtube/v3 +// Classes: +// GTLYouTubeGuideCategory (0 custom class methods, 4 custom properties) + +#import "GTLYouTubeGuideCategory.h" + +#import "GTLYouTubeGuideCategorySnippet.h" + +// ---------------------------------------------------------------------------- +// +// GTLYouTubeGuideCategory +// + +@implementation GTLYouTubeGuideCategory +@dynamic ETag, identifier, kind, snippet; + ++ (NSDictionary *)propertyToJSONKeyMap { + NSDictionary *map = + [NSDictionary dictionaryWithObjectsAndKeys: + @"etag", @"ETag", + @"id", @"identifier", + nil]; + return map; +} + ++ (void)load { + [self registerObjectClassForKind:@"youtube#guideCategory"]; +} + +@end diff --git a/XCDYouTubeKit Demo/Pods/Google-API-Client/Source/Services/YouTube/Generated/GTLYouTubeGuideCategoryListResponse.h b/XCDYouTubeKit Demo/Pods/Google-API-Client/Source/Services/YouTube/Generated/GTLYouTubeGuideCategoryListResponse.h new file mode 100644 index 00000000..d6b7edc2 --- /dev/null +++ b/XCDYouTubeKit Demo/Pods/Google-API-Client/Source/Services/YouTube/Generated/GTLYouTubeGuideCategoryListResponse.h @@ -0,0 +1,81 @@ +/* Copyright (c) 2013 Google Inc. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +// +// GTLYouTubeGuideCategoryListResponse.h +// + +// ---------------------------------------------------------------------------- +// NOTE: This file is generated from Google APIs Discovery Service. +// Service: +// YouTube Data API (youtube/v3) +// Description: +// Programmatic access to YouTube features. +// Documentation: +// https://developers.google.com/youtube/v3 +// Classes: +// GTLYouTubeGuideCategoryListResponse (0 custom class methods, 9 custom properties) + +#if GTL_BUILT_AS_FRAMEWORK + #import "GTL/GTLObject.h" +#else + #import "GTLObject.h" +#endif + +@class GTLYouTubeGuideCategory; +@class GTLYouTubePageInfo; +@class GTLYouTubeTokenPagination; + +// ---------------------------------------------------------------------------- +// +// GTLYouTubeGuideCategoryListResponse +// + +// This class supports NSFastEnumeration over its "items" property. It also +// supports -itemAtIndex: to retrieve individual objects from "items". + +@interface GTLYouTubeGuideCategoryListResponse : GTLCollectionObject + +// Etag of this resource. +@property (copy) NSString *ETag; + +// Serialized EventId of the request which produced this response. +@property (copy) NSString *eventId; + +// A list of categories that can be associated with YouTube channels. In this +// map, the category ID is the map key, and its value is the corresponding +// guideCategory resource. +@property (retain) NSArray *items; // of GTLYouTubeGuideCategory + +// Identifies what kind of resource this is. Value: the fixed string +// "youtube#guideCategoryListResponse". +@property (copy) NSString *kind; + +// The token that can be used as the value of the pageToken parameter to +// retrieve the next page in the result set. +@property (copy) NSString *nextPageToken; + +@property (retain) GTLYouTubePageInfo *pageInfo; + +// The token that can be used as the value of the pageToken parameter to +// retrieve the previous page in the result set. +@property (copy) NSString *prevPageToken; + +@property (retain) GTLYouTubeTokenPagination *tokenPagination; + +// The visitorId identifies the visitor. +@property (copy) NSString *visitorId; + +@end diff --git a/XCDYouTubeKit Demo/Pods/Google-API-Client/Source/Services/YouTube/Generated/GTLYouTubeGuideCategoryListResponse.m b/XCDYouTubeKit Demo/Pods/Google-API-Client/Source/Services/YouTube/Generated/GTLYouTubeGuideCategoryListResponse.m new file mode 100644 index 00000000..6b93e8c2 --- /dev/null +++ b/XCDYouTubeKit Demo/Pods/Google-API-Client/Source/Services/YouTube/Generated/GTLYouTubeGuideCategoryListResponse.m @@ -0,0 +1,64 @@ +/* Copyright (c) 2013 Google Inc. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +// +// GTLYouTubeGuideCategoryListResponse.m +// + +// ---------------------------------------------------------------------------- +// NOTE: This file is generated from Google APIs Discovery Service. +// Service: +// YouTube Data API (youtube/v3) +// Description: +// Programmatic access to YouTube features. +// Documentation: +// https://developers.google.com/youtube/v3 +// Classes: +// GTLYouTubeGuideCategoryListResponse (0 custom class methods, 9 custom properties) + +#import "GTLYouTubeGuideCategoryListResponse.h" + +#import "GTLYouTubeGuideCategory.h" +#import "GTLYouTubePageInfo.h" +#import "GTLYouTubeTokenPagination.h" + +// ---------------------------------------------------------------------------- +// +// GTLYouTubeGuideCategoryListResponse +// + +@implementation GTLYouTubeGuideCategoryListResponse +@dynamic ETag, eventId, items, kind, nextPageToken, pageInfo, prevPageToken, + tokenPagination, visitorId; + ++ (NSDictionary *)propertyToJSONKeyMap { + NSDictionary *map = + [NSDictionary dictionaryWithObject:@"etag" + forKey:@"ETag"]; + return map; +} + ++ (NSDictionary *)arrayPropertyToClassMap { + NSDictionary *map = + [NSDictionary dictionaryWithObject:[GTLYouTubeGuideCategory class] + forKey:@"items"]; + return map; +} + ++ (void)load { + [self registerObjectClassForKind:@"youtube#guideCategoryListResponse"]; +} + +@end diff --git a/XCDYouTubeKit Demo/Pods/Google-API-Client/Source/Services/YouTube/Generated/GTLYouTubeGuideCategorySnippet.h b/XCDYouTubeKit Demo/Pods/Google-API-Client/Source/Services/YouTube/Generated/GTLYouTubeGuideCategorySnippet.h new file mode 100644 index 00000000..77153ea8 --- /dev/null +++ b/XCDYouTubeKit Demo/Pods/Google-API-Client/Source/Services/YouTube/Generated/GTLYouTubeGuideCategorySnippet.h @@ -0,0 +1,50 @@ +/* Copyright (c) 2013 Google Inc. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +// +// GTLYouTubeGuideCategorySnippet.h +// + +// ---------------------------------------------------------------------------- +// NOTE: This file is generated from Google APIs Discovery Service. +// Service: +// YouTube Data API (youtube/v3) +// Description: +// Programmatic access to YouTube features. +// Documentation: +// https://developers.google.com/youtube/v3 +// Classes: +// GTLYouTubeGuideCategorySnippet (0 custom class methods, 2 custom properties) + +#if GTL_BUILT_AS_FRAMEWORK + #import "GTL/GTLObject.h" +#else + #import "GTLObject.h" +#endif + +// ---------------------------------------------------------------------------- +// +// GTLYouTubeGuideCategorySnippet +// + +// Basic details about a guide category. + +@interface GTLYouTubeGuideCategorySnippet : GTLObject +@property (copy) NSString *channelId; + +// Description of the guide category. +@property (copy) NSString *title; + +@end diff --git a/XCDYouTubeKit Demo/Pods/Google-API-Client/Source/Services/YouTube/Generated/GTLYouTubeGuideCategorySnippet.m b/XCDYouTubeKit Demo/Pods/Google-API-Client/Source/Services/YouTube/Generated/GTLYouTubeGuideCategorySnippet.m new file mode 100644 index 00000000..479e9853 --- /dev/null +++ b/XCDYouTubeKit Demo/Pods/Google-API-Client/Source/Services/YouTube/Generated/GTLYouTubeGuideCategorySnippet.m @@ -0,0 +1,40 @@ +/* Copyright (c) 2012 Google Inc. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +// +// GTLYouTubeGuideCategorySnippet.m +// + +// ---------------------------------------------------------------------------- +// NOTE: This file is generated from Google APIs Discovery Service. +// Service: +// YouTube Data API (youtube/v3) +// Description: +// Programmatic access to YouTube features. +// Documentation: +// https://developers.google.com/youtube/v3 +// Classes: +// GTLYouTubeGuideCategorySnippet (0 custom class methods, 2 custom properties) + +#import "GTLYouTubeGuideCategorySnippet.h" + +// ---------------------------------------------------------------------------- +// +// GTLYouTubeGuideCategorySnippet +// + +@implementation GTLYouTubeGuideCategorySnippet +@dynamic channelId, title; +@end diff --git a/XCDYouTubeKit Demo/Pods/Google-API-Client/Source/Services/YouTube/Generated/GTLYouTubeI18nLanguage.h b/XCDYouTubeKit Demo/Pods/Google-API-Client/Source/Services/YouTube/Generated/GTLYouTubeI18nLanguage.h new file mode 100644 index 00000000..27007870 --- /dev/null +++ b/XCDYouTubeKit Demo/Pods/Google-API-Client/Source/Services/YouTube/Generated/GTLYouTubeI18nLanguage.h @@ -0,0 +1,64 @@ +/* Copyright (c) 2014 Google Inc. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +// +// GTLYouTubeI18nLanguage.h +// + +// ---------------------------------------------------------------------------- +// NOTE: This file is generated from Google APIs Discovery Service. +// Service: +// YouTube Data API (youtube/v3) +// Description: +// Programmatic access to YouTube features. +// Documentation: +// https://developers.google.com/youtube/v3 +// Classes: +// GTLYouTubeI18nLanguage (0 custom class methods, 4 custom properties) + +#if GTL_BUILT_AS_FRAMEWORK + #import "GTL/GTLObject.h" +#else + #import "GTLObject.h" +#endif + +@class GTLYouTubeI18nLanguageSnippet; + +// ---------------------------------------------------------------------------- +// +// GTLYouTubeI18nLanguage +// + +// An i18nLanguage resource identifies a UI language currently supported by +// YouTube. + +@interface GTLYouTubeI18nLanguage : GTLObject + +// Etag of this resource. +@property (copy) NSString *ETag; + +// The ID that YouTube uses to uniquely identify the i18n language. +// identifier property maps to 'id' in JSON (to avoid Objective C's 'id'). +@property (copy) NSString *identifier; + +// Identifies what kind of resource this is. Value: the fixed string +// "youtube#i18nLanguage". +@property (copy) NSString *kind; + +// The snippet object contains basic details about the i18n language, such as +// language code and human-readable name. +@property (retain) GTLYouTubeI18nLanguageSnippet *snippet; + +@end diff --git a/XCDYouTubeKit Demo/Pods/Google-API-Client/Source/Services/YouTube/Generated/GTLYouTubeI18nLanguage.m b/XCDYouTubeKit Demo/Pods/Google-API-Client/Source/Services/YouTube/Generated/GTLYouTubeI18nLanguage.m new file mode 100644 index 00000000..f28efac1 --- /dev/null +++ b/XCDYouTubeKit Demo/Pods/Google-API-Client/Source/Services/YouTube/Generated/GTLYouTubeI18nLanguage.m @@ -0,0 +1,56 @@ +/* Copyright (c) 2014 Google Inc. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +// +// GTLYouTubeI18nLanguage.m +// + +// ---------------------------------------------------------------------------- +// NOTE: This file is generated from Google APIs Discovery Service. +// Service: +// YouTube Data API (youtube/v3) +// Description: +// Programmatic access to YouTube features. +// Documentation: +// https://developers.google.com/youtube/v3 +// Classes: +// GTLYouTubeI18nLanguage (0 custom class methods, 4 custom properties) + +#import "GTLYouTubeI18nLanguage.h" + +#import "GTLYouTubeI18nLanguageSnippet.h" + +// ---------------------------------------------------------------------------- +// +// GTLYouTubeI18nLanguage +// + +@implementation GTLYouTubeI18nLanguage +@dynamic ETag, identifier, kind, snippet; + ++ (NSDictionary *)propertyToJSONKeyMap { + NSDictionary *map = + [NSDictionary dictionaryWithObjectsAndKeys: + @"etag", @"ETag", + @"id", @"identifier", + nil]; + return map; +} + ++ (void)load { + [self registerObjectClassForKind:@"youtube#i18nLanguage"]; +} + +@end diff --git a/XCDYouTubeKit Demo/Pods/Google-API-Client/Source/Services/YouTube/Generated/GTLYouTubeI18nLanguageListResponse.h b/XCDYouTubeKit Demo/Pods/Google-API-Client/Source/Services/YouTube/Generated/GTLYouTubeI18nLanguageListResponse.h new file mode 100644 index 00000000..dea337f0 --- /dev/null +++ b/XCDYouTubeKit Demo/Pods/Google-API-Client/Source/Services/YouTube/Generated/GTLYouTubeI18nLanguageListResponse.h @@ -0,0 +1,66 @@ +/* Copyright (c) 2014 Google Inc. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +// +// GTLYouTubeI18nLanguageListResponse.h +// + +// ---------------------------------------------------------------------------- +// NOTE: This file is generated from Google APIs Discovery Service. +// Service: +// YouTube Data API (youtube/v3) +// Description: +// Programmatic access to YouTube features. +// Documentation: +// https://developers.google.com/youtube/v3 +// Classes: +// GTLYouTubeI18nLanguageListResponse (0 custom class methods, 5 custom properties) + +#if GTL_BUILT_AS_FRAMEWORK + #import "GTL/GTLObject.h" +#else + #import "GTLObject.h" +#endif + +@class GTLYouTubeI18nLanguage; + +// ---------------------------------------------------------------------------- +// +// GTLYouTubeI18nLanguageListResponse +// + +// This class supports NSFastEnumeration over its "items" property. It also +// supports -itemAtIndex: to retrieve individual objects from "items". + +@interface GTLYouTubeI18nLanguageListResponse : GTLCollectionObject + +// Etag of this resource. +@property (copy) NSString *ETag; + +// Serialized EventId of the request which produced this response. +@property (copy) NSString *eventId; + +// A list of supported i18n languages. In this map, the i18n language ID is the +// map key, and its value is the corresponding i18nLanguage resource. +@property (retain) NSArray *items; // of GTLYouTubeI18nLanguage + +// Identifies what kind of resource this is. Value: the fixed string +// "youtube#i18nLanguageListResponse". +@property (copy) NSString *kind; + +// The visitorId identifies the visitor. +@property (copy) NSString *visitorId; + +@end diff --git a/XCDYouTubeKit Demo/Pods/Google-API-Client/Source/Services/YouTube/Generated/GTLYouTubeI18nLanguageListResponse.m b/XCDYouTubeKit Demo/Pods/Google-API-Client/Source/Services/YouTube/Generated/GTLYouTubeI18nLanguageListResponse.m new file mode 100644 index 00000000..916980e1 --- /dev/null +++ b/XCDYouTubeKit Demo/Pods/Google-API-Client/Source/Services/YouTube/Generated/GTLYouTubeI18nLanguageListResponse.m @@ -0,0 +1,61 @@ +/* Copyright (c) 2014 Google Inc. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +// +// GTLYouTubeI18nLanguageListResponse.m +// + +// ---------------------------------------------------------------------------- +// NOTE: This file is generated from Google APIs Discovery Service. +// Service: +// YouTube Data API (youtube/v3) +// Description: +// Programmatic access to YouTube features. +// Documentation: +// https://developers.google.com/youtube/v3 +// Classes: +// GTLYouTubeI18nLanguageListResponse (0 custom class methods, 5 custom properties) + +#import "GTLYouTubeI18nLanguageListResponse.h" + +#import "GTLYouTubeI18nLanguage.h" + +// ---------------------------------------------------------------------------- +// +// GTLYouTubeI18nLanguageListResponse +// + +@implementation GTLYouTubeI18nLanguageListResponse +@dynamic ETag, eventId, items, kind, visitorId; + ++ (NSDictionary *)propertyToJSONKeyMap { + NSDictionary *map = + [NSDictionary dictionaryWithObject:@"etag" + forKey:@"ETag"]; + return map; +} + ++ (NSDictionary *)arrayPropertyToClassMap { + NSDictionary *map = + [NSDictionary dictionaryWithObject:[GTLYouTubeI18nLanguage class] + forKey:@"items"]; + return map; +} + ++ (void)load { + [self registerObjectClassForKind:@"youtube#i18nLanguageListResponse"]; +} + +@end diff --git a/XCDYouTubeKit Demo/Pods/Google-API-Client/Source/Services/YouTube/Generated/GTLYouTubeI18nLanguageSnippet.h b/XCDYouTubeKit Demo/Pods/Google-API-Client/Source/Services/YouTube/Generated/GTLYouTubeI18nLanguageSnippet.h new file mode 100644 index 00000000..e6b9cc73 --- /dev/null +++ b/XCDYouTubeKit Demo/Pods/Google-API-Client/Source/Services/YouTube/Generated/GTLYouTubeI18nLanguageSnippet.h @@ -0,0 +1,53 @@ +/* Copyright (c) 2014 Google Inc. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +// +// GTLYouTubeI18nLanguageSnippet.h +// + +// ---------------------------------------------------------------------------- +// NOTE: This file is generated from Google APIs Discovery Service. +// Service: +// YouTube Data API (youtube/v3) +// Description: +// Programmatic access to YouTube features. +// Documentation: +// https://developers.google.com/youtube/v3 +// Classes: +// GTLYouTubeI18nLanguageSnippet (0 custom class methods, 2 custom properties) + +#if GTL_BUILT_AS_FRAMEWORK + #import "GTL/GTLObject.h" +#else + #import "GTLObject.h" +#endif + +// ---------------------------------------------------------------------------- +// +// GTLYouTubeI18nLanguageSnippet +// + +// Basic details about an i18n language, such as language code and +// human-readable name. + +@interface GTLYouTubeI18nLanguageSnippet : GTLObject + +// A short BCP-47 code that uniquely identifies a language. +@property (copy) NSString *hl; + +// The human-readable name of the language in the language itself. +@property (copy) NSString *name; + +@end diff --git a/XCDYouTubeKit Demo/Pods/Google-API-Client/Source/Services/YouTube/Generated/GTLYouTubeI18nLanguageSnippet.m b/XCDYouTubeKit Demo/Pods/Google-API-Client/Source/Services/YouTube/Generated/GTLYouTubeI18nLanguageSnippet.m new file mode 100644 index 00000000..820db382 --- /dev/null +++ b/XCDYouTubeKit Demo/Pods/Google-API-Client/Source/Services/YouTube/Generated/GTLYouTubeI18nLanguageSnippet.m @@ -0,0 +1,40 @@ +/* Copyright (c) 2014 Google Inc. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +// +// GTLYouTubeI18nLanguageSnippet.m +// + +// ---------------------------------------------------------------------------- +// NOTE: This file is generated from Google APIs Discovery Service. +// Service: +// YouTube Data API (youtube/v3) +// Description: +// Programmatic access to YouTube features. +// Documentation: +// https://developers.google.com/youtube/v3 +// Classes: +// GTLYouTubeI18nLanguageSnippet (0 custom class methods, 2 custom properties) + +#import "GTLYouTubeI18nLanguageSnippet.h" + +// ---------------------------------------------------------------------------- +// +// GTLYouTubeI18nLanguageSnippet +// + +@implementation GTLYouTubeI18nLanguageSnippet +@dynamic hl, name; +@end diff --git a/XCDYouTubeKit Demo/Pods/Google-API-Client/Source/Services/YouTube/Generated/GTLYouTubeI18nRegion.h b/XCDYouTubeKit Demo/Pods/Google-API-Client/Source/Services/YouTube/Generated/GTLYouTubeI18nRegion.h new file mode 100644 index 00000000..5a4d78ae --- /dev/null +++ b/XCDYouTubeKit Demo/Pods/Google-API-Client/Source/Services/YouTube/Generated/GTLYouTubeI18nRegion.h @@ -0,0 +1,63 @@ +/* Copyright (c) 2014 Google Inc. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +// +// GTLYouTubeI18nRegion.h +// + +// ---------------------------------------------------------------------------- +// NOTE: This file is generated from Google APIs Discovery Service. +// Service: +// YouTube Data API (youtube/v3) +// Description: +// Programmatic access to YouTube features. +// Documentation: +// https://developers.google.com/youtube/v3 +// Classes: +// GTLYouTubeI18nRegion (0 custom class methods, 4 custom properties) + +#if GTL_BUILT_AS_FRAMEWORK + #import "GTL/GTLObject.h" +#else + #import "GTLObject.h" +#endif + +@class GTLYouTubeI18nRegionSnippet; + +// ---------------------------------------------------------------------------- +// +// GTLYouTubeI18nRegion +// + +// A i18nRegion resource identifies a region where YouTube is available. + +@interface GTLYouTubeI18nRegion : GTLObject + +// Etag of this resource. +@property (copy) NSString *ETag; + +// The ID that YouTube uses to uniquely identify the i18n region. +// identifier property maps to 'id' in JSON (to avoid Objective C's 'id'). +@property (copy) NSString *identifier; + +// Identifies what kind of resource this is. Value: the fixed string +// "youtube#i18nRegion". +@property (copy) NSString *kind; + +// The snippet object contains basic details about the i18n region, such as +// region code and human-readable name. +@property (retain) GTLYouTubeI18nRegionSnippet *snippet; + +@end diff --git a/XCDYouTubeKit Demo/Pods/Google-API-Client/Source/Services/YouTube/Generated/GTLYouTubeI18nRegion.m b/XCDYouTubeKit Demo/Pods/Google-API-Client/Source/Services/YouTube/Generated/GTLYouTubeI18nRegion.m new file mode 100644 index 00000000..c8485765 --- /dev/null +++ b/XCDYouTubeKit Demo/Pods/Google-API-Client/Source/Services/YouTube/Generated/GTLYouTubeI18nRegion.m @@ -0,0 +1,56 @@ +/* Copyright (c) 2014 Google Inc. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +// +// GTLYouTubeI18nRegion.m +// + +// ---------------------------------------------------------------------------- +// NOTE: This file is generated from Google APIs Discovery Service. +// Service: +// YouTube Data API (youtube/v3) +// Description: +// Programmatic access to YouTube features. +// Documentation: +// https://developers.google.com/youtube/v3 +// Classes: +// GTLYouTubeI18nRegion (0 custom class methods, 4 custom properties) + +#import "GTLYouTubeI18nRegion.h" + +#import "GTLYouTubeI18nRegionSnippet.h" + +// ---------------------------------------------------------------------------- +// +// GTLYouTubeI18nRegion +// + +@implementation GTLYouTubeI18nRegion +@dynamic ETag, identifier, kind, snippet; + ++ (NSDictionary *)propertyToJSONKeyMap { + NSDictionary *map = + [NSDictionary dictionaryWithObjectsAndKeys: + @"etag", @"ETag", + @"id", @"identifier", + nil]; + return map; +} + ++ (void)load { + [self registerObjectClassForKind:@"youtube#i18nRegion"]; +} + +@end diff --git a/XCDYouTubeKit Demo/Pods/Google-API-Client/Source/Services/YouTube/Generated/GTLYouTubeI18nRegionListResponse.h b/XCDYouTubeKit Demo/Pods/Google-API-Client/Source/Services/YouTube/Generated/GTLYouTubeI18nRegionListResponse.h new file mode 100644 index 00000000..9e27c07a --- /dev/null +++ b/XCDYouTubeKit Demo/Pods/Google-API-Client/Source/Services/YouTube/Generated/GTLYouTubeI18nRegionListResponse.h @@ -0,0 +1,66 @@ +/* Copyright (c) 2014 Google Inc. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +// +// GTLYouTubeI18nRegionListResponse.h +// + +// ---------------------------------------------------------------------------- +// NOTE: This file is generated from Google APIs Discovery Service. +// Service: +// YouTube Data API (youtube/v3) +// Description: +// Programmatic access to YouTube features. +// Documentation: +// https://developers.google.com/youtube/v3 +// Classes: +// GTLYouTubeI18nRegionListResponse (0 custom class methods, 5 custom properties) + +#if GTL_BUILT_AS_FRAMEWORK + #import "GTL/GTLObject.h" +#else + #import "GTLObject.h" +#endif + +@class GTLYouTubeI18nRegion; + +// ---------------------------------------------------------------------------- +// +// GTLYouTubeI18nRegionListResponse +// + +// This class supports NSFastEnumeration over its "items" property. It also +// supports -itemAtIndex: to retrieve individual objects from "items". + +@interface GTLYouTubeI18nRegionListResponse : GTLCollectionObject + +// Etag of this resource. +@property (copy) NSString *ETag; + +// Serialized EventId of the request which produced this response. +@property (copy) NSString *eventId; + +// A list of regions where YouTube is available. In this map, the i18n region ID +// is the map key, and its value is the corresponding i18nRegion resource. +@property (retain) NSArray *items; // of GTLYouTubeI18nRegion + +// Identifies what kind of resource this is. Value: the fixed string +// "youtube#i18nRegionListResponse". +@property (copy) NSString *kind; + +// The visitorId identifies the visitor. +@property (copy) NSString *visitorId; + +@end diff --git a/XCDYouTubeKit Demo/Pods/Google-API-Client/Source/Services/YouTube/Generated/GTLYouTubeI18nRegionListResponse.m b/XCDYouTubeKit Demo/Pods/Google-API-Client/Source/Services/YouTube/Generated/GTLYouTubeI18nRegionListResponse.m new file mode 100644 index 00000000..ef743fee --- /dev/null +++ b/XCDYouTubeKit Demo/Pods/Google-API-Client/Source/Services/YouTube/Generated/GTLYouTubeI18nRegionListResponse.m @@ -0,0 +1,61 @@ +/* Copyright (c) 2014 Google Inc. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +// +// GTLYouTubeI18nRegionListResponse.m +// + +// ---------------------------------------------------------------------------- +// NOTE: This file is generated from Google APIs Discovery Service. +// Service: +// YouTube Data API (youtube/v3) +// Description: +// Programmatic access to YouTube features. +// Documentation: +// https://developers.google.com/youtube/v3 +// Classes: +// GTLYouTubeI18nRegionListResponse (0 custom class methods, 5 custom properties) + +#import "GTLYouTubeI18nRegionListResponse.h" + +#import "GTLYouTubeI18nRegion.h" + +// ---------------------------------------------------------------------------- +// +// GTLYouTubeI18nRegionListResponse +// + +@implementation GTLYouTubeI18nRegionListResponse +@dynamic ETag, eventId, items, kind, visitorId; + ++ (NSDictionary *)propertyToJSONKeyMap { + NSDictionary *map = + [NSDictionary dictionaryWithObject:@"etag" + forKey:@"ETag"]; + return map; +} + ++ (NSDictionary *)arrayPropertyToClassMap { + NSDictionary *map = + [NSDictionary dictionaryWithObject:[GTLYouTubeI18nRegion class] + forKey:@"items"]; + return map; +} + ++ (void)load { + [self registerObjectClassForKind:@"youtube#i18nRegionListResponse"]; +} + +@end diff --git a/XCDYouTubeKit Demo/Pods/Google-API-Client/Source/Services/YouTube/Generated/GTLYouTubeI18nRegionSnippet.h b/XCDYouTubeKit Demo/Pods/Google-API-Client/Source/Services/YouTube/Generated/GTLYouTubeI18nRegionSnippet.h new file mode 100644 index 00000000..8a1501a1 --- /dev/null +++ b/XCDYouTubeKit Demo/Pods/Google-API-Client/Source/Services/YouTube/Generated/GTLYouTubeI18nRegionSnippet.h @@ -0,0 +1,53 @@ +/* Copyright (c) 2014 Google Inc. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +// +// GTLYouTubeI18nRegionSnippet.h +// + +// ---------------------------------------------------------------------------- +// NOTE: This file is generated from Google APIs Discovery Service. +// Service: +// YouTube Data API (youtube/v3) +// Description: +// Programmatic access to YouTube features. +// Documentation: +// https://developers.google.com/youtube/v3 +// Classes: +// GTLYouTubeI18nRegionSnippet (0 custom class methods, 2 custom properties) + +#if GTL_BUILT_AS_FRAMEWORK + #import "GTL/GTLObject.h" +#else + #import "GTLObject.h" +#endif + +// ---------------------------------------------------------------------------- +// +// GTLYouTubeI18nRegionSnippet +// + +// Basic details about an i18n region, such as region code and human-readable +// name. + +@interface GTLYouTubeI18nRegionSnippet : GTLObject + +// The region code as a 2-letter ISO country code. +@property (copy) NSString *gl; + +// The human-readable name of the region. +@property (copy) NSString *name; + +@end diff --git a/XCDYouTubeKit Demo/Pods/Google-API-Client/Source/Services/YouTube/Generated/GTLYouTubeI18nRegionSnippet.m b/XCDYouTubeKit Demo/Pods/Google-API-Client/Source/Services/YouTube/Generated/GTLYouTubeI18nRegionSnippet.m new file mode 100644 index 00000000..b94cb938 --- /dev/null +++ b/XCDYouTubeKit Demo/Pods/Google-API-Client/Source/Services/YouTube/Generated/GTLYouTubeI18nRegionSnippet.m @@ -0,0 +1,40 @@ +/* Copyright (c) 2014 Google Inc. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +// +// GTLYouTubeI18nRegionSnippet.m +// + +// ---------------------------------------------------------------------------- +// NOTE: This file is generated from Google APIs Discovery Service. +// Service: +// YouTube Data API (youtube/v3) +// Description: +// Programmatic access to YouTube features. +// Documentation: +// https://developers.google.com/youtube/v3 +// Classes: +// GTLYouTubeI18nRegionSnippet (0 custom class methods, 2 custom properties) + +#import "GTLYouTubeI18nRegionSnippet.h" + +// ---------------------------------------------------------------------------- +// +// GTLYouTubeI18nRegionSnippet +// + +@implementation GTLYouTubeI18nRegionSnippet +@dynamic gl, name; +@end diff --git a/XCDYouTubeKit Demo/Pods/Google-API-Client/Source/Services/YouTube/Generated/GTLYouTubeImageSettings.h b/XCDYouTubeKit Demo/Pods/Google-API-Client/Source/Services/YouTube/Generated/GTLYouTubeImageSettings.h new file mode 100644 index 00000000..7756e3c0 --- /dev/null +++ b/XCDYouTubeKit Demo/Pods/Google-API-Client/Source/Services/YouTube/Generated/GTLYouTubeImageSettings.h @@ -0,0 +1,121 @@ +/* Copyright (c) 2013 Google Inc. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +// +// GTLYouTubeImageSettings.h +// + +// ---------------------------------------------------------------------------- +// NOTE: This file is generated from Google APIs Discovery Service. +// Service: +// YouTube Data API (youtube/v3) +// Description: +// Programmatic access to YouTube features. +// Documentation: +// https://developers.google.com/youtube/v3 +// Classes: +// GTLYouTubeImageSettings (0 custom class methods, 22 custom properties) + +#if GTL_BUILT_AS_FRAMEWORK + #import "GTL/GTLObject.h" +#else + #import "GTLObject.h" +#endif + +@class GTLYouTubeLocalizedProperty; + +// ---------------------------------------------------------------------------- +// +// GTLYouTubeImageSettings +// + +// Branding properties for images associated with the channel. + +@interface GTLYouTubeImageSettings : GTLObject + +// The URL for the background image shown on the video watch page. The image +// should be 1200px by 615px, with a maximum file size of 128k. +@property (retain) GTLYouTubeLocalizedProperty *backgroundImageUrl; + +// This is used only in update requests; if it's set, we use this URL to +// generate all of the above banner URLs. +@property (copy) NSString *bannerExternalUrl; + +// Banner image. Desktop size (1060x175). +@property (copy) NSString *bannerImageUrl; + +// Banner image. Mobile size high resolution (1440x395). +@property (copy) NSString *bannerMobileExtraHdImageUrl; + +// Banner image. Mobile size high resolution (1280x360). +@property (copy) NSString *bannerMobileHdImageUrl; + +// Banner image. Mobile size (640x175). +@property (copy) NSString *bannerMobileImageUrl; + +// Banner image. Mobile size low resolution (320x88). +@property (copy) NSString *bannerMobileLowImageUrl; + +// Banner image. Mobile size medium/high resolution (960x263). +@property (copy) NSString *bannerMobileMediumHdImageUrl; + +// Banner image. Tablet size extra high resolution (2560x424). +@property (copy) NSString *bannerTabletExtraHdImageUrl; + +// Banner image. Tablet size high resolution (2276x377). +@property (copy) NSString *bannerTabletHdImageUrl; + +// Banner image. Tablet size (1707x283). +@property (copy) NSString *bannerTabletImageUrl; + +// Banner image. Tablet size low resolution (1138x188). +@property (copy) NSString *bannerTabletLowImageUrl; + +// Banner image. TV size high resolution (1920x1080). +@property (copy) NSString *bannerTvHighImageUrl; + +// Banner image. TV size extra high resolution (2120x1192). +@property (copy) NSString *bannerTvImageUrl; + +// Banner image. TV size low resolution (854x480). +@property (copy) NSString *bannerTvLowImageUrl; + +// Banner image. TV size medium resolution (1280x720). +@property (copy) NSString *bannerTvMediumImageUrl; + +// The image map script for the large banner image. +@property (retain) GTLYouTubeLocalizedProperty *largeBrandedBannerImageImapScript; + +// The URL for the 854px by 70px image that appears below the video player in +// the expanded video view of the video watch page. +@property (retain) GTLYouTubeLocalizedProperty *largeBrandedBannerImageUrl; + +// The image map script for the small banner image. +@property (retain) GTLYouTubeLocalizedProperty *smallBrandedBannerImageImapScript; + +// The URL for the 640px by 70px banner image that appears below the video +// player in the default view of the video watch page. +@property (retain) GTLYouTubeLocalizedProperty *smallBrandedBannerImageUrl; + +// The URL for a 1px by 1px tracking pixel that can be used to collect +// statistics for views of the channel or video pages. +@property (copy) NSString *trackingImageUrl; + +// The URL for the image that appears above the top-left corner of the video +// player. This is a 25-pixel-high image with a flexible width that cannot +// exceed 170 pixels. +@property (copy) NSString *watchIconImageUrl; + +@end diff --git a/XCDYouTubeKit Demo/Pods/Google-API-Client/Source/Services/YouTube/Generated/GTLYouTubeImageSettings.m b/XCDYouTubeKit Demo/Pods/Google-API-Client/Source/Services/YouTube/Generated/GTLYouTubeImageSettings.m new file mode 100644 index 00000000..4794df39 --- /dev/null +++ b/XCDYouTubeKit Demo/Pods/Google-API-Client/Source/Services/YouTube/Generated/GTLYouTubeImageSettings.m @@ -0,0 +1,50 @@ +/* Copyright (c) 2013 Google Inc. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +// +// GTLYouTubeImageSettings.m +// + +// ---------------------------------------------------------------------------- +// NOTE: This file is generated from Google APIs Discovery Service. +// Service: +// YouTube Data API (youtube/v3) +// Description: +// Programmatic access to YouTube features. +// Documentation: +// https://developers.google.com/youtube/v3 +// Classes: +// GTLYouTubeImageSettings (0 custom class methods, 22 custom properties) + +#import "GTLYouTubeImageSettings.h" + +#import "GTLYouTubeLocalizedProperty.h" + +// ---------------------------------------------------------------------------- +// +// GTLYouTubeImageSettings +// + +@implementation GTLYouTubeImageSettings +@dynamic backgroundImageUrl, bannerExternalUrl, bannerImageUrl, + bannerMobileExtraHdImageUrl, bannerMobileHdImageUrl, + bannerMobileImageUrl, bannerMobileLowImageUrl, + bannerMobileMediumHdImageUrl, bannerTabletExtraHdImageUrl, + bannerTabletHdImageUrl, bannerTabletImageUrl, bannerTabletLowImageUrl, + bannerTvHighImageUrl, bannerTvImageUrl, bannerTvLowImageUrl, + bannerTvMediumImageUrl, largeBrandedBannerImageImapScript, + largeBrandedBannerImageUrl, smallBrandedBannerImageImapScript, + smallBrandedBannerImageUrl, trackingImageUrl, watchIconImageUrl; +@end diff --git a/XCDYouTubeKit Demo/Pods/Google-API-Client/Source/Services/YouTube/Generated/GTLYouTubeIngestionInfo.h b/XCDYouTubeKit Demo/Pods/Google-API-Client/Source/Services/YouTube/Generated/GTLYouTubeIngestionInfo.h new file mode 100644 index 00000000..4e39ac7c --- /dev/null +++ b/XCDYouTubeKit Demo/Pods/Google-API-Client/Source/Services/YouTube/Generated/GTLYouTubeIngestionInfo.h @@ -0,0 +1,62 @@ +/* Copyright (c) 2013 Google Inc. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +// +// GTLYouTubeIngestionInfo.h +// + +// ---------------------------------------------------------------------------- +// NOTE: This file is generated from Google APIs Discovery Service. +// Service: +// YouTube Data API (youtube/v3) +// Description: +// Programmatic access to YouTube features. +// Documentation: +// https://developers.google.com/youtube/v3 +// Classes: +// GTLYouTubeIngestionInfo (0 custom class methods, 3 custom properties) + +#if GTL_BUILT_AS_FRAMEWORK + #import "GTL/GTLObject.h" +#else + #import "GTLObject.h" +#endif + +// ---------------------------------------------------------------------------- +// +// GTLYouTubeIngestionInfo +// + +// Describes information necessary for ingesting an RTMP or an HTTP stream. + +@interface GTLYouTubeIngestionInfo : GTLObject + +// The backup ingestion URL that you should use to stream video to YouTube. You +// have the option of simultaneously streaming the content that you are sending +// to the ingestionAddress to this URL. +@property (copy) NSString *backupIngestionAddress; + +// The primary ingestion URL that you should use to stream video to YouTube. You +// must stream video to this URL. +// Depending on which application or tool you use to encode your video stream, +// you may need to enter the stream URL and stream name separately or you may +// need to concatenate them in the following format: +// STREAM_URL/STREAM_NAME +@property (copy) NSString *ingestionAddress; + +// The HTTP or RTMP stream name that YouTube assigns to the video stream. +@property (copy) NSString *streamName; + +@end diff --git a/XCDYouTubeKit Demo/Pods/Google-API-Client/Source/Services/YouTube/Generated/GTLYouTubeIngestionInfo.m b/XCDYouTubeKit Demo/Pods/Google-API-Client/Source/Services/YouTube/Generated/GTLYouTubeIngestionInfo.m new file mode 100644 index 00000000..4bd8a029 --- /dev/null +++ b/XCDYouTubeKit Demo/Pods/Google-API-Client/Source/Services/YouTube/Generated/GTLYouTubeIngestionInfo.m @@ -0,0 +1,40 @@ +/* Copyright (c) 2013 Google Inc. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +// +// GTLYouTubeIngestionInfo.m +// + +// ---------------------------------------------------------------------------- +// NOTE: This file is generated from Google APIs Discovery Service. +// Service: +// YouTube Data API (youtube/v3) +// Description: +// Programmatic access to YouTube features. +// Documentation: +// https://developers.google.com/youtube/v3 +// Classes: +// GTLYouTubeIngestionInfo (0 custom class methods, 3 custom properties) + +#import "GTLYouTubeIngestionInfo.h" + +// ---------------------------------------------------------------------------- +// +// GTLYouTubeIngestionInfo +// + +@implementation GTLYouTubeIngestionInfo +@dynamic backupIngestionAddress, ingestionAddress, streamName; +@end diff --git a/XCDYouTubeKit Demo/Pods/Google-API-Client/Source/Services/YouTube/Generated/GTLYouTubeInvideoBranding.h b/XCDYouTubeKit Demo/Pods/Google-API-Client/Source/Services/YouTube/Generated/GTLYouTubeInvideoBranding.h new file mode 100644 index 00000000..ee7f41e8 --- /dev/null +++ b/XCDYouTubeKit Demo/Pods/Google-API-Client/Source/Services/YouTube/Generated/GTLYouTubeInvideoBranding.h @@ -0,0 +1,51 @@ +/* Copyright (c) 2013 Google Inc. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +// +// GTLYouTubeInvideoBranding.h +// + +// ---------------------------------------------------------------------------- +// NOTE: This file is generated from Google APIs Discovery Service. +// Service: +// YouTube Data API (youtube/v3) +// Description: +// Programmatic access to YouTube features. +// Documentation: +// https://developers.google.com/youtube/v3 +// Classes: +// GTLYouTubeInvideoBranding (0 custom class methods, 5 custom properties) + +#if GTL_BUILT_AS_FRAMEWORK + #import "GTL/GTLObject.h" +#else + #import "GTLObject.h" +#endif + +@class GTLYouTubeInvideoPosition; +@class GTLYouTubeInvideoTiming; + +// ---------------------------------------------------------------------------- +// +// GTLYouTubeInvideoBranding +// + +@interface GTLYouTubeInvideoBranding : GTLObject +@property (copy) NSString *imageBytes; // GTLBase64 can encode/decode (probably web-safe format) +@property (copy) NSString *imageUrl; +@property (retain) GTLYouTubeInvideoPosition *position; +@property (copy) NSString *targetChannelId; +@property (retain) GTLYouTubeInvideoTiming *timing; +@end diff --git a/XCDYouTubeKit Demo/Pods/Google-API-Client/Source/Services/YouTube/Generated/GTLYouTubeInvideoBranding.m b/XCDYouTubeKit Demo/Pods/Google-API-Client/Source/Services/YouTube/Generated/GTLYouTubeInvideoBranding.m new file mode 100644 index 00000000..3de73640 --- /dev/null +++ b/XCDYouTubeKit Demo/Pods/Google-API-Client/Source/Services/YouTube/Generated/GTLYouTubeInvideoBranding.m @@ -0,0 +1,43 @@ +/* Copyright (c) 2013 Google Inc. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +// +// GTLYouTubeInvideoBranding.m +// + +// ---------------------------------------------------------------------------- +// NOTE: This file is generated from Google APIs Discovery Service. +// Service: +// YouTube Data API (youtube/v3) +// Description: +// Programmatic access to YouTube features. +// Documentation: +// https://developers.google.com/youtube/v3 +// Classes: +// GTLYouTubeInvideoBranding (0 custom class methods, 5 custom properties) + +#import "GTLYouTubeInvideoBranding.h" + +#import "GTLYouTubeInvideoPosition.h" +#import "GTLYouTubeInvideoTiming.h" + +// ---------------------------------------------------------------------------- +// +// GTLYouTubeInvideoBranding +// + +@implementation GTLYouTubeInvideoBranding +@dynamic imageBytes, imageUrl, position, targetChannelId, timing; +@end diff --git a/XCDYouTubeKit Demo/Pods/Google-API-Client/Source/Services/YouTube/Generated/GTLYouTubeInvideoPosition.h b/XCDYouTubeKit Demo/Pods/Google-API-Client/Source/Services/YouTube/Generated/GTLYouTubeInvideoPosition.h new file mode 100644 index 00000000..c5d6a210 --- /dev/null +++ b/XCDYouTubeKit Demo/Pods/Google-API-Client/Source/Services/YouTube/Generated/GTLYouTubeInvideoPosition.h @@ -0,0 +1,53 @@ +/* Copyright (c) 2013 Google Inc. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +// +// GTLYouTubeInvideoPosition.h +// + +// ---------------------------------------------------------------------------- +// NOTE: This file is generated from Google APIs Discovery Service. +// Service: +// YouTube Data API (youtube/v3) +// Description: +// Programmatic access to YouTube features. +// Documentation: +// https://developers.google.com/youtube/v3 +// Classes: +// GTLYouTubeInvideoPosition (0 custom class methods, 2 custom properties) + +#if GTL_BUILT_AS_FRAMEWORK + #import "GTL/GTLObject.h" +#else + #import "GTLObject.h" +#endif + +// ---------------------------------------------------------------------------- +// +// GTLYouTubeInvideoPosition +// + +// Describes the spatial position of a visual widget inside a video. It is a +// union of various position types, out of which only will be set one. + +@interface GTLYouTubeInvideoPosition : GTLObject + +// Describes in which corner of the video the visual widget will appear. +@property (copy) NSString *cornerPosition; + +// Defines the position type. +@property (copy) NSString *type; + +@end diff --git a/XCDYouTubeKit Demo/Pods/Google-API-Client/Source/Services/YouTube/Generated/GTLYouTubeInvideoPosition.m b/XCDYouTubeKit Demo/Pods/Google-API-Client/Source/Services/YouTube/Generated/GTLYouTubeInvideoPosition.m new file mode 100644 index 00000000..972f9dbb --- /dev/null +++ b/XCDYouTubeKit Demo/Pods/Google-API-Client/Source/Services/YouTube/Generated/GTLYouTubeInvideoPosition.m @@ -0,0 +1,40 @@ +/* Copyright (c) 2013 Google Inc. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +// +// GTLYouTubeInvideoPosition.m +// + +// ---------------------------------------------------------------------------- +// NOTE: This file is generated from Google APIs Discovery Service. +// Service: +// YouTube Data API (youtube/v3) +// Description: +// Programmatic access to YouTube features. +// Documentation: +// https://developers.google.com/youtube/v3 +// Classes: +// GTLYouTubeInvideoPosition (0 custom class methods, 2 custom properties) + +#import "GTLYouTubeInvideoPosition.h" + +// ---------------------------------------------------------------------------- +// +// GTLYouTubeInvideoPosition +// + +@implementation GTLYouTubeInvideoPosition +@dynamic cornerPosition, type; +@end diff --git a/XCDYouTubeKit Demo/Pods/Google-API-Client/Source/Services/YouTube/Generated/GTLYouTubeInvideoPromotion.h b/XCDYouTubeKit Demo/Pods/Google-API-Client/Source/Services/YouTube/Generated/GTLYouTubeInvideoPromotion.h new file mode 100644 index 00000000..aaff9c2f --- /dev/null +++ b/XCDYouTubeKit Demo/Pods/Google-API-Client/Source/Services/YouTube/Generated/GTLYouTubeInvideoPromotion.h @@ -0,0 +1,72 @@ +/* Copyright (c) 2014 Google Inc. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +// +// GTLYouTubeInvideoPromotion.h +// + +// ---------------------------------------------------------------------------- +// NOTE: This file is generated from Google APIs Discovery Service. +// Service: +// YouTube Data API (youtube/v3) +// Description: +// Programmatic access to YouTube features. +// Documentation: +// https://developers.google.com/youtube/v3 +// Classes: +// GTLYouTubeInvideoPromotion (0 custom class methods, 4 custom properties) + +#if GTL_BUILT_AS_FRAMEWORK + #import "GTL/GTLObject.h" +#else + #import "GTLObject.h" +#endif + +@class GTLYouTubeInvideoPosition; +@class GTLYouTubeInvideoTiming; +@class GTLYouTubePromotedItem; + +// ---------------------------------------------------------------------------- +// +// GTLYouTubeInvideoPromotion +// + +// Describes an invideo promotion campaign consisting of multiple promoted +// items. A campaign belongs to a single channel_id. + +// This class supports NSFastEnumeration over its "items" property. It also +// supports -itemAtIndex: to retrieve individual objects from "items". + +@interface GTLYouTubeInvideoPromotion : GTLCollectionObject + +// The default temporal position within the video where the promoted item will +// be displayed. Can be overriden by more specific timing in the item. +@property (retain) GTLYouTubeInvideoTiming *defaultTiming; + +// List of promoted items in decreasing priority. +@property (retain) NSArray *items; // of GTLYouTubePromotedItem + +// The spatial position within the video where the promoted item will be +// displayed. +@property (retain) GTLYouTubeInvideoPosition *position; + +// Indicates whether the channel's promotional campaign uses "smart timing." +// This feature attempts to show promotions at a point in the video when they +// are more likely to be clicked and less likely to disrupt the viewing +// experience. This feature also picks up a single promotion to show on each +// video. +@property (retain) NSNumber *useSmartTiming; // boolValue + +@end diff --git a/XCDYouTubeKit Demo/Pods/Google-API-Client/Source/Services/YouTube/Generated/GTLYouTubeInvideoPromotion.m b/XCDYouTubeKit Demo/Pods/Google-API-Client/Source/Services/YouTube/Generated/GTLYouTubeInvideoPromotion.m new file mode 100644 index 00000000..991392d5 --- /dev/null +++ b/XCDYouTubeKit Demo/Pods/Google-API-Client/Source/Services/YouTube/Generated/GTLYouTubeInvideoPromotion.m @@ -0,0 +1,52 @@ +/* Copyright (c) 2014 Google Inc. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +// +// GTLYouTubeInvideoPromotion.m +// + +// ---------------------------------------------------------------------------- +// NOTE: This file is generated from Google APIs Discovery Service. +// Service: +// YouTube Data API (youtube/v3) +// Description: +// Programmatic access to YouTube features. +// Documentation: +// https://developers.google.com/youtube/v3 +// Classes: +// GTLYouTubeInvideoPromotion (0 custom class methods, 4 custom properties) + +#import "GTLYouTubeInvideoPromotion.h" + +#import "GTLYouTubeInvideoPosition.h" +#import "GTLYouTubeInvideoTiming.h" +#import "GTLYouTubePromotedItem.h" + +// ---------------------------------------------------------------------------- +// +// GTLYouTubeInvideoPromotion +// + +@implementation GTLYouTubeInvideoPromotion +@dynamic defaultTiming, items, position, useSmartTiming; + ++ (NSDictionary *)arrayPropertyToClassMap { + NSDictionary *map = + [NSDictionary dictionaryWithObject:[GTLYouTubePromotedItem class] + forKey:@"items"]; + return map; +} + +@end diff --git a/XCDYouTubeKit Demo/Pods/Google-API-Client/Source/Services/YouTube/Generated/GTLYouTubeInvideoTiming.h b/XCDYouTubeKit Demo/Pods/Google-API-Client/Source/Services/YouTube/Generated/GTLYouTubeInvideoTiming.h new file mode 100644 index 00000000..f596b660 --- /dev/null +++ b/XCDYouTubeKit Demo/Pods/Google-API-Client/Source/Services/YouTube/Generated/GTLYouTubeInvideoTiming.h @@ -0,0 +1,61 @@ +/* Copyright (c) 2013 Google Inc. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +// +// GTLYouTubeInvideoTiming.h +// + +// ---------------------------------------------------------------------------- +// NOTE: This file is generated from Google APIs Discovery Service. +// Service: +// YouTube Data API (youtube/v3) +// Description: +// Programmatic access to YouTube features. +// Documentation: +// https://developers.google.com/youtube/v3 +// Classes: +// GTLYouTubeInvideoTiming (0 custom class methods, 3 custom properties) + +#if GTL_BUILT_AS_FRAMEWORK + #import "GTL/GTLObject.h" +#else + #import "GTLObject.h" +#endif + +// ---------------------------------------------------------------------------- +// +// GTLYouTubeInvideoTiming +// + +// Describes a temporal position of a visual widget inside a video. + +@interface GTLYouTubeInvideoTiming : GTLObject + +// Defines the duration in milliseconds for which the promotion should be +// displayed. If missing, the client should use the default. +@property (retain) NSNumber *durationMs; // unsignedLongLongValue + +// Defines the time at which the promotion will appear. Depending on the value +// of type the value of the offsetMs field will represent a time offset from the +// start or from the end of the video, expressed in milliseconds. +@property (retain) NSNumber *offsetMs; // unsignedLongLongValue + +// Describes a timing type. If the value is offsetFromStart, then the offsetMs +// field represents an offset from the start of the video. If the value is +// offsetFromEnd, then the offsetMs field represents an offset from the end of +// the video. +@property (copy) NSString *type; + +@end diff --git a/XCDYouTubeKit Demo/Pods/Google-API-Client/Source/Services/YouTube/Generated/GTLYouTubeInvideoTiming.m b/XCDYouTubeKit Demo/Pods/Google-API-Client/Source/Services/YouTube/Generated/GTLYouTubeInvideoTiming.m new file mode 100644 index 00000000..1ff03614 --- /dev/null +++ b/XCDYouTubeKit Demo/Pods/Google-API-Client/Source/Services/YouTube/Generated/GTLYouTubeInvideoTiming.m @@ -0,0 +1,40 @@ +/* Copyright (c) 2013 Google Inc. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +// +// GTLYouTubeInvideoTiming.m +// + +// ---------------------------------------------------------------------------- +// NOTE: This file is generated from Google APIs Discovery Service. +// Service: +// YouTube Data API (youtube/v3) +// Description: +// Programmatic access to YouTube features. +// Documentation: +// https://developers.google.com/youtube/v3 +// Classes: +// GTLYouTubeInvideoTiming (0 custom class methods, 3 custom properties) + +#import "GTLYouTubeInvideoTiming.h" + +// ---------------------------------------------------------------------------- +// +// GTLYouTubeInvideoTiming +// + +@implementation GTLYouTubeInvideoTiming +@dynamic durationMs, offsetMs, type; +@end diff --git a/XCDYouTubeKit Demo/Pods/Google-API-Client/Source/Services/YouTube/Generated/GTLYouTubeLanguageTag.h b/XCDYouTubeKit Demo/Pods/Google-API-Client/Source/Services/YouTube/Generated/GTLYouTubeLanguageTag.h new file mode 100644 index 00000000..12c3d5e5 --- /dev/null +++ b/XCDYouTubeKit Demo/Pods/Google-API-Client/Source/Services/YouTube/Generated/GTLYouTubeLanguageTag.h @@ -0,0 +1,44 @@ +/* Copyright (c) 2014 Google Inc. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +// +// GTLYouTubeLanguageTag.h +// + +// ---------------------------------------------------------------------------- +// NOTE: This file is generated from Google APIs Discovery Service. +// Service: +// YouTube Data API (youtube/v3) +// Description: +// Programmatic access to YouTube features. +// Documentation: +// https://developers.google.com/youtube/v3 +// Classes: +// GTLYouTubeLanguageTag (0 custom class methods, 1 custom properties) + +#if GTL_BUILT_AS_FRAMEWORK + #import "GTL/GTLObject.h" +#else + #import "GTLObject.h" +#endif + +// ---------------------------------------------------------------------------- +// +// GTLYouTubeLanguageTag +// + +@interface GTLYouTubeLanguageTag : GTLObject +@property (copy) NSString *value; +@end diff --git a/XCDYouTubeKit Demo/Pods/Google-API-Client/Source/Services/YouTube/Generated/GTLYouTubeLanguageTag.m b/XCDYouTubeKit Demo/Pods/Google-API-Client/Source/Services/YouTube/Generated/GTLYouTubeLanguageTag.m new file mode 100644 index 00000000..c99f7605 --- /dev/null +++ b/XCDYouTubeKit Demo/Pods/Google-API-Client/Source/Services/YouTube/Generated/GTLYouTubeLanguageTag.m @@ -0,0 +1,40 @@ +/* Copyright (c) 2014 Google Inc. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +// +// GTLYouTubeLanguageTag.m +// + +// ---------------------------------------------------------------------------- +// NOTE: This file is generated from Google APIs Discovery Service. +// Service: +// YouTube Data API (youtube/v3) +// Description: +// Programmatic access to YouTube features. +// Documentation: +// https://developers.google.com/youtube/v3 +// Classes: +// GTLYouTubeLanguageTag (0 custom class methods, 1 custom properties) + +#import "GTLYouTubeLanguageTag.h" + +// ---------------------------------------------------------------------------- +// +// GTLYouTubeLanguageTag +// + +@implementation GTLYouTubeLanguageTag +@dynamic value; +@end diff --git a/XCDYouTubeKit Demo/Pods/Google-API-Client/Source/Services/YouTube/Generated/GTLYouTubeLiveBroadcast.h b/XCDYouTubeKit Demo/Pods/Google-API-Client/Source/Services/YouTube/Generated/GTLYouTubeLiveBroadcast.h new file mode 100644 index 00000000..38d7f1ca --- /dev/null +++ b/XCDYouTubeKit Demo/Pods/Google-API-Client/Source/Services/YouTube/Generated/GTLYouTubeLiveBroadcast.h @@ -0,0 +1,75 @@ +/* Copyright (c) 2013 Google Inc. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +// +// GTLYouTubeLiveBroadcast.h +// + +// ---------------------------------------------------------------------------- +// NOTE: This file is generated from Google APIs Discovery Service. +// Service: +// YouTube Data API (youtube/v3) +// Description: +// Programmatic access to YouTube features. +// Documentation: +// https://developers.google.com/youtube/v3 +// Classes: +// GTLYouTubeLiveBroadcast (0 custom class methods, 6 custom properties) + +#if GTL_BUILT_AS_FRAMEWORK + #import "GTL/GTLObject.h" +#else + #import "GTLObject.h" +#endif + +@class GTLYouTubeLiveBroadcastContentDetails; +@class GTLYouTubeLiveBroadcastSnippet; +@class GTLYouTubeLiveBroadcastStatus; + +// ---------------------------------------------------------------------------- +// +// GTLYouTubeLiveBroadcast +// + +// A liveBroadcast resource represents an event that will be streamed, via live +// video, on YouTube. + +@interface GTLYouTubeLiveBroadcast : GTLObject + +// The contentDetails object contains information about the event's video +// content, such as whether the content can be shown in an embedded video player +// or if it will be archived and therefore available for viewing after the event +// has concluded. +@property (retain) GTLYouTubeLiveBroadcastContentDetails *contentDetails; + +// Etag of this resource. +@property (copy) NSString *ETag; + +// The ID that YouTube assigns to uniquely identify the broadcast. +// identifier property maps to 'id' in JSON (to avoid Objective C's 'id'). +@property (copy) NSString *identifier; + +// Identifies what kind of resource this is. Value: the fixed string +// "youtube#liveBroadcast". +@property (copy) NSString *kind; + +// The snippet object contains basic details about the event, including its +// title, description, start time, and end time. +@property (retain) GTLYouTubeLiveBroadcastSnippet *snippet; + +// The status object contains information about the event's status. +@property (retain) GTLYouTubeLiveBroadcastStatus *status; + +@end diff --git a/XCDYouTubeKit Demo/Pods/Google-API-Client/Source/Services/YouTube/Generated/GTLYouTubeLiveBroadcast.m b/XCDYouTubeKit Demo/Pods/Google-API-Client/Source/Services/YouTube/Generated/GTLYouTubeLiveBroadcast.m new file mode 100644 index 00000000..03ce9d1f --- /dev/null +++ b/XCDYouTubeKit Demo/Pods/Google-API-Client/Source/Services/YouTube/Generated/GTLYouTubeLiveBroadcast.m @@ -0,0 +1,58 @@ +/* Copyright (c) 2013 Google Inc. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +// +// GTLYouTubeLiveBroadcast.m +// + +// ---------------------------------------------------------------------------- +// NOTE: This file is generated from Google APIs Discovery Service. +// Service: +// YouTube Data API (youtube/v3) +// Description: +// Programmatic access to YouTube features. +// Documentation: +// https://developers.google.com/youtube/v3 +// Classes: +// GTLYouTubeLiveBroadcast (0 custom class methods, 6 custom properties) + +#import "GTLYouTubeLiveBroadcast.h" + +#import "GTLYouTubeLiveBroadcastContentDetails.h" +#import "GTLYouTubeLiveBroadcastSnippet.h" +#import "GTLYouTubeLiveBroadcastStatus.h" + +// ---------------------------------------------------------------------------- +// +// GTLYouTubeLiveBroadcast +// + +@implementation GTLYouTubeLiveBroadcast +@dynamic contentDetails, ETag, identifier, kind, snippet, status; + ++ (NSDictionary *)propertyToJSONKeyMap { + NSDictionary *map = + [NSDictionary dictionaryWithObjectsAndKeys: + @"etag", @"ETag", + @"id", @"identifier", + nil]; + return map; +} + ++ (void)load { + [self registerObjectClassForKind:@"youtube#liveBroadcast"]; +} + +@end diff --git a/XCDYouTubeKit Demo/Pods/Google-API-Client/Source/Services/YouTube/Generated/GTLYouTubeLiveBroadcastContentDetails.h b/XCDYouTubeKit Demo/Pods/Google-API-Client/Source/Services/YouTube/Generated/GTLYouTubeLiveBroadcastContentDetails.h new file mode 100644 index 00000000..9ccd19c7 --- /dev/null +++ b/XCDYouTubeKit Demo/Pods/Google-API-Client/Source/Services/YouTube/Generated/GTLYouTubeLiveBroadcastContentDetails.h @@ -0,0 +1,95 @@ +/* Copyright (c) 2013 Google Inc. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +// +// GTLYouTubeLiveBroadcastContentDetails.h +// + +// ---------------------------------------------------------------------------- +// NOTE: This file is generated from Google APIs Discovery Service. +// Service: +// YouTube Data API (youtube/v3) +// Description: +// Programmatic access to YouTube features. +// Documentation: +// https://developers.google.com/youtube/v3 +// Classes: +// GTLYouTubeLiveBroadcastContentDetails (0 custom class methods, 8 custom properties) + +#if GTL_BUILT_AS_FRAMEWORK + #import "GTL/GTLObject.h" +#else + #import "GTLObject.h" +#endif + +@class GTLYouTubeMonitorStreamInfo; + +// ---------------------------------------------------------------------------- +// +// GTLYouTubeLiveBroadcastContentDetails +// + +// Detailed settings of a broadcast. + +@interface GTLYouTubeLiveBroadcastContentDetails : GTLObject + +// This value uniquely identifies the live stream bound to the broadcast. +@property (copy) NSString *boundStreamId; + +// This setting indicates whether closed captioning is enabled for this +// broadcast. The ingestion URL of the closed captions is returned through the +// liveStreams API. +@property (retain) NSNumber *enableClosedCaptions; // boolValue + +// This setting indicates whether YouTube should enable content encryption for +// the broadcast. +@property (retain) NSNumber *enableContentEncryption; // boolValue + +// This setting determines whether viewers can access DVR controls while +// watching the video. DVR controls enable the viewer to control the video +// playback experience by pausing, rewinding, or fast forwarding content. The +// default value for this property is true. +// Important: You must set the value to true and also set the enableArchive +// property's value to true if you want to make playback available immediately +// after the broadcast ends. +@property (retain) NSNumber *enableDvr; // boolValue + +// This setting indicates whether the broadcast video can be played in an +// embedded player. If you choose to archive the video (using the enableArchive +// property), this setting will also apply to the archived video. +@property (retain) NSNumber *enableEmbed; // boolValue + +// The monitorStream object contains information about the monitor stream, which +// the broadcaster can use to review the event content before the broadcast +// stream is shown publicly. +@property (retain) GTLYouTubeMonitorStreamInfo *monitorStream; + +// Automatically start recording after the event goes live. The default value +// for this property is true. +// Important: You must also set the enableDvr property's value to true if you +// want the playback to be available immediately after the broadcast ends. If +// you set this property's value to true but do not also set the enableDvr +// property to true, there may be a delay of around one day before the archived +// video will be available for playback. +@property (retain) NSNumber *recordFromStart; // boolValue + +// This setting indicates whether the broadcast should automatically begin with +// an in-stream slate when you update the broadcast's status to live. After +// updating the status, you then need to send a liveCuepoints.insert request +// that sets the cuepoint's eventState to end to remove the in-stream slate and +// make your broadcast stream visible to viewers. +@property (retain) NSNumber *startWithSlate; // boolValue + +@end diff --git a/XCDYouTubeKit Demo/Pods/Google-API-Client/Source/Services/YouTube/Generated/GTLYouTubeLiveBroadcastContentDetails.m b/XCDYouTubeKit Demo/Pods/Google-API-Client/Source/Services/YouTube/Generated/GTLYouTubeLiveBroadcastContentDetails.m new file mode 100644 index 00000000..f2f06cfe --- /dev/null +++ b/XCDYouTubeKit Demo/Pods/Google-API-Client/Source/Services/YouTube/Generated/GTLYouTubeLiveBroadcastContentDetails.m @@ -0,0 +1,43 @@ +/* Copyright (c) 2013 Google Inc. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +// +// GTLYouTubeLiveBroadcastContentDetails.m +// + +// ---------------------------------------------------------------------------- +// NOTE: This file is generated from Google APIs Discovery Service. +// Service: +// YouTube Data API (youtube/v3) +// Description: +// Programmatic access to YouTube features. +// Documentation: +// https://developers.google.com/youtube/v3 +// Classes: +// GTLYouTubeLiveBroadcastContentDetails (0 custom class methods, 8 custom properties) + +#import "GTLYouTubeLiveBroadcastContentDetails.h" + +#import "GTLYouTubeMonitorStreamInfo.h" + +// ---------------------------------------------------------------------------- +// +// GTLYouTubeLiveBroadcastContentDetails +// + +@implementation GTLYouTubeLiveBroadcastContentDetails +@dynamic boundStreamId, enableClosedCaptions, enableContentEncryption, + enableDvr, enableEmbed, monitorStream, recordFromStart, startWithSlate; +@end diff --git a/XCDYouTubeKit Demo/Pods/Google-API-Client/Source/Services/YouTube/Generated/GTLYouTubeLiveBroadcastListResponse.h b/XCDYouTubeKit Demo/Pods/Google-API-Client/Source/Services/YouTube/Generated/GTLYouTubeLiveBroadcastListResponse.h new file mode 100644 index 00000000..0e270358 --- /dev/null +++ b/XCDYouTubeKit Demo/Pods/Google-API-Client/Source/Services/YouTube/Generated/GTLYouTubeLiveBroadcastListResponse.h @@ -0,0 +1,79 @@ +/* Copyright (c) 2013 Google Inc. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +// +// GTLYouTubeLiveBroadcastListResponse.h +// + +// ---------------------------------------------------------------------------- +// NOTE: This file is generated from Google APIs Discovery Service. +// Service: +// YouTube Data API (youtube/v3) +// Description: +// Programmatic access to YouTube features. +// Documentation: +// https://developers.google.com/youtube/v3 +// Classes: +// GTLYouTubeLiveBroadcastListResponse (0 custom class methods, 9 custom properties) + +#if GTL_BUILT_AS_FRAMEWORK + #import "GTL/GTLObject.h" +#else + #import "GTLObject.h" +#endif + +@class GTLYouTubeLiveBroadcast; +@class GTLYouTubePageInfo; +@class GTLYouTubeTokenPagination; + +// ---------------------------------------------------------------------------- +// +// GTLYouTubeLiveBroadcastListResponse +// + +// This class supports NSFastEnumeration over its "items" property. It also +// supports -itemAtIndex: to retrieve individual objects from "items". + +@interface GTLYouTubeLiveBroadcastListResponse : GTLCollectionObject + +// Etag of this resource. +@property (copy) NSString *ETag; + +// Serialized EventId of the request which produced this response. +@property (copy) NSString *eventId; + +// A list of broadcasts that match the request criteria. +@property (retain) NSArray *items; // of GTLYouTubeLiveBroadcast + +// Identifies what kind of resource this is. Value: the fixed string +// "youtube#liveBroadcastListResponse". +@property (copy) NSString *kind; + +// The token that can be used as the value of the pageToken parameter to +// retrieve the next page in the result set. +@property (copy) NSString *nextPageToken; + +@property (retain) GTLYouTubePageInfo *pageInfo; + +// The token that can be used as the value of the pageToken parameter to +// retrieve the previous page in the result set. +@property (copy) NSString *prevPageToken; + +@property (retain) GTLYouTubeTokenPagination *tokenPagination; + +// The visitorId identifies the visitor. +@property (copy) NSString *visitorId; + +@end diff --git a/XCDYouTubeKit Demo/Pods/Google-API-Client/Source/Services/YouTube/Generated/GTLYouTubeLiveBroadcastListResponse.m b/XCDYouTubeKit Demo/Pods/Google-API-Client/Source/Services/YouTube/Generated/GTLYouTubeLiveBroadcastListResponse.m new file mode 100644 index 00000000..fc617ded --- /dev/null +++ b/XCDYouTubeKit Demo/Pods/Google-API-Client/Source/Services/YouTube/Generated/GTLYouTubeLiveBroadcastListResponse.m @@ -0,0 +1,64 @@ +/* Copyright (c) 2013 Google Inc. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +// +// GTLYouTubeLiveBroadcastListResponse.m +// + +// ---------------------------------------------------------------------------- +// NOTE: This file is generated from Google APIs Discovery Service. +// Service: +// YouTube Data API (youtube/v3) +// Description: +// Programmatic access to YouTube features. +// Documentation: +// https://developers.google.com/youtube/v3 +// Classes: +// GTLYouTubeLiveBroadcastListResponse (0 custom class methods, 9 custom properties) + +#import "GTLYouTubeLiveBroadcastListResponse.h" + +#import "GTLYouTubeLiveBroadcast.h" +#import "GTLYouTubePageInfo.h" +#import "GTLYouTubeTokenPagination.h" + +// ---------------------------------------------------------------------------- +// +// GTLYouTubeLiveBroadcastListResponse +// + +@implementation GTLYouTubeLiveBroadcastListResponse +@dynamic ETag, eventId, items, kind, nextPageToken, pageInfo, prevPageToken, + tokenPagination, visitorId; + ++ (NSDictionary *)propertyToJSONKeyMap { + NSDictionary *map = + [NSDictionary dictionaryWithObject:@"etag" + forKey:@"ETag"]; + return map; +} + ++ (NSDictionary *)arrayPropertyToClassMap { + NSDictionary *map = + [NSDictionary dictionaryWithObject:[GTLYouTubeLiveBroadcast class] + forKey:@"items"]; + return map; +} + ++ (void)load { + [self registerObjectClassForKind:@"youtube#liveBroadcastListResponse"]; +} + +@end diff --git a/XCDYouTubeKit Demo/Pods/Google-API-Client/Source/Services/YouTube/Generated/GTLYouTubeLiveBroadcastSnippet.h b/XCDYouTubeKit Demo/Pods/Google-API-Client/Source/Services/YouTube/Generated/GTLYouTubeLiveBroadcastSnippet.h new file mode 100644 index 00000000..fa9d5278 --- /dev/null +++ b/XCDYouTubeKit Demo/Pods/Google-API-Client/Source/Services/YouTube/Generated/GTLYouTubeLiveBroadcastSnippet.h @@ -0,0 +1,88 @@ +/* Copyright (c) 2013 Google Inc. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +// +// GTLYouTubeLiveBroadcastSnippet.h +// + +// ---------------------------------------------------------------------------- +// NOTE: This file is generated from Google APIs Discovery Service. +// Service: +// YouTube Data API (youtube/v3) +// Description: +// Programmatic access to YouTube features. +// Documentation: +// https://developers.google.com/youtube/v3 +// Classes: +// GTLYouTubeLiveBroadcastSnippet (0 custom class methods, 9 custom properties) + +#if GTL_BUILT_AS_FRAMEWORK + #import "GTL/GTLObject.h" +#else + #import "GTLObject.h" +#endif + +@class GTLYouTubeThumbnailDetails; + +// ---------------------------------------------------------------------------- +// +// GTLYouTubeLiveBroadcastSnippet +// + +@interface GTLYouTubeLiveBroadcastSnippet : GTLObject + +// The date and time that the broadcast actually ended. This information is only +// available once the broadcast's state is complete. The value is specified in +// ISO 8601 (YYYY-MM-DDThh:mm:ss.sZ) format. +@property (retain) GTLDateTime *actualEndTime; + +// The date and time that the broadcast actually started. This information is +// only available once the broadcast's state is live. The value is specified in +// ISO 8601 (YYYY-MM-DDThh:mm:ss.sZ) format. +@property (retain) GTLDateTime *actualStartTime; + +// The ID that YouTube uses to uniquely identify the channel that is publishing +// the broadcast. +@property (copy) NSString *channelId; + +// The broadcast's description. As with the title, you can set this field by +// modifying the broadcast resource or by setting the description field of the +// corresponding video resource. +// Remapped to 'descriptionProperty' to avoid NSObject's 'description'. +@property (copy) NSString *descriptionProperty; + +// The date and time that the broadcast was added to YouTube's live broadcast +// schedule. The value is specified in ISO 8601 (YYYY-MM-DDThh:mm:ss.sZ) format. +@property (retain) GTLDateTime *publishedAt; + +// The date and time that the broadcast is scheduled to end. The value is +// specified in ISO 8601 (YYYY-MM-DDThh:mm:ss.sZ) format. +@property (retain) GTLDateTime *scheduledEndTime; + +// The date and time that the broadcast is scheduled to start. The value is +// specified in ISO 8601 (YYYY-MM-DDThh:mm:ss.sZ) format. +@property (retain) GTLDateTime *scheduledStartTime; + +// A map of thumbnail images associated with the broadcast. For each nested +// object in this object, the key is the name of the thumbnail image, and the +// value is an object that contains other information about the thumbnail. +@property (retain) GTLYouTubeThumbnailDetails *thumbnails; + +// The broadcast's title. Note that the broadcast represents exactly one YouTube +// video. You can set this field by modifying the broadcast resource or by +// setting the title field of the corresponding video resource. +@property (copy) NSString *title; + +@end diff --git a/XCDYouTubeKit Demo/Pods/Google-API-Client/Source/Services/YouTube/Generated/GTLYouTubeLiveBroadcastSnippet.m b/XCDYouTubeKit Demo/Pods/Google-API-Client/Source/Services/YouTube/Generated/GTLYouTubeLiveBroadcastSnippet.m new file mode 100644 index 00000000..dd558808 --- /dev/null +++ b/XCDYouTubeKit Demo/Pods/Google-API-Client/Source/Services/YouTube/Generated/GTLYouTubeLiveBroadcastSnippet.m @@ -0,0 +1,51 @@ +/* Copyright (c) 2013 Google Inc. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +// +// GTLYouTubeLiveBroadcastSnippet.m +// + +// ---------------------------------------------------------------------------- +// NOTE: This file is generated from Google APIs Discovery Service. +// Service: +// YouTube Data API (youtube/v3) +// Description: +// Programmatic access to YouTube features. +// Documentation: +// https://developers.google.com/youtube/v3 +// Classes: +// GTLYouTubeLiveBroadcastSnippet (0 custom class methods, 9 custom properties) + +#import "GTLYouTubeLiveBroadcastSnippet.h" + +#import "GTLYouTubeThumbnailDetails.h" + +// ---------------------------------------------------------------------------- +// +// GTLYouTubeLiveBroadcastSnippet +// + +@implementation GTLYouTubeLiveBroadcastSnippet +@dynamic actualEndTime, actualStartTime, channelId, descriptionProperty, + publishedAt, scheduledEndTime, scheduledStartTime, thumbnails, title; + ++ (NSDictionary *)propertyToJSONKeyMap { + NSDictionary *map = + [NSDictionary dictionaryWithObject:@"description" + forKey:@"descriptionProperty"]; + return map; +} + +@end diff --git a/XCDYouTubeKit Demo/Pods/Google-API-Client/Source/Services/YouTube/Generated/GTLYouTubeLiveBroadcastStatus.h b/XCDYouTubeKit Demo/Pods/Google-API-Client/Source/Services/YouTube/Generated/GTLYouTubeLiveBroadcastStatus.h new file mode 100644 index 00000000..5f298a6d --- /dev/null +++ b/XCDYouTubeKit Demo/Pods/Google-API-Client/Source/Services/YouTube/Generated/GTLYouTubeLiveBroadcastStatus.h @@ -0,0 +1,61 @@ +/* Copyright (c) 2014 Google Inc. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +// +// GTLYouTubeLiveBroadcastStatus.h +// + +// ---------------------------------------------------------------------------- +// NOTE: This file is generated from Google APIs Discovery Service. +// Service: +// YouTube Data API (youtube/v3) +// Description: +// Programmatic access to YouTube features. +// Documentation: +// https://developers.google.com/youtube/v3 +// Classes: +// GTLYouTubeLiveBroadcastStatus (0 custom class methods, 4 custom properties) + +#if GTL_BUILT_AS_FRAMEWORK + #import "GTL/GTLObject.h" +#else + #import "GTLObject.h" +#endif + +// ---------------------------------------------------------------------------- +// +// GTLYouTubeLiveBroadcastStatus +// + +@interface GTLYouTubeLiveBroadcastStatus : GTLObject + +// The broadcast's status. The status can be updated using the API's +// liveBroadcasts.transition method. +@property (copy) NSString *lifeCycleStatus; + +// Priority of the live broadcast event (internal state). +@property (copy) NSString *liveBroadcastPriority; + +// The broadcast's privacy status. Note that the broadcast represents exactly +// one YouTube video, so the privacy settings are identical to those supported +// for videos. In addition, you can set this field by modifying the broadcast +// resource or by setting the privacyStatus field of the corresponding video +// resource. +@property (copy) NSString *privacyStatus; + +// The broadcast's recording status. +@property (copy) NSString *recordingStatus; + +@end diff --git a/XCDYouTubeKit Demo/Pods/Google-API-Client/Source/Services/YouTube/Generated/GTLYouTubeLiveBroadcastStatus.m b/XCDYouTubeKit Demo/Pods/Google-API-Client/Source/Services/YouTube/Generated/GTLYouTubeLiveBroadcastStatus.m new file mode 100644 index 00000000..707e6c85 --- /dev/null +++ b/XCDYouTubeKit Demo/Pods/Google-API-Client/Source/Services/YouTube/Generated/GTLYouTubeLiveBroadcastStatus.m @@ -0,0 +1,40 @@ +/* Copyright (c) 2014 Google Inc. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +// +// GTLYouTubeLiveBroadcastStatus.m +// + +// ---------------------------------------------------------------------------- +// NOTE: This file is generated from Google APIs Discovery Service. +// Service: +// YouTube Data API (youtube/v3) +// Description: +// Programmatic access to YouTube features. +// Documentation: +// https://developers.google.com/youtube/v3 +// Classes: +// GTLYouTubeLiveBroadcastStatus (0 custom class methods, 4 custom properties) + +#import "GTLYouTubeLiveBroadcastStatus.h" + +// ---------------------------------------------------------------------------- +// +// GTLYouTubeLiveBroadcastStatus +// + +@implementation GTLYouTubeLiveBroadcastStatus +@dynamic lifeCycleStatus, liveBroadcastPriority, privacyStatus, recordingStatus; +@end diff --git a/XCDYouTubeKit Demo/Pods/Google-API-Client/Source/Services/YouTube/Generated/GTLYouTubeLiveStream.h b/XCDYouTubeKit Demo/Pods/Google-API-Client/Source/Services/YouTube/Generated/GTLYouTubeLiveStream.h new file mode 100644 index 00000000..19c3726f --- /dev/null +++ b/XCDYouTubeKit Demo/Pods/Google-API-Client/Source/Services/YouTube/Generated/GTLYouTubeLiveStream.h @@ -0,0 +1,78 @@ +/* Copyright (c) 2013 Google Inc. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +// +// GTLYouTubeLiveStream.h +// + +// ---------------------------------------------------------------------------- +// NOTE: This file is generated from Google APIs Discovery Service. +// Service: +// YouTube Data API (youtube/v3) +// Description: +// Programmatic access to YouTube features. +// Documentation: +// https://developers.google.com/youtube/v3 +// Classes: +// GTLYouTubeLiveStream (0 custom class methods, 7 custom properties) + +#if GTL_BUILT_AS_FRAMEWORK + #import "GTL/GTLObject.h" +#else + #import "GTLObject.h" +#endif + +@class GTLYouTubeCdnSettings; +@class GTLYouTubeLiveStreamContentDetails; +@class GTLYouTubeLiveStreamSnippet; +@class GTLYouTubeLiveStreamStatus; + +// ---------------------------------------------------------------------------- +// +// GTLYouTubeLiveStream +// + +// A live stream describes a live ingestion point. + +@interface GTLYouTubeLiveStream : GTLObject + +// The cdn object defines the live stream's content delivery network (CDN) +// settings. These settings provide details about the manner in which you stream +// your content to YouTube. +@property (retain) GTLYouTubeCdnSettings *cdn; + +// The content_details object contains information about the stream, including +// the closed captions ingestion URL. +@property (retain) GTLYouTubeLiveStreamContentDetails *contentDetails; + +// Etag of this resource. +@property (copy) NSString *ETag; + +// The ID that YouTube assigns to uniquely identify the stream. +// identifier property maps to 'id' in JSON (to avoid Objective C's 'id'). +@property (copy) NSString *identifier; + +// Identifies what kind of resource this is. Value: the fixed string +// "youtube#liveStream". +@property (copy) NSString *kind; + +// The snippet object contains basic details about the stream, including its +// channel, title, and description. +@property (retain) GTLYouTubeLiveStreamSnippet *snippet; + +// The status object contains information about live stream's status. +@property (retain) GTLYouTubeLiveStreamStatus *status; + +@end diff --git a/XCDYouTubeKit Demo/Pods/Google-API-Client/Source/Services/YouTube/Generated/GTLYouTubeLiveStream.m b/XCDYouTubeKit Demo/Pods/Google-API-Client/Source/Services/YouTube/Generated/GTLYouTubeLiveStream.m new file mode 100644 index 00000000..f1aa40a1 --- /dev/null +++ b/XCDYouTubeKit Demo/Pods/Google-API-Client/Source/Services/YouTube/Generated/GTLYouTubeLiveStream.m @@ -0,0 +1,59 @@ +/* Copyright (c) 2013 Google Inc. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +// +// GTLYouTubeLiveStream.m +// + +// ---------------------------------------------------------------------------- +// NOTE: This file is generated from Google APIs Discovery Service. +// Service: +// YouTube Data API (youtube/v3) +// Description: +// Programmatic access to YouTube features. +// Documentation: +// https://developers.google.com/youtube/v3 +// Classes: +// GTLYouTubeLiveStream (0 custom class methods, 7 custom properties) + +#import "GTLYouTubeLiveStream.h" + +#import "GTLYouTubeCdnSettings.h" +#import "GTLYouTubeLiveStreamContentDetails.h" +#import "GTLYouTubeLiveStreamSnippet.h" +#import "GTLYouTubeLiveStreamStatus.h" + +// ---------------------------------------------------------------------------- +// +// GTLYouTubeLiveStream +// + +@implementation GTLYouTubeLiveStream +@dynamic cdn, contentDetails, ETag, identifier, kind, snippet, status; + ++ (NSDictionary *)propertyToJSONKeyMap { + NSDictionary *map = + [NSDictionary dictionaryWithObjectsAndKeys: + @"etag", @"ETag", + @"id", @"identifier", + nil]; + return map; +} + ++ (void)load { + [self registerObjectClassForKind:@"youtube#liveStream"]; +} + +@end diff --git a/XCDYouTubeKit Demo/Pods/Google-API-Client/Source/Services/YouTube/Generated/GTLYouTubeLiveStreamContentDetails.h b/XCDYouTubeKit Demo/Pods/Google-API-Client/Source/Services/YouTube/Generated/GTLYouTubeLiveStreamContentDetails.h new file mode 100644 index 00000000..58509467 --- /dev/null +++ b/XCDYouTubeKit Demo/Pods/Google-API-Client/Source/Services/YouTube/Generated/GTLYouTubeLiveStreamContentDetails.h @@ -0,0 +1,64 @@ +/* Copyright (c) 2014 Google Inc. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +// +// GTLYouTubeLiveStreamContentDetails.h +// + +// ---------------------------------------------------------------------------- +// NOTE: This file is generated from Google APIs Discovery Service. +// Service: +// YouTube Data API (youtube/v3) +// Description: +// Programmatic access to YouTube features. +// Documentation: +// https://developers.google.com/youtube/v3 +// Classes: +// GTLYouTubeLiveStreamContentDetails (0 custom class methods, 2 custom properties) + +#if GTL_BUILT_AS_FRAMEWORK + #import "GTL/GTLObject.h" +#else + #import "GTLObject.h" +#endif + +// ---------------------------------------------------------------------------- +// +// GTLYouTubeLiveStreamContentDetails +// + +// Detailed settings of a stream. + +@interface GTLYouTubeLiveStreamContentDetails : GTLObject + +// The ingestion URL where the closed captions of this stream are sent. +@property (copy) NSString *closedCaptionsIngestionUrl; + +// Indicates whether the stream is reusable, which means that it can be bound to +// multiple broadcasts. It is common for broadcasters to reuse the same stream +// for many different broadcasts if those broadcasts occur at different times. +// If you set this value to false, then the stream will not be reusable, which +// means that it can only be bound to one broadcast. Non-reusable streams differ +// from reusable streams in the following ways: +// - A non-reusable stream can only be bound to one broadcast. +// - A non-reusable stream might be deleted by an automated process after the +// broadcast ends. +// - The liveStreams.list method does not list non-reusable streams if you call +// the method and set the mine parameter to true. The only way to use that +// method to retrieve the resource for a non-reusable stream is to use the id +// parameter to identify the stream. +@property (retain) NSNumber *isReusable; // boolValue + +@end diff --git a/XCDYouTubeKit Demo/Pods/Google-API-Client/Source/Services/YouTube/Generated/GTLYouTubeLiveStreamContentDetails.m b/XCDYouTubeKit Demo/Pods/Google-API-Client/Source/Services/YouTube/Generated/GTLYouTubeLiveStreamContentDetails.m new file mode 100644 index 00000000..dbb779f3 --- /dev/null +++ b/XCDYouTubeKit Demo/Pods/Google-API-Client/Source/Services/YouTube/Generated/GTLYouTubeLiveStreamContentDetails.m @@ -0,0 +1,40 @@ +/* Copyright (c) 2014 Google Inc. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +// +// GTLYouTubeLiveStreamContentDetails.m +// + +// ---------------------------------------------------------------------------- +// NOTE: This file is generated from Google APIs Discovery Service. +// Service: +// YouTube Data API (youtube/v3) +// Description: +// Programmatic access to YouTube features. +// Documentation: +// https://developers.google.com/youtube/v3 +// Classes: +// GTLYouTubeLiveStreamContentDetails (0 custom class methods, 2 custom properties) + +#import "GTLYouTubeLiveStreamContentDetails.h" + +// ---------------------------------------------------------------------------- +// +// GTLYouTubeLiveStreamContentDetails +// + +@implementation GTLYouTubeLiveStreamContentDetails +@dynamic closedCaptionsIngestionUrl, isReusable; +@end diff --git a/XCDYouTubeKit Demo/Pods/Google-API-Client/Source/Services/YouTube/Generated/GTLYouTubeLiveStreamListResponse.h b/XCDYouTubeKit Demo/Pods/Google-API-Client/Source/Services/YouTube/Generated/GTLYouTubeLiveStreamListResponse.h new file mode 100644 index 00000000..b1daeb11 --- /dev/null +++ b/XCDYouTubeKit Demo/Pods/Google-API-Client/Source/Services/YouTube/Generated/GTLYouTubeLiveStreamListResponse.h @@ -0,0 +1,79 @@ +/* Copyright (c) 2013 Google Inc. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +// +// GTLYouTubeLiveStreamListResponse.h +// + +// ---------------------------------------------------------------------------- +// NOTE: This file is generated from Google APIs Discovery Service. +// Service: +// YouTube Data API (youtube/v3) +// Description: +// Programmatic access to YouTube features. +// Documentation: +// https://developers.google.com/youtube/v3 +// Classes: +// GTLYouTubeLiveStreamListResponse (0 custom class methods, 9 custom properties) + +#if GTL_BUILT_AS_FRAMEWORK + #import "GTL/GTLObject.h" +#else + #import "GTLObject.h" +#endif + +@class GTLYouTubeLiveStream; +@class GTLYouTubePageInfo; +@class GTLYouTubeTokenPagination; + +// ---------------------------------------------------------------------------- +// +// GTLYouTubeLiveStreamListResponse +// + +// This class supports NSFastEnumeration over its "items" property. It also +// supports -itemAtIndex: to retrieve individual objects from "items". + +@interface GTLYouTubeLiveStreamListResponse : GTLCollectionObject + +// Etag of this resource. +@property (copy) NSString *ETag; + +// Serialized EventId of the request which produced this response. +@property (copy) NSString *eventId; + +// A list of live streams that match the request criteria. +@property (retain) NSArray *items; // of GTLYouTubeLiveStream + +// Identifies what kind of resource this is. Value: the fixed string +// "youtube#liveStreamListResponse". +@property (copy) NSString *kind; + +// The token that can be used as the value of the pageToken parameter to +// retrieve the next page in the result set. +@property (copy) NSString *nextPageToken; + +@property (retain) GTLYouTubePageInfo *pageInfo; + +// The token that can be used as the value of the pageToken parameter to +// retrieve the previous page in the result set. +@property (copy) NSString *prevPageToken; + +@property (retain) GTLYouTubeTokenPagination *tokenPagination; + +// The visitorId identifies the visitor. +@property (copy) NSString *visitorId; + +@end diff --git a/XCDYouTubeKit Demo/Pods/Google-API-Client/Source/Services/YouTube/Generated/GTLYouTubeLiveStreamListResponse.m b/XCDYouTubeKit Demo/Pods/Google-API-Client/Source/Services/YouTube/Generated/GTLYouTubeLiveStreamListResponse.m new file mode 100644 index 00000000..609eddab --- /dev/null +++ b/XCDYouTubeKit Demo/Pods/Google-API-Client/Source/Services/YouTube/Generated/GTLYouTubeLiveStreamListResponse.m @@ -0,0 +1,64 @@ +/* Copyright (c) 2013 Google Inc. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +// +// GTLYouTubeLiveStreamListResponse.m +// + +// ---------------------------------------------------------------------------- +// NOTE: This file is generated from Google APIs Discovery Service. +// Service: +// YouTube Data API (youtube/v3) +// Description: +// Programmatic access to YouTube features. +// Documentation: +// https://developers.google.com/youtube/v3 +// Classes: +// GTLYouTubeLiveStreamListResponse (0 custom class methods, 9 custom properties) + +#import "GTLYouTubeLiveStreamListResponse.h" + +#import "GTLYouTubeLiveStream.h" +#import "GTLYouTubePageInfo.h" +#import "GTLYouTubeTokenPagination.h" + +// ---------------------------------------------------------------------------- +// +// GTLYouTubeLiveStreamListResponse +// + +@implementation GTLYouTubeLiveStreamListResponse +@dynamic ETag, eventId, items, kind, nextPageToken, pageInfo, prevPageToken, + tokenPagination, visitorId; + ++ (NSDictionary *)propertyToJSONKeyMap { + NSDictionary *map = + [NSDictionary dictionaryWithObject:@"etag" + forKey:@"ETag"]; + return map; +} + ++ (NSDictionary *)arrayPropertyToClassMap { + NSDictionary *map = + [NSDictionary dictionaryWithObject:[GTLYouTubeLiveStream class] + forKey:@"items"]; + return map; +} + ++ (void)load { + [self registerObjectClassForKind:@"youtube#liveStreamListResponse"]; +} + +@end diff --git a/XCDYouTubeKit Demo/Pods/Google-API-Client/Source/Services/YouTube/Generated/GTLYouTubeLiveStreamSnippet.h b/XCDYouTubeKit Demo/Pods/Google-API-Client/Source/Services/YouTube/Generated/GTLYouTubeLiveStreamSnippet.h new file mode 100644 index 00000000..18f09acb --- /dev/null +++ b/XCDYouTubeKit Demo/Pods/Google-API-Client/Source/Services/YouTube/Generated/GTLYouTubeLiveStreamSnippet.h @@ -0,0 +1,59 @@ +/* Copyright (c) 2013 Google Inc. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +// +// GTLYouTubeLiveStreamSnippet.h +// + +// ---------------------------------------------------------------------------- +// NOTE: This file is generated from Google APIs Discovery Service. +// Service: +// YouTube Data API (youtube/v3) +// Description: +// Programmatic access to YouTube features. +// Documentation: +// https://developers.google.com/youtube/v3 +// Classes: +// GTLYouTubeLiveStreamSnippet (0 custom class methods, 4 custom properties) + +#if GTL_BUILT_AS_FRAMEWORK + #import "GTL/GTLObject.h" +#else + #import "GTLObject.h" +#endif + +// ---------------------------------------------------------------------------- +// +// GTLYouTubeLiveStreamSnippet +// + +@interface GTLYouTubeLiveStreamSnippet : GTLObject + +// The ID that YouTube uses to uniquely identify the channel that is +// transmitting the stream. +@property (copy) NSString *channelId; + +// The stream's description. The value cannot be longer than 10000 characters. +// Remapped to 'descriptionProperty' to avoid NSObject's 'description'. +@property (copy) NSString *descriptionProperty; + +// The date and time that the stream was created. The value is specified in ISO +// 8601 (YYYY-MM-DDThh:mm:ss.sZ) format. +@property (retain) GTLDateTime *publishedAt; + +// The stream's title. The value must be between 1 and 128 characters long. +@property (copy) NSString *title; + +@end diff --git a/XCDYouTubeKit Demo/Pods/Google-API-Client/Source/Services/YouTube/Generated/GTLYouTubeLiveStreamSnippet.m b/XCDYouTubeKit Demo/Pods/Google-API-Client/Source/Services/YouTube/Generated/GTLYouTubeLiveStreamSnippet.m new file mode 100644 index 00000000..007464aa --- /dev/null +++ b/XCDYouTubeKit Demo/Pods/Google-API-Client/Source/Services/YouTube/Generated/GTLYouTubeLiveStreamSnippet.m @@ -0,0 +1,48 @@ +/* Copyright (c) 2013 Google Inc. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +// +// GTLYouTubeLiveStreamSnippet.m +// + +// ---------------------------------------------------------------------------- +// NOTE: This file is generated from Google APIs Discovery Service. +// Service: +// YouTube Data API (youtube/v3) +// Description: +// Programmatic access to YouTube features. +// Documentation: +// https://developers.google.com/youtube/v3 +// Classes: +// GTLYouTubeLiveStreamSnippet (0 custom class methods, 4 custom properties) + +#import "GTLYouTubeLiveStreamSnippet.h" + +// ---------------------------------------------------------------------------- +// +// GTLYouTubeLiveStreamSnippet +// + +@implementation GTLYouTubeLiveStreamSnippet +@dynamic channelId, descriptionProperty, publishedAt, title; + ++ (NSDictionary *)propertyToJSONKeyMap { + NSDictionary *map = + [NSDictionary dictionaryWithObject:@"description" + forKey:@"descriptionProperty"]; + return map; +} + +@end diff --git a/XCDYouTubeKit Demo/Pods/Google-API-Client/Source/Services/YouTube/Generated/GTLYouTubeLiveStreamStatus.h b/XCDYouTubeKit Demo/Pods/Google-API-Client/Source/Services/YouTube/Generated/GTLYouTubeLiveStreamStatus.h new file mode 100644 index 00000000..7b5f793c --- /dev/null +++ b/XCDYouTubeKit Demo/Pods/Google-API-Client/Source/Services/YouTube/Generated/GTLYouTubeLiveStreamStatus.h @@ -0,0 +1,46 @@ +/* Copyright (c) 2013 Google Inc. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +// +// GTLYouTubeLiveStreamStatus.h +// + +// ---------------------------------------------------------------------------- +// NOTE: This file is generated from Google APIs Discovery Service. +// Service: +// YouTube Data API (youtube/v3) +// Description: +// Programmatic access to YouTube features. +// Documentation: +// https://developers.google.com/youtube/v3 +// Classes: +// GTLYouTubeLiveStreamStatus (0 custom class methods, 1 custom properties) + +#if GTL_BUILT_AS_FRAMEWORK + #import "GTL/GTLObject.h" +#else + #import "GTLObject.h" +#endif + +// ---------------------------------------------------------------------------- +// +// GTLYouTubeLiveStreamStatus +// + +// Brief description of the live stream status. + +@interface GTLYouTubeLiveStreamStatus : GTLObject +@property (copy) NSString *streamStatus; +@end diff --git a/XCDYouTubeKit Demo/Pods/Google-API-Client/Source/Services/YouTube/Generated/GTLYouTubeLiveStreamStatus.m b/XCDYouTubeKit Demo/Pods/Google-API-Client/Source/Services/YouTube/Generated/GTLYouTubeLiveStreamStatus.m new file mode 100644 index 00000000..ce8e1c84 --- /dev/null +++ b/XCDYouTubeKit Demo/Pods/Google-API-Client/Source/Services/YouTube/Generated/GTLYouTubeLiveStreamStatus.m @@ -0,0 +1,40 @@ +/* Copyright (c) 2013 Google Inc. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +// +// GTLYouTubeLiveStreamStatus.m +// + +// ---------------------------------------------------------------------------- +// NOTE: This file is generated from Google APIs Discovery Service. +// Service: +// YouTube Data API (youtube/v3) +// Description: +// Programmatic access to YouTube features. +// Documentation: +// https://developers.google.com/youtube/v3 +// Classes: +// GTLYouTubeLiveStreamStatus (0 custom class methods, 1 custom properties) + +#import "GTLYouTubeLiveStreamStatus.h" + +// ---------------------------------------------------------------------------- +// +// GTLYouTubeLiveStreamStatus +// + +@implementation GTLYouTubeLiveStreamStatus +@dynamic streamStatus; +@end diff --git a/XCDYouTubeKit Demo/Pods/Google-API-Client/Source/Services/YouTube/Generated/GTLYouTubeLocalizedProperty.h b/XCDYouTubeKit Demo/Pods/Google-API-Client/Source/Services/YouTube/Generated/GTLYouTubeLocalizedProperty.h new file mode 100644 index 00000000..b49504f4 --- /dev/null +++ b/XCDYouTubeKit Demo/Pods/Google-API-Client/Source/Services/YouTube/Generated/GTLYouTubeLocalizedProperty.h @@ -0,0 +1,54 @@ +/* Copyright (c) 2014 Google Inc. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +// +// GTLYouTubeLocalizedProperty.h +// + +// ---------------------------------------------------------------------------- +// NOTE: This file is generated from Google APIs Discovery Service. +// Service: +// YouTube Data API (youtube/v3) +// Description: +// Programmatic access to YouTube features. +// Documentation: +// https://developers.google.com/youtube/v3 +// Classes: +// GTLYouTubeLocalizedProperty (0 custom class methods, 3 custom properties) + +#if GTL_BUILT_AS_FRAMEWORK + #import "GTL/GTLObject.h" +#else + #import "GTLObject.h" +#endif + +@class GTLYouTubeLanguageTag; +@class GTLYouTubeLocalizedString; + +// ---------------------------------------------------------------------------- +// +// GTLYouTubeLocalizedProperty +// + +@interface GTLYouTubeLocalizedProperty : GTLObject + +// Remapped to 'defaultProperty' to avoid language reserved word 'default'. +@property (copy) NSString *defaultProperty; + +// The language of the default property. +@property (retain) GTLYouTubeLanguageTag *defaultLanguage; + +@property (retain) NSArray *localized; // of GTLYouTubeLocalizedString +@end diff --git a/XCDYouTubeKit Demo/Pods/Google-API-Client/Source/Services/YouTube/Generated/GTLYouTubeLocalizedProperty.m b/XCDYouTubeKit Demo/Pods/Google-API-Client/Source/Services/YouTube/Generated/GTLYouTubeLocalizedProperty.m new file mode 100644 index 00000000..be2fbd6b --- /dev/null +++ b/XCDYouTubeKit Demo/Pods/Google-API-Client/Source/Services/YouTube/Generated/GTLYouTubeLocalizedProperty.m @@ -0,0 +1,58 @@ +/* Copyright (c) 2014 Google Inc. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +// +// GTLYouTubeLocalizedProperty.m +// + +// ---------------------------------------------------------------------------- +// NOTE: This file is generated from Google APIs Discovery Service. +// Service: +// YouTube Data API (youtube/v3) +// Description: +// Programmatic access to YouTube features. +// Documentation: +// https://developers.google.com/youtube/v3 +// Classes: +// GTLYouTubeLocalizedProperty (0 custom class methods, 3 custom properties) + +#import "GTLYouTubeLocalizedProperty.h" + +#import "GTLYouTubeLanguageTag.h" +#import "GTLYouTubeLocalizedString.h" + +// ---------------------------------------------------------------------------- +// +// GTLYouTubeLocalizedProperty +// + +@implementation GTLYouTubeLocalizedProperty +@dynamic defaultProperty, defaultLanguage, localized; + ++ (NSDictionary *)propertyToJSONKeyMap { + NSDictionary *map = + [NSDictionary dictionaryWithObject:@"default" + forKey:@"defaultProperty"]; + return map; +} + ++ (NSDictionary *)arrayPropertyToClassMap { + NSDictionary *map = + [NSDictionary dictionaryWithObject:[GTLYouTubeLocalizedString class] + forKey:@"localized"]; + return map; +} + +@end diff --git a/XCDYouTubeKit Demo/Pods/Google-API-Client/Source/Services/YouTube/Generated/GTLYouTubeLocalizedString.h b/XCDYouTubeKit Demo/Pods/Google-API-Client/Source/Services/YouTube/Generated/GTLYouTubeLocalizedString.h new file mode 100644 index 00000000..44453550 --- /dev/null +++ b/XCDYouTubeKit Demo/Pods/Google-API-Client/Source/Services/YouTube/Generated/GTLYouTubeLocalizedString.h @@ -0,0 +1,45 @@ +/* Copyright (c) 2014 Google Inc. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +// +// GTLYouTubeLocalizedString.h +// + +// ---------------------------------------------------------------------------- +// NOTE: This file is generated from Google APIs Discovery Service. +// Service: +// YouTube Data API (youtube/v3) +// Description: +// Programmatic access to YouTube features. +// Documentation: +// https://developers.google.com/youtube/v3 +// Classes: +// GTLYouTubeLocalizedString (0 custom class methods, 2 custom properties) + +#if GTL_BUILT_AS_FRAMEWORK + #import "GTL/GTLObject.h" +#else + #import "GTLObject.h" +#endif + +// ---------------------------------------------------------------------------- +// +// GTLYouTubeLocalizedString +// + +@interface GTLYouTubeLocalizedString : GTLObject +@property (copy) NSString *language; +@property (copy) NSString *value; +@end diff --git a/XCDYouTubeKit Demo/Pods/Google-API-Client/Source/Services/YouTube/Generated/GTLYouTubeLocalizedString.m b/XCDYouTubeKit Demo/Pods/Google-API-Client/Source/Services/YouTube/Generated/GTLYouTubeLocalizedString.m new file mode 100644 index 00000000..260eeb08 --- /dev/null +++ b/XCDYouTubeKit Demo/Pods/Google-API-Client/Source/Services/YouTube/Generated/GTLYouTubeLocalizedString.m @@ -0,0 +1,40 @@ +/* Copyright (c) 2013 Google Inc. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +// +// GTLYouTubeLocalizedString.m +// + +// ---------------------------------------------------------------------------- +// NOTE: This file is generated from Google APIs Discovery Service. +// Service: +// YouTube Data API (youtube/v3) +// Description: +// Programmatic access to YouTube features. +// Documentation: +// https://developers.google.com/youtube/v3 +// Classes: +// GTLYouTubeLocalizedString (0 custom class methods, 2 custom properties) + +#import "GTLYouTubeLocalizedString.h" + +// ---------------------------------------------------------------------------- +// +// GTLYouTubeLocalizedString +// + +@implementation GTLYouTubeLocalizedString +@dynamic language, value; +@end diff --git a/XCDYouTubeKit Demo/Pods/Google-API-Client/Source/Services/YouTube/Generated/GTLYouTubeMonitorStreamInfo.h b/XCDYouTubeKit Demo/Pods/Google-API-Client/Source/Services/YouTube/Generated/GTLYouTubeMonitorStreamInfo.h new file mode 100644 index 00000000..b3f8a943 --- /dev/null +++ b/XCDYouTubeKit Demo/Pods/Google-API-Client/Source/Services/YouTube/Generated/GTLYouTubeMonitorStreamInfo.h @@ -0,0 +1,64 @@ +/* Copyright (c) 2013 Google Inc. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +// +// GTLYouTubeMonitorStreamInfo.h +// + +// ---------------------------------------------------------------------------- +// NOTE: This file is generated from Google APIs Discovery Service. +// Service: +// YouTube Data API (youtube/v3) +// Description: +// Programmatic access to YouTube features. +// Documentation: +// https://developers.google.com/youtube/v3 +// Classes: +// GTLYouTubeMonitorStreamInfo (0 custom class methods, 3 custom properties) + +#if GTL_BUILT_AS_FRAMEWORK + #import "GTL/GTLObject.h" +#else + #import "GTLObject.h" +#endif + +// ---------------------------------------------------------------------------- +// +// GTLYouTubeMonitorStreamInfo +// + +// Settings and Info of the monitor stream + +@interface GTLYouTubeMonitorStreamInfo : GTLObject + +// If you have set the enableMonitorStream property to true, then this property +// determines the length of the live broadcast delay. +@property (retain) NSNumber *broadcastStreamDelayMs; // unsignedIntValue + +// HTML code that embeds a player that plays the monitor stream. +@property (copy) NSString *embedHtml; + +// This value determines whether the monitor stream is enabled for the +// broadcast. If the monitor stream is enabled, then YouTube will broadcast the +// event content on a special stream intended only for the broadcaster's +// consumption. The broadcaster can use the stream to review the event content +// and also to identify the optimal times to insert cuepoints. +// You need to set this value to true if you intend to have a broadcast delay +// for your event. +// Note: This property cannot be updated once the broadcast is in the testing or +// live state. +@property (retain) NSNumber *enableMonitorStream; // boolValue + +@end diff --git a/XCDYouTubeKit Demo/Pods/Google-API-Client/Source/Services/YouTube/Generated/GTLYouTubeMonitorStreamInfo.m b/XCDYouTubeKit Demo/Pods/Google-API-Client/Source/Services/YouTube/Generated/GTLYouTubeMonitorStreamInfo.m new file mode 100644 index 00000000..dbf67300 --- /dev/null +++ b/XCDYouTubeKit Demo/Pods/Google-API-Client/Source/Services/YouTube/Generated/GTLYouTubeMonitorStreamInfo.m @@ -0,0 +1,40 @@ +/* Copyright (c) 2013 Google Inc. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +// +// GTLYouTubeMonitorStreamInfo.m +// + +// ---------------------------------------------------------------------------- +// NOTE: This file is generated from Google APIs Discovery Service. +// Service: +// YouTube Data API (youtube/v3) +// Description: +// Programmatic access to YouTube features. +// Documentation: +// https://developers.google.com/youtube/v3 +// Classes: +// GTLYouTubeMonitorStreamInfo (0 custom class methods, 3 custom properties) + +#import "GTLYouTubeMonitorStreamInfo.h" + +// ---------------------------------------------------------------------------- +// +// GTLYouTubeMonitorStreamInfo +// + +@implementation GTLYouTubeMonitorStreamInfo +@dynamic broadcastStreamDelayMs, embedHtml, enableMonitorStream; +@end diff --git a/XCDYouTubeKit Demo/Pods/Google-API-Client/Source/Services/YouTube/Generated/GTLYouTubePageInfo.h b/XCDYouTubeKit Demo/Pods/Google-API-Client/Source/Services/YouTube/Generated/GTLYouTubePageInfo.h new file mode 100644 index 00000000..967237d7 --- /dev/null +++ b/XCDYouTubeKit Demo/Pods/Google-API-Client/Source/Services/YouTube/Generated/GTLYouTubePageInfo.h @@ -0,0 +1,53 @@ +/* Copyright (c) 2012 Google Inc. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +// +// GTLYouTubePageInfo.h +// + +// ---------------------------------------------------------------------------- +// NOTE: This file is generated from Google APIs Discovery Service. +// Service: +// YouTube Data API (youtube/v3) +// Description: +// Programmatic access to YouTube features. +// Documentation: +// https://developers.google.com/youtube/v3 +// Classes: +// GTLYouTubePageInfo (0 custom class methods, 2 custom properties) + +#if GTL_BUILT_AS_FRAMEWORK + #import "GTL/GTLObject.h" +#else + #import "GTLObject.h" +#endif + +// ---------------------------------------------------------------------------- +// +// GTLYouTubePageInfo +// + +// Paging details for lists of resources, including total number of items +// available and number of resources returned in a single page. + +@interface GTLYouTubePageInfo : GTLObject + +// The number of results included in the API response. +@property (retain) NSNumber *resultsPerPage; // intValue + +// The total number of results in the result set. +@property (retain) NSNumber *totalResults; // intValue + +@end diff --git a/XCDYouTubeKit Demo/Pods/Google-API-Client/Source/Services/YouTube/Generated/GTLYouTubePageInfo.m b/XCDYouTubeKit Demo/Pods/Google-API-Client/Source/Services/YouTube/Generated/GTLYouTubePageInfo.m new file mode 100644 index 00000000..a5dbc60e --- /dev/null +++ b/XCDYouTubeKit Demo/Pods/Google-API-Client/Source/Services/YouTube/Generated/GTLYouTubePageInfo.m @@ -0,0 +1,40 @@ +/* Copyright (c) 2012 Google Inc. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +// +// GTLYouTubePageInfo.m +// + +// ---------------------------------------------------------------------------- +// NOTE: This file is generated from Google APIs Discovery Service. +// Service: +// YouTube Data API (youtube/v3) +// Description: +// Programmatic access to YouTube features. +// Documentation: +// https://developers.google.com/youtube/v3 +// Classes: +// GTLYouTubePageInfo (0 custom class methods, 2 custom properties) + +#import "GTLYouTubePageInfo.h" + +// ---------------------------------------------------------------------------- +// +// GTLYouTubePageInfo +// + +@implementation GTLYouTubePageInfo +@dynamic resultsPerPage, totalResults; +@end diff --git a/XCDYouTubeKit Demo/Pods/Google-API-Client/Source/Services/YouTube/Generated/GTLYouTubePlaylist.h b/XCDYouTubeKit Demo/Pods/Google-API-Client/Source/Services/YouTube/Generated/GTLYouTubePlaylist.h new file mode 100644 index 00000000..be428c4f --- /dev/null +++ b/XCDYouTubeKit Demo/Pods/Google-API-Client/Source/Services/YouTube/Generated/GTLYouTubePlaylist.h @@ -0,0 +1,93 @@ +/* Copyright (c) 2013 Google Inc. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +// +// GTLYouTubePlaylist.h +// + +// ---------------------------------------------------------------------------- +// NOTE: This file is generated from Google APIs Discovery Service. +// Service: +// YouTube Data API (youtube/v3) +// Description: +// Programmatic access to YouTube features. +// Documentation: +// https://developers.google.com/youtube/v3 +// Classes: +// GTLYouTubePlaylist (0 custom class methods, 7 custom properties) + +#if GTL_BUILT_AS_FRAMEWORK + #import "GTL/GTLObject.h" +#else + #import "GTLObject.h" +#endif + +@class GTLYouTubePlaylistContentDetails; +@class GTLYouTubePlaylistPlayer; +@class GTLYouTubePlaylistSnippet; +@class GTLYouTubePlaylistStatus; + +// ---------------------------------------------------------------------------- +// +// GTLYouTubePlaylist +// + +// A playlist resource represents a YouTube playlist. A playlist is a collection +// of videos that can be viewed sequentially and shared with other users. A +// playlist can contain up to 200 videos, and YouTube does not limit the number +// of playlists that each user creates. By default, playlists are publicly +// visible to other users, but playlists can be public or private. +// YouTube also uses playlists to identify special collections of videos for a +// channel, such as: +// - uploaded videos +// - favorite videos +// - positively rated (liked) videos +// - watch history +// - watch later To be more specific, these lists are associated with a channel, +// which is a collection of a person, group, or company's videos, playlists, and +// other YouTube information. You can retrieve the playlist IDs for each of +// these lists from the channel resource for a given channel. +// You can then use the playlistItems.list method to retrieve any of those +// lists. You can also add or remove items from those lists by calling the +// playlistItems.insert and playlistItems.delete methods. + +@interface GTLYouTubePlaylist : GTLObject + +// The contentDetails object contains information like video count. +@property (retain) GTLYouTubePlaylistContentDetails *contentDetails; + +// Etag of this resource. +@property (copy) NSString *ETag; + +// The ID that YouTube uses to uniquely identify the playlist. +// identifier property maps to 'id' in JSON (to avoid Objective C's 'id'). +@property (copy) NSString *identifier; + +// Identifies what kind of resource this is. Value: the fixed string +// "youtube#playlist". +@property (copy) NSString *kind; + +// The player object contains information that you would use to play the +// playlist in an embedded player. +@property (retain) GTLYouTubePlaylistPlayer *player; + +// The snippet object contains basic details about the playlist, such as its +// title and description. +@property (retain) GTLYouTubePlaylistSnippet *snippet; + +// The status object contains status information for the playlist. +@property (retain) GTLYouTubePlaylistStatus *status; + +@end diff --git a/XCDYouTubeKit Demo/Pods/Google-API-Client/Source/Services/YouTube/Generated/GTLYouTubePlaylist.m b/XCDYouTubeKit Demo/Pods/Google-API-Client/Source/Services/YouTube/Generated/GTLYouTubePlaylist.m new file mode 100644 index 00000000..393d57e5 --- /dev/null +++ b/XCDYouTubeKit Demo/Pods/Google-API-Client/Source/Services/YouTube/Generated/GTLYouTubePlaylist.m @@ -0,0 +1,59 @@ +/* Copyright (c) 2012 Google Inc. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +// +// GTLYouTubePlaylist.m +// + +// ---------------------------------------------------------------------------- +// NOTE: This file is generated from Google APIs Discovery Service. +// Service: +// YouTube Data API (youtube/v3) +// Description: +// Programmatic access to YouTube features. +// Documentation: +// https://developers.google.com/youtube/v3 +// Classes: +// GTLYouTubePlaylist (0 custom class methods, 7 custom properties) + +#import "GTLYouTubePlaylist.h" + +#import "GTLYouTubePlaylistContentDetails.h" +#import "GTLYouTubePlaylistPlayer.h" +#import "GTLYouTubePlaylistSnippet.h" +#import "GTLYouTubePlaylistStatus.h" + +// ---------------------------------------------------------------------------- +// +// GTLYouTubePlaylist +// + +@implementation GTLYouTubePlaylist +@dynamic contentDetails, ETag, identifier, kind, player, snippet, status; + ++ (NSDictionary *)propertyToJSONKeyMap { + NSDictionary *map = + [NSDictionary dictionaryWithObjectsAndKeys: + @"etag", @"ETag", + @"id", @"identifier", + nil]; + return map; +} + ++ (void)load { + [self registerObjectClassForKind:@"youtube#playlist"]; +} + +@end diff --git a/XCDYouTubeKit Demo/Pods/Google-API-Client/Source/Services/YouTube/Generated/GTLYouTubePlaylistContentDetails.h b/XCDYouTubeKit Demo/Pods/Google-API-Client/Source/Services/YouTube/Generated/GTLYouTubePlaylistContentDetails.h new file mode 100644 index 00000000..d704913c --- /dev/null +++ b/XCDYouTubeKit Demo/Pods/Google-API-Client/Source/Services/YouTube/Generated/GTLYouTubePlaylistContentDetails.h @@ -0,0 +1,47 @@ +/* Copyright (c) 2013 Google Inc. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +// +// GTLYouTubePlaylistContentDetails.h +// + +// ---------------------------------------------------------------------------- +// NOTE: This file is generated from Google APIs Discovery Service. +// Service: +// YouTube Data API (youtube/v3) +// Description: +// Programmatic access to YouTube features. +// Documentation: +// https://developers.google.com/youtube/v3 +// Classes: +// GTLYouTubePlaylistContentDetails (0 custom class methods, 1 custom properties) + +#if GTL_BUILT_AS_FRAMEWORK + #import "GTL/GTLObject.h" +#else + #import "GTLObject.h" +#endif + +// ---------------------------------------------------------------------------- +// +// GTLYouTubePlaylistContentDetails +// + +@interface GTLYouTubePlaylistContentDetails : GTLObject + +// The number of videos in the playlist. +@property (retain) NSNumber *itemCount; // unsignedIntValue + +@end diff --git a/XCDYouTubeKit Demo/Pods/Google-API-Client/Source/Services/YouTube/Generated/GTLYouTubePlaylistContentDetails.m b/XCDYouTubeKit Demo/Pods/Google-API-Client/Source/Services/YouTube/Generated/GTLYouTubePlaylistContentDetails.m new file mode 100644 index 00000000..6c1d8fa0 --- /dev/null +++ b/XCDYouTubeKit Demo/Pods/Google-API-Client/Source/Services/YouTube/Generated/GTLYouTubePlaylistContentDetails.m @@ -0,0 +1,40 @@ +/* Copyright (c) 2012 Google Inc. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +// +// GTLYouTubePlaylistContentDetails.m +// + +// ---------------------------------------------------------------------------- +// NOTE: This file is generated from Google APIs Discovery Service. +// Service: +// YouTube Data API (youtube/v3) +// Description: +// Programmatic access to YouTube features. +// Documentation: +// https://developers.google.com/youtube/v3 +// Classes: +// GTLYouTubePlaylistContentDetails (0 custom class methods, 1 custom properties) + +#import "GTLYouTubePlaylistContentDetails.h" + +// ---------------------------------------------------------------------------- +// +// GTLYouTubePlaylistContentDetails +// + +@implementation GTLYouTubePlaylistContentDetails +@dynamic itemCount; +@end diff --git a/XCDYouTubeKit Demo/Pods/Google-API-Client/Source/Services/YouTube/Generated/GTLYouTubePlaylistItem.h b/XCDYouTubeKit Demo/Pods/Google-API-Client/Source/Services/YouTube/Generated/GTLYouTubePlaylistItem.h new file mode 100644 index 00000000..4000ff38 --- /dev/null +++ b/XCDYouTubeKit Demo/Pods/Google-API-Client/Source/Services/YouTube/Generated/GTLYouTubePlaylistItem.h @@ -0,0 +1,91 @@ +/* Copyright (c) 2013 Google Inc. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +// +// GTLYouTubePlaylistItem.h +// + +// ---------------------------------------------------------------------------- +// NOTE: This file is generated from Google APIs Discovery Service. +// Service: +// YouTube Data API (youtube/v3) +// Description: +// Programmatic access to YouTube features. +// Documentation: +// https://developers.google.com/youtube/v3 +// Classes: +// GTLYouTubePlaylistItem (0 custom class methods, 6 custom properties) + +#if GTL_BUILT_AS_FRAMEWORK + #import "GTL/GTLObject.h" +#else + #import "GTLObject.h" +#endif + +@class GTLYouTubePlaylistItemContentDetails; +@class GTLYouTubePlaylistItemSnippet; +@class GTLYouTubePlaylistItemStatus; + +// ---------------------------------------------------------------------------- +// +// GTLYouTubePlaylistItem +// + +// A playlistItem resource identifies another resource, such as a video, that is +// included in a playlist. In addition, the playlistItem resource contains +// details about the included resource that pertain specifically to how that +// resource is used in that playlist. +// YouTube uses playlists to identify special collections of videos for a +// channel, such as: +// - uploaded videos +// - favorite videos +// - positively rated (liked) videos +// - watch history +// - watch later To be more specific, these lists are associated with a channel, +// which is a collection of a person, group, or company's videos, playlists, and +// other YouTube information. +// You can retrieve the playlist IDs for each of these lists from the channel +// resource for a given channel. You can then use the playlistItems.list method +// to retrieve any of those lists. You can also add or remove items from those +// lists by calling the playlistItems.insert and playlistItems.delete methods. +// For example, if a user gives a positive rating to a video, you would insert +// that video into the liked videos playlist for that user's channel. + +@interface GTLYouTubePlaylistItem : GTLObject + +// The contentDetails object is included in the resource if the included item is +// a YouTube video. The object contains additional information about the video. +@property (retain) GTLYouTubePlaylistItemContentDetails *contentDetails; + +// Etag of this resource. +@property (copy) NSString *ETag; + +// The ID that YouTube uses to uniquely identify the playlist item. +// identifier property maps to 'id' in JSON (to avoid Objective C's 'id'). +@property (copy) NSString *identifier; + +// Identifies what kind of resource this is. Value: the fixed string +// "youtube#playlistItem". +@property (copy) NSString *kind; + +// The snippet object contains basic details about the playlist item, such as +// its title and position in the playlist. +@property (retain) GTLYouTubePlaylistItemSnippet *snippet; + +// The status object contains information about the playlist item's privacy +// status. +@property (retain) GTLYouTubePlaylistItemStatus *status; + +@end diff --git a/XCDYouTubeKit Demo/Pods/Google-API-Client/Source/Services/YouTube/Generated/GTLYouTubePlaylistItem.m b/XCDYouTubeKit Demo/Pods/Google-API-Client/Source/Services/YouTube/Generated/GTLYouTubePlaylistItem.m new file mode 100644 index 00000000..6058af5c --- /dev/null +++ b/XCDYouTubeKit Demo/Pods/Google-API-Client/Source/Services/YouTube/Generated/GTLYouTubePlaylistItem.m @@ -0,0 +1,58 @@ +/* Copyright (c) 2013 Google Inc. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +// +// GTLYouTubePlaylistItem.m +// + +// ---------------------------------------------------------------------------- +// NOTE: This file is generated from Google APIs Discovery Service. +// Service: +// YouTube Data API (youtube/v3) +// Description: +// Programmatic access to YouTube features. +// Documentation: +// https://developers.google.com/youtube/v3 +// Classes: +// GTLYouTubePlaylistItem (0 custom class methods, 6 custom properties) + +#import "GTLYouTubePlaylistItem.h" + +#import "GTLYouTubePlaylistItemContentDetails.h" +#import "GTLYouTubePlaylistItemSnippet.h" +#import "GTLYouTubePlaylistItemStatus.h" + +// ---------------------------------------------------------------------------- +// +// GTLYouTubePlaylistItem +// + +@implementation GTLYouTubePlaylistItem +@dynamic contentDetails, ETag, identifier, kind, snippet, status; + ++ (NSDictionary *)propertyToJSONKeyMap { + NSDictionary *map = + [NSDictionary dictionaryWithObjectsAndKeys: + @"etag", @"ETag", + @"id", @"identifier", + nil]; + return map; +} + ++ (void)load { + [self registerObjectClassForKind:@"youtube#playlistItem"]; +} + +@end diff --git a/XCDYouTubeKit Demo/Pods/Google-API-Client/Source/Services/YouTube/Generated/GTLYouTubePlaylistItemContentDetails.h b/XCDYouTubeKit Demo/Pods/Google-API-Client/Source/Services/YouTube/Generated/GTLYouTubePlaylistItemContentDetails.h new file mode 100644 index 00000000..bfb31d9b --- /dev/null +++ b/XCDYouTubeKit Demo/Pods/Google-API-Client/Source/Services/YouTube/Generated/GTLYouTubePlaylistItemContentDetails.h @@ -0,0 +1,63 @@ +/* Copyright (c) 2013 Google Inc. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +// +// GTLYouTubePlaylistItemContentDetails.h +// + +// ---------------------------------------------------------------------------- +// NOTE: This file is generated from Google APIs Discovery Service. +// Service: +// YouTube Data API (youtube/v3) +// Description: +// Programmatic access to YouTube features. +// Documentation: +// https://developers.google.com/youtube/v3 +// Classes: +// GTLYouTubePlaylistItemContentDetails (0 custom class methods, 4 custom properties) + +#if GTL_BUILT_AS_FRAMEWORK + #import "GTL/GTLObject.h" +#else + #import "GTLObject.h" +#endif + +// ---------------------------------------------------------------------------- +// +// GTLYouTubePlaylistItemContentDetails +// + +@interface GTLYouTubePlaylistItemContentDetails : GTLObject + +// The time, measured in seconds from the start of the video, when the video +// should stop playing. (The playlist owner can specify the times when the video +// should start and stop playing when the video is played in the context of the +// playlist.) By default, assume that the video.endTime is the end of the video. +@property (copy) NSString *endAt; + +// A user-generated note for this item. +@property (copy) NSString *note; + +// The time, measured in seconds from the start of the video, when the video +// should start playing. (The playlist owner can specify the times when the +// video should start and stop playing when the video is played in the context +// of the playlist.) The default value is 0. +@property (copy) NSString *startAt; + +// The ID that YouTube uses to uniquely identify a video. To retrieve the video +// resource, set the id query parameter to this value in your API request. +@property (copy) NSString *videoId; + +@end diff --git a/XCDYouTubeKit Demo/Pods/Google-API-Client/Source/Services/YouTube/Generated/GTLYouTubePlaylistItemContentDetails.m b/XCDYouTubeKit Demo/Pods/Google-API-Client/Source/Services/YouTube/Generated/GTLYouTubePlaylistItemContentDetails.m new file mode 100644 index 00000000..62ee7db5 --- /dev/null +++ b/XCDYouTubeKit Demo/Pods/Google-API-Client/Source/Services/YouTube/Generated/GTLYouTubePlaylistItemContentDetails.m @@ -0,0 +1,40 @@ +/* Copyright (c) 2013 Google Inc. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +// +// GTLYouTubePlaylistItemContentDetails.m +// + +// ---------------------------------------------------------------------------- +// NOTE: This file is generated from Google APIs Discovery Service. +// Service: +// YouTube Data API (youtube/v3) +// Description: +// Programmatic access to YouTube features. +// Documentation: +// https://developers.google.com/youtube/v3 +// Classes: +// GTLYouTubePlaylistItemContentDetails (0 custom class methods, 4 custom properties) + +#import "GTLYouTubePlaylistItemContentDetails.h" + +// ---------------------------------------------------------------------------- +// +// GTLYouTubePlaylistItemContentDetails +// + +@implementation GTLYouTubePlaylistItemContentDetails +@dynamic endAt, note, startAt, videoId; +@end diff --git a/XCDYouTubeKit Demo/Pods/Google-API-Client/Source/Services/YouTube/Generated/GTLYouTubePlaylistItemListResponse.h b/XCDYouTubeKit Demo/Pods/Google-API-Client/Source/Services/YouTube/Generated/GTLYouTubePlaylistItemListResponse.h new file mode 100644 index 00000000..a5a192e7 --- /dev/null +++ b/XCDYouTubeKit Demo/Pods/Google-API-Client/Source/Services/YouTube/Generated/GTLYouTubePlaylistItemListResponse.h @@ -0,0 +1,79 @@ +/* Copyright (c) 2013 Google Inc. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +// +// GTLYouTubePlaylistItemListResponse.h +// + +// ---------------------------------------------------------------------------- +// NOTE: This file is generated from Google APIs Discovery Service. +// Service: +// YouTube Data API (youtube/v3) +// Description: +// Programmatic access to YouTube features. +// Documentation: +// https://developers.google.com/youtube/v3 +// Classes: +// GTLYouTubePlaylistItemListResponse (0 custom class methods, 9 custom properties) + +#if GTL_BUILT_AS_FRAMEWORK + #import "GTL/GTLObject.h" +#else + #import "GTLObject.h" +#endif + +@class GTLYouTubePageInfo; +@class GTLYouTubePlaylistItem; +@class GTLYouTubeTokenPagination; + +// ---------------------------------------------------------------------------- +// +// GTLYouTubePlaylistItemListResponse +// + +// This class supports NSFastEnumeration over its "items" property. It also +// supports -itemAtIndex: to retrieve individual objects from "items". + +@interface GTLYouTubePlaylistItemListResponse : GTLCollectionObject + +// Etag of this resource. +@property (copy) NSString *ETag; + +// Serialized EventId of the request which produced this response. +@property (copy) NSString *eventId; + +// A list of playlist items that match the request criteria. +@property (retain) NSArray *items; // of GTLYouTubePlaylistItem + +// Identifies what kind of resource this is. Value: the fixed string +// "youtube#playlistItemListResponse". +@property (copy) NSString *kind; + +// The token that can be used as the value of the pageToken parameter to +// retrieve the next page in the result set. +@property (copy) NSString *nextPageToken; + +@property (retain) GTLYouTubePageInfo *pageInfo; + +// The token that can be used as the value of the pageToken parameter to +// retrieve the previous page in the result set. +@property (copy) NSString *prevPageToken; + +@property (retain) GTLYouTubeTokenPagination *tokenPagination; + +// The visitorId identifies the visitor. +@property (copy) NSString *visitorId; + +@end diff --git a/XCDYouTubeKit Demo/Pods/Google-API-Client/Source/Services/YouTube/Generated/GTLYouTubePlaylistItemListResponse.m b/XCDYouTubeKit Demo/Pods/Google-API-Client/Source/Services/YouTube/Generated/GTLYouTubePlaylistItemListResponse.m new file mode 100644 index 00000000..1d93650d --- /dev/null +++ b/XCDYouTubeKit Demo/Pods/Google-API-Client/Source/Services/YouTube/Generated/GTLYouTubePlaylistItemListResponse.m @@ -0,0 +1,64 @@ +/* Copyright (c) 2013 Google Inc. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +// +// GTLYouTubePlaylistItemListResponse.m +// + +// ---------------------------------------------------------------------------- +// NOTE: This file is generated from Google APIs Discovery Service. +// Service: +// YouTube Data API (youtube/v3) +// Description: +// Programmatic access to YouTube features. +// Documentation: +// https://developers.google.com/youtube/v3 +// Classes: +// GTLYouTubePlaylistItemListResponse (0 custom class methods, 9 custom properties) + +#import "GTLYouTubePlaylistItemListResponse.h" + +#import "GTLYouTubePageInfo.h" +#import "GTLYouTubePlaylistItem.h" +#import "GTLYouTubeTokenPagination.h" + +// ---------------------------------------------------------------------------- +// +// GTLYouTubePlaylistItemListResponse +// + +@implementation GTLYouTubePlaylistItemListResponse +@dynamic ETag, eventId, items, kind, nextPageToken, pageInfo, prevPageToken, + tokenPagination, visitorId; + ++ (NSDictionary *)propertyToJSONKeyMap { + NSDictionary *map = + [NSDictionary dictionaryWithObject:@"etag" + forKey:@"ETag"]; + return map; +} + ++ (NSDictionary *)arrayPropertyToClassMap { + NSDictionary *map = + [NSDictionary dictionaryWithObject:[GTLYouTubePlaylistItem class] + forKey:@"items"]; + return map; +} + ++ (void)load { + [self registerObjectClassForKind:@"youtube#playlistItemListResponse"]; +} + +@end diff --git a/XCDYouTubeKit Demo/Pods/Google-API-Client/Source/Services/YouTube/Generated/GTLYouTubePlaylistItemSnippet.h b/XCDYouTubeKit Demo/Pods/Google-API-Client/Source/Services/YouTube/Generated/GTLYouTubePlaylistItemSnippet.h new file mode 100644 index 00000000..259c7024 --- /dev/null +++ b/XCDYouTubeKit Demo/Pods/Google-API-Client/Source/Services/YouTube/Generated/GTLYouTubePlaylistItemSnippet.h @@ -0,0 +1,85 @@ +/* Copyright (c) 2013 Google Inc. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +// +// GTLYouTubePlaylistItemSnippet.h +// + +// ---------------------------------------------------------------------------- +// NOTE: This file is generated from Google APIs Discovery Service. +// Service: +// YouTube Data API (youtube/v3) +// Description: +// Programmatic access to YouTube features. +// Documentation: +// https://developers.google.com/youtube/v3 +// Classes: +// GTLYouTubePlaylistItemSnippet (0 custom class methods, 9 custom properties) + +#if GTL_BUILT_AS_FRAMEWORK + #import "GTL/GTLObject.h" +#else + #import "GTLObject.h" +#endif + +@class GTLYouTubeResourceId; +@class GTLYouTubeThumbnailDetails; + +// ---------------------------------------------------------------------------- +// +// GTLYouTubePlaylistItemSnippet +// + +// Basic details about a playlist, including title, description and thumbnails. + +@interface GTLYouTubePlaylistItemSnippet : GTLObject + +// The ID that YouTube uses to uniquely identify the user that added the item to +// the playlist. +@property (copy) NSString *channelId; + +// Channel title for the channel that the playlist item belongs to. +@property (copy) NSString *channelTitle; + +// The item's description. +// Remapped to 'descriptionProperty' to avoid NSObject's 'description'. +@property (copy) NSString *descriptionProperty; + +// The ID that YouTube uses to uniquely identify the playlist that the playlist +// item is in. +@property (copy) NSString *playlistId; + +// The order in which the item appears in the playlist. The value uses a +// zero-based index, so the first item has a position of 0, the second item has +// a position of 1, and so forth. +@property (retain) NSNumber *position; // unsignedIntValue + +// The date and time that the item was added to the playlist. The value is +// specified in ISO 8601 (YYYY-MM-DDThh:mm:ss.sZ) format. +@property (retain) GTLDateTime *publishedAt; + +// The id object contains information that can be used to uniquely identify the +// resource that is included in the playlist as the playlist item. +@property (retain) GTLYouTubeResourceId *resourceId; + +// A map of thumbnail images associated with the playlist item. For each object +// in the map, the key is the name of the thumbnail image, and the value is an +// object that contains other information about the thumbnail. +@property (retain) GTLYouTubeThumbnailDetails *thumbnails; + +// The item's title. +@property (copy) NSString *title; + +@end diff --git a/XCDYouTubeKit Demo/Pods/Google-API-Client/Source/Services/YouTube/Generated/GTLYouTubePlaylistItemSnippet.m b/XCDYouTubeKit Demo/Pods/Google-API-Client/Source/Services/YouTube/Generated/GTLYouTubePlaylistItemSnippet.m new file mode 100644 index 00000000..a1b014f5 --- /dev/null +++ b/XCDYouTubeKit Demo/Pods/Google-API-Client/Source/Services/YouTube/Generated/GTLYouTubePlaylistItemSnippet.m @@ -0,0 +1,52 @@ +/* Copyright (c) 2013 Google Inc. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +// +// GTLYouTubePlaylistItemSnippet.m +// + +// ---------------------------------------------------------------------------- +// NOTE: This file is generated from Google APIs Discovery Service. +// Service: +// YouTube Data API (youtube/v3) +// Description: +// Programmatic access to YouTube features. +// Documentation: +// https://developers.google.com/youtube/v3 +// Classes: +// GTLYouTubePlaylistItemSnippet (0 custom class methods, 9 custom properties) + +#import "GTLYouTubePlaylistItemSnippet.h" + +#import "GTLYouTubeResourceId.h" +#import "GTLYouTubeThumbnailDetails.h" + +// ---------------------------------------------------------------------------- +// +// GTLYouTubePlaylistItemSnippet +// + +@implementation GTLYouTubePlaylistItemSnippet +@dynamic channelId, channelTitle, descriptionProperty, playlistId, position, + publishedAt, resourceId, thumbnails, title; + ++ (NSDictionary *)propertyToJSONKeyMap { + NSDictionary *map = + [NSDictionary dictionaryWithObject:@"description" + forKey:@"descriptionProperty"]; + return map; +} + +@end diff --git a/XCDYouTubeKit Demo/Pods/Google-API-Client/Source/Services/YouTube/Generated/GTLYouTubePlaylistItemStatus.h b/XCDYouTubeKit Demo/Pods/Google-API-Client/Source/Services/YouTube/Generated/GTLYouTubePlaylistItemStatus.h new file mode 100644 index 00000000..0521d779 --- /dev/null +++ b/XCDYouTubeKit Demo/Pods/Google-API-Client/Source/Services/YouTube/Generated/GTLYouTubePlaylistItemStatus.h @@ -0,0 +1,49 @@ +/* Copyright (c) 2013 Google Inc. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +// +// GTLYouTubePlaylistItemStatus.h +// + +// ---------------------------------------------------------------------------- +// NOTE: This file is generated from Google APIs Discovery Service. +// Service: +// YouTube Data API (youtube/v3) +// Description: +// Programmatic access to YouTube features. +// Documentation: +// https://developers.google.com/youtube/v3 +// Classes: +// GTLYouTubePlaylistItemStatus (0 custom class methods, 1 custom properties) + +#if GTL_BUILT_AS_FRAMEWORK + #import "GTL/GTLObject.h" +#else + #import "GTLObject.h" +#endif + +// ---------------------------------------------------------------------------- +// +// GTLYouTubePlaylistItemStatus +// + +// Information about the playlist item's privacy status. + +@interface GTLYouTubePlaylistItemStatus : GTLObject + +// This resource's privacy status. +@property (copy) NSString *privacyStatus; + +@end diff --git a/XCDYouTubeKit Demo/Pods/Google-API-Client/Source/Services/YouTube/Generated/GTLYouTubePlaylistItemStatus.m b/XCDYouTubeKit Demo/Pods/Google-API-Client/Source/Services/YouTube/Generated/GTLYouTubePlaylistItemStatus.m new file mode 100644 index 00000000..103267c9 --- /dev/null +++ b/XCDYouTubeKit Demo/Pods/Google-API-Client/Source/Services/YouTube/Generated/GTLYouTubePlaylistItemStatus.m @@ -0,0 +1,40 @@ +/* Copyright (c) 2013 Google Inc. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +// +// GTLYouTubePlaylistItemStatus.m +// + +// ---------------------------------------------------------------------------- +// NOTE: This file is generated from Google APIs Discovery Service. +// Service: +// YouTube Data API (youtube/v3) +// Description: +// Programmatic access to YouTube features. +// Documentation: +// https://developers.google.com/youtube/v3 +// Classes: +// GTLYouTubePlaylistItemStatus (0 custom class methods, 1 custom properties) + +#import "GTLYouTubePlaylistItemStatus.h" + +// ---------------------------------------------------------------------------- +// +// GTLYouTubePlaylistItemStatus +// + +@implementation GTLYouTubePlaylistItemStatus +@dynamic privacyStatus; +@end diff --git a/XCDYouTubeKit Demo/Pods/Google-API-Client/Source/Services/YouTube/Generated/GTLYouTubePlaylistListResponse.h b/XCDYouTubeKit Demo/Pods/Google-API-Client/Source/Services/YouTube/Generated/GTLYouTubePlaylistListResponse.h new file mode 100644 index 00000000..54736d8c --- /dev/null +++ b/XCDYouTubeKit Demo/Pods/Google-API-Client/Source/Services/YouTube/Generated/GTLYouTubePlaylistListResponse.h @@ -0,0 +1,79 @@ +/* Copyright (c) 2013 Google Inc. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +// +// GTLYouTubePlaylistListResponse.h +// + +// ---------------------------------------------------------------------------- +// NOTE: This file is generated from Google APIs Discovery Service. +// Service: +// YouTube Data API (youtube/v3) +// Description: +// Programmatic access to YouTube features. +// Documentation: +// https://developers.google.com/youtube/v3 +// Classes: +// GTLYouTubePlaylistListResponse (0 custom class methods, 9 custom properties) + +#if GTL_BUILT_AS_FRAMEWORK + #import "GTL/GTLObject.h" +#else + #import "GTLObject.h" +#endif + +@class GTLYouTubePageInfo; +@class GTLYouTubePlaylist; +@class GTLYouTubeTokenPagination; + +// ---------------------------------------------------------------------------- +// +// GTLYouTubePlaylistListResponse +// + +// This class supports NSFastEnumeration over its "items" property. It also +// supports -itemAtIndex: to retrieve individual objects from "items". + +@interface GTLYouTubePlaylistListResponse : GTLCollectionObject + +// Etag of this resource. +@property (copy) NSString *ETag; + +// Serialized EventId of the request which produced this response. +@property (copy) NSString *eventId; + +// A list of playlists that match the request criteria. +@property (retain) NSArray *items; // of GTLYouTubePlaylist + +// Identifies what kind of resource this is. Value: the fixed string +// "youtube#playlistListResponse". +@property (copy) NSString *kind; + +// The token that can be used as the value of the pageToken parameter to +// retrieve the next page in the result set. +@property (copy) NSString *nextPageToken; + +@property (retain) GTLYouTubePageInfo *pageInfo; + +// The token that can be used as the value of the pageToken parameter to +// retrieve the previous page in the result set. +@property (copy) NSString *prevPageToken; + +@property (retain) GTLYouTubeTokenPagination *tokenPagination; + +// The visitorId identifies the visitor. +@property (copy) NSString *visitorId; + +@end diff --git a/XCDYouTubeKit Demo/Pods/Google-API-Client/Source/Services/YouTube/Generated/GTLYouTubePlaylistListResponse.m b/XCDYouTubeKit Demo/Pods/Google-API-Client/Source/Services/YouTube/Generated/GTLYouTubePlaylistListResponse.m new file mode 100644 index 00000000..7cadf335 --- /dev/null +++ b/XCDYouTubeKit Demo/Pods/Google-API-Client/Source/Services/YouTube/Generated/GTLYouTubePlaylistListResponse.m @@ -0,0 +1,64 @@ +/* Copyright (c) 2013 Google Inc. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +// +// GTLYouTubePlaylistListResponse.m +// + +// ---------------------------------------------------------------------------- +// NOTE: This file is generated from Google APIs Discovery Service. +// Service: +// YouTube Data API (youtube/v3) +// Description: +// Programmatic access to YouTube features. +// Documentation: +// https://developers.google.com/youtube/v3 +// Classes: +// GTLYouTubePlaylistListResponse (0 custom class methods, 9 custom properties) + +#import "GTLYouTubePlaylistListResponse.h" + +#import "GTLYouTubePageInfo.h" +#import "GTLYouTubePlaylist.h" +#import "GTLYouTubeTokenPagination.h" + +// ---------------------------------------------------------------------------- +// +// GTLYouTubePlaylistListResponse +// + +@implementation GTLYouTubePlaylistListResponse +@dynamic ETag, eventId, items, kind, nextPageToken, pageInfo, prevPageToken, + tokenPagination, visitorId; + ++ (NSDictionary *)propertyToJSONKeyMap { + NSDictionary *map = + [NSDictionary dictionaryWithObject:@"etag" + forKey:@"ETag"]; + return map; +} + ++ (NSDictionary *)arrayPropertyToClassMap { + NSDictionary *map = + [NSDictionary dictionaryWithObject:[GTLYouTubePlaylist class] + forKey:@"items"]; + return map; +} + ++ (void)load { + [self registerObjectClassForKind:@"youtube#playlistListResponse"]; +} + +@end diff --git a/XCDYouTubeKit Demo/Pods/Google-API-Client/Source/Services/YouTube/Generated/GTLYouTubePlaylistPlayer.h b/XCDYouTubeKit Demo/Pods/Google-API-Client/Source/Services/YouTube/Generated/GTLYouTubePlaylistPlayer.h new file mode 100644 index 00000000..5d218402 --- /dev/null +++ b/XCDYouTubeKit Demo/Pods/Google-API-Client/Source/Services/YouTube/Generated/GTLYouTubePlaylistPlayer.h @@ -0,0 +1,47 @@ +/* Copyright (c) 2013 Google Inc. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +// +// GTLYouTubePlaylistPlayer.h +// + +// ---------------------------------------------------------------------------- +// NOTE: This file is generated from Google APIs Discovery Service. +// Service: +// YouTube Data API (youtube/v3) +// Description: +// Programmatic access to YouTube features. +// Documentation: +// https://developers.google.com/youtube/v3 +// Classes: +// GTLYouTubePlaylistPlayer (0 custom class methods, 1 custom properties) + +#if GTL_BUILT_AS_FRAMEWORK + #import "GTL/GTLObject.h" +#else + #import "GTLObject.h" +#endif + +// ---------------------------------------------------------------------------- +// +// GTLYouTubePlaylistPlayer +// + +@interface GTLYouTubePlaylistPlayer : GTLObject + +// An