youtube  v3
you_tube_service.h
1 // Copyright 2010 Google Inc.
2 //
3 // Licensed under the Apache License, Version 2.0 (the "License"); you may not
4 // use this file except in compliance with the License. You may obtain a copy of
5 // the License at
6 //
7 // http://www.apache.org/licenses/LICENSE-2.0
8 //
9 // Unless required by applicable law or agreed to in writing, software
10 // distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
11 // WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
12 // License for the specific language governing permissions and limitations under
13 // the License.
14 //
15 //------------------------------------------------------------------------------
16 // This code was generated by google-apis-code-generator 1.5.1
17 // Build date: 2018-10-08 17:45:39 UTC
18 // on: 2020-02-27, 01:46:08 UTC
19 // C++ generator version: 0.1.4
20 //
21 // Changes to this file may cause incorrect behavior and will be lost if
22 // the code is regenerated.
23 //------------------------------------------------------------------------------
24 #ifndef GOOGLE_YOUTUBE_API_YOU_TUBE_SERVICE_H_
25 #define GOOGLE_YOUTUBE_API_YOU_TUBE_SERVICE_H_
26 
27 #include <string>
28 #include "googleapis/base/integral_types.h"
29 #include "googleapis/base/macros.h"
30 #include "googleapis/client/service/client_service.h"
31 #include "googleapis/client/service/media_uploader.h"
32 #include "googleapis/client/service/service_request_pager.h"
33 #include "googleapis/client/util/date_time.h"
34 #include "googleapis/client/util/status.h"
35 #include "googleapis/client/util/uri_template.h"
36 
37 #include "google/youtube_api/activity.h"
38 #include "google/youtube_api/activity_list_response.h"
39 #include "google/youtube_api/caption.h"
40 #include "google/youtube_api/caption_list_response.h"
41 #include "google/youtube_api/channel.h"
42 #include "google/youtube_api/channel_banner_resource.h"
43 #include "google/youtube_api/channel_list_response.h"
44 #include "google/youtube_api/channel_section.h"
45 #include "google/youtube_api/channel_section_list_response.h"
46 #include "google/youtube_api/comment.h"
47 #include "google/youtube_api/comment_list_response.h"
48 #include "google/youtube_api/comment_thread.h"
49 #include "google/youtube_api/comment_thread_list_response.h"
50 #include "google/youtube_api/guide_category_list_response.h"
51 #include "google/youtube_api/i18n_language_list_response.h"
52 #include "google/youtube_api/i18n_region_list_response.h"
53 #include "google/youtube_api/invideo_branding.h"
54 #include "google/youtube_api/live_broadcast.h"
55 #include "google/youtube_api/live_broadcast_list_response.h"
56 #include "google/youtube_api/live_chat_ban.h"
57 #include "google/youtube_api/live_chat_message.h"
58 #include "google/youtube_api/live_chat_message_list_response.h"
59 #include "google/youtube_api/live_chat_moderator.h"
60 #include "google/youtube_api/live_chat_moderator_list_response.h"
61 #include "google/youtube_api/live_stream.h"
62 #include "google/youtube_api/live_stream_list_response.h"
63 #include "google/youtube_api/member_list_response.h"
64 #include "google/youtube_api/memberships_level_list_response.h"
65 #include "google/youtube_api/playlist.h"
66 #include "google/youtube_api/playlist_item.h"
67 #include "google/youtube_api/playlist_item_list_response.h"
68 #include "google/youtube_api/playlist_list_response.h"
69 #include "google/youtube_api/search_list_response.h"
70 #include "google/youtube_api/sponsor_list_response.h"
71 #include "google/youtube_api/subscription.h"
72 #include "google/youtube_api/subscription_list_response.h"
73 #include "google/youtube_api/super_chat_event_list_response.h"
74 #include "google/youtube_api/thumbnail_set_response.h"
75 #include "google/youtube_api/video.h"
76 #include "google/youtube_api/video_abuse_report.h"
77 #include "google/youtube_api/video_abuse_report_reason_list_response.h"
78 #include "google/youtube_api/video_category_list_response.h"
79 #include "google/youtube_api/video_get_rating_response.h"
80 #include "google/youtube_api/video_list_response.h"
81 
82 
83 namespace google_youtube_api {
84 using namespace googleapis;
115 class YouTubeService;
116 
125  : public client::ClientServiceRequest {
126  public:
149  const client::ClientService* service,
150  client::AuthorizationCredential* credential,
151  client::HttpRequest::HttpMethod method,
152  const StringPiece& uri_template);
153 
157  virtual ~YouTubeServiceBaseRequest();
158 
159 
163  void clear_alt() {
164  _have_alt_ = false;
165  client::ClearCppValueHelper(&alt_);
166  }
167 
168 
174  const string& get_alt() const { return alt_; }
175 
181  string* mutable_alt() {
182  _have_alt_ = true;
183  return &alt_;
184  }
185 
186 
192  void set_alt(const string& value) {
193  _have_alt_ = true;
194  alt_ = value;
195  }
196 
197 
198 
202  void clear_fields() {
203  _have_fields_ = false;
204  client::ClearCppValueHelper(&fields_);
205  }
206 
207 
213  const string& get_fields() const { return fields_; }
214 
220  string* mutable_fields() {
221  _have_fields_ = true;
222  return &fields_;
223  }
224 
225 
232  void set_fields(const string& value) {
233  _have_fields_ = true;
234  fields_ = value;
235  }
236 
237 
238 
242  void clear_key() {
243  _have_key_ = false;
244  client::ClearCppValueHelper(&key_);
245  }
246 
247 
253  const string& get_key() const { return key_; }
254 
260  string* mutable_key() {
261  _have_key_ = true;
262  return &key_;
263  }
264 
265 
273  void set_key(const string& value) {
274  _have_key_ = true;
275  key_ = value;
276  }
277 
278 
279 
284  _have_oauth_token_ = false;
285  client::ClearCppValueHelper(&oauth_token_);
286  }
287 
288 
294  const string& get_oauth_token() const { return oauth_token_; }
295 
302  string* mutable_oauthToken() {
303  _have_oauth_token_ = true;
304  return &oauth_token_;
305  }
306 
307 
313  void set_oauth_token(const string& value) {
314  _have_oauth_token_ = true;
315  oauth_token_ = value;
316  }
317 
318 
319 
324  _have_pretty_print_ = false;
325  client::ClearCppValueHelper(&pretty_print_);
326  }
327 
328 
334  bool get_pretty_print() const { return pretty_print_; }
335 
341  void set_pretty_print(bool value) {
342  _have_pretty_print_ = true;
343  pretty_print_ = value;
344  }
345 
350  _have_quota_user_ = false;
351  client::ClearCppValueHelper(&quota_user_);
352  }
353 
354 
360  const string& get_quota_user() const { return quota_user_; }
361 
368  string* mutable_quotaUser() {
369  _have_quota_user_ = true;
370  return &quota_user_;
371  }
372 
373 
380  void set_quota_user(const string& value) {
381  _have_quota_user_ = true;
382  quota_user_ = value;
383  }
384 
385 
386 
390  void clear_user_ip() {
391  _have_user_ip_ = false;
392  client::ClearCppValueHelper(&user_ip_);
393  }
394 
395 
401  const string& get_user_ip() const { return user_ip_; }
402 
408  string* mutable_userIp() {
409  _have_user_ip_ = true;
410  return &user_ip_;
411  }
412 
413 
420  void set_user_ip(const string& value) {
421  _have_user_ip_ = true;
422  user_ip_ = value;
423  }
424 
435  virtual util::Status AppendVariable(
436  const StringPiece& variable_name,
437  const client::UriTemplateConfig& config,
438  string* target);
439 
445  virtual util::Status AppendOptionalQueryParameters(string* target);
446 
447 
448  protected:
454  void AddJsonContentToRequest(const client::JsonCppData *content);
455 
456  private:
457  string alt_;
458  string fields_;
459  string key_;
460  string oauth_token_;
461  bool pretty_print_;
462  string quota_user_;
463  string user_ip_;
464  bool _have_alt_ : 1;
465  bool _have_fields_ : 1;
466  bool _have_key_ : 1;
467  bool _have_oauth_token_ : 1;
468  bool _have_pretty_print_ : 1;
469  bool _have_quota_user_ : 1;
470  bool _have_user_ip_ : 1;
471 
472  DISALLOW_COPY_AND_ASSIGN(YouTubeServiceBaseRequest);
473 };
474 
475 
476 
491  public:
504  const YouTubeService* _service_,
505  client::AuthorizationCredential* _credential_,
506  const absl::string_view& part,
507  const Activity& _content_);
508 
513 
514 
524  virtual util::Status AppendVariable(
525  const StringPiece& variable_name,
526  const client::UriTemplateConfig& config,
527  string* target);
528 
534  virtual util::Status AppendOptionalQueryParameters(string* target);
535 
536 
548  Activity* data) {
549  return YouTubeServiceBaseRequest::ExecuteAndParseResponse(data);
550  }
551 
552  private:
553  string part_; string _content_;
554  DISALLOW_COPY_AND_ASSIGN(ActivitiesResource_InsertMethod);
555 };
556 
572  public:
590  const YouTubeService* _service_,
591  client::AuthorizationCredential* _credential_,
592  const absl::string_view& part);
593 
598 
599 
604  _have_channel_id_ = false;
605  client::ClearCppValueHelper(&channel_id_);
606  }
607 
608 
614  const string& get_channel_id() const { return channel_id_; }
615 
622  string* mutable_channelId() {
623  _have_channel_id_ = true;
624  return &channel_id_;
625  }
626 
627 
634  void set_channel_id(const string& value) {
635  _have_channel_id_ = true;
636  channel_id_ = value;
637  }
638 
639 
640 
644  void clear_home() {
645  _have_home_ = false;
646  client::ClearCppValueHelper(&home_);
647  }
648 
649 
655  bool get_home() const { return home_; }
656 
664  void set_home(bool value) {
665  _have_home_ = true;
666  home_ = value;
667  }
668 
673  _have_max_results_ = false;
674  client::ClearCppValueHelper(&max_results_);
675  }
676 
677 
683  uint32 get_max_results() const { return max_results_; }
684 
691  void set_max_results(uint32 value) {
692  _have_max_results_ = true;
693  max_results_ = value;
694  }
695 
699  void clear_mine() {
700  _have_mine_ = false;
701  client::ClearCppValueHelper(&mine_);
702  }
703 
704 
710  bool get_mine() const { return mine_; }
711 
718  void set_mine(bool value) {
719  _have_mine_ = true;
720  mine_ = value;
721  }
722 
727  _have_page_token_ = false;
728  client::ClearCppValueHelper(&page_token_);
729  }
730 
731 
737  const string& get_page_token() const { return page_token_; }
738 
745  string* mutable_pageToken() {
746  _have_page_token_ = true;
747  return &page_token_;
748  }
749 
750 
759  void set_page_token(const string& value) {
760  _have_page_token_ = true;
761  page_token_ = value;
762  }
763 
764 
765 
771  _have_published_after_ = false;
772  client::ClearCppValueHelper(&published_after_);
773  }
774 
775 
781  client::DateTime get_published_after() const { return published_after_; }
782 
793  void set_published_after(client::DateTime value) {
794  _have_published_after_ = true;
795  published_after_ = value;
796  }
797 
803  _have_published_before_ = false;
804  client::ClearCppValueHelper(&published_before_);
805  }
806 
807 
813  client::DateTime get_published_before() const { return published_before_; }
814 
825  void set_published_before(client::DateTime value) {
826  _have_published_before_ = true;
827  published_before_ = value;
828  }
829 
834  _have_region_code_ = false;
835  client::ClearCppValueHelper(&region_code_);
836  }
837 
838 
844  const string& get_region_code() const { return region_code_; }
845 
852  string* mutable_regionCode() {
853  _have_region_code_ = true;
854  return &region_code_;
855  }
856 
857 
867  void set_region_code(const string& value) {
868  _have_region_code_ = true;
869  region_code_ = value;
870  }
871 
881  virtual util::Status AppendVariable(
882  const StringPiece& variable_name,
883  const client::UriTemplateConfig& config,
884  string* target);
885 
891  virtual util::Status AppendOptionalQueryParameters(string* target);
892 
893 
905  ActivityListResponse* data) {
906  return YouTubeServiceBaseRequest::ExecuteAndParseResponse(data);
907  }
908 
909  private:
910  string part_;
911  string channel_id_;
912  bool home_;
913  uint32 max_results_;
914  bool mine_;
915  string page_token_;
916  client::DateTime published_after_;
917  client::DateTime published_before_;
918  string region_code_;
919  bool _have_channel_id_ : 1;
920  bool _have_home_ : 1;
921  bool _have_max_results_ : 1;
922  bool _have_mine_ : 1;
923  bool _have_page_token_ : 1;
924  bool _have_published_after_ : 1;
925  bool _have_published_before_ : 1;
926  bool _have_region_code_ : 1;
927  DISALLOW_COPY_AND_ASSIGN(ActivitiesResource_ListMethod);
928 };
929 
930 typedef client::ServiceRequestPager<
933  ActivitiesResource_ListMethodPager;
934 
935 
936 
951  public:
963  const YouTubeService* _service_,
964  client::AuthorizationCredential* _credential_,
965  const absl::string_view& id);
966 
971 
972 
977  _have_on_behalf_of_ = false;
978  client::ClearCppValueHelper(&on_behalf_of_);
979  }
980 
981 
987  const string& get_on_behalf_of() const { return on_behalf_of_; }
988 
995  string* mutable_onBehalfOf() {
996  _have_on_behalf_of_ = true;
997  return &on_behalf_of_;
998  }
999 
1000 
1007  void set_on_behalf_of(const string& value) {
1008  _have_on_behalf_of_ = true;
1009  on_behalf_of_ = value;
1010  }
1011 
1012 
1013 
1019  _have_on_behalf_of_content_owner_ = false;
1020  client::ClearCppValueHelper(&on_behalf_of_content_owner_);
1021  }
1022 
1023 
1029  const string& get_on_behalf_of_content_owner() const { return on_behalf_of_content_owner_; }
1030 
1038  _have_on_behalf_of_content_owner_ = true;
1039  return &on_behalf_of_content_owner_;
1040  }
1041 
1042 
1059  void set_on_behalf_of_content_owner(const string& value) {
1060  _have_on_behalf_of_content_owner_ = true;
1061  on_behalf_of_content_owner_ = value;
1062  }
1063 
1073  virtual util::Status AppendVariable(
1074  const StringPiece& variable_name,
1075  const client::UriTemplateConfig& config,
1076  string* target);
1077 
1083  virtual util::Status AppendOptionalQueryParameters(string* target);
1084 
1085 
1086  private:
1087  string id_;
1088  string on_behalf_of_;
1089  string on_behalf_of_content_owner_;
1090  bool _have_on_behalf_of_ : 1;
1091  bool _have_on_behalf_of_content_owner_ : 1;
1092  DISALLOW_COPY_AND_ASSIGN(CaptionsResource_DeleteMethod);
1093 };
1094 
1109  public:
1121  const YouTubeService* _service_,
1122  client::AuthorizationCredential* _credential_,
1123  const absl::string_view& id);
1124 
1129 
1130 
1135  _have_on_behalf_of_ = false;
1136  client::ClearCppValueHelper(&on_behalf_of_);
1137  }
1138 
1139 
1145  const string& get_on_behalf_of() const { return on_behalf_of_; }
1146 
1154  _have_on_behalf_of_ = true;
1155  return &on_behalf_of_;
1156  }
1157 
1158 
1165  void set_on_behalf_of(const string& value) {
1166  _have_on_behalf_of_ = true;
1167  on_behalf_of_ = value;
1168  }
1169 
1170 
1171 
1177  _have_on_behalf_of_content_owner_ = false;
1178  client::ClearCppValueHelper(&on_behalf_of_content_owner_);
1179  }
1180 
1181 
1187  const string& get_on_behalf_of_content_owner() const { return on_behalf_of_content_owner_; }
1188 
1196  _have_on_behalf_of_content_owner_ = true;
1197  return &on_behalf_of_content_owner_;
1198  }
1199 
1200 
1217  void set_on_behalf_of_content_owner(const string& value) {
1218  _have_on_behalf_of_content_owner_ = true;
1219  on_behalf_of_content_owner_ = value;
1220  }
1221 
1222 
1223 
1227  void clear_tfmt() {
1228  _have_tfmt_ = false;
1229  client::ClearCppValueHelper(&tfmt_);
1230  }
1231 
1232 
1238  const string& get_tfmt() const { return tfmt_; }
1239 
1245  string* mutable_tfmt() {
1246  _have_tfmt_ = true;
1247  return &tfmt_;
1248  }
1249 
1250 
1258  void set_tfmt(const string& value) {
1259  _have_tfmt_ = true;
1260  tfmt_ = value;
1261  }
1262 
1263 
1264 
1268  void clear_tlang() {
1269  _have_tlang_ = false;
1270  client::ClearCppValueHelper(&tlang_);
1271  }
1272 
1273 
1279  const string& get_tlang() const { return tlang_; }
1280 
1286  string* mutable_tlang() {
1287  _have_tlang_ = true;
1288  return &tlang_;
1289  }
1290 
1291 
1301  void set_tlang(const string& value) {
1302  _have_tlang_ = true;
1303  tlang_ = value;
1304  }
1305 
1315  virtual util::Status AppendVariable(
1316  const StringPiece& variable_name,
1317  const client::UriTemplateConfig& config,
1318  string* target);
1319 
1325  virtual util::Status AppendOptionalQueryParameters(string* target);
1326 
1327 
1333  bool get_use_media_download() const {
1334  return YouTubeServiceBaseRequest::get_use_media_download();
1335  }
1336 
1342  void set_use_media_download(bool use) {
1343  YouTubeServiceBaseRequest::set_use_media_download(use);
1344  }
1345 
1346  private:
1347  string id_;
1348  string on_behalf_of_;
1349  string on_behalf_of_content_owner_;
1350  string tfmt_;
1351  string tlang_;
1352  bool _have_on_behalf_of_ : 1;
1353  bool _have_on_behalf_of_content_owner_ : 1;
1354  bool _have_tfmt_ : 1;
1355  bool _have_tlang_ : 1;
1356  DISALLOW_COPY_AND_ASSIGN(CaptionsResource_DownloadMethod);
1357 };
1358 
1373  public:
1389  const YouTubeService* _service_,
1390  client::AuthorizationCredential* _credential_,
1391  const absl::string_view& part);
1409  const YouTubeService* _service_,
1410  client::AuthorizationCredential* _credential_,
1411  const absl::string_view& part,
1412  const Caption* _metadata_,
1413  const StringPiece& _media_content_type_,
1414  client::DataReader* _media_content_reader_);
1415 
1419  virtual ~CaptionsResource_InsertMethod();
1420 
1421 
1426  _have_on_behalf_of_ = false;
1427  client::ClearCppValueHelper(&on_behalf_of_);
1428  }
1429 
1430 
1436  const string& get_on_behalf_of() const { return on_behalf_of_; }
1437 
1445  _have_on_behalf_of_ = true;
1446  return &on_behalf_of_;
1447  }
1448 
1449 
1456  void set_on_behalf_of(const string& value) {
1457  _have_on_behalf_of_ = true;
1458  on_behalf_of_ = value;
1459  }
1460 
1461 
1462 
1468  _have_on_behalf_of_content_owner_ = false;
1469  client::ClearCppValueHelper(&on_behalf_of_content_owner_);
1470  }
1471 
1472 
1478  const string& get_on_behalf_of_content_owner() const { return on_behalf_of_content_owner_; }
1479 
1487  _have_on_behalf_of_content_owner_ = true;
1488  return &on_behalf_of_content_owner_;
1489  }
1490 
1491 
1508  void set_on_behalf_of_content_owner(const string& value) {
1509  _have_on_behalf_of_content_owner_ = true;
1510  on_behalf_of_content_owner_ = value;
1511  }
1512 
1513 
1514 
1518  void clear_sync() {
1519  _have_sync_ = false;
1520  client::ClearCppValueHelper(&sync_);
1521  }
1522 
1523 
1529  bool get_sync() const { return sync_; }
1530 
1544  void set_sync(bool value) {
1545  _have_sync_ = true;
1546  sync_ = value;
1547  }
1548 
1558  virtual util::Status AppendVariable(
1559  const StringPiece& variable_name,
1560  const client::UriTemplateConfig& config,
1561  string* target);
1562 
1568  virtual util::Status AppendOptionalQueryParameters(string* target);
1569 
1570 
1582  Caption* data) {
1583  return YouTubeServiceBaseRequest::ExecuteAndParseResponse(data);
1584  }
1585 
1586 
1594  static const client::MediaUploadSpec SIMPLE_MEDIA_UPLOAD;
1598  static const client::MediaUploadSpec RESUMABLE_MEDIA_UPLOAD;
1599 
1600  private:
1601  string part_;
1602  string on_behalf_of_;
1603  string on_behalf_of_content_owner_;
1604  bool sync_;
1605  bool _have_on_behalf_of_ : 1;
1606  bool _have_on_behalf_of_content_owner_ : 1;
1607  bool _have_sync_ : 1;
1608  DISALLOW_COPY_AND_ASSIGN(CaptionsResource_InsertMethod);
1609 };
1610 
1625  public:
1639  const YouTubeService* _service_,
1640  client::AuthorizationCredential* _credential_,
1641  const absl::string_view& part,
1642  const absl::string_view& video_id);
1643 
1647  virtual ~CaptionsResource_ListMethod();
1648 
1649 
1653  void clear_id() {
1654  _have_id_ = false;
1655  client::ClearCppValueHelper(&id_);
1656  }
1657 
1658 
1664  const string& get_id() const { return id_; }
1665 
1671  string* mutable_id() {
1672  _have_id_ = true;
1673  return &id_;
1674  }
1675 
1676 
1684  void set_id(const string& value) {
1685  _have_id_ = true;
1686  id_ = value;
1687  }
1688 
1689 
1690 
1695  _have_on_behalf_of_ = false;
1696  client::ClearCppValueHelper(&on_behalf_of_);
1697  }
1698 
1699 
1705  const string& get_on_behalf_of() const { return on_behalf_of_; }
1706 
1714  _have_on_behalf_of_ = true;
1715  return &on_behalf_of_;
1716  }
1717 
1718 
1725  void set_on_behalf_of(const string& value) {
1726  _have_on_behalf_of_ = true;
1727  on_behalf_of_ = value;
1728  }
1729 
1730 
1731 
1737  _have_on_behalf_of_content_owner_ = false;
1738  client::ClearCppValueHelper(&on_behalf_of_content_owner_);
1739  }
1740 
1741 
1747  const string& get_on_behalf_of_content_owner() const { return on_behalf_of_content_owner_; }
1748 
1756  _have_on_behalf_of_content_owner_ = true;
1757  return &on_behalf_of_content_owner_;
1758  }
1759 
1760 
1777  void set_on_behalf_of_content_owner(const string& value) {
1778  _have_on_behalf_of_content_owner_ = true;
1779  on_behalf_of_content_owner_ = value;
1780  }
1781 
1791  virtual util::Status AppendVariable(
1792  const StringPiece& variable_name,
1793  const client::UriTemplateConfig& config,
1794  string* target);
1795 
1801  virtual util::Status AppendOptionalQueryParameters(string* target);
1802 
1803 
1815  CaptionListResponse* data) {
1816  return YouTubeServiceBaseRequest::ExecuteAndParseResponse(data);
1817  }
1818 
1819  private:
1820  string part_;
1821  string video_id_;
1822  string id_;
1823  string on_behalf_of_;
1824  string on_behalf_of_content_owner_;
1825  bool _have_id_ : 1;
1826  bool _have_on_behalf_of_ : 1;
1827  bool _have_on_behalf_of_content_owner_ : 1;
1828  DISALLOW_COPY_AND_ASSIGN(CaptionsResource_ListMethod);
1829 };
1830 
1845  public:
1864  const YouTubeService* _service_,
1865  client::AuthorizationCredential* _credential_,
1866  const absl::string_view& part);
1887  const YouTubeService* _service_,
1888  client::AuthorizationCredential* _credential_,
1889  const absl::string_view& part,
1890  const Caption* _metadata_,
1891  const StringPiece& _media_content_type_,
1892  client::DataReader* _media_content_reader_);
1893 
1897  virtual ~CaptionsResource_UpdateMethod();
1898 
1899 
1904  _have_on_behalf_of_ = false;
1905  client::ClearCppValueHelper(&on_behalf_of_);
1906  }
1907 
1908 
1914  const string& get_on_behalf_of() const { return on_behalf_of_; }
1915 
1923  _have_on_behalf_of_ = true;
1924  return &on_behalf_of_;
1925  }
1926 
1927 
1934  void set_on_behalf_of(const string& value) {
1935  _have_on_behalf_of_ = true;
1936  on_behalf_of_ = value;
1937  }
1938 
1939 
1940 
1946  _have_on_behalf_of_content_owner_ = false;
1947  client::ClearCppValueHelper(&on_behalf_of_content_owner_);
1948  }
1949 
1950 
1956  const string& get_on_behalf_of_content_owner() const { return on_behalf_of_content_owner_; }
1957 
1965  _have_on_behalf_of_content_owner_ = true;
1966  return &on_behalf_of_content_owner_;
1967  }
1968 
1969 
1986  void set_on_behalf_of_content_owner(const string& value) {
1987  _have_on_behalf_of_content_owner_ = true;
1988  on_behalf_of_content_owner_ = value;
1989  }
1990 
1991 
1992 
1996  void clear_sync() {
1997  _have_sync_ = false;
1998  client::ClearCppValueHelper(&sync_);
1999  }
2000 
2001 
2007  bool get_sync() const { return sync_; }
2008 
2020  void set_sync(bool value) {
2021  _have_sync_ = true;
2022  sync_ = value;
2023  }
2024 
2034  virtual util::Status AppendVariable(
2035  const StringPiece& variable_name,
2036  const client::UriTemplateConfig& config,
2037  string* target);
2038 
2044  virtual util::Status AppendOptionalQueryParameters(string* target);
2045 
2046 
2058  Caption* data) {
2059  return YouTubeServiceBaseRequest::ExecuteAndParseResponse(data);
2060  }
2061 
2062 
2070  static const client::MediaUploadSpec SIMPLE_MEDIA_UPLOAD;
2074  static const client::MediaUploadSpec RESUMABLE_MEDIA_UPLOAD;
2075 
2076  private:
2077  string part_;
2078  string on_behalf_of_;
2079  string on_behalf_of_content_owner_;
2080  bool sync_;
2081  bool _have_on_behalf_of_ : 1;
2082  bool _have_on_behalf_of_content_owner_ : 1;
2083  bool _have_sync_ : 1;
2084  DISALLOW_COPY_AND_ASSIGN(CaptionsResource_UpdateMethod);
2085 };
2086 
2087 
2088 
2104  public:
2117  const YouTubeService* _service_,
2118  client::AuthorizationCredential* _credential_);
2134  const YouTubeService* _service_,
2135  client::AuthorizationCredential* _credential_,
2136  const ChannelBannerResource* _metadata_,
2137  const StringPiece& _media_content_type_,
2138  client::DataReader* _media_content_reader_);
2139 
2144 
2145 
2150  _have_channel_id_ = false;
2151  client::ClearCppValueHelper(&channel_id_);
2152  }
2153 
2154 
2160  const string& get_channel_id() const { return channel_id_; }
2161 
2168  string* mutable_channelId() {
2169  _have_channel_id_ = true;
2170  return &channel_id_;
2171  }
2172 
2173 
2186  void set_channel_id(const string& value) {
2187  _have_channel_id_ = true;
2188  channel_id_ = value;
2189  }
2190 
2191 
2192 
2198  _have_on_behalf_of_content_owner_ = false;
2199  client::ClearCppValueHelper(&on_behalf_of_content_owner_);
2200  }
2201 
2202 
2208  const string& get_on_behalf_of_content_owner() const { return on_behalf_of_content_owner_; }
2209 
2217  _have_on_behalf_of_content_owner_ = true;
2218  return &on_behalf_of_content_owner_;
2219  }
2220 
2221 
2238  void set_on_behalf_of_content_owner(const string& value) {
2239  _have_on_behalf_of_content_owner_ = true;
2240  on_behalf_of_content_owner_ = value;
2241  }
2242 
2252  virtual util::Status AppendVariable(
2253  const StringPiece& variable_name,
2254  const client::UriTemplateConfig& config,
2255  string* target);
2256 
2262  virtual util::Status AppendOptionalQueryParameters(string* target);
2263 
2264 
2276  ChannelBannerResource* data) {
2277  return YouTubeServiceBaseRequest::ExecuteAndParseResponse(data);
2278  }
2279 
2280 
2288  static const client::MediaUploadSpec SIMPLE_MEDIA_UPLOAD;
2292  static const client::MediaUploadSpec RESUMABLE_MEDIA_UPLOAD;
2293 
2294  private:
2295  string channel_id_;
2296  string on_behalf_of_content_owner_;
2297  bool _have_channel_id_ : 1;
2298  bool _have_on_behalf_of_content_owner_ : 1;
2299  DISALLOW_COPY_AND_ASSIGN(ChannelBannersResource_InsertMethod);
2300 };
2301 
2302 
2303 
2319  public:
2331  const YouTubeService* _service_,
2332  client::AuthorizationCredential* _credential_,
2333  const absl::string_view& id);
2334 
2339 
2340 
2346  _have_on_behalf_of_content_owner_ = false;
2347  client::ClearCppValueHelper(&on_behalf_of_content_owner_);
2348  }
2349 
2350 
2356  const string& get_on_behalf_of_content_owner() const { return on_behalf_of_content_owner_; }
2357 
2365  _have_on_behalf_of_content_owner_ = true;
2366  return &on_behalf_of_content_owner_;
2367  }
2368 
2369 
2386  void set_on_behalf_of_content_owner(const string& value) {
2387  _have_on_behalf_of_content_owner_ = true;
2388  on_behalf_of_content_owner_ = value;
2389  }
2390 
2400  virtual util::Status AppendVariable(
2401  const StringPiece& variable_name,
2402  const client::UriTemplateConfig& config,
2403  string* target);
2404 
2410  virtual util::Status AppendOptionalQueryParameters(string* target);
2411 
2412 
2413  private:
2414  string id_;
2415  string on_behalf_of_content_owner_;
2416  bool _have_on_behalf_of_content_owner_ : 1;
2417  DISALLOW_COPY_AND_ASSIGN(ChannelSectionsResource_DeleteMethod);
2418 };
2419 
2435  public:
2451  const YouTubeService* _service_,
2452  client::AuthorizationCredential* _credential_,
2453  const absl::string_view& part,
2454  const ChannelSection& _content_);
2455 
2460 
2461 
2467  _have_on_behalf_of_content_owner_ = false;
2468  client::ClearCppValueHelper(&on_behalf_of_content_owner_);
2469  }
2470 
2471 
2477  const string& get_on_behalf_of_content_owner() const { return on_behalf_of_content_owner_; }
2478 
2486  _have_on_behalf_of_content_owner_ = true;
2487  return &on_behalf_of_content_owner_;
2488  }
2489 
2490 
2507  void set_on_behalf_of_content_owner(const string& value) {
2508  _have_on_behalf_of_content_owner_ = true;
2509  on_behalf_of_content_owner_ = value;
2510  }
2511 
2512 
2513 
2519  _have_on_behalf_of_content_owner_channel_ = false;
2520  client::ClearCppValueHelper(&on_behalf_of_content_owner_channel_);
2521  }
2522 
2523 
2529  const string& get_on_behalf_of_content_owner_channel() const { return on_behalf_of_content_owner_channel_; }
2530 
2538  _have_on_behalf_of_content_owner_channel_ = true;
2539  return &on_behalf_of_content_owner_channel_;
2540  }
2541 
2542 
2566  void set_on_behalf_of_content_owner_channel(const string& value) {
2567  _have_on_behalf_of_content_owner_channel_ = true;
2568  on_behalf_of_content_owner_channel_ = value;
2569  }
2570 
2580  virtual util::Status AppendVariable(
2581  const StringPiece& variable_name,
2582  const client::UriTemplateConfig& config,
2583  string* target);
2584 
2590  virtual util::Status AppendOptionalQueryParameters(string* target);
2591 
2592 
2604  ChannelSection* data) {
2605  return YouTubeServiceBaseRequest::ExecuteAndParseResponse(data);
2606  }
2607 
2608  private:
2609  string part_;
2610  string on_behalf_of_content_owner_;
2611  string on_behalf_of_content_owner_channel_;
2612  bool _have_on_behalf_of_content_owner_ : 1;
2613  bool _have_on_behalf_of_content_owner_channel_ : 1; string _content_;
2614  DISALLOW_COPY_AND_ASSIGN(ChannelSectionsResource_InsertMethod);
2615 };
2616 
2633  public:
2652  const YouTubeService* _service_,
2653  client::AuthorizationCredential* _credential_,
2654  const absl::string_view& part);
2655 
2660 
2661 
2666  _have_channel_id_ = false;
2667  client::ClearCppValueHelper(&channel_id_);
2668  }
2669 
2670 
2676  const string& get_channel_id() const { return channel_id_; }
2677 
2684  string* mutable_channelId() {
2685  _have_channel_id_ = true;
2686  return &channel_id_;
2687  }
2688 
2689 
2696  void set_channel_id(const string& value) {
2697  _have_channel_id_ = true;
2698  channel_id_ = value;
2699  }
2700 
2701 
2702 
2706  void clear_hl() {
2707  _have_hl_ = false;
2708  client::ClearCppValueHelper(&hl_);
2709  }
2710 
2711 
2717  const string& get_hl() const { return hl_; }
2718 
2724  string* mutable_hl() {
2725  _have_hl_ = true;
2726  return &hl_;
2727  }
2728 
2729 
2742  void set_hl(const string& value) {
2743  _have_hl_ = true;
2744  hl_ = value;
2745  }
2746 
2747 
2748 
2752  void clear_id() {
2753  _have_id_ = false;
2754  client::ClearCppValueHelper(&id_);
2755  }
2756 
2757 
2763  const string& get_id() const { return id_; }
2764 
2770  string* mutable_id() {
2771  _have_id_ = true;
2772  return &id_;
2773  }
2774 
2775 
2784  void set_id(const string& value) {
2785  _have_id_ = true;
2786  id_ = value;
2787  }
2788 
2789 
2790 
2794  void clear_mine() {
2795  _have_mine_ = false;
2796  client::ClearCppValueHelper(&mine_);
2797  }
2798 
2799 
2805  bool get_mine() const { return mine_; }
2806 
2813  void set_mine(bool value) {
2814  _have_mine_ = true;
2815  mine_ = value;
2816  }
2817 
2823  _have_on_behalf_of_content_owner_ = false;
2824  client::ClearCppValueHelper(&on_behalf_of_content_owner_);
2825  }
2826 
2827 
2833  const string& get_on_behalf_of_content_owner() const { return on_behalf_of_content_owner_; }
2834 
2842  _have_on_behalf_of_content_owner_ = true;
2843  return &on_behalf_of_content_owner_;
2844  }
2845 
2846 
2863  void set_on_behalf_of_content_owner(const string& value) {
2864  _have_on_behalf_of_content_owner_ = true;
2865  on_behalf_of_content_owner_ = value;
2866  }
2867 
2877  virtual util::Status AppendVariable(
2878  const StringPiece& variable_name,
2879  const client::UriTemplateConfig& config,
2880  string* target);
2881 
2887  virtual util::Status AppendOptionalQueryParameters(string* target);
2888 
2889 
2902  return YouTubeServiceBaseRequest::ExecuteAndParseResponse(data);
2903  }
2904 
2905  private:
2906  string part_;
2907  string channel_id_;
2908  string hl_;
2909  string id_;
2910  bool mine_;
2911  string on_behalf_of_content_owner_;
2912  bool _have_channel_id_ : 1;
2913  bool _have_hl_ : 1;
2914  bool _have_id_ : 1;
2915  bool _have_mine_ : 1;
2916  bool _have_on_behalf_of_content_owner_ : 1;
2917  DISALLOW_COPY_AND_ASSIGN(ChannelSectionsResource_ListMethod);
2918 };
2919 
2935  public:
2951  const YouTubeService* _service_,
2952  client::AuthorizationCredential* _credential_,
2953  const absl::string_view& part,
2954  const ChannelSection& _content_);
2955 
2960 
2961 
2967  _have_on_behalf_of_content_owner_ = false;
2968  client::ClearCppValueHelper(&on_behalf_of_content_owner_);
2969  }
2970 
2971 
2977  const string& get_on_behalf_of_content_owner() const { return on_behalf_of_content_owner_; }
2978 
2986  _have_on_behalf_of_content_owner_ = true;
2987  return &on_behalf_of_content_owner_;
2988  }
2989 
2990 
3007  void set_on_behalf_of_content_owner(const string& value) {
3008  _have_on_behalf_of_content_owner_ = true;
3009  on_behalf_of_content_owner_ = value;
3010  }
3011 
3021  virtual util::Status AppendVariable(
3022  const StringPiece& variable_name,
3023  const client::UriTemplateConfig& config,
3024  string* target);
3025 
3031  virtual util::Status AppendOptionalQueryParameters(string* target);
3032 
3033 
3045  ChannelSection* data) {
3046  return YouTubeServiceBaseRequest::ExecuteAndParseResponse(data);
3047  }
3048 
3049  private:
3050  string part_;
3051  string on_behalf_of_content_owner_;
3052  bool _have_on_behalf_of_content_owner_ : 1; string _content_;
3053  DISALLOW_COPY_AND_ASSIGN(ChannelSectionsResource_UpdateMethod);
3054 };
3055 
3056 
3057 
3075  public:
3092  const YouTubeService* _service_,
3093  client::AuthorizationCredential* _credential_,
3094  const absl::string_view& part);
3095 
3099  virtual ~ChannelsResource_ListMethod();
3100 
3101 
3106  _have_category_id_ = false;
3107  client::ClearCppValueHelper(&category_id_);
3108  }
3109 
3110 
3116  const string& get_category_id() const { return category_id_; }
3117 
3125  _have_category_id_ = true;
3126  return &category_id_;
3127  }
3128 
3129 
3137  void set_category_id(const string& value) {
3138  _have_category_id_ = true;
3139  category_id_ = value;
3140  }
3141 
3142 
3143 
3148  _have_for_username_ = false;
3149  client::ClearCppValueHelper(&for_username_);
3150  }
3151 
3152 
3158  const string& get_for_username() const { return for_username_; }
3159 
3167  _have_for_username_ = true;
3168  return &for_username_;
3169  }
3170 
3171 
3178  void set_for_username(const string& value) {
3179  _have_for_username_ = true;
3180  for_username_ = value;
3181  }
3182 
3183 
3184 
3188  void clear_hl() {
3189  _have_hl_ = false;
3190  client::ClearCppValueHelper(&hl_);
3191  }
3192 
3193 
3199  const string& get_hl() const { return hl_; }
3200 
3206  string* mutable_hl() {
3207  _have_hl_ = true;
3208  return &hl_;
3209  }
3210 
3211 
3219  void set_hl(const string& value) {
3220  _have_hl_ = true;
3221  hl_ = value;
3222  }
3223 
3224 
3225 
3229  void clear_id() {
3230  _have_id_ = false;
3231  client::ClearCppValueHelper(&id_);
3232  }
3233 
3234 
3240  const string& get_id() const { return id_; }
3241 
3247  string* mutable_id() {
3248  _have_id_ = true;
3249  return &id_;
3250  }
3251 
3252 
3261  void set_id(const string& value) {
3262  _have_id_ = true;
3263  id_ = value;
3264  }
3265 
3266 
3267 
3272  _have_managed_by_me_ = false;
3273  client::ClearCppValueHelper(&managed_by_me_);
3274  }
3275 
3276 
3282  bool get_managed_by_me() const { return managed_by_me_; }
3283 
3296  void set_managed_by_me(bool value) {
3297  _have_managed_by_me_ = true;
3298  managed_by_me_ = value;
3299  }
3300 
3305  _have_max_results_ = false;
3306  client::ClearCppValueHelper(&max_results_);
3307  }
3308 
3309 
3315  uint32 get_max_results() const { return max_results_; }
3316 
3323  void set_max_results(uint32 value) {
3324  _have_max_results_ = true;
3325  max_results_ = value;
3326  }
3327 
3331  void clear_mine() {
3332  _have_mine_ = false;
3333  client::ClearCppValueHelper(&mine_);
3334  }
3335 
3336 
3342  bool get_mine() const { return mine_; }
3343 
3350  void set_mine(bool value) {
3351  _have_mine_ = true;
3352  mine_ = value;
3353  }
3354 
3359  _have_my_subscribers_ = false;
3360  client::ClearCppValueHelper(&my_subscribers_);
3361  }
3362 
3363 
3369  bool get_my_subscribers() const { return my_subscribers_; }
3370 
3378  void set_my_subscribers(bool value) {
3379  _have_my_subscribers_ = true;
3380  my_subscribers_ = value;
3381  }
3382 
3388  _have_on_behalf_of_content_owner_ = false;
3389  client::ClearCppValueHelper(&on_behalf_of_content_owner_);
3390  }
3391 
3392 
3398  const string& get_on_behalf_of_content_owner() const { return on_behalf_of_content_owner_; }
3399 
3407  _have_on_behalf_of_content_owner_ = true;
3408  return &on_behalf_of_content_owner_;
3409  }
3410 
3411 
3428  void set_on_behalf_of_content_owner(const string& value) {
3429  _have_on_behalf_of_content_owner_ = true;
3430  on_behalf_of_content_owner_ = value;
3431  }
3432 
3433 
3434 
3439  _have_page_token_ = false;
3440  client::ClearCppValueHelper(&page_token_);
3441  }
3442 
3443 
3449  const string& get_page_token() const { return page_token_; }
3450 
3457  string* mutable_pageToken() {
3458  _have_page_token_ = true;
3459  return &page_token_;
3460  }
3461 
3462 
3471  void set_page_token(const string& value) {
3472  _have_page_token_ = true;
3473  page_token_ = value;
3474  }
3475 
3485  virtual util::Status AppendVariable(
3486  const StringPiece& variable_name,
3487  const client::UriTemplateConfig& config,
3488  string* target);
3489 
3495  virtual util::Status AppendOptionalQueryParameters(string* target);
3496 
3497 
3509  ChannelListResponse* data) {
3510  return YouTubeServiceBaseRequest::ExecuteAndParseResponse(data);
3511  }
3512 
3513  private:
3514  string part_;
3515  string category_id_;
3516  string for_username_;
3517  string hl_;
3518  string id_;
3519  bool managed_by_me_;
3520  uint32 max_results_;
3521  bool mine_;
3522  bool my_subscribers_;
3523  string on_behalf_of_content_owner_;
3524  string page_token_;
3525  bool _have_category_id_ : 1;
3526  bool _have_for_username_ : 1;
3527  bool _have_hl_ : 1;
3528  bool _have_id_ : 1;
3529  bool _have_managed_by_me_ : 1;
3530  bool _have_max_results_ : 1;
3531  bool _have_mine_ : 1;
3532  bool _have_my_subscribers_ : 1;
3533  bool _have_on_behalf_of_content_owner_ : 1;
3534  bool _have_page_token_ : 1;
3535  DISALLOW_COPY_AND_ASSIGN(ChannelsResource_ListMethod);
3536 };
3537 
3538 typedef client::ServiceRequestPager<
3541  ChannelsResource_ListMethodPager;
3542 
3558  public:
3579  const YouTubeService* _service_,
3580  client::AuthorizationCredential* _credential_,
3581  const absl::string_view& part,
3582  const Channel& _content_);
3583 
3587  virtual ~ChannelsResource_UpdateMethod();
3588 
3589 
3595  _have_on_behalf_of_content_owner_ = false;
3596  client::ClearCppValueHelper(&on_behalf_of_content_owner_);
3597  }
3598 
3599 
3605  const string& get_on_behalf_of_content_owner() const { return on_behalf_of_content_owner_; }
3606 
3614  _have_on_behalf_of_content_owner_ = true;
3615  return &on_behalf_of_content_owner_;
3616  }
3617 
3618 
3632  void set_on_behalf_of_content_owner(const string& value) {
3633  _have_on_behalf_of_content_owner_ = true;
3634  on_behalf_of_content_owner_ = value;
3635  }
3636 
3646  virtual util::Status AppendVariable(
3647  const StringPiece& variable_name,
3648  const client::UriTemplateConfig& config,
3649  string* target);
3650 
3656  virtual util::Status AppendOptionalQueryParameters(string* target);
3657 
3658 
3670  Channel* data) {
3671  return YouTubeServiceBaseRequest::ExecuteAndParseResponse(data);
3672  }
3673 
3674  private:
3675  string part_;
3676  string on_behalf_of_content_owner_;
3677  bool _have_on_behalf_of_content_owner_ : 1; string _content_;
3678  DISALLOW_COPY_AND_ASSIGN(ChannelsResource_UpdateMethod);
3679 };
3680 
3681 
3682 
3696  public:
3709  const YouTubeService* _service_,
3710  client::AuthorizationCredential* _credential_,
3711  const absl::string_view& part,
3712  const CommentThread& _content_);
3713 
3718 
3719 
3729  virtual util::Status AppendVariable(
3730  const StringPiece& variable_name,
3731  const client::UriTemplateConfig& config,
3732  string* target);
3733 
3739  virtual util::Status AppendOptionalQueryParameters(string* target);
3740 
3741 
3753  CommentThread* data) {
3754  return YouTubeServiceBaseRequest::ExecuteAndParseResponse(data);
3755  }
3756 
3757  private:
3758  string part_; string _content_;
3759  DISALLOW_COPY_AND_ASSIGN(CommentThreadsResource_InsertMethod);
3760 };
3761 
3775  public:
3787  const YouTubeService* _service_,
3788  client::AuthorizationCredential* _credential_,
3789  const absl::string_view& part);
3790 
3795 
3796 
3802  _have_all_threads_related_to_channel_id_ = false;
3803  client::ClearCppValueHelper(&all_threads_related_to_channel_id_);
3804  }
3805 
3806 
3812  const string& get_all_threads_related_to_channel_id() const { return all_threads_related_to_channel_id_; }
3813 
3821  _have_all_threads_related_to_channel_id_ = true;
3822  return &all_threads_related_to_channel_id_;
3823  }
3824 
3825 
3834  void set_all_threads_related_to_channel_id(const string& value) {
3835  _have_all_threads_related_to_channel_id_ = true;
3836  all_threads_related_to_channel_id_ = value;
3837  }
3838 
3839 
3840 
3845  _have_channel_id_ = false;
3846  client::ClearCppValueHelper(&channel_id_);
3847  }
3848 
3849 
3855  const string& get_channel_id() const { return channel_id_; }
3856 
3863  string* mutable_channelId() {
3864  _have_channel_id_ = true;
3865  return &channel_id_;
3866  }
3867 
3868 
3877  void set_channel_id(const string& value) {
3878  _have_channel_id_ = true;
3879  channel_id_ = value;
3880  }
3881 
3882 
3883 
3887  void clear_id() {
3888  _have_id_ = false;
3889  client::ClearCppValueHelper(&id_);
3890  }
3891 
3892 
3898  const string& get_id() const { return id_; }
3899 
3905  string* mutable_id() {
3906  _have_id_ = true;
3907  return &id_;
3908  }
3909 
3910 
3917  void set_id(const string& value) {
3918  _have_id_ = true;
3919  id_ = value;
3920  }
3921 
3922 
3923 
3928  _have_max_results_ = false;
3929  client::ClearCppValueHelper(&max_results_);
3930  }
3931 
3932 
3938  uint32 get_max_results() const { return max_results_; }
3939 
3949  void set_max_results(uint32 value) {
3950  _have_max_results_ = true;
3951  max_results_ = value;
3952  }
3953 
3959  _have_moderation_status_ = false;
3960  client::ClearCppValueHelper(&moderation_status_);
3961  }
3962 
3963 
3969  const string& get_moderation_status() const { return moderation_status_; }
3970 
3978  _have_moderation_status_ = true;
3979  return &moderation_status_;
3980  }
3981 
3982 
3992  void set_moderation_status(const string& value) {
3993  _have_moderation_status_ = true;
3994  moderation_status_ = value;
3995  }
3996 
3997 
3998 
4002  void clear_order() {
4003  _have_order_ = false;
4004  client::ClearCppValueHelper(&order_);
4005  }
4006 
4007 
4013  const string& get_order() const { return order_; }
4014 
4020  string* mutable_order() {
4021  _have_order_ = true;
4022  return &order_;
4023  }
4024 
4025 
4040  void set_order(const string& value) {
4041  _have_order_ = true;
4042  order_ = value;
4043  }
4044 
4045 
4046 
4051  _have_page_token_ = false;
4052  client::ClearCppValueHelper(&page_token_);
4053  }
4054 
4055 
4061  const string& get_page_token() const { return page_token_; }
4062 
4069  string* mutable_pageToken() {
4070  _have_page_token_ = true;
4071  return &page_token_;
4072  }
4073 
4074 
4086  void set_page_token(const string& value) {
4087  _have_page_token_ = true;
4088  page_token_ = value;
4089  }
4090 
4091 
4092 
4097  _have_search_terms_ = false;
4098  client::ClearCppValueHelper(&search_terms_);
4099  }
4100 
4101 
4107  const string& get_search_terms() const { return search_terms_; }
4108 
4116  _have_search_terms_ = true;
4117  return &search_terms_;
4118  }
4119 
4120 
4131  void set_search_terms(const string& value) {
4132  _have_search_terms_ = true;
4133  search_terms_ = value;
4134  }
4135 
4136 
4137 
4142  _have_text_format_ = false;
4143  client::ClearCppValueHelper(&text_format_);
4144  }
4145 
4146 
4152  const string& get_text_format() const { return text_format_; }
4153 
4161  _have_text_format_ = true;
4162  return &text_format_;
4163  }
4164 
4165 
4173  void set_text_format(const string& value) {
4174  _have_text_format_ = true;
4175  text_format_ = value;
4176  }
4177 
4178 
4179 
4184  _have_video_id_ = false;
4185  client::ClearCppValueHelper(&video_id_);
4186  }
4187 
4188 
4194  const string& get_video_id() const { return video_id_; }
4195 
4202  string* mutable_videoId() {
4203  _have_video_id_ = true;
4204  return &video_id_;
4205  }
4206 
4207 
4214  void set_video_id(const string& value) {
4215  _have_video_id_ = true;
4216  video_id_ = value;
4217  }
4218 
4228  virtual util::Status AppendVariable(
4229  const StringPiece& variable_name,
4230  const client::UriTemplateConfig& config,
4231  string* target);
4232 
4238  virtual util::Status AppendOptionalQueryParameters(string* target);
4239 
4240 
4252  CommentThreadListResponse* data) {
4253  return YouTubeServiceBaseRequest::ExecuteAndParseResponse(data);
4254  }
4255 
4256  private:
4257  string part_;
4258  string all_threads_related_to_channel_id_;
4259  string channel_id_;
4260  string id_;
4261  uint32 max_results_;
4262  string moderation_status_;
4263  string order_;
4264  string page_token_;
4265  string search_terms_;
4266  string text_format_;
4267  string video_id_;
4268  bool _have_all_threads_related_to_channel_id_ : 1;
4269  bool _have_channel_id_ : 1;
4270  bool _have_id_ : 1;
4271  bool _have_max_results_ : 1;
4272  bool _have_moderation_status_ : 1;
4273  bool _have_order_ : 1;
4274  bool _have_page_token_ : 1;
4275  bool _have_search_terms_ : 1;
4276  bool _have_text_format_ : 1;
4277  bool _have_video_id_ : 1;
4278  DISALLOW_COPY_AND_ASSIGN(CommentThreadsResource_ListMethod);
4279 };
4280 
4281 typedef client::ServiceRequestPager<
4284  CommentThreadsResource_ListMethodPager;
4285 
4299  public:
4313  const YouTubeService* _service_,
4314  client::AuthorizationCredential* _credential_,
4315  const absl::string_view& part,
4316  const CommentThread& _content_);
4317 
4322 
4323 
4333  virtual util::Status AppendVariable(
4334  const StringPiece& variable_name,
4335  const client::UriTemplateConfig& config,
4336  string* target);
4337 
4343  virtual util::Status AppendOptionalQueryParameters(string* target);
4344 
4345 
4357  CommentThread* data) {
4358  return YouTubeServiceBaseRequest::ExecuteAndParseResponse(data);
4359  }
4360 
4361  private:
4362  string part_; string _content_;
4363  DISALLOW_COPY_AND_ASSIGN(CommentThreadsResource_UpdateMethod);
4364 };
4365 
4366 
4367 
4381  public:
4392  const YouTubeService* _service_,
4393  client::AuthorizationCredential* _credential_,
4394  const absl::string_view& id);
4395 
4399  virtual ~CommentsResource_DeleteMethod();
4400 
4401 
4411  virtual util::Status AppendVariable(
4412  const StringPiece& variable_name,
4413  const client::UriTemplateConfig& config,
4414  string* target);
4415 
4421  virtual util::Status AppendOptionalQueryParameters(string* target);
4422 
4423 
4424  private:
4425  string id_;
4426  DISALLOW_COPY_AND_ASSIGN(CommentsResource_DeleteMethod);
4427 };
4428 
4442  public:
4455  const YouTubeService* _service_,
4456  client::AuthorizationCredential* _credential_,
4457  const absl::string_view& part,
4458  const Comment& _content_);
4459 
4463  virtual ~CommentsResource_InsertMethod();
4464 
4465 
4475  virtual util::Status AppendVariable(
4476  const StringPiece& variable_name,
4477  const client::UriTemplateConfig& config,
4478  string* target);
4479 
4485  virtual util::Status AppendOptionalQueryParameters(string* target);
4486 
4487 
4499  Comment* data) {
4500  return YouTubeServiceBaseRequest::ExecuteAndParseResponse(data);
4501  }
4502 
4503  private:
4504  string part_; string _content_;
4505  DISALLOW_COPY_AND_ASSIGN(CommentsResource_InsertMethod);
4506 };
4507 
4521  public:
4532  const YouTubeService* _service_,
4533  client::AuthorizationCredential* _credential_,
4534  const absl::string_view& part);
4535 
4539  virtual ~CommentsResource_ListMethod();
4540 
4541 
4545  void clear_id() {
4546  _have_id_ = false;
4547  client::ClearCppValueHelper(&id_);
4548  }
4549 
4550 
4556  const string& get_id() const { return id_; }
4557 
4563  string* mutable_id() {
4564  _have_id_ = true;
4565  return &id_;
4566  }
4567 
4568 
4576  void set_id(const string& value) {
4577  _have_id_ = true;
4578  id_ = value;
4579  }
4580 
4581 
4582 
4587  _have_max_results_ = false;
4588  client::ClearCppValueHelper(&max_results_);
4589  }
4590 
4591 
4597  uint32 get_max_results() const { return max_results_; }
4598 
4608  void set_max_results(uint32 value) {
4609  _have_max_results_ = true;
4610  max_results_ = value;
4611  }
4612 
4617  _have_page_token_ = false;
4618  client::ClearCppValueHelper(&page_token_);
4619  }
4620 
4621 
4627  const string& get_page_token() const { return page_token_; }
4628 
4635  string* mutable_pageToken() {
4636  _have_page_token_ = true;
4637  return &page_token_;
4638  }
4639 
4640 
4652  void set_page_token(const string& value) {
4653  _have_page_token_ = true;
4654  page_token_ = value;
4655  }
4656 
4657 
4658 
4663  _have_parent_id_ = false;
4664  client::ClearCppValueHelper(&parent_id_);
4665  }
4666 
4667 
4673  const string& get_parent_id() const { return parent_id_; }
4674 
4681  string* mutable_parentId() {
4682  _have_parent_id_ = true;
4683  return &parent_id_;
4684  }
4685 
4686 
4696  void set_parent_id(const string& value) {
4697  _have_parent_id_ = true;
4698  parent_id_ = value;
4699  }
4700 
4701 
4702 
4707  _have_text_format_ = false;
4708  client::ClearCppValueHelper(&text_format_);
4709  }
4710 
4711 
4717  const string& get_text_format() const { return text_format_; }
4718 
4726  _have_text_format_ = true;
4727  return &text_format_;
4728  }
4729 
4730 
4737  void set_text_format(const string& value) {
4738  _have_text_format_ = true;
4739  text_format_ = value;
4740  }
4741 
4751  virtual util::Status AppendVariable(
4752  const StringPiece& variable_name,
4753  const client::UriTemplateConfig& config,
4754  string* target);
4755 
4761  virtual util::Status AppendOptionalQueryParameters(string* target);
4762 
4763 
4775  CommentListResponse* data) {
4776  return YouTubeServiceBaseRequest::ExecuteAndParseResponse(data);
4777  }
4778 
4779  private:
4780  string part_;
4781  string id_;
4782  uint32 max_results_;
4783  string page_token_;
4784  string parent_id_;
4785  string text_format_;
4786  bool _have_id_ : 1;
4787  bool _have_max_results_ : 1;
4788  bool _have_page_token_ : 1;
4789  bool _have_parent_id_ : 1;
4790  bool _have_text_format_ : 1;
4791  DISALLOW_COPY_AND_ASSIGN(CommentsResource_ListMethod);
4792 };
4793 
4794 typedef client::ServiceRequestPager<
4797  CommentsResource_ListMethodPager;
4798 
4812  public:
4823  const YouTubeService* _service_,
4824  client::AuthorizationCredential* _credential_,
4825  const absl::string_view& id);
4826 
4831 
4832 
4842  virtual util::Status AppendVariable(
4843  const StringPiece& variable_name,
4844  const client::UriTemplateConfig& config,
4845  string* target);
4846 
4852  virtual util::Status AppendOptionalQueryParameters(string* target);
4853 
4854 
4855  private:
4856  string id_;
4857  DISALLOW_COPY_AND_ASSIGN(CommentsResource_MarkAsSpamMethod);
4858 };
4859 
4873  public:
4886  const YouTubeService* _service_,
4887  client::AuthorizationCredential* _credential_,
4888  const absl::string_view& id,
4889  const absl::string_view& moderation_status);
4890 
4895 
4896 
4901  _have_ban_author_ = false;
4902  client::ClearCppValueHelper(&ban_author_);
4903  }
4904 
4905 
4911  bool get_ban_author() const { return ban_author_; }
4912 
4923  void set_ban_author(bool value) {
4924  _have_ban_author_ = true;
4925  ban_author_ = value;
4926  }
4927 
4937  virtual util::Status AppendVariable(
4938  const StringPiece& variable_name,
4939  const client::UriTemplateConfig& config,
4940  string* target);
4941 
4947  virtual util::Status AppendOptionalQueryParameters(string* target);
4948 
4949 
4950  private:
4951  string id_;
4952  string moderation_status_;
4953  bool ban_author_;
4954  bool _have_ban_author_ : 1;
4955  DISALLOW_COPY_AND_ASSIGN(CommentsResource_SetModerationStatusMethod);
4956 };
4957 
4971  public:
4985  const YouTubeService* _service_,
4986  client::AuthorizationCredential* _credential_,
4987  const absl::string_view& part,
4988  const Comment& _content_);
4989 
4993  virtual ~CommentsResource_UpdateMethod();
4994 
4995 
5005  virtual util::Status AppendVariable(
5006  const StringPiece& variable_name,
5007  const client::UriTemplateConfig& config,
5008  string* target);
5009 
5015  virtual util::Status AppendOptionalQueryParameters(string* target);
5016 
5017 
5029  Comment* data) {
5030  return YouTubeServiceBaseRequest::ExecuteAndParseResponse(data);
5031  }
5032 
5033  private:
5034  string part_; string _content_;
5035  DISALLOW_COPY_AND_ASSIGN(CommentsResource_UpdateMethod);
5036 };
5037 
5038 
5039 
5056  public:
5068  const YouTubeService* _service_,
5069  client::AuthorizationCredential* _credential_,
5070  const absl::string_view& part);
5071 
5076 
5077 
5081  void clear_hl() {
5082  _have_hl_ = false;
5083  client::ClearCppValueHelper(&hl_);
5084  }
5085 
5086 
5092  const string& get_hl() const { return hl_; }
5093 
5099  string* mutable_hl() {
5100  _have_hl_ = true;
5101  return &hl_;
5102  }
5103 
5104 
5111  void set_hl(const string& value) {
5112  _have_hl_ = true;
5113  hl_ = value;
5114  }
5115 
5116 
5117 
5121  void clear_id() {
5122  _have_id_ = false;
5123  client::ClearCppValueHelper(&id_);
5124  }
5125 
5126 
5132  const string& get_id() const { return id_; }
5133 
5139  string* mutable_id() {
5140  _have_id_ = true;
5141  return &id_;
5142  }
5143 
5144 
5153  void set_id(const string& value) {
5154  _have_id_ = true;
5155  id_ = value;
5156  }
5157 
5158 
5159 
5164  _have_region_code_ = false;
5165  client::ClearCppValueHelper(&region_code_);
5166  }
5167 
5168 
5174  const string& get_region_code() const { return region_code_; }
5175 
5183  _have_region_code_ = true;
5184  return &region_code_;
5185  }
5186 
5187 
5195  void set_region_code(const string& value) {
5196  _have_region_code_ = true;
5197  region_code_ = value;
5198  }
5199 
5209  virtual util::Status AppendVariable(
5210  const StringPiece& variable_name,
5211  const client::UriTemplateConfig& config,
5212  string* target);
5213 
5219  virtual util::Status AppendOptionalQueryParameters(string* target);
5220 
5221 
5233  GuideCategoryListResponse* data) {
5234  return YouTubeServiceBaseRequest::ExecuteAndParseResponse(data);
5235  }
5236 
5237  private:
5238  string part_;
5239  string hl_;
5240  string id_;
5241  string region_code_;
5242  bool _have_hl_ : 1;
5243  bool _have_id_ : 1;
5244  bool _have_region_code_ : 1;
5245  DISALLOW_COPY_AND_ASSIGN(GuideCategoriesResource_ListMethod);
5246 };
5247 
5248 
5249 
5266  public:
5278  const YouTubeService* _service_,
5279  client::AuthorizationCredential* _credential_,
5280  const absl::string_view& part);
5281 
5286 
5287 
5291  void clear_hl() {
5292  _have_hl_ = false;
5293  client::ClearCppValueHelper(&hl_);
5294  }
5295 
5296 
5302  const string& get_hl() const { return hl_; }
5303 
5309  string* mutable_hl() {
5310  _have_hl_ = true;
5311  return &hl_;
5312  }
5313 
5314 
5321  void set_hl(const string& value) {
5322  _have_hl_ = true;
5323  hl_ = value;
5324  }
5325 
5335  virtual util::Status AppendVariable(
5336  const StringPiece& variable_name,
5337  const client::UriTemplateConfig& config,
5338  string* target);
5339 
5345  virtual util::Status AppendOptionalQueryParameters(string* target);
5346 
5347 
5359  I18nLanguageListResponse* data) {
5360  return YouTubeServiceBaseRequest::ExecuteAndParseResponse(data);
5361  }
5362 
5363  private:
5364  string part_;
5365  string hl_;
5366  bool _have_hl_ : 1;
5367  DISALLOW_COPY_AND_ASSIGN(I18nLanguagesResource_ListMethod);
5368 };
5369 
5370 
5371 
5388  public:
5400  const YouTubeService* _service_,
5401  client::AuthorizationCredential* _credential_,
5402  const absl::string_view& part);
5403 
5407  virtual ~I18nRegionsResource_ListMethod();
5408 
5409 
5413  void clear_hl() {
5414  _have_hl_ = false;
5415  client::ClearCppValueHelper(&hl_);
5416  }
5417 
5418 
5424  const string& get_hl() const { return hl_; }
5425 
5431  string* mutable_hl() {
5432  _have_hl_ = true;
5433  return &hl_;
5434  }
5435 
5436 
5443  void set_hl(const string& value) {
5444  _have_hl_ = true;
5445  hl_ = value;
5446  }
5447 
5457  virtual util::Status AppendVariable(
5458  const StringPiece& variable_name,
5459  const client::UriTemplateConfig& config,
5460  string* target);
5461 
5467  virtual util::Status AppendOptionalQueryParameters(string* target);
5468 
5469 
5481  I18nRegionListResponse* data) {
5482  return YouTubeServiceBaseRequest::ExecuteAndParseResponse(data);
5483  }
5484 
5485  private:
5486  string part_;
5487  string hl_;
5488  bool _have_hl_ : 1;
5489  DISALLOW_COPY_AND_ASSIGN(I18nRegionsResource_ListMethod);
5490 };
5491 
5492 
5493 
5508  public:
5523  const YouTubeService* _service_,
5524  client::AuthorizationCredential* _credential_,
5525  const absl::string_view& id,
5526  const absl::string_view& part);
5527 
5532 
5533 
5539  _have_on_behalf_of_content_owner_ = false;
5540  client::ClearCppValueHelper(&on_behalf_of_content_owner_);
5541  }
5542 
5543 
5549  const string& get_on_behalf_of_content_owner() const { return on_behalf_of_content_owner_; }
5550 
5558  _have_on_behalf_of_content_owner_ = true;
5559  return &on_behalf_of_content_owner_;
5560  }
5561 
5562 
5579  void set_on_behalf_of_content_owner(const string& value) {
5580  _have_on_behalf_of_content_owner_ = true;
5581  on_behalf_of_content_owner_ = value;
5582  }
5583 
5584 
5585 
5591  _have_on_behalf_of_content_owner_channel_ = false;
5592  client::ClearCppValueHelper(&on_behalf_of_content_owner_channel_);
5593  }
5594 
5595 
5601  const string& get_on_behalf_of_content_owner_channel() const { return on_behalf_of_content_owner_channel_; }
5602 
5610  _have_on_behalf_of_content_owner_channel_ = true;
5611  return &on_behalf_of_content_owner_channel_;
5612  }
5613 
5614 
5638  void set_on_behalf_of_content_owner_channel(const string& value) {
5639  _have_on_behalf_of_content_owner_channel_ = true;
5640  on_behalf_of_content_owner_channel_ = value;
5641  }
5642 
5643 
5644 
5649  _have_stream_id_ = false;
5650  client::ClearCppValueHelper(&stream_id_);
5651  }
5652 
5653 
5659  const string& get_stream_id() const { return stream_id_; }
5660 
5667  string* mutable_streamId() {
5668  _have_stream_id_ = true;
5669  return &stream_id_;
5670  }
5671 
5672 
5681  void set_stream_id(const string& value) {
5682  _have_stream_id_ = true;
5683  stream_id_ = value;
5684  }
5685 
5695  virtual util::Status AppendVariable(
5696  const StringPiece& variable_name,
5697  const client::UriTemplateConfig& config,
5698  string* target);
5699 
5705  virtual util::Status AppendOptionalQueryParameters(string* target);
5706 
5707 
5719  LiveBroadcast* data) {
5720  return YouTubeServiceBaseRequest::ExecuteAndParseResponse(data);
5721  }
5722 
5723  private:
5724  string id_;
5725  string part_;
5726  string on_behalf_of_content_owner_;
5727  string on_behalf_of_content_owner_channel_;
5728  string stream_id_;
5729  bool _have_on_behalf_of_content_owner_ : 1;
5730  bool _have_on_behalf_of_content_owner_channel_ : 1;
5731  bool _have_stream_id_ : 1;
5732  DISALLOW_COPY_AND_ASSIGN(LiveBroadcastsResource_BindMethod);
5733 };
5734 
5749  public:
5764  const YouTubeService* _service_,
5765  client::AuthorizationCredential* _credential_,
5766  const absl::string_view& id,
5767  const absl::string_view& part);
5768 
5773 
5774 
5779  _have_display_slate_ = false;
5780  client::ClearCppValueHelper(&display_slate_);
5781  }
5782 
5783 
5789  bool get_display_slate() const { return display_slate_; }
5790 
5797  void set_display_slate(bool value) {
5798  _have_display_slate_ = true;
5799  display_slate_ = value;
5800  }
5801 
5806  _have_offset_time_ms_ = false;
5807  client::ClearCppValueHelper(&offset_time_ms_);
5808  }
5809 
5810 
5816  uint64 get_offset_time_ms() const { return offset_time_ms_; }
5817 
5836  void set_offset_time_ms(uint64 value) {
5837  _have_offset_time_ms_ = true;
5838  offset_time_ms_ = value;
5839  }
5840 
5846  _have_on_behalf_of_content_owner_ = false;
5847  client::ClearCppValueHelper(&on_behalf_of_content_owner_);
5848  }
5849 
5850 
5856  const string& get_on_behalf_of_content_owner() const { return on_behalf_of_content_owner_; }
5857 
5865  _have_on_behalf_of_content_owner_ = true;
5866  return &on_behalf_of_content_owner_;
5867  }
5868 
5869 
5886  void set_on_behalf_of_content_owner(const string& value) {
5887  _have_on_behalf_of_content_owner_ = true;
5888  on_behalf_of_content_owner_ = value;
5889  }
5890 
5891 
5892 
5898  _have_on_behalf_of_content_owner_channel_ = false;
5899  client::ClearCppValueHelper(&on_behalf_of_content_owner_channel_);
5900  }
5901 
5902 
5908  const string& get_on_behalf_of_content_owner_channel() const { return on_behalf_of_content_owner_channel_; }
5909 
5917  _have_on_behalf_of_content_owner_channel_ = true;
5918  return &on_behalf_of_content_owner_channel_;
5919  }
5920 
5921 
5945  void set_on_behalf_of_content_owner_channel(const string& value) {
5946  _have_on_behalf_of_content_owner_channel_ = true;
5947  on_behalf_of_content_owner_channel_ = value;
5948  }
5949 
5950 
5951 
5956  _have_walltime_ = false;
5957  client::ClearCppValueHelper(&walltime_);
5958  }
5959 
5960 
5966  client::DateTime get_walltime() const { return walltime_; }
5967 
5975  void set_walltime(client::DateTime value) {
5976  _have_walltime_ = true;
5977  walltime_ = value;
5978  }
5979 
5989  virtual util::Status AppendVariable(
5990  const StringPiece& variable_name,
5991  const client::UriTemplateConfig& config,
5992  string* target);
5993 
5999  virtual util::Status AppendOptionalQueryParameters(string* target);
6000 
6001 
6013  LiveBroadcast* data) {
6014  return YouTubeServiceBaseRequest::ExecuteAndParseResponse(data);
6015  }
6016 
6017  private:
6018  string id_;
6019  string part_;
6020  bool display_slate_;
6021  uint64 offset_time_ms_;
6022  string on_behalf_of_content_owner_;
6023  string on_behalf_of_content_owner_channel_;
6024  client::DateTime walltime_;
6025  bool _have_display_slate_ : 1;
6026  bool _have_offset_time_ms_ : 1;
6027  bool _have_on_behalf_of_content_owner_ : 1;
6028  bool _have_on_behalf_of_content_owner_channel_ : 1;
6029  bool _have_walltime_ : 1;
6030  DISALLOW_COPY_AND_ASSIGN(LiveBroadcastsResource_ControlMethod);
6031 };
6032 
6047  public:
6058  const YouTubeService* _service_,
6059  client::AuthorizationCredential* _credential_,
6060  const absl::string_view& id);
6061 
6066 
6067 
6073  _have_on_behalf_of_content_owner_ = false;
6074  client::ClearCppValueHelper(&on_behalf_of_content_owner_);
6075  }
6076 
6077 
6083  const string& get_on_behalf_of_content_owner() const { return on_behalf_of_content_owner_; }
6084 
6092  _have_on_behalf_of_content_owner_ = true;
6093  return &on_behalf_of_content_owner_;
6094  }
6095 
6096 
6113  void set_on_behalf_of_content_owner(const string& value) {
6114  _have_on_behalf_of_content_owner_ = true;
6115  on_behalf_of_content_owner_ = value;
6116  }
6117 
6118 
6119 
6125  _have_on_behalf_of_content_owner_channel_ = false;
6126  client::ClearCppValueHelper(&on_behalf_of_content_owner_channel_);
6127  }
6128 
6129 
6135  const string& get_on_behalf_of_content_owner_channel() const { return on_behalf_of_content_owner_channel_; }
6136 
6144  _have_on_behalf_of_content_owner_channel_ = true;
6145  return &on_behalf_of_content_owner_channel_;
6146  }
6147 
6148 
6172  void set_on_behalf_of_content_owner_channel(const string& value) {
6173  _have_on_behalf_of_content_owner_channel_ = true;
6174  on_behalf_of_content_owner_channel_ = value;
6175  }
6176 
6186  virtual util::Status AppendVariable(
6187  const StringPiece& variable_name,
6188  const client::UriTemplateConfig& config,
6189  string* target);
6190 
6196  virtual util::Status AppendOptionalQueryParameters(string* target);
6197 
6198 
6199  private:
6200  string id_;
6201  string on_behalf_of_content_owner_;
6202  string on_behalf_of_content_owner_channel_;
6203  bool _have_on_behalf_of_content_owner_ : 1;
6204  bool _have_on_behalf_of_content_owner_channel_ : 1;
6205  DISALLOW_COPY_AND_ASSIGN(LiveBroadcastsResource_DeleteMethod);
6206 };
6207 
6222  public:
6238  const YouTubeService* _service_,
6239  client::AuthorizationCredential* _credential_,
6240  const absl::string_view& part,
6241  const LiveBroadcast& _content_);
6242 
6247 
6248 
6254  _have_on_behalf_of_content_owner_ = false;
6255  client::ClearCppValueHelper(&on_behalf_of_content_owner_);
6256  }
6257 
6258 
6264  const string& get_on_behalf_of_content_owner() const { return on_behalf_of_content_owner_; }
6265 
6273  _have_on_behalf_of_content_owner_ = true;
6274  return &on_behalf_of_content_owner_;
6275  }
6276 
6277 
6294  void set_on_behalf_of_content_owner(const string& value) {
6295  _have_on_behalf_of_content_owner_ = true;
6296  on_behalf_of_content_owner_ = value;
6297  }
6298 
6299 
6300 
6306  _have_on_behalf_of_content_owner_channel_ = false;
6307  client::ClearCppValueHelper(&on_behalf_of_content_owner_channel_);
6308  }
6309 
6310 
6316  const string& get_on_behalf_of_content_owner_channel() const { return on_behalf_of_content_owner_channel_; }
6317 
6325  _have_on_behalf_of_content_owner_channel_ = true;
6326  return &on_behalf_of_content_owner_channel_;
6327  }
6328 
6329 
6353  void set_on_behalf_of_content_owner_channel(const string& value) {
6354  _have_on_behalf_of_content_owner_channel_ = true;
6355  on_behalf_of_content_owner_channel_ = value;
6356  }
6357 
6367  virtual util::Status AppendVariable(
6368  const StringPiece& variable_name,
6369  const client::UriTemplateConfig& config,
6370  string* target);
6371 
6377  virtual util::Status AppendOptionalQueryParameters(string* target);
6378 
6379 
6391  LiveBroadcast* data) {
6392  return YouTubeServiceBaseRequest::ExecuteAndParseResponse(data);
6393  }
6394 
6395  private:
6396  string part_;
6397  string on_behalf_of_content_owner_;
6398  string on_behalf_of_content_owner_channel_;
6399  bool _have_on_behalf_of_content_owner_ : 1;
6400  bool _have_on_behalf_of_content_owner_channel_ : 1; string _content_;
6401  DISALLOW_COPY_AND_ASSIGN(LiveBroadcastsResource_InsertMethod);
6402 };
6403 
6419  public:
6432  const YouTubeService* _service_,
6433  client::AuthorizationCredential* _credential_,
6434  const absl::string_view& part);
6435 
6440 
6441 
6447  _have_broadcast_status_ = false;
6448  client::ClearCppValueHelper(&broadcast_status_);
6449  }
6450 
6451 
6457  const string& get_broadcast_status() const { return broadcast_status_; }
6458 
6466  _have_broadcast_status_ = true;
6467  return &broadcast_status_;
6468  }
6469 
6470 
6477  void set_broadcast_status(const string& value) {
6478  _have_broadcast_status_ = true;
6479  broadcast_status_ = value;
6480  }
6481 
6482 
6483 
6488  _have_broadcast_type_ = false;
6489  client::ClearCppValueHelper(&broadcast_type_);
6490  }
6491 
6492 
6498  const string& get_broadcast_type() const { return broadcast_type_; }
6499 
6507  _have_broadcast_type_ = true;
6508  return &broadcast_type_;
6509  }
6510 
6511 
6519  void set_broadcast_type(const string& value) {
6520  _have_broadcast_type_ = true;
6521  broadcast_type_ = value;
6522  }
6523 
6524 
6525 
6529  void clear_id() {
6530  _have_id_ = false;
6531  client::ClearCppValueHelper(&id_);
6532  }
6533 
6534 
6540  const string& get_id() const { return id_; }
6541 
6547  string* mutable_id() {
6548  _have_id_ = true;
6549  return &id_;
6550  }
6551 
6552 
6560  void set_id(const string& value) {
6561  _have_id_ = true;
6562  id_ = value;
6563  }
6564 
6565 
6566 
6571  _have_max_results_ = false;
6572  client::ClearCppValueHelper(&max_results_);
6573  }
6574 
6575 
6581  uint32 get_max_results() const { return max_results_; }
6582 
6589  void set_max_results(uint32 value) {
6590  _have_max_results_ = true;
6591  max_results_ = value;
6592  }
6593 
6597  void clear_mine() {
6598  _have_mine_ = false;
6599  client::ClearCppValueHelper(&mine_);
6600  }
6601 
6602 
6608  bool get_mine() const { return mine_; }
6609 
6617  void set_mine(bool value) {
6618  _have_mine_ = true;
6619  mine_ = value;
6620  }
6621 
6627  _have_on_behalf_of_content_owner_ = false;
6628  client::ClearCppValueHelper(&on_behalf_of_content_owner_);
6629  }
6630 
6631 
6637  const string& get_on_behalf_of_content_owner() const { return on_behalf_of_content_owner_; }
6638 
6646  _have_on_behalf_of_content_owner_ = true;
6647  return &on_behalf_of_content_owner_;
6648  }
6649 
6650 
6667  void set_on_behalf_of_content_owner(const string& value) {
6668  _have_on_behalf_of_content_owner_ = true;
6669  on_behalf_of_content_owner_ = value;
6670  }
6671 
6672 
6673 
6679  _have_on_behalf_of_content_owner_channel_ = false;
6680  client::ClearCppValueHelper(&on_behalf_of_content_owner_channel_);
6681  }
6682 
6683 
6689  const string& get_on_behalf_of_content_owner_channel() const { return on_behalf_of_content_owner_channel_; }
6690 
6698  _have_on_behalf_of_content_owner_channel_ = true;
6699  return &on_behalf_of_content_owner_channel_;
6700  }
6701 
6702 
6726  void set_on_behalf_of_content_owner_channel(const string& value) {
6727  _have_on_behalf_of_content_owner_channel_ = true;
6728  on_behalf_of_content_owner_channel_ = value;
6729  }
6730 
6731 
6732 
6737  _have_page_token_ = false;
6738  client::ClearCppValueHelper(&page_token_);
6739  }
6740 
6741 
6747  const string& get_page_token() const { return page_token_; }
6748 
6755  string* mutable_pageToken() {
6756  _have_page_token_ = true;
6757  return &page_token_;
6758  }
6759 
6760 
6769  void set_page_token(const string& value) {
6770  _have_page_token_ = true;
6771  page_token_ = value;
6772  }
6773 
6783  virtual util::Status AppendVariable(
6784  const StringPiece& variable_name,
6785  const client::UriTemplateConfig& config,
6786  string* target);
6787 
6793  virtual util::Status AppendOptionalQueryParameters(string* target);
6794 
6795 
6807  LiveBroadcastListResponse* data) {
6808  return YouTubeServiceBaseRequest::ExecuteAndParseResponse(data);
6809  }
6810 
6811  private:
6812  string part_;
6813  string broadcast_status_;
6814  string broadcast_type_;
6815  string id_;
6816  uint32 max_results_;
6817  bool mine_;
6818  string on_behalf_of_content_owner_;
6819  string on_behalf_of_content_owner_channel_;
6820  string page_token_;
6821  bool _have_broadcast_status_ : 1;
6822  bool _have_broadcast_type_ : 1;
6823  bool _have_id_ : 1;
6824  bool _have_max_results_ : 1;
6825  bool _have_mine_ : 1;
6826  bool _have_on_behalf_of_content_owner_ : 1;
6827  bool _have_on_behalf_of_content_owner_channel_ : 1;
6828  bool _have_page_token_ : 1;
6829  DISALLOW_COPY_AND_ASSIGN(LiveBroadcastsResource_ListMethod);
6830 };
6831 
6832 typedef client::ServiceRequestPager<
6835  LiveBroadcastsResource_ListMethodPager;
6836 
6851  public:
6870  const YouTubeService* _service_,
6871  client::AuthorizationCredential* _credential_,
6872  const absl::string_view& broadcast_status,
6873  const absl::string_view& id,
6874  const absl::string_view& part);
6875 
6880 
6881 
6887  _have_on_behalf_of_content_owner_ = false;
6888  client::ClearCppValueHelper(&on_behalf_of_content_owner_);
6889  }
6890 
6891 
6897  const string& get_on_behalf_of_content_owner() const { return on_behalf_of_content_owner_; }
6898 
6906  _have_on_behalf_of_content_owner_ = true;
6907  return &on_behalf_of_content_owner_;
6908  }
6909 
6910 
6927  void set_on_behalf_of_content_owner(const string& value) {
6928  _have_on_behalf_of_content_owner_ = true;
6929  on_behalf_of_content_owner_ = value;
6930  }
6931 
6932 
6933 
6939  _have_on_behalf_of_content_owner_channel_ = false;
6940  client::ClearCppValueHelper(&on_behalf_of_content_owner_channel_);
6941  }
6942 
6943 
6949  const string& get_on_behalf_of_content_owner_channel() const { return on_behalf_of_content_owner_channel_; }
6950 
6958  _have_on_behalf_of_content_owner_channel_ = true;
6959  return &on_behalf_of_content_owner_channel_;
6960  }
6961 
6962 
6986  void set_on_behalf_of_content_owner_channel(const string& value) {
6987  _have_on_behalf_of_content_owner_channel_ = true;
6988  on_behalf_of_content_owner_channel_ = value;
6989  }
6990 
7000  virtual util::Status AppendVariable(
7001  const StringPiece& variable_name,
7002  const client::UriTemplateConfig& config,
7003  string* target);
7004 
7010  virtual util::Status AppendOptionalQueryParameters(string* target);
7011 
7012 
7024  LiveBroadcast* data) {
7025  return YouTubeServiceBaseRequest::ExecuteAndParseResponse(data);
7026  }
7027 
7028  private:
7029  string broadcast_status_;
7030  string id_;
7031  string part_;
7032  string on_behalf_of_content_owner_;
7033  string on_behalf_of_content_owner_channel_;
7034  bool _have_on_behalf_of_content_owner_ : 1;
7035  bool _have_on_behalf_of_content_owner_channel_ : 1;
7036  DISALLOW_COPY_AND_ASSIGN(LiveBroadcastsResource_TransitionMethod);
7037 };
7038 
7053  public:
7079  const YouTubeService* _service_,
7080  client::AuthorizationCredential* _credential_,
7081  const absl::string_view& part,
7082  const LiveBroadcast& _content_);
7083 
7088 
7089 
7095  _have_on_behalf_of_content_owner_ = false;
7096  client::ClearCppValueHelper(&on_behalf_of_content_owner_);
7097  }
7098 
7099 
7105  const string& get_on_behalf_of_content_owner() const { return on_behalf_of_content_owner_; }
7106 
7114  _have_on_behalf_of_content_owner_ = true;
7115  return &on_behalf_of_content_owner_;
7116  }
7117 
7118 
7135  void set_on_behalf_of_content_owner(const string& value) {
7136  _have_on_behalf_of_content_owner_ = true;
7137  on_behalf_of_content_owner_ = value;
7138  }
7139 
7140 
7141 
7147  _have_on_behalf_of_content_owner_channel_ = false;
7148  client::ClearCppValueHelper(&on_behalf_of_content_owner_channel_);
7149  }
7150 
7151 
7157  const string& get_on_behalf_of_content_owner_channel() const { return on_behalf_of_content_owner_channel_; }
7158 
7166  _have_on_behalf_of_content_owner_channel_ = true;
7167  return &on_behalf_of_content_owner_channel_;
7168  }
7169 
7170 
7194  void set_on_behalf_of_content_owner_channel(const string& value) {
7195  _have_on_behalf_of_content_owner_channel_ = true;
7196  on_behalf_of_content_owner_channel_ = value;
7197  }
7198 
7208  virtual util::Status AppendVariable(
7209  const StringPiece& variable_name,
7210  const client::UriTemplateConfig& config,
7211  string* target);
7212 
7218  virtual util::Status AppendOptionalQueryParameters(string* target);
7219 
7220 
7232  LiveBroadcast* data) {
7233  return YouTubeServiceBaseRequest::ExecuteAndParseResponse(data);
7234  }
7235 
7236  private:
7237  string part_;
7238  string on_behalf_of_content_owner_;
7239  string on_behalf_of_content_owner_channel_;
7240  bool _have_on_behalf_of_content_owner_ : 1;
7241  bool _have_on_behalf_of_content_owner_channel_ : 1; string _content_;
7242  DISALLOW_COPY_AND_ASSIGN(LiveBroadcastsResource_UpdateMethod);
7243 };
7244 
7245 
7246 
7261  public:
7272  const YouTubeService* _service_,
7273  client::AuthorizationCredential* _credential_,
7274  const absl::string_view& id);
7275 
7280 
7281 
7291  virtual util::Status AppendVariable(
7292  const StringPiece& variable_name,
7293  const client::UriTemplateConfig& config,
7294  string* target);
7295 
7301  virtual util::Status AppendOptionalQueryParameters(string* target);
7302 
7303 
7304  private:
7305  string id_;
7306  DISALLOW_COPY_AND_ASSIGN(LiveChatBansResource_DeleteMethod);
7307 };
7308 
7323  public:
7337  const YouTubeService* _service_,
7338  client::AuthorizationCredential* _credential_,
7339  const absl::string_view& part,
7340  const LiveChatBan& _content_);
7341 
7346 
7347 
7357  virtual util::Status AppendVariable(
7358  const StringPiece& variable_name,
7359  const client::UriTemplateConfig& config,
7360  string* target);
7361 
7367  virtual util::Status AppendOptionalQueryParameters(string* target);
7368 
7369 
7381  LiveChatBan* data) {
7382  return YouTubeServiceBaseRequest::ExecuteAndParseResponse(data);
7383  }
7384 
7385  private:
7386  string part_; string _content_;
7387  DISALLOW_COPY_AND_ASSIGN(LiveChatBansResource_InsertMethod);
7388 };
7389 
7390 
7391 
7406  public:
7417  const YouTubeService* _service_,
7418  client::AuthorizationCredential* _credential_,
7419  const absl::string_view& id);
7420 
7425 
7426 
7436  virtual util::Status AppendVariable(
7437  const StringPiece& variable_name,
7438  const client::UriTemplateConfig& config,
7439  string* target);
7440 
7446  virtual util::Status AppendOptionalQueryParameters(string* target);
7447 
7448 
7449  private:
7450  string id_;
7451  DISALLOW_COPY_AND_ASSIGN(LiveChatMessagesResource_DeleteMethod);
7452 };
7453 
7468  public:
7481  const YouTubeService* _service_,
7482  client::AuthorizationCredential* _credential_,
7483  const absl::string_view& part,
7484  const LiveChatMessage& _content_);
7485 
7490 
7491 
7501  virtual util::Status AppendVariable(
7502  const StringPiece& variable_name,
7503  const client::UriTemplateConfig& config,
7504  string* target);
7505 
7511  virtual util::Status AppendOptionalQueryParameters(string* target);
7512 
7513 
7525  LiveChatMessage* data) {
7526  return YouTubeServiceBaseRequest::ExecuteAndParseResponse(data);
7527  }
7528 
7529  private:
7530  string part_; string _content_;
7531  DISALLOW_COPY_AND_ASSIGN(LiveChatMessagesResource_InsertMethod);
7532 };
7533 
7549  public:
7563  const YouTubeService* _service_,
7564  client::AuthorizationCredential* _credential_,
7565  const absl::string_view& live_chat_id,
7566  const absl::string_view& part);
7567 
7572 
7573 
7577  void clear_hl() {
7578  _have_hl_ = false;
7579  client::ClearCppValueHelper(&hl_);
7580  }
7581 
7582 
7588  const string& get_hl() const { return hl_; }
7589 
7595  string* mutable_hl() {
7596  _have_hl_ = true;
7597  return &hl_;
7598  }
7599 
7600 
7614  void set_hl(const string& value) {
7615  _have_hl_ = true;
7616  hl_ = value;
7617  }
7618 
7619 
7620 
7625  _have_max_results_ = false;
7626  client::ClearCppValueHelper(&max_results_);
7627  }
7628 
7629 
7635  uint32 get_max_results() const { return max_results_; }
7636 
7643  void set_max_results(uint32 value) {
7644  _have_max_results_ = true;
7645  max_results_ = value;
7646  }
7647 
7652  _have_page_token_ = false;
7653  client::ClearCppValueHelper(&page_token_);
7654  }
7655 
7656 
7662  const string& get_page_token() const { return page_token_; }
7663 
7670  string* mutable_pageToken() {
7671  _have_page_token_ = true;
7672  return &page_token_;
7673  }
7674 
7675 
7683  void set_page_token(const string& value) {
7684  _have_page_token_ = true;
7685  page_token_ = value;
7686  }
7687 
7688 
7689 
7695  _have_profile_image_size_ = false;
7696  client::ClearCppValueHelper(&profile_image_size_);
7697  }
7698 
7699 
7705  uint32 get_profile_image_size() const { return profile_image_size_; }
7706 
7714  void set_profile_image_size(uint32 value) {
7715  _have_profile_image_size_ = true;
7716  profile_image_size_ = value;
7717  }
7718 
7728  virtual util::Status AppendVariable(
7729  const StringPiece& variable_name,
7730  const client::UriTemplateConfig& config,
7731  string* target);
7732 
7738  virtual util::Status AppendOptionalQueryParameters(string* target);
7739 
7740 
7753  return YouTubeServiceBaseRequest::ExecuteAndParseResponse(data);
7754  }
7755 
7756  private:
7757  string live_chat_id_;
7758  string part_;
7759  string hl_;
7760  uint32 max_results_;
7761  string page_token_;
7762  uint32 profile_image_size_;
7763  bool _have_hl_ : 1;
7764  bool _have_max_results_ : 1;
7765  bool _have_page_token_ : 1;
7766  bool _have_profile_image_size_ : 1;
7767  DISALLOW_COPY_AND_ASSIGN(LiveChatMessagesResource_ListMethod);
7768 };
7769 
7770 typedef client::ServiceRequestPager<
7773  LiveChatMessagesResource_ListMethodPager;
7774 
7775 
7776 
7791  public:
7802  const YouTubeService* _service_,
7803  client::AuthorizationCredential* _credential_,
7804  const absl::string_view& id);
7805 
7810 
7811 
7821  virtual util::Status AppendVariable(
7822  const StringPiece& variable_name,
7823  const client::UriTemplateConfig& config,
7824  string* target);
7825 
7831  virtual util::Status AppendOptionalQueryParameters(string* target);
7832 
7833 
7834  private:
7835  string id_;
7836  DISALLOW_COPY_AND_ASSIGN(LiveChatModeratorsResource_DeleteMethod);
7837 };
7838 
7853  public:
7867  const YouTubeService* _service_,
7868  client::AuthorizationCredential* _credential_,
7869  const absl::string_view& part,
7870  const LiveChatModerator& _content_);
7871 
7876 
7877 
7887  virtual util::Status AppendVariable(
7888  const StringPiece& variable_name,
7889  const client::UriTemplateConfig& config,
7890  string* target);
7891 
7897  virtual util::Status AppendOptionalQueryParameters(string* target);
7898 
7899 
7911  LiveChatModerator* data) {
7912  return YouTubeServiceBaseRequest::ExecuteAndParseResponse(data);
7913  }
7914 
7915  private:
7916  string part_; string _content_;
7917  DISALLOW_COPY_AND_ASSIGN(LiveChatModeratorsResource_InsertMethod);
7918 };
7919 
7935  public:
7949  const YouTubeService* _service_,
7950  client::AuthorizationCredential* _credential_,
7951  const absl::string_view& live_chat_id,
7952  const absl::string_view& part);
7953 
7958 
7959 
7964  _have_max_results_ = false;
7965  client::ClearCppValueHelper(&max_results_);
7966  }
7967 
7968 
7974  uint32 get_max_results() const { return max_results_; }
7975 
7982  void set_max_results(uint32 value) {
7983  _have_max_results_ = true;
7984  max_results_ = value;
7985  }
7986 
7991  _have_page_token_ = false;
7992  client::ClearCppValueHelper(&page_token_);
7993  }
7994 
7995 
8001  const string& get_page_token() const { return page_token_; }
8002 
8009  string* mutable_pageToken() {
8010  _have_page_token_ = true;
8011  return &page_token_;
8012  }
8013 
8014 
8023  void set_page_token(const string& value) {
8024  _have_page_token_ = true;
8025  page_token_ = value;
8026  }
8027 
8037  virtual util::Status AppendVariable(
8038  const StringPiece& variable_name,
8039  const client::UriTemplateConfig& config,
8040  string* target);
8041 
8047  virtual util::Status AppendOptionalQueryParameters(string* target);
8048 
8049 
8062  return YouTubeServiceBaseRequest::ExecuteAndParseResponse(data);
8063  }
8064 
8065  private:
8066  string live_chat_id_;
8067  string part_;
8068  uint32 max_results_;
8069  string page_token_;
8070  bool _have_max_results_ : 1;
8071  bool _have_page_token_ : 1;
8072  DISALLOW_COPY_AND_ASSIGN(LiveChatModeratorsResource_ListMethod);
8073 };
8074 
8075 typedef client::ServiceRequestPager<
8078  LiveChatModeratorsResource_ListMethodPager;
8079 
8080 
8081 
8096  public:
8107  const YouTubeService* _service_,
8108  client::AuthorizationCredential* _credential_,
8109  const absl::string_view& id);
8110 
8115 
8116 
8122  _have_on_behalf_of_content_owner_ = false;
8123  client::ClearCppValueHelper(&on_behalf_of_content_owner_);
8124  }
8125 
8126 
8132  const string& get_on_behalf_of_content_owner() const { return on_behalf_of_content_owner_; }
8133 
8141  _have_on_behalf_of_content_owner_ = true;
8142  return &on_behalf_of_content_owner_;
8143  }
8144 
8145 
8162  void set_on_behalf_of_content_owner(const string& value) {
8163  _have_on_behalf_of_content_owner_ = true;
8164  on_behalf_of_content_owner_ = value;
8165  }
8166 
8167 
8168 
8174  _have_on_behalf_of_content_owner_channel_ = false;
8175  client::ClearCppValueHelper(&on_behalf_of_content_owner_channel_);
8176  }
8177 
8178 
8184  const string& get_on_behalf_of_content_owner_channel() const { return on_behalf_of_content_owner_channel_; }
8185 
8193  _have_on_behalf_of_content_owner_channel_ = true;
8194  return &on_behalf_of_content_owner_channel_;
8195  }
8196 
8197 
8221  void set_on_behalf_of_content_owner_channel(const string& value) {
8222  _have_on_behalf_of_content_owner_channel_ = true;
8223  on_behalf_of_content_owner_channel_ = value;
8224  }
8225 
8235  virtual util::Status AppendVariable(
8236  const StringPiece& variable_name,
8237  const client::UriTemplateConfig& config,
8238  string* target);
8239 
8245  virtual util::Status AppendOptionalQueryParameters(string* target);
8246 
8247 
8248  private:
8249  string id_;
8250  string on_behalf_of_content_owner_;
8251  string on_behalf_of_content_owner_channel_;
8252  bool _have_on_behalf_of_content_owner_ : 1;
8253  bool _have_on_behalf_of_content_owner_channel_ : 1;
8254  DISALLOW_COPY_AND_ASSIGN(LiveStreamsResource_DeleteMethod);
8255 };
8256 
8271  public:
8287  const YouTubeService* _service_,
8288  client::AuthorizationCredential* _credential_,
8289  const absl::string_view& part,
8290  const LiveStream& _content_);
8291 
8296 
8297 
8303  _have_on_behalf_of_content_owner_ = false;
8304  client::ClearCppValueHelper(&on_behalf_of_content_owner_);
8305  }
8306 
8307 
8313  const string& get_on_behalf_of_content_owner() const { return on_behalf_of_content_owner_; }
8314 
8322  _have_on_behalf_of_content_owner_ = true;
8323  return &on_behalf_of_content_owner_;
8324  }
8325 
8326 
8343  void set_on_behalf_of_content_owner(const string& value) {
8344  _have_on_behalf_of_content_owner_ = true;
8345  on_behalf_of_content_owner_ = value;
8346  }
8347 
8348 
8349 
8355  _have_on_behalf_of_content_owner_channel_ = false;
8356  client::ClearCppValueHelper(&on_behalf_of_content_owner_channel_);
8357  }
8358 
8359 
8365  const string& get_on_behalf_of_content_owner_channel() const { return on_behalf_of_content_owner_channel_; }
8366 
8374  _have_on_behalf_of_content_owner_channel_ = true;
8375  return &on_behalf_of_content_owner_channel_;
8376  }
8377 
8378 
8402  void set_on_behalf_of_content_owner_channel(const string& value) {
8403  _have_on_behalf_of_content_owner_channel_ = true;
8404  on_behalf_of_content_owner_channel_ = value;
8405  }
8406 
8416  virtual util::Status AppendVariable(
8417  const StringPiece& variable_name,
8418  const client::UriTemplateConfig& config,
8419  string* target);
8420 
8426  virtual util::Status AppendOptionalQueryParameters(string* target);
8427 
8428 
8440  LiveStream* data) {
8441  return YouTubeServiceBaseRequest::ExecuteAndParseResponse(data);
8442  }
8443 
8444  private:
8445  string part_;
8446  string on_behalf_of_content_owner_;
8447  string on_behalf_of_content_owner_channel_;
8448  bool _have_on_behalf_of_content_owner_ : 1;
8449  bool _have_on_behalf_of_content_owner_channel_ : 1; string _content_;
8450  DISALLOW_COPY_AND_ASSIGN(LiveStreamsResource_InsertMethod);
8451 };
8452 
8468  public:
8481  const YouTubeService* _service_,
8482  client::AuthorizationCredential* _credential_,
8483  const absl::string_view& part);
8484 
8488  virtual ~LiveStreamsResource_ListMethod();
8489 
8490 
8494  void clear_id() {
8495  _have_id_ = false;
8496  client::ClearCppValueHelper(&id_);
8497  }
8498 
8499 
8505  const string& get_id() const { return id_; }
8506 
8512  string* mutable_id() {
8513  _have_id_ = true;
8514  return &id_;
8515  }
8516 
8517 
8525  void set_id(const string& value) {
8526  _have_id_ = true;
8527  id_ = value;
8528  }
8529 
8530 
8531 
8536  _have_max_results_ = false;
8537  client::ClearCppValueHelper(&max_results_);
8538  }
8539 
8540 
8546  uint32 get_max_results() const { return max_results_; }
8547 
8554  void set_max_results(uint32 value) {
8555  _have_max_results_ = true;
8556  max_results_ = value;
8557  }
8558 
8562  void clear_mine() {
8563  _have_mine_ = false;
8564  client::ClearCppValueHelper(&mine_);
8565  }
8566 
8567 
8573  bool get_mine() const { return mine_; }
8574 
8582  void set_mine(bool value) {
8583  _have_mine_ = true;
8584  mine_ = value;
8585  }
8586 
8592  _have_on_behalf_of_content_owner_ = false;
8593  client::ClearCppValueHelper(&on_behalf_of_content_owner_);
8594  }
8595 
8596 
8602  const string& get_on_behalf_of_content_owner() const { return on_behalf_of_content_owner_; }
8603 
8611  _have_on_behalf_of_content_owner_ = true;
8612  return &on_behalf_of_content_owner_;
8613  }
8614 
8615 
8632  void set_on_behalf_of_content_owner(const string& value) {
8633  _have_on_behalf_of_content_owner_ = true;
8634  on_behalf_of_content_owner_ = value;
8635  }
8636 
8637 
8638 
8644  _have_on_behalf_of_content_owner_channel_ = false;
8645  client::ClearCppValueHelper(&on_behalf_of_content_owner_channel_);
8646  }
8647 
8648 
8654  const string& get_on_behalf_of_content_owner_channel() const { return on_behalf_of_content_owner_channel_; }
8655 
8663  _have_on_behalf_of_content_owner_channel_ = true;
8664  return &on_behalf_of_content_owner_channel_;
8665  }
8666 
8667 
8691  void set_on_behalf_of_content_owner_channel(const string& value) {
8692  _have_on_behalf_of_content_owner_channel_ = true;
8693  on_behalf_of_content_owner_channel_ = value;
8694  }
8695 
8696 
8697 
8702  _have_page_token_ = false;
8703  client::ClearCppValueHelper(&page_token_);
8704  }
8705 
8706 
8712  const string& get_page_token() const { return page_token_; }
8713 
8720  string* mutable_pageToken() {
8721  _have_page_token_ = true;
8722  return &page_token_;
8723  }
8724 
8725 
8734  void set_page_token(const string& value) {
8735  _have_page_token_ = true;
8736  page_token_ = value;
8737  }
8738 
8748  virtual util::Status AppendVariable(
8749  const StringPiece& variable_name,
8750  const client::UriTemplateConfig& config,
8751  string* target);
8752 
8758  virtual util::Status AppendOptionalQueryParameters(string* target);
8759 
8760 
8772  LiveStreamListResponse* data) {
8773  return YouTubeServiceBaseRequest::ExecuteAndParseResponse(data);
8774  }
8775 
8776  private:
8777  string part_;
8778  string id_;
8779  uint32 max_results_;
8780  bool mine_;
8781  string on_behalf_of_content_owner_;
8782  string on_behalf_of_content_owner_channel_;
8783  string page_token_;
8784  bool _have_id_ : 1;
8785  bool _have_max_results_ : 1;
8786  bool _have_mine_ : 1;
8787  bool _have_on_behalf_of_content_owner_ : 1;
8788  bool _have_on_behalf_of_content_owner_channel_ : 1;
8789  bool _have_page_token_ : 1;
8790  DISALLOW_COPY_AND_ASSIGN(LiveStreamsResource_ListMethod);
8791 };
8792 
8793 typedef client::ServiceRequestPager<
8796  LiveStreamsResource_ListMethodPager;
8797 
8812  public:
8833  const YouTubeService* _service_,
8834  client::AuthorizationCredential* _credential_,
8835  const absl::string_view& part,
8836  const LiveStream& _content_);
8837 
8842 
8843 
8849  _have_on_behalf_of_content_owner_ = false;
8850  client::ClearCppValueHelper(&on_behalf_of_content_owner_);
8851  }
8852 
8853 
8859  const string& get_on_behalf_of_content_owner() const { return on_behalf_of_content_owner_; }
8860 
8868  _have_on_behalf_of_content_owner_ = true;
8869  return &on_behalf_of_content_owner_;
8870  }
8871 
8872 
8889  void set_on_behalf_of_content_owner(const string& value) {
8890  _have_on_behalf_of_content_owner_ = true;
8891  on_behalf_of_content_owner_ = value;
8892  }
8893 
8894 
8895 
8901  _have_on_behalf_of_content_owner_channel_ = false;
8902  client::ClearCppValueHelper(&on_behalf_of_content_owner_channel_);
8903  }
8904 
8905 
8911  const string& get_on_behalf_of_content_owner_channel() const { return on_behalf_of_content_owner_channel_; }
8912 
8920  _have_on_behalf_of_content_owner_channel_ = true;
8921  return &on_behalf_of_content_owner_channel_;
8922  }
8923 
8924 
8948  void set_on_behalf_of_content_owner_channel(const string& value) {
8949  _have_on_behalf_of_content_owner_channel_ = true;
8950  on_behalf_of_content_owner_channel_ = value;
8951  }
8952 
8962  virtual util::Status AppendVariable(
8963  const StringPiece& variable_name,
8964  const client::UriTemplateConfig& config,
8965  string* target);
8966 
8972  virtual util::Status AppendOptionalQueryParameters(string* target);
8973 
8974 
8986  LiveStream* data) {
8987  return YouTubeServiceBaseRequest::ExecuteAndParseResponse(data);
8988  }
8989 
8990  private:
8991  string part_;
8992  string on_behalf_of_content_owner_;
8993  string on_behalf_of_content_owner_channel_;
8994  bool _have_on_behalf_of_content_owner_ : 1;
8995  bool _have_on_behalf_of_content_owner_channel_ : 1; string _content_;
8996  DISALLOW_COPY_AND_ASSIGN(LiveStreamsResource_UpdateMethod);
8997 };
8998 
8999 
9000 
9017  public:
9028  const YouTubeService* _service_,
9029  client::AuthorizationCredential* _credential_,
9030  const absl::string_view& part);
9031 
9035  virtual ~MembersResource_ListMethod();
9036 
9037 
9043  _have_filter_by_member_channel_id_ = false;
9044  client::ClearCppValueHelper(&filter_by_member_channel_id_);
9045  }
9046 
9047 
9053  const string& get_filter_by_member_channel_id() const { return filter_by_member_channel_id_; }
9054 
9062  _have_filter_by_member_channel_id_ = true;
9063  return &filter_by_member_channel_id_;
9064  }
9065 
9066 
9076  void set_filter_by_member_channel_id(const string& value) {
9077  _have_filter_by_member_channel_id_ = true;
9078  filter_by_member_channel_id_ = value;
9079  }
9080 
9081 
9082 
9088  _have_has_access_to_level_ = false;
9089  client::ClearCppValueHelper(&has_access_to_level_);
9090  }
9091 
9092 
9098  const string& get_has_access_to_level() const { return has_access_to_level_; }
9099 
9107  _have_has_access_to_level_ = true;
9108  return &has_access_to_level_;
9109  }
9110 
9111 
9120  void set_has_access_to_level(const string& value) {
9121  _have_has_access_to_level_ = true;
9122  has_access_to_level_ = value;
9123  }
9124 
9125 
9126 
9131  _have_max_results_ = false;
9132  client::ClearCppValueHelper(&max_results_);
9133  }
9134 
9135 
9141  uint32 get_max_results() const { return max_results_; }
9142 
9149  void set_max_results(uint32 value) {
9150  _have_max_results_ = true;
9151  max_results_ = value;
9152  }
9153 
9157  void clear_mode() {
9158  _have_mode_ = false;
9159  client::ClearCppValueHelper(&mode_);
9160  }
9161 
9162 
9168  const string& get_mode() const { return mode_; }
9169 
9175  string* mutable_mode() {
9176  _have_mode_ = true;
9177  return &mode_;
9178  }
9179 
9180 
9187  void set_mode(const string& value) {
9188  _have_mode_ = true;
9189  mode_ = value;
9190  }
9191 
9192 
9193 
9198  _have_page_token_ = false;
9199  client::ClearCppValueHelper(&page_token_);
9200  }
9201 
9202 
9208  const string& get_page_token() const { return page_token_; }
9209 
9216  string* mutable_pageToken() {
9217  _have_page_token_ = true;
9218  return &page_token_;
9219  }
9220 
9221 
9230  void set_page_token(const string& value) {
9231  _have_page_token_ = true;
9232  page_token_ = value;
9233  }
9234 
9244  virtual util::Status AppendVariable(
9245  const StringPiece& variable_name,
9246  const client::UriTemplateConfig& config,
9247  string* target);
9248 
9254  virtual util::Status AppendOptionalQueryParameters(string* target);
9255 
9256 
9268  MemberListResponse* data) {
9269  return YouTubeServiceBaseRequest::ExecuteAndParseResponse(data);
9270  }
9271 
9272  private:
9273  string part_;
9274  string filter_by_member_channel_id_;
9275  string has_access_to_level_;
9276  uint32 max_results_;
9277  string mode_;
9278  string page_token_;
9279  bool _have_filter_by_member_channel_id_ : 1;
9280  bool _have_has_access_to_level_ : 1;
9281  bool _have_max_results_ : 1;
9282  bool _have_mode_ : 1;
9283  bool _have_page_token_ : 1;
9284  DISALLOW_COPY_AND_ASSIGN(MembersResource_ListMethod);
9285 };
9286 
9287 typedef client::ServiceRequestPager<
9290  MembersResource_ListMethodPager;
9291 
9292 
9293 
9310  public:
9322  const YouTubeService* _service_,
9323  client::AuthorizationCredential* _credential_,
9324  const absl::string_view& part);
9325 
9330 
9331 
9341  virtual util::Status AppendVariable(
9342  const StringPiece& variable_name,
9343  const client::UriTemplateConfig& config,
9344  string* target);
9345 
9351  virtual util::Status AppendOptionalQueryParameters(string* target);
9352 
9353 
9366  return YouTubeServiceBaseRequest::ExecuteAndParseResponse(data);
9367  }
9368 
9369  private:
9370  string part_;
9371  DISALLOW_COPY_AND_ASSIGN(MembershipsLevelsResource_ListMethod);
9372 };
9373 
9374 
9375 
9391  public:
9403  const YouTubeService* _service_,
9404  client::AuthorizationCredential* _credential_,
9405  const absl::string_view& id);
9406 
9411 
9412 
9418  _have_on_behalf_of_content_owner_ = false;
9419  client::ClearCppValueHelper(&on_behalf_of_content_owner_);
9420  }
9421 
9422 
9428  const string& get_on_behalf_of_content_owner() const { return on_behalf_of_content_owner_; }
9429 
9437  _have_on_behalf_of_content_owner_ = true;
9438  return &on_behalf_of_content_owner_;
9439  }
9440 
9441 
9458  void set_on_behalf_of_content_owner(const string& value) {
9459  _have_on_behalf_of_content_owner_ = true;
9460  on_behalf_of_content_owner_ = value;
9461  }
9462 
9472  virtual util::Status AppendVariable(
9473  const StringPiece& variable_name,
9474  const client::UriTemplateConfig& config,
9475  string* target);
9476 
9482  virtual util::Status AppendOptionalQueryParameters(string* target);
9483 
9484 
9485  private:
9486  string id_;
9487  string on_behalf_of_content_owner_;
9488  bool _have_on_behalf_of_content_owner_ : 1;
9489  DISALLOW_COPY_AND_ASSIGN(PlaylistItemsResource_DeleteMethod);
9490 };
9491 
9507  public:
9520  const YouTubeService* _service_,
9521  client::AuthorizationCredential* _credential_,
9522  const absl::string_view& part,
9523  const PlaylistItem& _content_);
9524 
9529 
9530 
9536  _have_on_behalf_of_content_owner_ = false;
9537  client::ClearCppValueHelper(&on_behalf_of_content_owner_);
9538  }
9539 
9540 
9546  const string& get_on_behalf_of_content_owner() const { return on_behalf_of_content_owner_; }
9547 
9555  _have_on_behalf_of_content_owner_ = true;
9556  return &on_behalf_of_content_owner_;
9557  }
9558 
9559 
9576  void set_on_behalf_of_content_owner(const string& value) {
9577  _have_on_behalf_of_content_owner_ = true;
9578  on_behalf_of_content_owner_ = value;
9579  }
9580 
9590  virtual util::Status AppendVariable(
9591  const StringPiece& variable_name,
9592  const client::UriTemplateConfig& config,
9593  string* target);
9594 
9600  virtual util::Status AppendOptionalQueryParameters(string* target);
9601 
9602 
9614  PlaylistItem* data) {
9615  return YouTubeServiceBaseRequest::ExecuteAndParseResponse(data);
9616  }
9617 
9618  private:
9619  string part_;
9620  string on_behalf_of_content_owner_;
9621  bool _have_on_behalf_of_content_owner_ : 1; string _content_;
9622  DISALLOW_COPY_AND_ASSIGN(PlaylistItemsResource_InsertMethod);
9623 };
9624 
9641  public:
9660  const YouTubeService* _service_,
9661  client::AuthorizationCredential* _credential_,
9662  const absl::string_view& part);
9663 
9668 
9669 
9673  void clear_id() {
9674  _have_id_ = false;
9675  client::ClearCppValueHelper(&id_);
9676  }
9677 
9678 
9684  const string& get_id() const { return id_; }
9685 
9691  string* mutable_id() {
9692  _have_id_ = true;
9693  return &id_;
9694  }
9695 
9696 
9703  void set_id(const string& value) {
9704  _have_id_ = true;
9705  id_ = value;
9706  }
9707 
9708 
9709 
9714  _have_max_results_ = false;
9715  client::ClearCppValueHelper(&max_results_);
9716  }
9717 
9718 
9724  uint32 get_max_results() const { return max_results_; }
9725 
9732  void set_max_results(uint32 value) {
9733  _have_max_results_ = true;
9734  max_results_ = value;
9735  }
9736 
9742  _have_on_behalf_of_content_owner_ = false;
9743  client::ClearCppValueHelper(&on_behalf_of_content_owner_);
9744  }
9745 
9746 
9752  const string& get_on_behalf_of_content_owner() const { return on_behalf_of_content_owner_; }
9753 
9761  _have_on_behalf_of_content_owner_ = true;
9762  return &on_behalf_of_content_owner_;
9763  }
9764 
9765 
9782  void set_on_behalf_of_content_owner(const string& value) {
9783  _have_on_behalf_of_content_owner_ = true;
9784  on_behalf_of_content_owner_ = value;
9785  }
9786 
9787 
9788 
9793  _have_page_token_ = false;
9794  client::ClearCppValueHelper(&page_token_);
9795  }
9796 
9797 
9803  const string& get_page_token() const { return page_token_; }
9804 
9811  string* mutable_pageToken() {
9812  _have_page_token_ = true;
9813  return &page_token_;
9814  }
9815 
9816 
9825  void set_page_token(const string& value) {
9826  _have_page_token_ = true;
9827  page_token_ = value;
9828  }
9829 
9830 
9831 
9836  _have_playlist_id_ = false;
9837  client::ClearCppValueHelper(&playlist_id_);
9838  }
9839 
9840 
9846  const string& get_playlist_id() const { return playlist_id_; }
9847 
9855  _have_playlist_id_ = true;
9856  return &playlist_id_;
9857  }
9858 
9859 
9869  void set_playlist_id(const string& value) {
9870  _have_playlist_id_ = true;
9871  playlist_id_ = value;
9872  }
9873 
9874 
9875 
9880  _have_video_id_ = false;
9881  client::ClearCppValueHelper(&video_id_);
9882  }
9883 
9884 
9890  const string& get_video_id() const { return video_id_; }
9891 
9898  string* mutable_videoId() {
9899  _have_video_id_ = true;
9900  return &video_id_;
9901  }
9902 
9903 
9910  void set_video_id(const string& value) {
9911  _have_video_id_ = true;
9912  video_id_ = value;
9913  }
9914 
9924  virtual util::Status AppendVariable(
9925  const StringPiece& variable_name,
9926  const client::UriTemplateConfig& config,
9927  string* target);
9928 
9934  virtual util::Status AppendOptionalQueryParameters(string* target);
9935 
9936 
9948  PlaylistItemListResponse* data) {
9949  return YouTubeServiceBaseRequest::ExecuteAndParseResponse(data);
9950  }
9951 
9952  private:
9953  string part_;
9954  string id_;
9955  uint32 max_results_;
9956  string on_behalf_of_content_owner_;
9957  string page_token_;
9958  string playlist_id_;
9959  string video_id_;
9960  bool _have_id_ : 1;
9961  bool _have_max_results_ : 1;
9962  bool _have_on_behalf_of_content_owner_ : 1;
9963  bool _have_page_token_ : 1;
9964  bool _have_playlist_id_ : 1;
9965  bool _have_video_id_ : 1;
9966  DISALLOW_COPY_AND_ASSIGN(PlaylistItemsResource_ListMethod);
9967 };
9968 
9969 typedef client::ServiceRequestPager<
9972  PlaylistItemsResource_ListMethodPager;
9973 
9989  public:
10013  const YouTubeService* _service_,
10014  client::AuthorizationCredential* _credential_,
10015  const absl::string_view& part,
10016  const PlaylistItem& _content_);
10017 
10022 
10023 
10029  _have_on_behalf_of_content_owner_ = false;
10030  client::ClearCppValueHelper(&on_behalf_of_content_owner_);
10031  }
10032 
10033 
10039  const string& get_on_behalf_of_content_owner() const { return on_behalf_of_content_owner_; }
10040 
10048  _have_on_behalf_of_content_owner_ = true;
10049  return &on_behalf_of_content_owner_;
10050  }
10051 
10052 
10069  void set_on_behalf_of_content_owner(const string& value) {
10070  _have_on_behalf_of_content_owner_ = true;
10071  on_behalf_of_content_owner_ = value;
10072  }
10073 
10083  virtual util::Status AppendVariable(
10084  const StringPiece& variable_name,
10085  const client::UriTemplateConfig& config,
10086  string* target);
10087 
10093  virtual util::Status AppendOptionalQueryParameters(string* target);
10094 
10095 
10107  PlaylistItem* data) {
10108  return YouTubeServiceBaseRequest::ExecuteAndParseResponse(data);
10109  }
10110 
10111  private:
10112  string part_;
10113  string on_behalf_of_content_owner_;
10114  bool _have_on_behalf_of_content_owner_ : 1; string _content_;
10115  DISALLOW_COPY_AND_ASSIGN(PlaylistItemsResource_UpdateMethod);
10116 };
10117 
10118 
10119 
10135  public:
10147  const YouTubeService* _service_,
10148  client::AuthorizationCredential* _credential_,
10149  const absl::string_view& id);
10150 
10154  virtual ~PlaylistsResource_DeleteMethod();
10155 
10156 
10162  _have_on_behalf_of_content_owner_ = false;
10163  client::ClearCppValueHelper(&on_behalf_of_content_owner_);
10164  }
10165 
10166 
10172  const string& get_on_behalf_of_content_owner() const { return on_behalf_of_content_owner_; }
10173 
10181  _have_on_behalf_of_content_owner_ = true;
10182  return &on_behalf_of_content_owner_;
10183  }
10184 
10185 
10202  void set_on_behalf_of_content_owner(const string& value) {
10203  _have_on_behalf_of_content_owner_ = true;
10204  on_behalf_of_content_owner_ = value;
10205  }
10206 
10216  virtual util::Status AppendVariable(
10217  const StringPiece& variable_name,
10218  const client::UriTemplateConfig& config,
10219  string* target);
10220 
10226  virtual util::Status AppendOptionalQueryParameters(string* target);
10227 
10228 
10229  private:
10230  string id_;
10231  string on_behalf_of_content_owner_;
10232  bool _have_on_behalf_of_content_owner_ : 1;
10233  DISALLOW_COPY_AND_ASSIGN(PlaylistsResource_DeleteMethod);
10234 };
10235 
10251  public:
10264  const YouTubeService* _service_,
10265  client::AuthorizationCredential* _credential_,
10266  const absl::string_view& part,
10267  const Playlist& _content_);
10268 
10272  virtual ~PlaylistsResource_InsertMethod();
10273 
10274 
10280  _have_on_behalf_of_content_owner_ = false;
10281  client::ClearCppValueHelper(&on_behalf_of_content_owner_);
10282  }
10283 
10284 
10290  const string& get_on_behalf_of_content_owner() const { return on_behalf_of_content_owner_; }
10291 
10299  _have_on_behalf_of_content_owner_ = true;
10300  return &on_behalf_of_content_owner_;
10301  }
10302 
10303 
10320  void set_on_behalf_of_content_owner(const string& value) {
10321  _have_on_behalf_of_content_owner_ = true;
10322  on_behalf_of_content_owner_ = value;
10323  }
10324 
10325 
10326 
10332  _have_on_behalf_of_content_owner_channel_ = false;
10333  client::ClearCppValueHelper(&on_behalf_of_content_owner_channel_);
10334  }
10335 
10336 
10342  const string& get_on_behalf_of_content_owner_channel() const { return on_behalf_of_content_owner_channel_; }
10343 
10351  _have_on_behalf_of_content_owner_channel_ = true;
10352  return &on_behalf_of_content_owner_channel_;
10353  }
10354 
10355 
10379  void set_on_behalf_of_content_owner_channel(const string& value) {
10380  _have_on_behalf_of_content_owner_channel_ = true;
10381  on_behalf_of_content_owner_channel_ = value;
10382  }
10383 
10393  virtual util::Status AppendVariable(
10394  const StringPiece& variable_name,
10395  const client::UriTemplateConfig& config,
10396  string* target);
10397 
10403  virtual util::Status AppendOptionalQueryParameters(string* target);
10404 
10405 
10417  Playlist* data) {
10418  return YouTubeServiceBaseRequest::ExecuteAndParseResponse(data);
10419  }
10420 
10421  private:
10422  string part_;
10423  string on_behalf_of_content_owner_;
10424  string on_behalf_of_content_owner_channel_;
10425  bool _have_on_behalf_of_content_owner_ : 1;
10426  bool _have_on_behalf_of_content_owner_channel_ : 1; string _content_;
10427  DISALLOW_COPY_AND_ASSIGN(PlaylistsResource_InsertMethod);
10428 };
10429 
10446  public:
10463  const YouTubeService* _service_,
10464  client::AuthorizationCredential* _credential_,
10465  const absl::string_view& part);
10466 
10470  virtual ~PlaylistsResource_ListMethod();
10471 
10472 
10477  _have_channel_id_ = false;
10478  client::ClearCppValueHelper(&channel_id_);
10479  }
10480 
10481 
10487  const string& get_channel_id() const { return channel_id_; }
10488 
10495  string* mutable_channelId() {
10496  _have_channel_id_ = true;
10497  return &channel_id_;
10498  }
10499 
10500 
10507  void set_channel_id(const string& value) {
10508  _have_channel_id_ = true;
10509  channel_id_ = value;
10510  }
10511 
10512 
10513 
10517  void clear_hl() {
10518  _have_hl_ = false;
10519  client::ClearCppValueHelper(&hl_);
10520  }
10521 
10522 
10528  const string& get_hl() const { return hl_; }
10529 
10535  string* mutable_hl() {
10536  _have_hl_ = true;
10537  return &hl_;
10538  }
10539 
10540 
10547  void set_hl(const string& value) {
10548  _have_hl_ = true;
10549  hl_ = value;
10550  }
10551 
10552 
10553 
10557  void clear_id() {
10558  _have_id_ = false;
10559  client::ClearCppValueHelper(&id_);
10560  }
10561 
10562 
10568  const string& get_id() const { return id_; }
10569 
10575  string* mutable_id() {
10576  _have_id_ = true;
10577  return &id_;
10578  }
10579 
10580 
10589  void set_id(const string& value) {
10590  _have_id_ = true;
10591  id_ = value;
10592  }
10593 
10594 
10595 
10600  _have_max_results_ = false;
10601  client::ClearCppValueHelper(&max_results_);
10602  }
10603 
10604 
10610  uint32 get_max_results() const { return max_results_; }
10611 
10618  void set_max_results(uint32 value) {
10619  _have_max_results_ = true;
10620  max_results_ = value;
10621  }
10622 
10626  void clear_mine() {
10627  _have_mine_ = false;
10628  client::ClearCppValueHelper(&mine_);
10629  }
10630 
10631 
10637  bool get_mine() const { return mine_; }
10638 
10645  void set_mine(bool value) {
10646  _have_mine_ = true;
10647  mine_ = value;
10648  }
10649 
10655  _have_on_behalf_of_content_owner_ = false;
10656  client::ClearCppValueHelper(&on_behalf_of_content_owner_);
10657  }
10658 
10659 
10665  const string& get_on_behalf_of_content_owner() const { return on_behalf_of_content_owner_; }
10666 
10674  _have_on_behalf_of_content_owner_ = true;
10675  return &on_behalf_of_content_owner_;
10676  }
10677 
10678 
10695  void set_on_behalf_of_content_owner(const string& value) {
10696  _have_on_behalf_of_content_owner_ = true;
10697  on_behalf_of_content_owner_ = value;
10698  }
10699 
10700 
10701 
10707  _have_on_behalf_of_content_owner_channel_ = false;
10708  client::ClearCppValueHelper(&on_behalf_of_content_owner_channel_);
10709  }
10710 
10711 
10717  const string& get_on_behalf_of_content_owner_channel() const { return on_behalf_of_content_owner_channel_; }
10718 
10726  _have_on_behalf_of_content_owner_channel_ = true;
10727  return &on_behalf_of_content_owner_channel_;
10728  }
10729 
10730 
10754  void set_on_behalf_of_content_owner_channel(const string& value) {
10755  _have_on_behalf_of_content_owner_channel_ = true;
10756  on_behalf_of_content_owner_channel_ = value;
10757  }
10758 
10759 
10760 
10765  _have_page_token_ = false;
10766  client::ClearCppValueHelper(&page_token_);
10767  }
10768 
10769 
10775  const string& get_page_token() const { return page_token_; }
10776 
10783  string* mutable_pageToken() {
10784  _have_page_token_ = true;
10785  return &page_token_;
10786  }
10787 
10788 
10797  void set_page_token(const string& value) {
10798  _have_page_token_ = true;
10799  page_token_ = value;
10800  }
10801 
10811  virtual util::Status AppendVariable(
10812  const StringPiece& variable_name,
10813  const client::UriTemplateConfig& config,
10814  string* target);
10815 
10821  virtual util::Status AppendOptionalQueryParameters(string* target);
10822 
10823 
10835  PlaylistListResponse* data) {
10836  return YouTubeServiceBaseRequest::ExecuteAndParseResponse(data);
10837  }
10838 
10839  private:
10840  string part_;
10841  string channel_id_;
10842  string hl_;
10843  string id_;
10844  uint32 max_results_;
10845  bool mine_;
10846  string on_behalf_of_content_owner_;
10847  string on_behalf_of_content_owner_channel_;
10848  string page_token_;
10849  bool _have_channel_id_ : 1;
10850  bool _have_hl_ : 1;
10851  bool _have_id_ : 1;
10852  bool _have_max_results_ : 1;
10853  bool _have_mine_ : 1;
10854  bool _have_on_behalf_of_content_owner_ : 1;
10855  bool _have_on_behalf_of_content_owner_channel_ : 1;
10856  bool _have_page_token_ : 1;
10857  DISALLOW_COPY_AND_ASSIGN(PlaylistsResource_ListMethod);
10858 };
10859 
10860 typedef client::ServiceRequestPager<
10863  PlaylistsResource_ListMethodPager;
10864 
10880  public:
10900  const YouTubeService* _service_,
10901  client::AuthorizationCredential* _credential_,
10902  const absl::string_view& part,
10903  const Playlist& _content_);
10904 
10908  virtual ~PlaylistsResource_UpdateMethod();
10909 
10910 
10916  _have_on_behalf_of_content_owner_ = false;
10917  client::ClearCppValueHelper(&on_behalf_of_content_owner_);
10918  }
10919 
10920 
10926  const string& get_on_behalf_of_content_owner() const { return on_behalf_of_content_owner_; }
10927 
10935  _have_on_behalf_of_content_owner_ = true;
10936  return &on_behalf_of_content_owner_;
10937  }
10938 
10939 
10956  void set_on_behalf_of_content_owner(const string& value) {
10957  _have_on_behalf_of_content_owner_ = true;
10958  on_behalf_of_content_owner_ = value;
10959  }
10960 
10970  virtual util::Status AppendVariable(
10971  const StringPiece& variable_name,
10972  const client::UriTemplateConfig& config,
10973  string* target);
10974 
10980  virtual util::Status AppendOptionalQueryParameters(string* target);
10981 
10982 
10994  Playlist* data) {
10995  return YouTubeServiceBaseRequest::ExecuteAndParseResponse(data);
10996  }
10997 
10998  private:
10999  string part_;
11000  string on_behalf_of_content_owner_;
11001  bool _have_on_behalf_of_content_owner_ : 1; string _content_;
11002  DISALLOW_COPY_AND_ASSIGN(PlaylistsResource_UpdateMethod);
11003 };
11004 
11005 
11006 
11023  public:
11035  const YouTubeService* _service_,
11036  client::AuthorizationCredential* _credential_,
11037  const absl::string_view& part);
11038 
11042  virtual ~SearchResource_ListMethod();
11043 
11044 
11049  _have_channel_id_ = false;
11050  client::ClearCppValueHelper(&channel_id_);
11051  }
11052 
11053 
11059  const string& get_channel_id() const { return channel_id_; }
11060 
11067  string* mutable_channelId() {
11068  _have_channel_id_ = true;
11069  return &channel_id_;
11070  }
11071 
11072 
11079  void set_channel_id(const string& value) {
11080  _have_channel_id_ = true;
11081  channel_id_ = value;
11082  }
11083 
11084 
11085 
11090  _have_channel_type_ = false;
11091  client::ClearCppValueHelper(&channel_type_);
11092  }
11093 
11094 
11100  const string& get_channel_type() const { return channel_type_; }
11101 
11109  _have_channel_type_ = true;
11110  return &channel_type_;
11111  }
11112 
11113 
11120  void set_channel_type(const string& value) {
11121  _have_channel_type_ = true;
11122  channel_type_ = value;
11123  }
11124 
11125 
11126 
11131  _have_event_type_ = false;
11132  client::ClearCppValueHelper(&event_type_);
11133  }
11134 
11135 
11141  const string& get_event_type() const { return event_type_; }
11142 
11149  string* mutable_eventType() {
11150  _have_event_type_ = true;
11151  return &event_type_;
11152  }
11153 
11154 
11162  void set_event_type(const string& value) {
11163  _have_event_type_ = true;
11164  event_type_ = value;
11165  }
11166 
11167 
11168 
11174  _have_for_content_owner_ = false;
11175  client::ClearCppValueHelper(&for_content_owner_);
11176  }
11177 
11178 
11184  bool get_for_content_owner() const { return for_content_owner_; }
11185 
11198  void set_for_content_owner(bool value) {
11199  _have_for_content_owner_ = true;
11200  for_content_owner_ = value;
11201  }
11202 
11207  _have_for_developer_ = false;
11208  client::ClearCppValueHelper(&for_developer_);
11209  }
11210 
11211 
11217  bool get_for_developer() const { return for_developer_; }
11218 
11229  void set_for_developer(bool value) {
11230  _have_for_developer_ = true;
11231  for_developer_ = value;
11232  }
11233 
11238  _have_for_mine_ = false;
11239  client::ClearCppValueHelper(&for_mine_);
11240  }
11241 
11242 
11248  bool get_for_mine() const { return for_mine_; }
11249 
11258  void set_for_mine(bool value) {
11259  _have_for_mine_ = true;
11260  for_mine_ = value;
11261  }
11262 
11267  _have_location_ = false;
11268  client::ClearCppValueHelper(&location_);
11269  }
11270 
11271 
11277  const string& get_location() const { return location_; }
11278 
11285  string* mutable_location() {
11286  _have_location_ = true;
11287  return &location_;
11288  }
11289 
11290 
11310  void set_location(const string& value) {
11311  _have_location_ = true;
11312  location_ = value;
11313  }
11314 
11315 
11316 
11322  _have_location_radius_ = false;
11323  client::ClearCppValueHelper(&location_radius_);
11324  }
11325 
11326 
11332  const string& get_location_radius() const { return location_radius_; }
11333 
11341  _have_location_radius_ = true;
11342  return &location_radius_;
11343  }
11344 
11345 
11360  void set_location_radius(const string& value) {
11361  _have_location_radius_ = true;
11362  location_radius_ = value;
11363  }
11364 
11365 
11366 
11371  _have_max_results_ = false;
11372  client::ClearCppValueHelper(&max_results_);
11373  }
11374 
11375 
11381  uint32 get_max_results() const { return max_results_; }
11382 
11389  void set_max_results(uint32 value) {
11390  _have_max_results_ = true;
11391  max_results_ = value;
11392  }
11393 
11399  _have_on_behalf_of_content_owner_ = false;
11400  client::ClearCppValueHelper(&on_behalf_of_content_owner_);
11401  }
11402 
11403 
11409  const string& get_on_behalf_of_content_owner() const { return on_behalf_of_content_owner_; }
11410 
11418  _have_on_behalf_of_content_owner_ = true;
11419  return &on_behalf_of_content_owner_;
11420  }
11421 
11422 
11439  void set_on_behalf_of_content_owner(const string& value) {
11440  _have_on_behalf_of_content_owner_ = true;
11441  on_behalf_of_content_owner_ = value;
11442  }
11443 
11444 
11445 
11449  void clear_order() {
11450  _have_order_ = false;
11451  client::ClearCppValueHelper(&order_);
11452  }
11453 
11454 
11460  const string& get_order() const { return order_; }
11461 
11467  string* mutable_order() {
11468  _have_order_ = true;
11469  return &order_;
11470  }
11471 
11472 
11479  void set_order(const string& value) {
11480  _have_order_ = true;
11481  order_ = value;
11482  }
11483 
11484 
11485 
11490  _have_page_token_ = false;
11491  client::ClearCppValueHelper(&page_token_);
11492  }
11493 
11494 
11500  const string& get_page_token() const { return page_token_; }
11501 
11508  string* mutable_pageToken() {
11509  _have_page_token_ = true;
11510  return &page_token_;
11511  }
11512 
11513 
11522  void set_page_token(const string& value) {
11523  _have_page_token_ = true;
11524  page_token_ = value;
11525  }
11526 
11527 
11528 
11534  _have_published_after_ = false;
11535  client::ClearCppValueHelper(&published_after_);
11536  }
11537 
11538 
11544  client::DateTime get_published_after() const { return published_after_; }
11545 
11554  void set_published_after(client::DateTime value) {
11555  _have_published_after_ = true;
11556  published_after_ = value;
11557  }
11558 
11564  _have_published_before_ = false;
11565  client::ClearCppValueHelper(&published_before_);
11566  }
11567 
11568 
11574  client::DateTime get_published_before() const { return published_before_; }
11575 
11584  void set_published_before(client::DateTime value) {
11585  _have_published_before_ = true;
11586  published_before_ = value;
11587  }
11588 
11592  void clear_q() {
11593  _have_q_ = false;
11594  client::ClearCppValueHelper(&q_);
11595  }
11596 
11597 
11603  const string& get_q() const { return q_; }
11604 
11610  string* mutable_q() {
11611  _have_q_ = true;
11612  return &q_;
11613  }
11614 
11615 
11630  void set_q(const string& value) {
11631  _have_q_ = true;
11632  q_ = value;
11633  }
11634 
11635 
11636 
11641  _have_region_code_ = false;
11642  client::ClearCppValueHelper(&region_code_);
11643  }
11644 
11645 
11651  const string& get_region_code() const { return region_code_; }
11652 
11660  _have_region_code_ = true;
11661  return &region_code_;
11662  }
11663 
11664 
11672  void set_region_code(const string& value) {
11673  _have_region_code_ = true;
11674  region_code_ = value;
11675  }
11676 
11677 
11678 
11684  _have_related_to_video_id_ = false;
11685  client::ClearCppValueHelper(&related_to_video_id_);
11686  }
11687 
11688 
11694  const string& get_related_to_video_id() const { return related_to_video_id_; }
11695 
11703  _have_related_to_video_id_ = true;
11704  return &related_to_video_id_;
11705  }
11706 
11707 
11716  void set_related_to_video_id(const string& value) {
11717  _have_related_to_video_id_ = true;
11718  related_to_video_id_ = value;
11719  }
11720 
11721 
11722 
11728  _have_relevance_language_ = false;
11729  client::ClearCppValueHelper(&relevance_language_);
11730  }
11731 
11732 
11738  const string& get_relevance_language() const { return relevance_language_; }
11739 
11747  _have_relevance_language_ = true;
11748  return &relevance_language_;
11749  }
11750 
11751 
11763  void set_relevance_language(const string& value) {
11764  _have_relevance_language_ = true;
11765  relevance_language_ = value;
11766  }
11767 
11768 
11769 
11774  _have_safe_search_ = false;
11775  client::ClearCppValueHelper(&safe_search_);
11776  }
11777 
11778 
11784  const string& get_safe_search() const { return safe_search_; }
11785 
11793  _have_safe_search_ = true;
11794  return &safe_search_;
11795  }
11796 
11797 
11804  void set_safe_search(const string& value) {
11805  _have_safe_search_ = true;
11806  safe_search_ = value;
11807  }
11808 
11809 
11810 
11815  _have_topic_id_ = false;
11816  client::ClearCppValueHelper(&topic_id_);
11817  }
11818 
11819 
11825  const string& get_topic_id() const { return topic_id_; }
11826 
11833  string* mutable_topicId() {
11834  _have_topic_id_ = true;
11835  return &topic_id_;
11836  }
11837 
11838 
11846  void set_topic_id(const string& value) {
11847  _have_topic_id_ = true;
11848  topic_id_ = value;
11849  }
11850 
11851 
11852 
11856  void clear_type() {
11857  _have_type_ = false;
11858  client::ClearCppValueHelper(&type_);
11859  }
11860 
11861 
11867  const string& get_type() const { return type_; }
11868 
11874  string* mutable_type() {
11875  _have_type_ = true;
11876  return &type_;
11877  }
11878 
11879 
11887  void set_type(const string& value) {
11888  _have_type_ = true;
11889  type_ = value;
11890  }
11891 
11892 
11893 
11898  _have_video_caption_ = false;
11899  client::ClearCppValueHelper(&video_caption_);
11900  }
11901 
11902 
11908  const string& get_video_caption() const { return video_caption_; }
11909 
11917  _have_video_caption_ = true;
11918  return &video_caption_;
11919  }
11920 
11921 
11930  void set_video_caption(const string& value) {
11931  _have_video_caption_ = true;
11932  video_caption_ = value;
11933  }
11934 
11935 
11936 
11942  _have_video_category_id_ = false;
11943  client::ClearCppValueHelper(&video_category_id_);
11944  }
11945 
11946 
11952  const string& get_video_category_id() const { return video_category_id_; }
11953 
11961  _have_video_category_id_ = true;
11962  return &video_category_id_;
11963  }
11964 
11965 
11973  void set_video_category_id(const string& value) {
11974  _have_video_category_id_ = true;
11975  video_category_id_ = value;
11976  }
11977 
11978 
11979 
11985  _have_video_definition_ = false;
11986  client::ClearCppValueHelper(&video_definition_);
11987  }
11988 
11989 
11995  const string& get_video_definition() const { return video_definition_; }
11996 
12004  _have_video_definition_ = true;
12005  return &video_definition_;
12006  }
12007 
12008 
12019  void set_video_definition(const string& value) {
12020  _have_video_definition_ = true;
12021  video_definition_ = value;
12022  }
12023 
12024 
12025 
12031  _have_video_dimension_ = false;
12032  client::ClearCppValueHelper(&video_dimension_);
12033  }
12034 
12035 
12041  const string& get_video_dimension() const { return video_dimension_; }
12042 
12050  _have_video_dimension_ = true;
12051  return &video_dimension_;
12052  }
12053 
12054 
12062  void set_video_dimension(const string& value) {
12063  _have_video_dimension_ = true;
12064  video_dimension_ = value;
12065  }
12066 
12067 
12068 
12073  _have_video_duration_ = false;
12074  client::ClearCppValueHelper(&video_duration_);
12075  }
12076 
12077 
12083  const string& get_video_duration() const { return video_duration_; }
12084 
12092  _have_video_duration_ = true;
12093  return &video_duration_;
12094  }
12095 
12096 
12104  void set_video_duration(const string& value) {
12105  _have_video_duration_ = true;
12106  video_duration_ = value;
12107  }
12108 
12109 
12110 
12116  _have_video_embeddable_ = false;
12117  client::ClearCppValueHelper(&video_embeddable_);
12118  }
12119 
12120 
12126  const string& get_video_embeddable() const { return video_embeddable_; }
12127 
12135  _have_video_embeddable_ = true;
12136  return &video_embeddable_;
12137  }
12138 
12139 
12148  void set_video_embeddable(const string& value) {
12149  _have_video_embeddable_ = true;
12150  video_embeddable_ = value;
12151  }
12152 
12153 
12154 
12159  _have_video_license_ = false;
12160  client::ClearCppValueHelper(&video_license_);
12161  }
12162 
12163 
12169  const string& get_video_license() const { return video_license_; }
12170 
12178  _have_video_license_ = true;
12179  return &video_license_;
12180  }
12181 
12182 
12193  void set_video_license(const string& value) {
12194  _have_video_license_ = true;
12195  video_license_ = value;
12196  }
12197 
12198 
12199 
12205  _have_video_syndicated_ = false;
12206  client::ClearCppValueHelper(&video_syndicated_);
12207  }
12208 
12209 
12215  const string& get_video_syndicated() const { return video_syndicated_; }
12216 
12224  _have_video_syndicated_ = true;
12225  return &video_syndicated_;
12226  }
12227 
12228 
12237  void set_video_syndicated(const string& value) {
12238  _have_video_syndicated_ = true;
12239  video_syndicated_ = value;
12240  }
12241 
12242 
12243 
12248  _have_video_type_ = false;
12249  client::ClearCppValueHelper(&video_type_);
12250  }
12251 
12252 
12258  const string& get_video_type() const { return video_type_; }
12259 
12266  string* mutable_videoType() {
12267  _have_video_type_ = true;
12268  return &video_type_;
12269  }
12270 
12271 
12279  void set_video_type(const string& value) {
12280  _have_video_type_ = true;
12281  video_type_ = value;
12282  }
12283 
12293  virtual util::Status AppendVariable(
12294  const StringPiece& variable_name,
12295  const client::UriTemplateConfig& config,
12296  string* target);
12297 
12303  virtual util::Status AppendOptionalQueryParameters(string* target);
12304 
12305 
12317  SearchListResponse* data) {
12318  return YouTubeServiceBaseRequest::ExecuteAndParseResponse(data);
12319  }
12320 
12321  private:
12322  string part_;
12323  string channel_id_;
12324  string channel_type_;
12325  string event_type_;
12326  bool for_content_owner_;
12327  bool for_developer_;
12328  bool for_mine_;
12329  string location_;
12330  string location_radius_;
12331  uint32 max_results_;
12332  string on_behalf_of_content_owner_;
12333  string order_;
12334  string page_token_;
12335  client::DateTime published_after_;
12336  client::DateTime published_before_;
12337  string q_;
12338  string region_code_;
12339  string related_to_video_id_;
12340  string relevance_language_;
12341  string safe_search_;
12342  string topic_id_;
12343  string type_;
12344  string video_caption_;
12345  string video_category_id_;
12346  string video_definition_;
12347  string video_dimension_;
12348  string video_duration_;
12349  string video_embeddable_;
12350  string video_license_;
12351  string video_syndicated_;
12352  string video_type_;
12353  bool _have_channel_id_ : 1;
12354  bool _have_channel_type_ : 1;
12355  bool _have_event_type_ : 1;
12356  bool _have_for_content_owner_ : 1;
12357  bool _have_for_developer_ : 1;
12358  bool _have_for_mine_ : 1;
12359  bool _have_location_ : 1;
12360  bool _have_location_radius_ : 1;
12361  bool _have_max_results_ : 1;
12362  bool _have_on_behalf_of_content_owner_ : 1;
12363  bool _have_order_ : 1;
12364  bool _have_page_token_ : 1;
12365  bool _have_published_after_ : 1;
12366  bool _have_published_before_ : 1;
12367  bool _have_q_ : 1;
12368  bool _have_region_code_ : 1;
12369  bool _have_related_to_video_id_ : 1;
12370  bool _have_relevance_language_ : 1;
12371  bool _have_safe_search_ : 1;
12372  bool _have_topic_id_ : 1;
12373  bool _have_type_ : 1;
12374  bool _have_video_caption_ : 1;
12375  bool _have_video_category_id_ : 1;
12376  bool _have_video_definition_ : 1;
12377  bool _have_video_dimension_ : 1;
12378  bool _have_video_duration_ : 1;
12379  bool _have_video_embeddable_ : 1;
12380  bool _have_video_license_ : 1;
12381  bool _have_video_syndicated_ : 1;
12382  bool _have_video_type_ : 1;
12383  DISALLOW_COPY_AND_ASSIGN(SearchResource_ListMethod);
12384 };
12385 
12386 typedef client::ServiceRequestPager<
12389  SearchResource_ListMethodPager;
12390 
12391 
12392 
12408  public:
12419  const YouTubeService* _service_,
12420  client::AuthorizationCredential* _credential_,
12421  const absl::string_view& part);
12422 
12426  virtual ~SponsorsResource_ListMethod();
12427 
12428 
12432  void clear_filter() {
12433  _have_filter_ = false;
12434  client::ClearCppValueHelper(&filter_);
12435  }
12436 
12437 
12443  const string& get_filter() const { return filter_; }
12444 
12450  string* mutable_filter() {
12451  _have_filter_ = true;
12452  return &filter_;
12453  }
12454 
12455 
12462  void set_filter(const string& value) {
12463  _have_filter_ = true;
12464  filter_ = value;
12465  }
12466 
12467 
12468 
12473  _have_max_results_ = false;
12474  client::ClearCppValueHelper(&max_results_);
12475  }
12476 
12477 
12483  uint32 get_max_results() const { return max_results_; }
12484 
12491  void set_max_results(uint32 value) {
12492  _have_max_results_ = true;
12493  max_results_ = value;
12494  }
12495 
12500  _have_page_token_ = false;
12501  client::ClearCppValueHelper(&page_token_);
12502  }
12503 
12504 
12510  const string& get_page_token() const { return page_token_; }
12511 
12518  string* mutable_pageToken() {
12519  _have_page_token_ = true;
12520  return &page_token_;
12521  }
12522 
12523 
12532  void set_page_token(const string& value) {
12533  _have_page_token_ = true;
12534  page_token_ = value;
12535  }
12536 
12546  virtual util::Status AppendVariable(
12547  const StringPiece& variable_name,
12548  const client::UriTemplateConfig& config,
12549  string* target);
12550 
12556  virtual util::Status AppendOptionalQueryParameters(string* target);
12557 
12558 
12570  SponsorListResponse* data) {
12571  return YouTubeServiceBaseRequest::ExecuteAndParseResponse(data);
12572  }
12573 
12574  private:
12575  string part_;
12576  string filter_;
12577  uint32 max_results_;
12578  string page_token_;
12579  bool _have_filter_ : 1;
12580  bool _have_max_results_ : 1;
12581  bool _have_page_token_ : 1;
12582  DISALLOW_COPY_AND_ASSIGN(SponsorsResource_ListMethod);
12583 };
12584 
12585 typedef client::ServiceRequestPager<
12588  SponsorsResource_ListMethodPager;
12589 
12590 
12591 
12607  public:
12619  const YouTubeService* _service_,
12620  client::AuthorizationCredential* _credential_,
12621  const absl::string_view& id);
12622 
12627 
12628 
12638  virtual util::Status AppendVariable(
12639  const StringPiece& variable_name,
12640  const client::UriTemplateConfig& config,
12641  string* target);
12642 
12648  virtual util::Status AppendOptionalQueryParameters(string* target);
12649 
12650 
12651  private:
12652  string id_;
12653  DISALLOW_COPY_AND_ASSIGN(SubscriptionsResource_DeleteMethod);
12654 };
12655 
12671  public:
12684  const YouTubeService* _service_,
12685  client::AuthorizationCredential* _credential_,
12686  const absl::string_view& part,
12687  const Subscription& _content_);
12688 
12693 
12694 
12704  virtual util::Status AppendVariable(
12705  const StringPiece& variable_name,
12706  const client::UriTemplateConfig& config,
12707  string* target);
12708 
12714  virtual util::Status AppendOptionalQueryParameters(string* target);
12715 
12716 
12728  Subscription* data) {
12729  return YouTubeServiceBaseRequest::ExecuteAndParseResponse(data);
12730  }
12731 
12732  private:
12733  string part_; string _content_;
12734  DISALLOW_COPY_AND_ASSIGN(SubscriptionsResource_InsertMethod);
12735 };
12736 
12753  public:
12771  const YouTubeService* _service_,
12772  client::AuthorizationCredential* _credential_,
12773  const absl::string_view& part);
12774 
12779 
12780 
12785  _have_channel_id_ = false;
12786  client::ClearCppValueHelper(&channel_id_);
12787  }
12788 
12789 
12795  const string& get_channel_id() const { return channel_id_; }
12796 
12803  string* mutable_channelId() {
12804  _have_channel_id_ = true;
12805  return &channel_id_;
12806  }
12807 
12808 
12815  void set_channel_id(const string& value) {
12816  _have_channel_id_ = true;
12817  channel_id_ = value;
12818  }
12819 
12820 
12821 
12826  _have_for_channel_id_ = false;
12827  client::ClearCppValueHelper(&for_channel_id_);
12828  }
12829 
12830 
12836  const string& get_for_channel_id() const { return for_channel_id_; }
12837 
12845  _have_for_channel_id_ = true;
12846  return &for_channel_id_;
12847  }
12848 
12849 
12857  void set_for_channel_id(const string& value) {
12858  _have_for_channel_id_ = true;
12859  for_channel_id_ = value;
12860  }
12861 
12862 
12863 
12867  void clear_id() {
12868  _have_id_ = false;
12869  client::ClearCppValueHelper(&id_);
12870  }
12871 
12872 
12878  const string& get_id() const { return id_; }
12879 
12885  string* mutable_id() {
12886  _have_id_ = true;
12887  return &id_;
12888  }
12889 
12890 
12899  void set_id(const string& value) {
12900  _have_id_ = true;
12901  id_ = value;
12902  }
12903 
12904 
12905 
12910  _have_max_results_ = false;
12911  client::ClearCppValueHelper(&max_results_);
12912  }
12913 
12914 
12920  uint32 get_max_results() const { return max_results_; }
12921 
12928  void set_max_results(uint32 value) {
12929  _have_max_results_ = true;
12930  max_results_ = value;
12931  }
12932 
12936  void clear_mine() {
12937  _have_mine_ = false;
12938  client::ClearCppValueHelper(&mine_);
12939  }
12940 
12941 
12947  bool get_mine() const { return mine_; }
12948 
12955  void set_mine(bool value) {
12956  _have_mine_ = true;
12957  mine_ = value;
12958  }
12959 
12965  _have_my_recent_subscribers_ = false;
12966  client::ClearCppValueHelper(&my_recent_subscribers_);
12967  }
12968 
12969 
12975  bool get_my_recent_subscribers() const { return my_recent_subscribers_; }
12976 
12984  void set_my_recent_subscribers(bool value) {
12985  _have_my_recent_subscribers_ = true;
12986  my_recent_subscribers_ = value;
12987  }
12988 
12993  _have_my_subscribers_ = false;
12994  client::ClearCppValueHelper(&my_subscribers_);
12995  }
12996 
12997 
13003  bool get_my_subscribers() const { return my_subscribers_; }
13004 
13011  void set_my_subscribers(bool value) {
13012  _have_my_subscribers_ = true;
13013  my_subscribers_ = value;
13014  }
13015 
13021  _have_on_behalf_of_content_owner_ = false;
13022  client::ClearCppValueHelper(&on_behalf_of_content_owner_);
13023  }
13024 
13025 
13031  const string& get_on_behalf_of_content_owner() const { return on_behalf_of_content_owner_; }
13032 
13040  _have_on_behalf_of_content_owner_ = true;
13041  return &on_behalf_of_content_owner_;
13042  }
13043 
13044 
13061  void set_on_behalf_of_content_owner(const string& value) {
13062  _have_on_behalf_of_content_owner_ = true;
13063  on_behalf_of_content_owner_ = value;
13064  }
13065 
13066 
13067 
13073  _have_on_behalf_of_content_owner_channel_ = false;
13074  client::ClearCppValueHelper(&on_behalf_of_content_owner_channel_);
13075  }
13076 
13077 
13083  const string& get_on_behalf_of_content_owner_channel() const { return on_behalf_of_content_owner_channel_; }
13084 
13092  _have_on_behalf_of_content_owner_channel_ = true;
13093  return &on_behalf_of_content_owner_channel_;
13094  }
13095 
13096 
13120  void set_on_behalf_of_content_owner_channel(const string& value) {
13121  _have_on_behalf_of_content_owner_channel_ = true;
13122  on_behalf_of_content_owner_channel_ = value;
13123  }
13124 
13125 
13126 
13130  void clear_order() {
13131  _have_order_ = false;
13132  client::ClearCppValueHelper(&order_);
13133  }
13134 
13135 
13141  const string& get_order() const { return order_; }
13142 
13148  string* mutable_order() {
13149  _have_order_ = true;
13150  return &order_;
13151  }
13152 
13153 
13160  void set_order(const string& value) {
13161  _have_order_ = true;
13162  order_ = value;
13163  }
13164 
13165 
13166 
13171  _have_page_token_ = false;
13172  client::ClearCppValueHelper(&page_token_);
13173  }
13174 
13175 
13181  const string& get_page_token() const { return page_token_; }
13182 
13189  string* mutable_pageToken() {
13190  _have_page_token_ = true;
13191  return &page_token_;
13192  }
13193 
13194 
13203  void set_page_token(const string& value) {
13204  _have_page_token_ = true;
13205  page_token_ = value;
13206  }
13207 
13217  virtual util::Status AppendVariable(
13218  const StringPiece& variable_name,
13219  const client::UriTemplateConfig& config,
13220  string* target);
13221 
13227  virtual util::Status AppendOptionalQueryParameters(string* target);
13228 
13229 
13241  SubscriptionListResponse* data) {
13242  return YouTubeServiceBaseRequest::ExecuteAndParseResponse(data);
13243  }
13244 
13245  private:
13246  string part_;
13247  string channel_id_;
13248  string for_channel_id_;
13249  string id_;
13250  uint32 max_results_;
13251  bool mine_;
13252  bool my_recent_subscribers_;
13253  bool my_subscribers_;
13254  string on_behalf_of_content_owner_;
13255  string on_behalf_of_content_owner_channel_;
13256  string order_;
13257  string page_token_;
13258  bool _have_channel_id_ : 1;
13259  bool _have_for_channel_id_ : 1;
13260  bool _have_id_ : 1;
13261  bool _have_max_results_ : 1;
13262  bool _have_mine_ : 1;
13263  bool _have_my_recent_subscribers_ : 1;
13264  bool _have_my_subscribers_ : 1;
13265  bool _have_on_behalf_of_content_owner_ : 1;
13266  bool _have_on_behalf_of_content_owner_channel_ : 1;
13267  bool _have_order_ : 1;
13268  bool _have_page_token_ : 1;
13269  DISALLOW_COPY_AND_ASSIGN(SubscriptionsResource_ListMethod);
13270 };
13271 
13272 typedef client::ServiceRequestPager<
13275  SubscriptionsResource_ListMethodPager;
13276 
13277 
13278 
13294  public:
13306  const YouTubeService* _service_,
13307  client::AuthorizationCredential* _credential_,
13308  const absl::string_view& part);
13309 
13314 
13315 
13319  void clear_hl() {
13320  _have_hl_ = false;
13321  client::ClearCppValueHelper(&hl_);
13322  }
13323 
13324 
13330  const string& get_hl() const { return hl_; }
13331 
13337  string* mutable_hl() {
13338  _have_hl_ = true;
13339  return &hl_;
13340  }
13341 
13342 
13356  void set_hl(const string& value) {
13357  _have_hl_ = true;
13358  hl_ = value;
13359  }
13360 
13361 
13362 
13367  _have_max_results_ = false;
13368  client::ClearCppValueHelper(&max_results_);
13369  }
13370 
13371 
13377  uint32 get_max_results() const { return max_results_; }
13378 
13385  void set_max_results(uint32 value) {
13386  _have_max_results_ = true;
13387  max_results_ = value;
13388  }
13389 
13394  _have_page_token_ = false;
13395  client::ClearCppValueHelper(&page_token_);
13396  }
13397 
13398 
13404  const string& get_page_token() const { return page_token_; }
13405 
13412  string* mutable_pageToken() {
13413  _have_page_token_ = true;
13414  return &page_token_;
13415  }
13416 
13417 
13426  void set_page_token(const string& value) {
13427  _have_page_token_ = true;
13428  page_token_ = value;
13429  }
13430 
13440  virtual util::Status AppendVariable(
13441  const StringPiece& variable_name,
13442  const client::UriTemplateConfig& config,
13443  string* target);
13444 
13450  virtual util::Status AppendOptionalQueryParameters(string* target);
13451 
13452 
13465  return YouTubeServiceBaseRequest::ExecuteAndParseResponse(data);
13466  }
13467 
13468  private:
13469  string part_;
13470  string hl_;
13471  uint32 max_results_;
13472  string page_token_;
13473  bool _have_hl_ : 1;
13474  bool _have_max_results_ : 1;
13475  bool _have_page_token_ : 1;
13476  DISALLOW_COPY_AND_ASSIGN(SuperChatEventsResource_ListMethod);
13477 };
13478 
13479 typedef client::ServiceRequestPager<
13482  SuperChatEventsResource_ListMethodPager;
13483 
13484 
13485 
13502  public:
13518  const YouTubeService* _service_,
13519  client::AuthorizationCredential* _credential_,
13520  const absl::string_view& video_id,
13521  const StringPiece& _media_content_type_,
13522  client::DataReader* _media_content_reader_);
13523 
13527  virtual ~ThumbnailsResource_SetMethod();
13528 
13529 
13535  _have_on_behalf_of_content_owner_ = false;
13536  client::ClearCppValueHelper(&on_behalf_of_content_owner_);
13537  }
13538 
13539 
13545  const string& get_on_behalf_of_content_owner() const { return on_behalf_of_content_owner_; }
13546 
13554  _have_on_behalf_of_content_owner_ = true;
13555  return &on_behalf_of_content_owner_;
13556  }
13557 
13558 
13575  void set_on_behalf_of_content_owner(const string& value) {
13576  _have_on_behalf_of_content_owner_ = true;
13577  on_behalf_of_content_owner_ = value;
13578  }
13579 
13589  virtual util::Status AppendVariable(
13590  const StringPiece& variable_name,
13591  const client::UriTemplateConfig& config,
13592  string* target);
13593 
13599  virtual util::Status AppendOptionalQueryParameters(string* target);
13600 
13601 
13613  ThumbnailSetResponse* data) {
13614  return YouTubeServiceBaseRequest::ExecuteAndParseResponse(data);
13615  }
13616 
13617 
13625  static const client::MediaUploadSpec SIMPLE_MEDIA_UPLOAD;
13629  static const client::MediaUploadSpec RESUMABLE_MEDIA_UPLOAD;
13630 
13631  private:
13632  string video_id_;
13633  string on_behalf_of_content_owner_;
13634  bool _have_on_behalf_of_content_owner_ : 1;
13635  DISALLOW_COPY_AND_ASSIGN(ThumbnailsResource_SetMethod);
13636 };
13637 
13638 
13639 
13655  public:
13667  const YouTubeService* _service_,
13668  client::AuthorizationCredential* _credential_,
13669  const absl::string_view& part);
13670 
13675 
13676 
13680  void clear_hl() {
13681  _have_hl_ = false;
13682  client::ClearCppValueHelper(&hl_);
13683  }
13684 
13685 
13691  const string& get_hl() const { return hl_; }
13692 
13698  string* mutable_hl() {
13699  _have_hl_ = true;
13700  return &hl_;
13701  }
13702 
13703 
13710  void set_hl(const string& value) {
13711  _have_hl_ = true;
13712  hl_ = value;
13713  }
13714 
13724  virtual util::Status AppendVariable(
13725  const StringPiece& variable_name,
13726  const client::UriTemplateConfig& config,
13727  string* target);
13728 
13734  virtual util::Status AppendOptionalQueryParameters(string* target);
13735 
13736 
13749  return YouTubeServiceBaseRequest::ExecuteAndParseResponse(data);
13750  }
13751 
13752  private:
13753  string part_;
13754  string hl_;
13755  bool _have_hl_ : 1;
13756  DISALLOW_COPY_AND_ASSIGN(VideoAbuseReportReasonsResource_ListMethod);
13757 };
13758 
13759 
13760 
13777  public:
13789  const YouTubeService* _service_,
13790  client::AuthorizationCredential* _credential_,
13791  const absl::string_view& part);
13792 
13797 
13798 
13802  void clear_hl() {
13803  _have_hl_ = false;
13804  client::ClearCppValueHelper(&hl_);
13805  }
13806 
13807 
13813  const string& get_hl() const { return hl_; }
13814 
13820  string* mutable_hl() {
13821  _have_hl_ = true;
13822  return &hl_;
13823  }
13824 
13825 
13832  void set_hl(const string& value) {
13833  _have_hl_ = true;
13834  hl_ = value;
13835  }
13836 
13837 
13838 
13842  void clear_id() {
13843  _have_id_ = false;
13844  client::ClearCppValueHelper(&id_);
13845  }
13846 
13847 
13853  const string& get_id() const { return id_; }
13854 
13860  string* mutable_id() {
13861  _have_id_ = true;
13862  return &id_;
13863  }
13864 
13865 
13872  void set_id(const string& value) {
13873  _have_id_ = true;
13874  id_ = value;
13875  }
13876 
13877 
13878 
13883  _have_region_code_ = false;
13884  client::ClearCppValueHelper(&region_code_);
13885  }
13886 
13887 
13893  const string& get_region_code() const { return region_code_; }
13894 
13902  _have_region_code_ = true;
13903  return &region_code_;
13904  }
13905 
13906 
13914  void set_region_code(const string& value) {
13915  _have_region_code_ = true;
13916  region_code_ = value;
13917  }
13918 
13928  virtual util::Status AppendVariable(
13929  const StringPiece& variable_name,
13930  const client::UriTemplateConfig& config,
13931  string* target);
13932 
13938  virtual util::Status AppendOptionalQueryParameters(string* target);
13939 
13940 
13952  VideoCategoryListResponse* data) {
13953  return YouTubeServiceBaseRequest::ExecuteAndParseResponse(data);
13954  }
13955 
13956  private:
13957  string part_;
13958  string hl_;
13959  string id_;
13960  string region_code_;
13961  bool _have_hl_ : 1;
13962  bool _have_id_ : 1;
13963  bool _have_region_code_ : 1;
13964  DISALLOW_COPY_AND_ASSIGN(VideoCategoriesResource_ListMethod);
13965 };
13966 
13967 
13968 
13984  public:
13996  const YouTubeService* _service_,
13997  client::AuthorizationCredential* _credential_,
13998  const absl::string_view& id);
13999 
14003  virtual ~VideosResource_DeleteMethod();
14004 
14005 
14011  _have_on_behalf_of_content_owner_ = false;
14012  client::ClearCppValueHelper(&on_behalf_of_content_owner_);
14013  }
14014 
14015 
14021  const string& get_on_behalf_of_content_owner() const { return on_behalf_of_content_owner_; }
14022 
14030  _have_on_behalf_of_content_owner_ = true;
14031  return &on_behalf_of_content_owner_;
14032  }
14033 
14034 
14051  void set_on_behalf_of_content_owner(const string& value) {
14052  _have_on_behalf_of_content_owner_ = true;
14053  on_behalf_of_content_owner_ = value;
14054  }
14055 
14065  virtual util::Status AppendVariable(
14066  const StringPiece& variable_name,
14067  const client::UriTemplateConfig& config,
14068  string* target);
14069 
14075  virtual util::Status AppendOptionalQueryParameters(string* target);
14076 
14077 
14078  private:
14079  string id_;
14080  string on_behalf_of_content_owner_;
14081  bool _have_on_behalf_of_content_owner_ : 1;
14082  DISALLOW_COPY_AND_ASSIGN(VideosResource_DeleteMethod);
14083 };
14084 
14100  public:
14112  const YouTubeService* _service_,
14113  client::AuthorizationCredential* _credential_,
14114  const absl::string_view& id);
14115 
14119  virtual ~VideosResource_GetRatingMethod();
14120 
14121 
14127  _have_on_behalf_of_content_owner_ = false;
14128  client::ClearCppValueHelper(&on_behalf_of_content_owner_);
14129  }
14130 
14131 
14137  const string& get_on_behalf_of_content_owner() const { return on_behalf_of_content_owner_; }
14138 
14146  _have_on_behalf_of_content_owner_ = true;
14147  return &on_behalf_of_content_owner_;
14148  }
14149 
14150 
14167  void set_on_behalf_of_content_owner(const string& value) {
14168  _have_on_behalf_of_content_owner_ = true;
14169  on_behalf_of_content_owner_ = value;
14170  }
14171 
14181  virtual util::Status AppendVariable(
14182  const StringPiece& variable_name,
14183  const client::UriTemplateConfig& config,
14184  string* target);
14185 
14191  virtual util::Status AppendOptionalQueryParameters(string* target);
14192 
14193 
14205  VideoGetRatingResponse* data) {
14206  return YouTubeServiceBaseRequest::ExecuteAndParseResponse(data);
14207  }
14208 
14209  private:
14210  string id_;
14211  string on_behalf_of_content_owner_;
14212  bool _have_on_behalf_of_content_owner_ : 1;
14213  DISALLOW_COPY_AND_ASSIGN(VideosResource_GetRatingMethod);
14214 };
14215 
14232  public:
14256  const YouTubeService* _service_,
14257  client::AuthorizationCredential* _credential_,
14258  const absl::string_view& part);
14284  const YouTubeService* _service_,
14285  client::AuthorizationCredential* _credential_,
14286  const absl::string_view& part,
14287  const Video* _metadata_,
14288  const StringPiece& _media_content_type_,
14289  client::DataReader* _media_content_reader_);
14290 
14294  virtual ~VideosResource_InsertMethod();
14295 
14296 
14301  _have_auto_levels_ = false;
14302  client::ClearCppValueHelper(&auto_levels_);
14303  }
14304 
14305 
14311  bool get_auto_levels() const { return auto_levels_; }
14312 
14319  void set_auto_levels(bool value) {
14320  _have_auto_levels_ = true;
14321  auto_levels_ = value;
14322  }
14323 
14329  _have_notify_subscribers_ = false;
14330  client::ClearCppValueHelper(&notify_subscribers_);
14331  }
14332 
14333 
14339  bool get_notify_subscribers() const { return notify_subscribers_; }
14340 
14352  void set_notify_subscribers(bool value) {
14353  _have_notify_subscribers_ = true;
14354  notify_subscribers_ = value;
14355  }
14356 
14362  _have_on_behalf_of_content_owner_ = false;
14363  client::ClearCppValueHelper(&on_behalf_of_content_owner_);
14364  }
14365 
14366 
14372  const string& get_on_behalf_of_content_owner() const { return on_behalf_of_content_owner_; }
14373 
14381  _have_on_behalf_of_content_owner_ = true;
14382  return &on_behalf_of_content_owner_;
14383  }
14384 
14385 
14402  void set_on_behalf_of_content_owner(const string& value) {
14403  _have_on_behalf_of_content_owner_ = true;
14404  on_behalf_of_content_owner_ = value;
14405  }
14406 
14407 
14408 
14414  _have_on_behalf_of_content_owner_channel_ = false;
14415  client::ClearCppValueHelper(&on_behalf_of_content_owner_channel_);
14416  }
14417 
14418 
14424  const string& get_on_behalf_of_content_owner_channel() const { return on_behalf_of_content_owner_channel_; }
14425 
14433  _have_on_behalf_of_content_owner_channel_ = true;
14434  return &on_behalf_of_content_owner_channel_;
14435  }
14436 
14437 
14461  void set_on_behalf_of_content_owner_channel(const string& value) {
14462  _have_on_behalf_of_content_owner_channel_ = true;
14463  on_behalf_of_content_owner_channel_ = value;
14464  }
14465 
14466 
14467 
14472  _have_stabilize_ = false;
14473  client::ClearCppValueHelper(&stabilize_);
14474  }
14475 
14476 
14482  bool get_stabilize() const { return stabilize_; }
14483 
14490  void set_stabilize(bool value) {
14491  _have_stabilize_ = true;
14492  stabilize_ = value;
14493  }
14494 
14504  virtual util::Status AppendVariable(
14505  const StringPiece& variable_name,
14506  const client::UriTemplateConfig& config,
14507  string* target);
14508 
14514  virtual util::Status AppendOptionalQueryParameters(string* target);
14515 
14516 
14528  Video* data) {
14529  return YouTubeServiceBaseRequest::ExecuteAndParseResponse(data);
14530  }
14531 
14532 
14540  static const client::MediaUploadSpec SIMPLE_MEDIA_UPLOAD;
14544  static const client::MediaUploadSpec RESUMABLE_MEDIA_UPLOAD;
14545 
14546  private:
14547  string part_;
14548  bool auto_levels_;
14549  bool notify_subscribers_;
14550  string on_behalf_of_content_owner_;
14551  string on_behalf_of_content_owner_channel_;
14552  bool stabilize_;
14553  bool _have_auto_levels_ : 1;
14554  bool _have_notify_subscribers_ : 1;
14555  bool _have_on_behalf_of_content_owner_ : 1;
14556  bool _have_on_behalf_of_content_owner_channel_ : 1;
14557  bool _have_stabilize_ : 1;
14558  DISALLOW_COPY_AND_ASSIGN(VideosResource_InsertMethod);
14559 };
14560 
14577  public:
14594  const YouTubeService* _service_,
14595  client::AuthorizationCredential* _credential_,
14596  const absl::string_view& part);
14597 
14601  virtual ~VideosResource_ListMethod();
14602 
14603 
14607  void clear_chart() {
14608  _have_chart_ = false;
14609  client::ClearCppValueHelper(&chart_);
14610  }
14611 
14612 
14618  const string& get_chart() const { return chart_; }
14619 
14625  string* mutable_chart() {
14626  _have_chart_ = true;
14627  return &chart_;
14628  }
14629 
14630 
14637  void set_chart(const string& value) {
14638  _have_chart_ = true;
14639  chart_ = value;
14640  }
14641 
14642 
14643 
14647  void clear_hl() {
14648  _have_hl_ = false;
14649  client::ClearCppValueHelper(&hl_);
14650  }
14651 
14652 
14658  const string& get_hl() const { return hl_; }
14659 
14665  string* mutable_hl() {
14666  _have_hl_ = true;
14667  return &hl_;
14668  }
14669 
14670 
14684  void set_hl(const string& value) {
14685  _have_hl_ = true;
14686  hl_ = value;
14687  }
14688 
14689 
14690 
14694  void clear_id() {
14695  _have_id_ = false;
14696  client::ClearCppValueHelper(&id_);
14697  }
14698 
14699 
14705  const string& get_id() const { return id_; }
14706 
14712  string* mutable_id() {
14713  _have_id_ = true;
14714  return &id_;
14715  }
14716 
14717 
14725  void set_id(const string& value) {
14726  _have_id_ = true;
14727  id_ = value;
14728  }
14729 
14730 
14731 
14735  void clear_locale() {
14736  _have_locale_ = false;
14737  client::ClearCppValueHelper(&locale_);
14738  }
14739 
14740 
14746  const string& get_locale() const { return locale_; }
14747 
14753  string* mutable_locale() {
14754  _have_locale_ = true;
14755  return &locale_;
14756  }
14757 
14758 
14765  void set_locale(const string& value) {
14766  _have_locale_ = true;
14767  locale_ = value;
14768  }
14769 
14770 
14771 
14776  _have_max_height_ = false;
14777  client::ClearCppValueHelper(&max_height_);
14778  }
14779 
14780 
14786  uint32 get_max_height() const { return max_height_; }
14787 
14795  void set_max_height(uint32 value) {
14796  _have_max_height_ = true;
14797  max_height_ = value;
14798  }
14799 
14804  _have_max_results_ = false;
14805  client::ClearCppValueHelper(&max_results_);
14806  }
14807 
14808 
14814  uint32 get_max_results() const { return max_results_; }
14815 
14826  void set_max_results(uint32 value) {
14827  _have_max_results_ = true;
14828  max_results_ = value;
14829  }
14830 
14835  _have_max_width_ = false;
14836  client::ClearCppValueHelper(&max_width_);
14837  }
14838 
14839 
14845  uint32 get_max_width() const { return max_width_; }
14846 
14854  void set_max_width(uint32 value) {
14855  _have_max_width_ = true;
14856  max_width_ = value;
14857  }
14858 
14863  _have_my_rating_ = false;
14864  client::ClearCppValueHelper(&my_rating_);
14865  }
14866 
14867 
14873  const string& get_my_rating() const { return my_rating_; }
14874 
14881  string* mutable_myRating() {
14882  _have_my_rating_ = true;
14883  return &my_rating_;
14884  }
14885 
14886 
14894  void set_my_rating(const string& value) {
14895  _have_my_rating_ = true;
14896  my_rating_ = value;
14897  }
14898 
14899 
14900 
14906  _have_on_behalf_of_content_owner_ = false;
14907  client::ClearCppValueHelper(&on_behalf_of_content_owner_);
14908  }
14909 
14910 
14916  const string& get_on_behalf_of_content_owner() const { return on_behalf_of_content_owner_; }
14917 
14925  _have_on_behalf_of_content_owner_ = true;
14926  return &on_behalf_of_content_owner_;
14927  }
14928 
14929 
14946  void set_on_behalf_of_content_owner(const string& value) {
14947  _have_on_behalf_of_content_owner_ = true;
14948  on_behalf_of_content_owner_ = value;
14949  }
14950 
14951 
14952 
14957  _have_page_token_ = false;
14958  client::ClearCppValueHelper(&page_token_);
14959  }
14960 
14961 
14967  const string& get_page_token() const { return page_token_; }
14968 
14975  string* mutable_pageToken() {
14976  _have_page_token_ = true;
14977  return &page_token_;
14978  }
14979 
14980 
14993  void set_page_token(const string& value) {
14994  _have_page_token_ = true;
14995  page_token_ = value;
14996  }
14997 
14998 
14999 
15004  _have_region_code_ = false;
15005  client::ClearCppValueHelper(&region_code_);
15006  }
15007 
15008 
15014  const string& get_region_code() const { return region_code_; }
15015 
15023  _have_region_code_ = true;
15024  return &region_code_;
15025  }
15026 
15027 
15036  void set_region_code(const string& value) {
15037  _have_region_code_ = true;
15038  region_code_ = value;
15039  }
15040 
15041 
15042 
15048  _have_video_category_id_ = false;
15049  client::ClearCppValueHelper(&video_category_id_);
15050  }
15051 
15052 
15058  const string& get_video_category_id() const { return video_category_id_; }
15059 
15067  _have_video_category_id_ = true;
15068  return &video_category_id_;
15069  }
15070 
15071 
15080  void set_video_category_id(const string& value) {
15081  _have_video_category_id_ = true;
15082  video_category_id_ = value;
15083  }
15084 
15094  virtual util::Status AppendVariable(
15095  const StringPiece& variable_name,
15096  const client::UriTemplateConfig& config,
15097  string* target);
15098 
15104  virtual util::Status AppendOptionalQueryParameters(string* target);
15105 
15106 
15118  VideoListResponse* data) {
15119  return YouTubeServiceBaseRequest::ExecuteAndParseResponse(data);
15120  }
15121 
15122  private:
15123  string part_;
15124  string chart_;
15125  string hl_;
15126  string id_;
15127  string locale_;
15128  uint32 max_height_;
15129  uint32 max_results_;
15130  uint32 max_width_;
15131  string my_rating_;
15132  string on_behalf_of_content_owner_;
15133  string page_token_;
15134  string region_code_;
15135  string video_category_id_;
15136  bool _have_chart_ : 1;
15137  bool _have_hl_ : 1;
15138  bool _have_id_ : 1;
15139  bool _have_locale_ : 1;
15140  bool _have_max_height_ : 1;
15141  bool _have_max_results_ : 1;
15142  bool _have_max_width_ : 1;
15143  bool _have_my_rating_ : 1;
15144  bool _have_on_behalf_of_content_owner_ : 1;
15145  bool _have_page_token_ : 1;
15146  bool _have_region_code_ : 1;
15147  bool _have_video_category_id_ : 1;
15148  DISALLOW_COPY_AND_ASSIGN(VideosResource_ListMethod);
15149 };
15150 
15151 typedef client::ServiceRequestPager<
15154  VideosResource_ListMethodPager;
15155 
15171  public:
15183  const YouTubeService* _service_,
15184  client::AuthorizationCredential* _credential_,
15185  const absl::string_view& id,
15186  const absl::string_view& rating);
15187 
15191  virtual ~VideosResource_RateMethod();
15192 
15193 
15203  virtual util::Status AppendVariable(
15204  const StringPiece& variable_name,
15205  const client::UriTemplateConfig& config,
15206  string* target);
15207 
15213  virtual util::Status AppendOptionalQueryParameters(string* target);
15214 
15215 
15216  private:
15217  string id_;
15218  string rating_;
15219  DISALLOW_COPY_AND_ASSIGN(VideosResource_RateMethod);
15220 };
15221 
15237  public:
15247  const YouTubeService* _service_,
15248  client::AuthorizationCredential* _credential_,
15249  const VideoAbuseReport& _content_);
15250 
15255 
15256 
15262  _have_on_behalf_of_content_owner_ = false;
15263  client::ClearCppValueHelper(&on_behalf_of_content_owner_);
15264  }
15265 
15266 
15272  const string& get_on_behalf_of_content_owner() const { return on_behalf_of_content_owner_; }
15273 
15281  _have_on_behalf_of_content_owner_ = true;
15282  return &on_behalf_of_content_owner_;
15283  }
15284 
15285 
15302  void set_on_behalf_of_content_owner(const string& value) {
15303  _have_on_behalf_of_content_owner_ = true;
15304  on_behalf_of_content_owner_ = value;
15305  }
15306 
15316  virtual util::Status AppendVariable(
15317  const StringPiece& variable_name,
15318  const client::UriTemplateConfig& config,
15319  string* target);
15320 
15326  virtual util::Status AppendOptionalQueryParameters(string* target);
15327 
15328 
15329  private:
15330  string on_behalf_of_content_owner_;
15331  bool _have_on_behalf_of_content_owner_ : 1; string _content_;
15332  DISALLOW_COPY_AND_ASSIGN(VideosResource_ReportAbuseMethod);
15333 };
15334 
15350  public:
15380  const YouTubeService* _service_,
15381  client::AuthorizationCredential* _credential_,
15382  const absl::string_view& part,
15383  const Video& _content_);
15384 
15388  virtual ~VideosResource_UpdateMethod();
15389 
15390 
15396  _have_on_behalf_of_content_owner_ = false;
15397  client::ClearCppValueHelper(&on_behalf_of_content_owner_);
15398  }
15399 
15400 
15406  const string& get_on_behalf_of_content_owner() const { return on_behalf_of_content_owner_; }
15407 
15415  _have_on_behalf_of_content_owner_ = true;
15416  return &on_behalf_of_content_owner_;
15417  }
15418 
15419 
15436  void set_on_behalf_of_content_owner(const string& value) {
15437  _have_on_behalf_of_content_owner_ = true;
15438  on_behalf_of_content_owner_ = value;
15439  }
15440 
15450  virtual util::Status AppendVariable(
15451  const StringPiece& variable_name,
15452  const client::UriTemplateConfig& config,
15453  string* target);
15454 
15460  virtual util::Status AppendOptionalQueryParameters(string* target);
15461 
15462 
15474  Video* data) {
15475  return YouTubeServiceBaseRequest::ExecuteAndParseResponse(data);
15476  }
15477 
15478  private:
15479  string part_;
15480  string on_behalf_of_content_owner_;
15481  bool _have_on_behalf_of_content_owner_ : 1; string _content_;
15482  DISALLOW_COPY_AND_ASSIGN(VideosResource_UpdateMethod);
15483 };
15484 
15485 
15486 
15503  public:
15519  const YouTubeService* _service_,
15520  client::AuthorizationCredential* _credential_,
15521  const absl::string_view& channel_id);
15539  const YouTubeService* _service_,
15540  client::AuthorizationCredential* _credential_,
15541  const absl::string_view& channel_id,
15542  const InvideoBranding* _metadata_,
15543  const StringPiece& _media_content_type_,
15544  client::DataReader* _media_content_reader_);
15545 
15549  virtual ~WatermarksResource_SetMethod();
15550 
15551 
15557  _have_on_behalf_of_content_owner_ = false;
15558  client::ClearCppValueHelper(&on_behalf_of_content_owner_);
15559  }
15560 
15561 
15567  const string& get_on_behalf_of_content_owner() const { return on_behalf_of_content_owner_; }
15568 
15576  _have_on_behalf_of_content_owner_ = true;
15577  return &on_behalf_of_content_owner_;
15578  }
15579 
15580 
15597  void set_on_behalf_of_content_owner(const string& value) {
15598  _have_on_behalf_of_content_owner_ = true;
15599  on_behalf_of_content_owner_ = value;
15600  }
15601 
15611  virtual util::Status AppendVariable(
15612  const StringPiece& variable_name,
15613  const client::UriTemplateConfig& config,
15614  string* target);
15615 
15621  virtual util::Status AppendOptionalQueryParameters(string* target);
15622 
15623 
15624 
15632  static const client::MediaUploadSpec SIMPLE_MEDIA_UPLOAD;
15636  static const client::MediaUploadSpec RESUMABLE_MEDIA_UPLOAD;
15637 
15638  private:
15639  string channel_id_;
15640  string on_behalf_of_content_owner_;
15641  bool _have_on_behalf_of_content_owner_ : 1;
15642  DISALLOW_COPY_AND_ASSIGN(WatermarksResource_SetMethod);
15643 };
15644 
15660  public:
15671  const YouTubeService* _service_,
15672  client::AuthorizationCredential* _credential_,
15673  const absl::string_view& channel_id);
15674 
15678  virtual ~WatermarksResource_UnsetMethod();
15679 
15680 
15686  _have_on_behalf_of_content_owner_ = false;
15687  client::ClearCppValueHelper(&on_behalf_of_content_owner_);
15688  }
15689 
15690 
15696  const string& get_on_behalf_of_content_owner() const { return on_behalf_of_content_owner_; }
15697 
15705  _have_on_behalf_of_content_owner_ = true;
15706  return &on_behalf_of_content_owner_;
15707  }
15708 
15709 
15726  void set_on_behalf_of_content_owner(const string& value) {
15727  _have_on_behalf_of_content_owner_ = true;
15728  on_behalf_of_content_owner_ = value;
15729  }
15730 
15740  virtual util::Status AppendVariable(
15741  const StringPiece& variable_name,
15742  const client::UriTemplateConfig& config,
15743  string* target);
15744 
15750  virtual util::Status AppendOptionalQueryParameters(string* target);
15751 
15752 
15753  private:
15754  string channel_id_;
15755  string on_behalf_of_content_owner_;
15756  bool _have_on_behalf_of_content_owner_ : 1;
15757  DISALLOW_COPY_AND_ASSIGN(WatermarksResource_UnsetMethod);
15758 };
15759 
15760 
15761 
15770 class YouTubeService : public client::ClientService {
15771  public:
15775  static const char googleapis_API_NAME[];
15776 
15780  static const char googleapis_API_VERSION[];
15781 
15785  static const char googleapis_API_GENERATOR[];
15786 
15787 
15794  public:
15802  explicit ActivitiesResource(YouTubeService* service);
15803 
15808 
15809 
15822  ActivitiesResource_InsertMethod* NewInsertMethod(
15823  client::AuthorizationCredential* _credential_,
15824  const absl::string_view& part,
15825  const Activity& _content_) const;
15826 
15845  ActivitiesResource_ListMethod* NewListMethod(
15846  client::AuthorizationCredential* _credential_,
15847  const absl::string_view& part) const;
15848 
15866  ActivitiesResource_ListMethodPager* NewListMethodPager(
15867  client::AuthorizationCredential* _credential_,
15868  const absl::string_view& part) const;
15869 
15870  private:
15871  YouTubeService* service_;
15872 
15873  DISALLOW_COPY_AND_ASSIGN(ActivitiesResource);
15874  };
15875 
15882  public:
15890  explicit CaptionsResource(YouTubeService* service);
15891 
15896 
15897 
15909  CaptionsResource_DeleteMethod* NewDeleteMethod(
15910  client::AuthorizationCredential* _credential_,
15911  const absl::string_view& id) const;
15912 
15924  CaptionsResource_DownloadMethod* NewDownloadMethod(
15925  client::AuthorizationCredential* _credential_,
15926  const absl::string_view& id) const;
15927 
15928 
15941  CaptionsResource_InsertMethod* NewInsertMethod(
15942  client::AuthorizationCredential* _credential_,
15943  const absl::string_view& part) const;
15944 
15962  CaptionsResource_InsertMethod* NewInsertMethod(
15963  client::AuthorizationCredential* _credential_,
15964  const absl::string_view& part,
15965  const Caption* _metadata_,
15966  const StringPiece& _media_content_type_,
15967  client::DataReader* _media_content_reader_) const;
15968 
15983  CaptionsResource_ListMethod* NewListMethod(
15984  client::AuthorizationCredential* _credential_,
15985  const absl::string_view& part,
15986  const absl::string_view& video_id) const;
15987 
15988 
16004  CaptionsResource_UpdateMethod* NewUpdateMethod(
16005  client::AuthorizationCredential* _credential_,
16006  const absl::string_view& part) const;
16007 
16028  CaptionsResource_UpdateMethod* NewUpdateMethod(
16029  client::AuthorizationCredential* _credential_,
16030  const absl::string_view& part,
16031  const Caption* _metadata_,
16032  const StringPiece& _media_content_type_,
16033  client::DataReader* _media_content_reader_) const;
16034 
16035  private:
16036  YouTubeService* service_;
16037 
16038  DISALLOW_COPY_AND_ASSIGN(CaptionsResource);
16039  };
16040 
16047  public:
16055  explicit ChannelBannersResource(YouTubeService* service);
16056 
16061 
16062 
16063 
16074  ChannelBannersResource_InsertMethod* NewInsertMethod(
16075  client::AuthorizationCredential* _credential_) const;
16076 
16092  ChannelBannersResource_InsertMethod* NewInsertMethod(
16093  client::AuthorizationCredential* _credential_,
16094  const ChannelBannerResource* _metadata_,
16095  const StringPiece& _media_content_type_,
16096  client::DataReader* _media_content_reader_) const;
16097 
16098  private:
16099  YouTubeService* service_;
16100 
16101  DISALLOW_COPY_AND_ASSIGN(ChannelBannersResource);
16102  };
16103 
16110  public:
16118  explicit ChannelSectionsResource(YouTubeService* service);
16119 
16124 
16125 
16137  ChannelSectionsResource_DeleteMethod* NewDeleteMethod(
16138  client::AuthorizationCredential* _credential_,
16139  const absl::string_view& id) const;
16140 
16156  ChannelSectionsResource_InsertMethod* NewInsertMethod(
16157  client::AuthorizationCredential* _credential_,
16158  const absl::string_view& part,
16159  const ChannelSection& _content_) const;
16160 
16179  ChannelSectionsResource_ListMethod* NewListMethod(
16180  client::AuthorizationCredential* _credential_,
16181  const absl::string_view& part) const;
16182 
16198  ChannelSectionsResource_UpdateMethod* NewUpdateMethod(
16199  client::AuthorizationCredential* _credential_,
16200  const absl::string_view& part,
16201  const ChannelSection& _content_) const;
16202 
16203  private:
16204  YouTubeService* service_;
16205 
16206  DISALLOW_COPY_AND_ASSIGN(ChannelSectionsResource);
16207  };
16208 
16215  public:
16223  explicit ChannelsResource(YouTubeService* service);
16224 
16229 
16230 
16248  ChannelsResource_ListMethod* NewListMethod(
16249  client::AuthorizationCredential* _credential_,
16250  const absl::string_view& part) const;
16251 
16268  ChannelsResource_ListMethodPager* NewListMethodPager(
16269  client::AuthorizationCredential* _credential_,
16270  const absl::string_view& part) const;
16271 
16292  ChannelsResource_UpdateMethod* NewUpdateMethod(
16293  client::AuthorizationCredential* _credential_,
16294  const absl::string_view& part,
16295  const Channel& _content_) const;
16296 
16297  private:
16298  YouTubeService* service_;
16299 
16300  DISALLOW_COPY_AND_ASSIGN(ChannelsResource);
16301  };
16302 
16309  public:
16317  explicit CommentThreadsResource(YouTubeService* service);
16318 
16323 
16324 
16337  CommentThreadsResource_InsertMethod* NewInsertMethod(
16338  client::AuthorizationCredential* _credential_,
16339  const absl::string_view& part,
16340  const CommentThread& _content_) const;
16341 
16353  CommentThreadsResource_ListMethod* NewListMethod(
16354  client::AuthorizationCredential* _credential_,
16355  const absl::string_view& part) const;
16356 
16367  CommentThreadsResource_ListMethodPager* NewListMethodPager(
16368  client::AuthorizationCredential* _credential_,
16369  const absl::string_view& part) const;
16370 
16384  CommentThreadsResource_UpdateMethod* NewUpdateMethod(
16385  client::AuthorizationCredential* _credential_,
16386  const absl::string_view& part,
16387  const CommentThread& _content_) const;
16388 
16389  private:
16390  YouTubeService* service_;
16391 
16392  DISALLOW_COPY_AND_ASSIGN(CommentThreadsResource);
16393  };
16394 
16401  public:
16409  explicit CommentsResource(YouTubeService* service);
16410 
16415 
16416 
16427  CommentsResource_DeleteMethod* NewDeleteMethod(
16428  client::AuthorizationCredential* _credential_,
16429  const absl::string_view& id) const;
16430 
16443  CommentsResource_InsertMethod* NewInsertMethod(
16444  client::AuthorizationCredential* _credential_,
16445  const absl::string_view& part,
16446  const Comment& _content_) const;
16447 
16459  CommentsResource_ListMethod* NewListMethod(
16460  client::AuthorizationCredential* _credential_,
16461  const absl::string_view& part) const;
16462 
16473  CommentsResource_ListMethodPager* NewListMethodPager(
16474  client::AuthorizationCredential* _credential_,
16475  const absl::string_view& part) const;
16476 
16487  CommentsResource_MarkAsSpamMethod* NewMarkAsSpamMethod(
16488  client::AuthorizationCredential* _credential_,
16489  const absl::string_view& id) const;
16490 
16504  CommentsResource_SetModerationStatusMethod* NewSetModerationStatusMethod(
16505  client::AuthorizationCredential* _credential_,
16506  const absl::string_view& id,
16507  const absl::string_view& moderation_status) const;
16508 
16522  CommentsResource_UpdateMethod* NewUpdateMethod(
16523  client::AuthorizationCredential* _credential_,
16524  const absl::string_view& part,
16525  const Comment& _content_) const;
16526 
16527  private:
16528  YouTubeService* service_;
16529 
16530  DISALLOW_COPY_AND_ASSIGN(CommentsResource);
16531  };
16532 
16539  public:
16547  explicit GuideCategoriesResource(YouTubeService* service);
16548 
16553 
16554 
16566  GuideCategoriesResource_ListMethod* NewListMethod(
16567  client::AuthorizationCredential* _credential_,
16568  const absl::string_view& part) const;
16569 
16570  private:
16571  YouTubeService* service_;
16572 
16573  DISALLOW_COPY_AND_ASSIGN(GuideCategoriesResource);
16574  };
16575 
16582  public:
16590  explicit I18nLanguagesResource(YouTubeService* service);
16591 
16596 
16597 
16609  I18nLanguagesResource_ListMethod* NewListMethod(
16610  client::AuthorizationCredential* _credential_,
16611  const absl::string_view& part) const;
16612 
16613  private:
16614  YouTubeService* service_;
16615 
16616  DISALLOW_COPY_AND_ASSIGN(I18nLanguagesResource);
16617  };
16618 
16625  public:
16633  explicit I18nRegionsResource(YouTubeService* service);
16634 
16639 
16640 
16652  I18nRegionsResource_ListMethod* NewListMethod(
16653  client::AuthorizationCredential* _credential_,
16654  const absl::string_view& part) const;
16655 
16656  private:
16657  YouTubeService* service_;
16658 
16659  DISALLOW_COPY_AND_ASSIGN(I18nRegionsResource);
16660  };
16661 
16668  public:
16676  explicit LiveBroadcastsResource(YouTubeService* service);
16677 
16682 
16683 
16698  LiveBroadcastsResource_BindMethod* NewBindMethod(
16699  client::AuthorizationCredential* _credential_,
16700  const absl::string_view& id,
16701  const absl::string_view& part) const;
16702 
16718  LiveBroadcastsResource_ControlMethod* NewControlMethod(
16719  client::AuthorizationCredential* _credential_,
16720  const absl::string_view& id,
16721  const absl::string_view& part) const;
16722 
16733  LiveBroadcastsResource_DeleteMethod* NewDeleteMethod(
16734  client::AuthorizationCredential* _credential_,
16735  const absl::string_view& id) const;
16736 
16752  LiveBroadcastsResource_InsertMethod* NewInsertMethod(
16753  client::AuthorizationCredential* _credential_,
16754  const absl::string_view& part,
16755  const LiveBroadcast& _content_) const;
16756 
16769  LiveBroadcastsResource_ListMethod* NewListMethod(
16770  client::AuthorizationCredential* _credential_,
16771  const absl::string_view& part) const;
16772 
16784  LiveBroadcastsResource_ListMethodPager* NewListMethodPager(
16785  client::AuthorizationCredential* _credential_,
16786  const absl::string_view& part) const;
16787 
16806  LiveBroadcastsResource_TransitionMethod* NewTransitionMethod(
16807  client::AuthorizationCredential* _credential_,
16808  const absl::string_view& broadcast_status,
16809  const absl::string_view& id,
16810  const absl::string_view& part) const;
16811 
16837  LiveBroadcastsResource_UpdateMethod* NewUpdateMethod(
16838  client::AuthorizationCredential* _credential_,
16839  const absl::string_view& part,
16840  const LiveBroadcast& _content_) const;
16841 
16842  private:
16843  YouTubeService* service_;
16844 
16845  DISALLOW_COPY_AND_ASSIGN(LiveBroadcastsResource);
16846  };
16847 
16854  public:
16862  explicit LiveChatBansResource(YouTubeService* service);
16863 
16868 
16869 
16880  LiveChatBansResource_DeleteMethod* NewDeleteMethod(
16881  client::AuthorizationCredential* _credential_,
16882  const absl::string_view& id) const;
16883 
16897  LiveChatBansResource_InsertMethod* NewInsertMethod(
16898  client::AuthorizationCredential* _credential_,
16899  const absl::string_view& part,
16900  const LiveChatBan& _content_) const;
16901 
16902  private:
16903  YouTubeService* service_;
16904 
16905  DISALLOW_COPY_AND_ASSIGN(LiveChatBansResource);
16906  };
16907 
16914  public:
16922  explicit LiveChatMessagesResource(YouTubeService* service);
16923 
16928 
16929 
16940  LiveChatMessagesResource_DeleteMethod* NewDeleteMethod(
16941  client::AuthorizationCredential* _credential_,
16942  const absl::string_view& id) const;
16943 
16956  LiveChatMessagesResource_InsertMethod* NewInsertMethod(
16957  client::AuthorizationCredential* _credential_,
16958  const absl::string_view& part,
16959  const LiveChatMessage& _content_) const;
16960 
16974  LiveChatMessagesResource_ListMethod* NewListMethod(
16975  client::AuthorizationCredential* _credential_,
16976  const absl::string_view& live_chat_id,
16977  const absl::string_view& part) const;
16978 
16992  LiveChatMessagesResource_ListMethodPager* NewListMethodPager(
16993  client::AuthorizationCredential* _credential_,
16994  const absl::string_view& live_chat_id,
16995  const absl::string_view& part) const;
16996 
16997  private:
16998  YouTubeService* service_;
16999 
17000  DISALLOW_COPY_AND_ASSIGN(LiveChatMessagesResource);
17001  };
17002 
17009  public:
17017  explicit LiveChatModeratorsResource(YouTubeService* service);
17018 
17023 
17024 
17035  LiveChatModeratorsResource_DeleteMethod* NewDeleteMethod(
17036  client::AuthorizationCredential* _credential_,
17037  const absl::string_view& id) const;
17038 
17052  LiveChatModeratorsResource_InsertMethod* NewInsertMethod(
17053  client::AuthorizationCredential* _credential_,
17054  const absl::string_view& part,
17055  const LiveChatModerator& _content_) const;
17056 
17070  LiveChatModeratorsResource_ListMethod* NewListMethod(
17071  client::AuthorizationCredential* _credential_,
17072  const absl::string_view& live_chat_id,
17073  const absl::string_view& part) const;
17074 
17088  LiveChatModeratorsResource_ListMethodPager* NewListMethodPager(
17089  client::AuthorizationCredential* _credential_,
17090  const absl::string_view& live_chat_id,
17091  const absl::string_view& part) const;
17092 
17093  private:
17094  YouTubeService* service_;
17095 
17096  DISALLOW_COPY_AND_ASSIGN(LiveChatModeratorsResource);
17097  };
17098 
17105  public:
17113  explicit LiveStreamsResource(YouTubeService* service);
17114 
17119 
17120 
17131  LiveStreamsResource_DeleteMethod* NewDeleteMethod(
17132  client::AuthorizationCredential* _credential_,
17133  const absl::string_view& id) const;
17134 
17150  LiveStreamsResource_InsertMethod* NewInsertMethod(
17151  client::AuthorizationCredential* _credential_,
17152  const absl::string_view& part,
17153  const LiveStream& _content_) const;
17154 
17167  LiveStreamsResource_ListMethod* NewListMethod(
17168  client::AuthorizationCredential* _credential_,
17169  const absl::string_view& part) const;
17170 
17182  LiveStreamsResource_ListMethodPager* NewListMethodPager(
17183  client::AuthorizationCredential* _credential_,
17184  const absl::string_view& part) const;
17185 
17206  LiveStreamsResource_UpdateMethod* NewUpdateMethod(
17207  client::AuthorizationCredential* _credential_,
17208  const absl::string_view& part,
17209  const LiveStream& _content_) const;
17210 
17211  private:
17212  YouTubeService* service_;
17213 
17214  DISALLOW_COPY_AND_ASSIGN(LiveStreamsResource);
17215  };
17216 
17223  public:
17231  explicit MembersResource(YouTubeService* service);
17232 
17237 
17238 
17249  MembersResource_ListMethod* NewListMethod(
17250  client::AuthorizationCredential* _credential_,
17251  const absl::string_view& part) const;
17252 
17262  MembersResource_ListMethodPager* NewListMethodPager(
17263  client::AuthorizationCredential* _credential_,
17264  const absl::string_view& part) const;
17265 
17266  private:
17267  YouTubeService* service_;
17268 
17269  DISALLOW_COPY_AND_ASSIGN(MembersResource);
17270  };
17271 
17278  public:
17286  explicit MembershipsLevelsResource(YouTubeService* service);
17287 
17292 
17293 
17305  MembershipsLevelsResource_ListMethod* NewListMethod(
17306  client::AuthorizationCredential* _credential_,
17307  const absl::string_view& part) const;
17308 
17309  private:
17310  YouTubeService* service_;
17311 
17312  DISALLOW_COPY_AND_ASSIGN(MembershipsLevelsResource);
17313  };
17314 
17321  public:
17329  explicit PlaylistItemsResource(YouTubeService* service);
17330 
17335 
17336 
17348  PlaylistItemsResource_DeleteMethod* NewDeleteMethod(
17349  client::AuthorizationCredential* _credential_,
17350  const absl::string_view& id) const;
17351 
17364  PlaylistItemsResource_InsertMethod* NewInsertMethod(
17365  client::AuthorizationCredential* _credential_,
17366  const absl::string_view& part,
17367  const PlaylistItem& _content_) const;
17368 
17387  PlaylistItemsResource_ListMethod* NewListMethod(
17388  client::AuthorizationCredential* _credential_,
17389  const absl::string_view& part) const;
17390 
17408  PlaylistItemsResource_ListMethodPager* NewListMethodPager(
17409  client::AuthorizationCredential* _credential_,
17410  const absl::string_view& part) const;
17411 
17436  PlaylistItemsResource_UpdateMethod* NewUpdateMethod(
17437  client::AuthorizationCredential* _credential_,
17438  const absl::string_view& part,
17439  const PlaylistItem& _content_) const;
17440 
17441  private:
17442  YouTubeService* service_;
17443 
17444  DISALLOW_COPY_AND_ASSIGN(PlaylistItemsResource);
17445  };
17446 
17453  public:
17461  explicit PlaylistsResource(YouTubeService* service);
17462 
17467 
17468 
17480  PlaylistsResource_DeleteMethod* NewDeleteMethod(
17481  client::AuthorizationCredential* _credential_,
17482  const absl::string_view& id) const;
17483 
17496  PlaylistsResource_InsertMethod* NewInsertMethod(
17497  client::AuthorizationCredential* _credential_,
17498  const absl::string_view& part,
17499  const Playlist& _content_) const;
17500 
17518  PlaylistsResource_ListMethod* NewListMethod(
17519  client::AuthorizationCredential* _credential_,
17520  const absl::string_view& part) const;
17521 
17538  PlaylistsResource_ListMethodPager* NewListMethodPager(
17539  client::AuthorizationCredential* _credential_,
17540  const absl::string_view& part) const;
17541 
17561  PlaylistsResource_UpdateMethod* NewUpdateMethod(
17562  client::AuthorizationCredential* _credential_,
17563  const absl::string_view& part,
17564  const Playlist& _content_) const;
17565 
17566  private:
17567  YouTubeService* service_;
17568 
17569  DISALLOW_COPY_AND_ASSIGN(PlaylistsResource);
17570  };
17571 
17578  public:
17586  explicit SearchResource(YouTubeService* service);
17587 
17592 
17593 
17605  SearchResource_ListMethod* NewListMethod(
17606  client::AuthorizationCredential* _credential_,
17607  const absl::string_view& part) const;
17608 
17619  SearchResource_ListMethodPager* NewListMethodPager(
17620  client::AuthorizationCredential* _credential_,
17621  const absl::string_view& part) const;
17622 
17623  private:
17624  YouTubeService* service_;
17625 
17626  DISALLOW_COPY_AND_ASSIGN(SearchResource);
17627  };
17628 
17635  public:
17643  explicit SponsorsResource(YouTubeService* service);
17644 
17649 
17650 
17661  SponsorsResource_ListMethod* NewListMethod(
17662  client::AuthorizationCredential* _credential_,
17663  const absl::string_view& part) const;
17664 
17674  SponsorsResource_ListMethodPager* NewListMethodPager(
17675  client::AuthorizationCredential* _credential_,
17676  const absl::string_view& part) const;
17677 
17678  private:
17679  YouTubeService* service_;
17680 
17681  DISALLOW_COPY_AND_ASSIGN(SponsorsResource);
17682  };
17683 
17690  public:
17698  explicit SubscriptionsResource(YouTubeService* service);
17699 
17704 
17705 
17717  SubscriptionsResource_DeleteMethod* NewDeleteMethod(
17718  client::AuthorizationCredential* _credential_,
17719  const absl::string_view& id) const;
17720 
17733  SubscriptionsResource_InsertMethod* NewInsertMethod(
17734  client::AuthorizationCredential* _credential_,
17735  const absl::string_view& part,
17736  const Subscription& _content_) const;
17737 
17755  SubscriptionsResource_ListMethod* NewListMethod(
17756  client::AuthorizationCredential* _credential_,
17757  const absl::string_view& part) const;
17758 
17775  SubscriptionsResource_ListMethodPager* NewListMethodPager(
17776  client::AuthorizationCredential* _credential_,
17777  const absl::string_view& part) const;
17778 
17779  private:
17780  YouTubeService* service_;
17781 
17782  DISALLOW_COPY_AND_ASSIGN(SubscriptionsResource);
17783  };
17784 
17791  public:
17799  explicit SuperChatEventsResource(YouTubeService* service);
17800 
17805 
17806 
17818  SuperChatEventsResource_ListMethod* NewListMethod(
17819  client::AuthorizationCredential* _credential_,
17820  const absl::string_view& part) const;
17821 
17832  SuperChatEventsResource_ListMethodPager* NewListMethodPager(
17833  client::AuthorizationCredential* _credential_,
17834  const absl::string_view& part) const;
17835 
17836  private:
17837  YouTubeService* service_;
17838 
17839  DISALLOW_COPY_AND_ASSIGN(SuperChatEventsResource);
17840  };
17841 
17848  public:
17856  explicit ThumbnailsResource(YouTubeService* service);
17857 
17862 
17863 
17879  ThumbnailsResource_SetMethod* NewSetMethod(
17880  client::AuthorizationCredential* _credential_,
17881  const absl::string_view& video_id,
17882  const StringPiece& _media_content_type_,
17883  client::DataReader* _media_content_reader_) const;
17884 
17885  private:
17886  YouTubeService* service_;
17887 
17888  DISALLOW_COPY_AND_ASSIGN(ThumbnailsResource);
17889  };
17890 
17897  public:
17906 
17911 
17912 
17925  client::AuthorizationCredential* _credential_,
17926  const absl::string_view& part) const;
17927 
17928  private:
17929  YouTubeService* service_;
17930 
17931  DISALLOW_COPY_AND_ASSIGN(VideoAbuseReportReasonsResource);
17932  };
17933 
17940  public:
17948  explicit VideoCategoriesResource(YouTubeService* service);
17949 
17954 
17955 
17967  VideoCategoriesResource_ListMethod* NewListMethod(
17968  client::AuthorizationCredential* _credential_,
17969  const absl::string_view& part) const;
17970 
17971  private:
17972  YouTubeService* service_;
17973 
17974  DISALLOW_COPY_AND_ASSIGN(VideoCategoriesResource);
17975  };
17976 
17983  public:
17991  explicit VideosResource(YouTubeService* service);
17992 
17997 
17998 
18010  VideosResource_DeleteMethod* NewDeleteMethod(
18011  client::AuthorizationCredential* _credential_,
18012  const absl::string_view& id) const;
18013 
18026  VideosResource_GetRatingMethod* NewGetRatingMethod(
18027  client::AuthorizationCredential* _credential_,
18028  const absl::string_view& id) const;
18029 
18030 
18051  VideosResource_InsertMethod* NewInsertMethod(
18052  client::AuthorizationCredential* _credential_,
18053  const absl::string_view& part) const;
18054 
18080  VideosResource_InsertMethod* NewInsertMethod(
18081  client::AuthorizationCredential* _credential_,
18082  const absl::string_view& part,
18083  const Video* _metadata_,
18084  const StringPiece& _media_content_type_,
18085  client::DataReader* _media_content_reader_) const;
18086 
18103  VideosResource_ListMethod* NewListMethod(
18104  client::AuthorizationCredential* _credential_,
18105  const absl::string_view& part) const;
18106 
18122  VideosResource_ListMethodPager* NewListMethodPager(
18123  client::AuthorizationCredential* _credential_,
18124  const absl::string_view& part) const;
18125 
18137  VideosResource_RateMethod* NewRateMethod(
18138  client::AuthorizationCredential* _credential_,
18139  const absl::string_view& id,
18140  const absl::string_view& rating) const;
18141 
18151  VideosResource_ReportAbuseMethod* NewReportAbuseMethod(
18152  client::AuthorizationCredential* _credential_,
18153  const VideoAbuseReport& _content_) const;
18154 
18184  VideosResource_UpdateMethod* NewUpdateMethod(
18185  client::AuthorizationCredential* _credential_,
18186  const absl::string_view& part,
18187  const Video& _content_) const;
18188 
18189  private:
18190  YouTubeService* service_;
18191 
18192  DISALLOW_COPY_AND_ASSIGN(VideosResource);
18193  };
18194 
18201  public:
18209  explicit WatermarksResource(YouTubeService* service);
18210 
18215 
18216 
18217 
18230  WatermarksResource_SetMethod* NewSetMethod(
18231  client::AuthorizationCredential* _credential_,
18232  const absl::string_view& channel_id) const;
18233 
18251  WatermarksResource_SetMethod* NewSetMethod(
18252  client::AuthorizationCredential* _credential_,
18253  const absl::string_view& channel_id,
18254  const InvideoBranding* _metadata_,
18255  const StringPiece& _media_content_type_,
18256  client::DataReader* _media_content_reader_) const;
18257 
18268  WatermarksResource_UnsetMethod* NewUnsetMethod(
18269  client::AuthorizationCredential* _credential_,
18270  const absl::string_view& channel_id) const;
18271 
18272  private:
18273  YouTubeService* service_;
18274 
18275  DISALLOW_COPY_AND_ASSIGN(WatermarksResource);
18276  };
18277 
18278 
18279 
18286  explicit YouTubeService(client::HttpTransport* transport);
18287 
18291  virtual ~YouTubeService();
18292 
18299  return activities_;
18300  }
18301 
18302 
18309  return captions_;
18310  }
18311 
18312 
18319  return channel_banners_;
18320  }
18321 
18322 
18329  return channel_sections_;
18330  }
18331 
18332 
18339  return channels_;
18340  }
18341 
18342 
18349  return comment_threads_;
18350  }
18351 
18352 
18359  return comments_;
18360  }
18361 
18362 
18369  return guide_categories_;
18370  }
18371 
18372 
18379  return i18n_languages_;
18380  }
18381 
18382 
18389  return i18n_regions_;
18390  }
18391 
18392 
18399  return live_broadcasts_;
18400  }
18401 
18402 
18409  return live_chat_bans_;
18410  }
18411 
18412 
18419  return live_chat_messages_;
18420  }
18421 
18422 
18429  return live_chat_moderators_;
18430  }
18431 
18432 
18439  return live_streams_;
18440  }
18441 
18442 
18448  const MembersResource& get_members() const {
18449  return members_;
18450  }
18451 
18452 
18459  return memberships_levels_;
18460  }
18461 
18462 
18469  return playlist_items_;
18470  }
18471 
18472 
18479  return playlists_;
18480  }
18481 
18482 
18488  const SearchResource& get_search() const {
18489  return search_;
18490  }
18491 
18492 
18499  return sponsors_;
18500  }
18501 
18502 
18509  return subscriptions_;
18510  }
18511 
18512 
18519  return super_chat_events_;
18520  }
18521 
18522 
18529  return thumbnails_;
18530  }
18531 
18532 
18539  return video_abuse_report_reasons_;
18540  }
18541 
18542 
18549  return video_categories_;
18550  }
18551 
18552 
18558  const VideosResource& get_videos() const {
18559  return videos_;
18560  }
18561 
18562 
18569  return watermarks_;
18570  }
18571 
18578  class SCOPES {
18579  public:
18583  static const char YOUTUBE[];
18584 
18589  static const char YOUTUBE_FORCE_SSL[];
18590 
18594  static const char YOUTUBE_READONLY[];
18595 
18599  static const char YOUTUBE_UPLOAD[];
18600 
18604  static const char YOUTUBEPARTNER[];
18605 
18610  static const char YOUTUBEPARTNER_CHANNEL_AUDIT[];
18611 
18612  private:
18613  SCOPES(); // Never instantiated.
18614  ~SCOPES(); // Never instantiated.
18615  };
18616 
18617  private:
18618  ActivitiesResource activities_;
18619  CaptionsResource captions_;
18620  ChannelBannersResource channel_banners_;
18621  ChannelSectionsResource channel_sections_;
18622  ChannelsResource channels_;
18623  CommentThreadsResource comment_threads_;
18624  CommentsResource comments_;
18625  GuideCategoriesResource guide_categories_;
18626  I18nLanguagesResource i18n_languages_;
18627  I18nRegionsResource i18n_regions_;
18628  LiveBroadcastsResource live_broadcasts_;
18629  LiveChatBansResource live_chat_bans_;
18630  LiveChatMessagesResource live_chat_messages_;
18631  LiveChatModeratorsResource live_chat_moderators_;
18632  LiveStreamsResource live_streams_;
18633  MembersResource members_;
18634  MembershipsLevelsResource memberships_levels_;
18635  PlaylistItemsResource playlist_items_;
18636  PlaylistsResource playlists_;
18637  SearchResource search_;
18638  SponsorsResource sponsors_;
18639  SubscriptionsResource subscriptions_;
18640  SuperChatEventsResource super_chat_events_;
18641  ThumbnailsResource thumbnails_;
18642  VideoAbuseReportReasonsResource video_abuse_report_reasons_;
18643  VideoCategoriesResource video_categories_;
18644  VideosResource videos_;
18645  WatermarksResource watermarks_;
18646 
18647  DISALLOW_COPY_AND_ASSIGN(YouTubeService);
18648 };
18649 
18650 
18681 } // namespace google_youtube_api
18682 #endif // GOOGLE_YOUTUBE_API_YOU_TUBE_SERVICE_H_
util::Status ExecuteAndParseResponse(PlaylistItem *data)
Definition: you_tube_service.h:10106
void clear_on_behalf_of_content_owner()
Definition: you_tube_service.h:15556
string * mutable_onBehalfOfContentOwner()
Definition: you_tube_service.h:6272
const string & get_on_behalf_of_content_owner() const
Definition: you_tube_service.h:10172
util::Status ExecuteAndParseResponse(Comment *data)
Definition: you_tube_service.h:5028
void clear_video_license()
Definition: you_tube_service.h:12158
void clear_moderation_status()
Definition: you_tube_service.h:3958
string * mutable_onBehalfOfContentOwner()
Definition: you_tube_service.h:9760
const string & get_hl() const
Definition: you_tube_service.h:5424
const string & get_filter() const
Definition: you_tube_service.h:12443
void set_type(const string &value)
Definition: you_tube_service.h:11887
void clear_max_width()
Definition: you_tube_service.h:14834
void clear_channel_id()
Definition: you_tube_service.h:3844
void set_sync(bool value)
Definition: you_tube_service.h:1544
void clear_page_token()
Definition: you_tube_service.h:13170
Definition: video_abuse_report_reason_list_response.h:52
util::Status ExecuteAndParseResponse(LiveBroadcast *data)
Definition: you_tube_service.h:7023
void set_topic_id(const string &value)
Definition: you_tube_service.h:11846
string * mutable_filter()
Definition: you_tube_service.h:12450
void set_page_token(const string &value)
Definition: you_tube_service.h:6769
void set_pretty_print(bool value)
Definition: you_tube_service.h:341
void clear_related_to_video_id()
Definition: you_tube_service.h:11683
string * mutable_videoDuration()
Definition: you_tube_service.h:12091
void set_id(const string &value)
Definition: you_tube_service.h:6560
void set_on_behalf_of_content_owner_channel(const string &value)
Definition: you_tube_service.h:6353
void clear_on_behalf_of_content_owner_channel()
Definition: you_tube_service.h:6305
void clear_page_token()
Definition: you_tube_service.h:9197
void set_category_id(const string &value)
Definition: you_tube_service.h:3137
util::Status ExecuteAndParseResponse(ChannelSection *data)
Definition: you_tube_service.h:2603
util::Status ExecuteAndParseResponse(PlaylistItemListResponse *data)
Definition: you_tube_service.h:9947
const string & get_on_behalf_of_content_owner() const
Definition: you_tube_service.h:5549
void clear_max_results()
Definition: you_tube_service.h:4586
string * mutable_id()
Definition: you_tube_service.h:10575
~CaptionsResource()
Definition: you_tube_service.h:15895
Definition: you_tube_service.h:3074
void clear_published_before()
Definition: you_tube_service.h:11563
const string & get_chart() const
Definition: you_tube_service.h:14618
string * mutable_id()
Definition: you_tube_service.h:13860
void clear_max_results()
Definition: you_tube_service.h:11370
void set_moderation_status(const string &value)
Definition: you_tube_service.h:3992
void clear_on_behalf_of_content_owner()
Definition: you_tube_service.h:1176
uint32 get_max_results() const
Definition: you_tube_service.h:7974
const string & get_search_terms() const
Definition: you_tube_service.h:4107
string * mutable_onBehalfOfContentOwner()
Definition: you_tube_service.h:6645
void set_filter(const string &value)
Definition: you_tube_service.h:12462
const string & get_on_behalf_of_content_owner() const
Definition: you_tube_service.h:2833
void set_hl(const string &value)
Definition: you_tube_service.h:5111
const string & get_page_token() const
Definition: you_tube_service.h:4061
Definition: live_stream_list_response.h:54
string * mutable_videoType()
Definition: you_tube_service.h:12266
static const client::MediaUploadSpec RESUMABLE_MEDIA_UPLOAD
Definition: you_tube_service.h:2292
void set_on_behalf_of_content_owner_channel(const string &value)
Definition: you_tube_service.h:5945
const string & get_page_token() const
Definition: you_tube_service.h:14967
string * mutable_oauthToken()
Definition: you_tube_service.h:302
void set_on_behalf_of_content_owner(const string &value)
Definition: you_tube_service.h:2507
void set_on_behalf_of_content_owner(const string &value)
Definition: you_tube_service.h:1777
void clear_on_behalf_of_content_owner()
Definition: you_tube_service.h:13534
void clear_hl()
Definition: you_tube_service.h:2706
const PlaylistsResource & get_playlists() const
Definition: you_tube_service.h:18478
bool get_sync() const
Definition: you_tube_service.h:1529
Definition: live_chat_moderator.h:54
const string & get_id() const
Definition: you_tube_service.h:2763
string * mutable_channelId()
Definition: you_tube_service.h:11067
Definition: access_policy.cc:40
void clear_video_embeddable()
Definition: you_tube_service.h:12115
void set_max_results(uint32 value)
Definition: you_tube_service.h:12491
Definition: you_tube_service.h:15236
~LiveChatModeratorsResource()
Definition: you_tube_service.h:17022
Definition: live_chat_message_list_response.h:56
string * mutable_quotaUser()
Definition: you_tube_service.h:368
Definition: you_tube_service.h:17847
const string & get_region_code() const
Definition: you_tube_service.h:844
Definition: you_tube_service.h:4520
const string & get_page_token() const
Definition: you_tube_service.h:8001
void clear_order()
Definition: you_tube_service.h:4002
string * mutable_channelId()
Definition: you_tube_service.h:622
Definition: you_tube_service.h:17452
void clear_on_behalf_of_content_owner()
Definition: you_tube_service.h:6886
void clear_hl()
Definition: you_tube_service.h:13680
void set_hl(const string &value)
Definition: you_tube_service.h:2742
void clear_mine()
Definition: you_tube_service.h:2794
const string & get_on_behalf_of_content_owner() const
Definition: you_tube_service.h:8313
void set_on_behalf_of_content_owner(const string &value)
Definition: you_tube_service.h:1217
const string & get_on_behalf_of_content_owner() const
Definition: you_tube_service.h:6083
Definition: live_broadcast.h:56
const ChannelSectionsResource & get_channel_sections() const
Definition: you_tube_service.h:18328
string * mutable_eventType()
Definition: you_tube_service.h:11149
const VideoAbuseReportReasonsResource & get_video_abuse_report_reasons() const
Definition: you_tube_service.h:18538
Definition: caption_list_response.h:52
bool get_pretty_print() const
Definition: you_tube_service.h:334
void clear_page_token()
Definition: you_tube_service.h:726
string * mutable_textFormat()
Definition: you_tube_service.h:4725
const string & get_id() const
Definition: you_tube_service.h:9684
string * mutable_onBehalfOfContentOwnerChannel()
Definition: you_tube_service.h:6957
string * mutable_onBehalfOfContentOwner()
Definition: you_tube_service.h:2985
void clear_on_behalf_of_content_owner_channel()
Definition: you_tube_service.h:2518
util::Status ExecuteAndParseResponse(I18nLanguageListResponse *data)
Definition: you_tube_service.h:5358
string * mutable_onBehalfOfContentOwner()
Definition: you_tube_service.h:13553
const string & get_on_behalf_of_content_owner() const
Definition: you_tube_service.h:1029
void clear_on_behalf_of_content_owner()
Definition: you_tube_service.h:8848
Definition: you_tube_service.h:16400
util::Status ExecuteAndParseResponse(SubscriptionListResponse *data)
Definition: you_tube_service.h:13240
string * mutable_onBehalfOfContentOwner()
Definition: you_tube_service.h:5557
string * mutable_pageToken()
Definition: you_tube_service.h:9216
const string & get_id() const
Definition: you_tube_service.h:6540
string * mutable_onBehalfOfContentOwnerChannel()
Definition: you_tube_service.h:14432
~MembersResource()
Definition: you_tube_service.h:17236
void clear_max_results()
Definition: you_tube_service.h:13366
const SubscriptionsResource & get_subscriptions() const
Definition: you_tube_service.h:18508
const string & get_hl() const
Definition: you_tube_service.h:10528
Definition: memberships_level_list_response.h:52
void clear_on_behalf_of_content_owner()
Definition: you_tube_service.h:10915
const string & get_safe_search() const
Definition: you_tube_service.h:11784
uint32 get_max_results() const
Definition: you_tube_service.h:7635
void clear_on_behalf_of_content_owner_channel()
Definition: you_tube_service.h:10706
const string & get_on_behalf_of_content_owner_channel() const
Definition: you_tube_service.h:10342
Definition: playlist_item.h:74
Definition: you_tube_service.h:5387
string * mutable_videoId()
Definition: you_tube_service.h:9898
Definition: you_tube_service.h:8095
util::Status ExecuteAndParseResponse(CommentThreadListResponse *data)
Definition: you_tube_service.h:4251
void set_on_behalf_of_content_owner(const string &value)
Definition: you_tube_service.h:6927
void set_on_behalf_of_content_owner(const string &value)
Definition: you_tube_service.h:8632
void set_notify_subscribers(bool value)
Definition: you_tube_service.h:14352
void clear_ban_author()
Definition: you_tube_service.h:4900
void clear_id()
Definition: you_tube_service.h:9673
const string & get_on_behalf_of_content_owner() const
Definition: you_tube_service.h:15272
const string & get_id() const
Definition: you_tube_service.h:1664
string * mutable_regionCode()
Definition: you_tube_service.h:852
const LiveChatModeratorsResource & get_live_chat_moderators() const
Definition: you_tube_service.h:18428
void set_on_behalf_of_content_owner(const string &value)
Definition: you_tube_service.h:1986
void clear_offset_time_ms()
Definition: you_tube_service.h:5805
void set_my_subscribers(bool value)
Definition: you_tube_service.h:13011
util::Status ExecuteAndParseResponse(LiveBroadcast *data)
Definition: you_tube_service.h:6012
void clear_on_behalf_of_content_owner()
Definition: you_tube_service.h:2345
void clear_page_token()
Definition: you_tube_service.h:9792
string * mutable_id()
Definition: you_tube_service.h:3247
const string & get_video_license() const
Definition: you_tube_service.h:12169
void set_region_code(const string &value)
Definition: you_tube_service.h:11672
void clear_id()
Definition: you_tube_service.h:8494
string * mutable_chart()
Definition: you_tube_service.h:14625
string * mutable_onBehalfOfContentOwnerChannel()
Definition: you_tube_service.h:5916
Definition: you_tube_service.h:4441
util::Status ExecuteAndParseResponse(PlaylistListResponse *data)
Definition: you_tube_service.h:10834
void clear_video_duration()
Definition: you_tube_service.h:12072
void clear_key()
Definition: you_tube_service.h:242
void set_on_behalf_of_content_owner_channel(const string &value)
Definition: you_tube_service.h:14461
const string & get_order() const
Definition: you_tube_service.h:11460
string * mutable_pageToken()
Definition: you_tube_service.h:8009
void set_user_ip(const string &value)
Definition: you_tube_service.h:420
const string & get_key() const
Definition: you_tube_service.h:253
void clear_all_threads_related_to_channel_id()
Definition: you_tube_service.h:3801
string * mutable_relatedToVideoId()
Definition: you_tube_service.h:11702
void clear_on_behalf_of_content_owner()
Definition: you_tube_service.h:6072
const string & get_hl() const
Definition: you_tube_service.h:13691
void set_video_duration(const string &value)
Definition: you_tube_service.h:12104
void set_channel_id(const string &value)
Definition: you_tube_service.h:634
void set_hl(const string &value)
Definition: you_tube_service.h:13356
Definition: channel.h:62
uint32 get_max_results() const
Definition: you_tube_service.h:12483
string * mutable_onBehalfOfContentOwnerChannel()
Definition: you_tube_service.h:8662
string * mutable_hasAccessToLevel()
Definition: you_tube_service.h:9106
string * mutable_id()
Definition: you_tube_service.h:12885
const string & get_mode() const
Definition: you_tube_service.h:9168
const string & get_tfmt() const
Definition: you_tube_service.h:1238
const string & get_hl() const
Definition: you_tube_service.h:2717
void set_id(const string &value)
Definition: you_tube_service.h:10589
void clear_max_results()
Definition: you_tube_service.h:7624
const string & get_on_behalf_of() const
Definition: you_tube_service.h:1436
void set_max_results(uint32 value)
Definition: you_tube_service.h:6589
void set_on_behalf_of_content_owner_channel(const string &value)
Definition: you_tube_service.h:6172
void set_on_behalf_of_content_owner(const string &value)
Definition: you_tube_service.h:14167
void set_for_username(const string &value)
Definition: you_tube_service.h:3178
void set_id(const string &value)
Definition: you_tube_service.h:9703
Definition: you_tube_service.h:13501
client::DateTime get_published_after() const
Definition: you_tube_service.h:11544
string * mutable_onBehalfOf()
Definition: you_tube_service.h:995
Definition: you_tube_service.h:15349
uint32 get_max_results() const
Definition: you_tube_service.h:13377
void clear_my_rating()
Definition: you_tube_service.h:14862
Definition: channel_section.h:55
void set_key(const string &value)
Definition: you_tube_service.h:273
uint32 get_max_results() const
Definition: you_tube_service.h:6581
void clear_max_results()
Definition: you_tube_service.h:672
bool get_sync() const
Definition: you_tube_service.h:2007
string * mutable_onBehalfOfContentOwnerChannel()
Definition: you_tube_service.h:8192
~LiveStreamsResource()
Definition: you_tube_service.h:17118
string * mutable_videoLicense()
Definition: you_tube_service.h:12177
Definition: i18n_language_list_response.h:52
uint64 get_offset_time_ms() const
Definition: you_tube_service.h:5816
void clear_on_behalf_of_content_owner_channel()
Definition: you_tube_service.h:6938
util::Status ExecuteAndParseResponse(LiveChatModeratorListResponse *data)
Definition: you_tube_service.h:8060
const ThumbnailsResource & get_thumbnails() const
Definition: you_tube_service.h:18528
void clear_chart()
Definition: you_tube_service.h:14607
Definition: sponsor_list_response.h:54
void set_oauth_token(const string &value)
Definition: you_tube_service.h:313
void set_channel_id(const string &value)
Definition: you_tube_service.h:12815
const string & get_on_behalf_of_content_owner() const
Definition: you_tube_service.h:5856
void clear_video_dimension()
Definition: you_tube_service.h:12030
void clear_oauth_token()
Definition: you_tube_service.h:283
const string & get_on_behalf_of_content_owner() const
Definition: you_tube_service.h:8859
void set_on_behalf_of_content_owner(const string &value)
Definition: you_tube_service.h:7135
const string & get_location_radius() const
Definition: you_tube_service.h:11332
void clear_tlang()
Definition: you_tube_service.h:1268
string * mutable_onBehalfOfContentOwner()
Definition: you_tube_service.h:10298
const string & get_on_behalf_of_content_owner() const
Definition: you_tube_service.h:2477
Definition: invideo_branding.h:53
void set_on_behalf_of_content_owner_channel(const string &value)
Definition: you_tube_service.h:13120
const string & get_moderation_status() const
Definition: you_tube_service.h:3969
void clear_stabilize()
Definition: you_tube_service.h:14471
string * mutable_channelId()
Definition: you_tube_service.h:10495
string * mutable_onBehalfOfContentOwnerChannel()
Definition: you_tube_service.h:7165
string * mutable_onBehalfOfContentOwner()
Definition: you_tube_service.h:8867
void clear_q()
Definition: you_tube_service.h:11592
const CaptionsResource & get_captions() const
Definition: you_tube_service.h:18308
const string & get_page_token() const
Definition: you_tube_service.h:8712
const string & get_id() const
Definition: you_tube_service.h:4556
void clear_filter_by_member_channel_id()
Definition: you_tube_service.h:9042
string * mutable_categoryId()
Definition: you_tube_service.h:3124
Definition: video_category_list_response.h:54
void clear_on_behalf_of_content_owner()
Definition: you_tube_service.h:10161
void set_walltime(client::DateTime value)
Definition: you_tube_service.h:5975
string * mutable_onBehalfOf()
Definition: you_tube_service.h:1153
const string & get_on_behalf_of_content_owner() const
Definition: you_tube_service.h:10926
void set_id(const string &value)
Definition: you_tube_service.h:13872
void clear_on_behalf_of_content_owner()
Definition: you_tube_service.h:15261
void set_on_behalf_of_content_owner(const string &value)
Definition: you_tube_service.h:15597
void set_on_behalf_of_content_owner(const string &value)
Definition: you_tube_service.h:8889
void set_tlang(const string &value)
Definition: you_tube_service.h:1301
Definition: you_tube_service.h:15770
void clear_has_access_to_level()
Definition: you_tube_service.h:9087
uint32 get_max_results() const
Definition: you_tube_service.h:10610
void set_on_behalf_of_content_owner(const string &value)
Definition: you_tube_service.h:1059
void set_on_behalf_of_content_owner(const string &value)
Definition: you_tube_service.h:5886
~ChannelSectionsResource()
Definition: you_tube_service.h:16123
string * mutable_id()
Definition: you_tube_service.h:2770
string * mutable_onBehalfOfContentOwner()
Definition: you_tube_service.h:1195
void clear_page_token()
Definition: you_tube_service.h:4616
void clear_search_terms()
Definition: you_tube_service.h:4096
void clear_on_behalf_of_content_owner_channel()
Definition: you_tube_service.h:8900
void clear_page_token()
Definition: you_tube_service.h:12499
void set_channel_id(const string &value)
Definition: you_tube_service.h:11079
const string & get_on_behalf_of_content_owner() const
Definition: you_tube_service.h:14372
void clear_on_behalf_of_content_owner_channel()
Definition: you_tube_service.h:8354
string * mutable_onBehalfOfContentOwner()
Definition: you_tube_service.h:2841
string * mutable_channelId()
Definition: you_tube_service.h:2684
const string & get_on_behalf_of_content_owner() const
Definition: you_tube_service.h:2356
Definition: search_list_response.h:54
bool get_managed_by_me() const
Definition: you_tube_service.h:3282
void clear_published_after()
Definition: you_tube_service.h:770
const string & get_topic_id() const
Definition: you_tube_service.h:11825
void clear_user_ip()
Definition: you_tube_service.h:390
void set_hl(const string &value)
Definition: you_tube_service.h:5321
const string & get_region_code() const
Definition: you_tube_service.h:15014
void set_on_behalf_of_content_owner(const string &value)
Definition: you_tube_service.h:15436
void clear_type()
Definition: you_tube_service.h:11856
const string & get_channel_id() const
Definition: you_tube_service.h:11059
const string & get_page_token() const
Definition: you_tube_service.h:7662
void clear_sync()
Definition: you_tube_service.h:1996
void set_ban_author(bool value)
Definition: you_tube_service.h:4923
string * mutable_regionCode()
Definition: you_tube_service.h:11659
void set_mine(bool value)
Definition: you_tube_service.h:8582
uint32 get_max_width() const
Definition: you_tube_service.h:14845
void set_my_subscribers(bool value)
Definition: you_tube_service.h:3378
~SubscriptionsResource()
Definition: you_tube_service.h:17703
void set_hl(const string &value)
Definition: you_tube_service.h:13832
const SearchResource & get_search() const
Definition: you_tube_service.h:18488
void clear_on_behalf_of_content_owner()
Definition: you_tube_service.h:8302
const string & get_user_ip() const
Definition: you_tube_service.h:401
Definition: video.h:66
const string & get_on_behalf_of_content_owner_channel() const
Definition: you_tube_service.h:5601
string * mutable_onBehalfOfContentOwner()
Definition: you_tube_service.h:10180
void set_on_behalf_of_content_owner(const string &value)
Definition: you_tube_service.h:1508
string * mutable_broadcastType()
Definition: you_tube_service.h:6506
uint32 get_max_results() const
Definition: you_tube_service.h:14814
void clear_on_behalf_of_content_owner_channel()
Definition: you_tube_service.h:10331
string * mutable_hl()
Definition: you_tube_service.h:2724
void set_on_behalf_of_content_owner_channel(const string &value)
Definition: you_tube_service.h:8948
string * mutable_pageToken()
Definition: you_tube_service.h:14975
string * mutable_onBehalfOfContentOwnerChannel()
Definition: you_tube_service.h:6324
string * mutable_onBehalfOfContentOwnerChannel()
Definition: you_tube_service.h:10725
void clear_id()
Definition: you_tube_service.h:10557
const string & get_page_token() const
Definition: you_tube_service.h:9803
void set_alt(const string &value)
Definition: you_tube_service.h:192
void set_max_results(uint32 value)
Definition: you_tube_service.h:4608
void set_max_results(uint32 value)
Definition: you_tube_service.h:3323
string * mutable_locationRadius()
Definition: you_tube_service.h:11340
const string & get_on_behalf_of_content_owner() const
Definition: you_tube_service.h:15567
void set_max_results(uint32 value)
Definition: you_tube_service.h:7643
Definition: you_tube_service.h:18578
const string & get_id() const
Definition: you_tube_service.h:3898
client::DateTime get_walltime() const
Definition: you_tube_service.h:5966
const string & get_page_token() const
Definition: you_tube_service.h:3449
const string & get_region_code() const
Definition: you_tube_service.h:11651
bool get_display_slate() const
Definition: you_tube_service.h:5789
void clear_page_token()
Definition: you_tube_service.h:7990
string * mutable_regionCode()
Definition: you_tube_service.h:5182
const string & get_on_behalf_of_content_owner() const
Definition: you_tube_service.h:6637
const string & get_on_behalf_of_content_owner_channel() const
Definition: you_tube_service.h:8911
Definition: you_tube_service.h:9640
string * mutable_safeSearch()
Definition: you_tube_service.h:11792
const string & get_on_behalf_of() const
Definition: you_tube_service.h:1705
Definition: you_tube_service.h:10445
void clear_video_category_id()
Definition: you_tube_service.h:15047
util::Status ExecuteAndParseResponse(SponsorListResponse *data)
Definition: you_tube_service.h:12569
~PlaylistsResource()
Definition: you_tube_service.h:17466
Definition: you_tube_service.h:14099
void set_on_behalf_of_content_owner(const string &value)
Definition: you_tube_service.h:6294
const string & get_on_behalf_of_content_owner() const
Definition: you_tube_service.h:14916
void clear_on_behalf_of_content_owner()
Definition: you_tube_service.h:10279
const string & get_video_caption() const
Definition: you_tube_service.h:11908
void set_hl(const string &value)
Definition: you_tube_service.h:10547
util::Status ExecuteAndParseResponse(MemberListResponse *data)
Definition: you_tube_service.h:9267
void set_on_behalf_of_content_owner(const string &value)
Definition: you_tube_service.h:10320
void set_on_behalf_of_content_owner_channel(const string &value)
Definition: you_tube_service.h:5638
util::Status ExecuteAndParseResponse(Activity *data)
Definition: you_tube_service.h:547
void set_on_behalf_of_content_owner_channel(const string &value)
Definition: you_tube_service.h:8221
const string & get_on_behalf_of_content_owner_channel() const
Definition: you_tube_service.h:6949
Definition: subscription_list_response.h:54
string * mutable_videoDefinition()
Definition: you_tube_service.h:12003
string * mutable_channelId()
Definition: you_tube_service.h:2168
const VideosResource & get_videos() const
Definition: you_tube_service.h:18558
const string & get_on_behalf_of_content_owner() const
Definition: you_tube_service.h:10039
Definition: member_list_response.h:54
void clear_my_recent_subscribers()
Definition: you_tube_service.h:12964
string * mutable_key()
Definition: you_tube_service.h:260
Definition: you_tube_service.h:4970
Definition: you_tube_service.h:13983
string * mutable_onBehalfOfContentOwner()
Definition: you_tube_service.h:6091
void set_on_behalf_of(const string &value)
Definition: you_tube_service.h:1934
void clear_hl()
Definition: you_tube_service.h:13319
void set_managed_by_me(bool value)
Definition: you_tube_service.h:3296
void clear_on_behalf_of_content_owner_channel()
Definition: you_tube_service.h:7146
~VideoAbuseReportReasonsResource()
Definition: you_tube_service.h:17910
string * mutable_q()
Definition: you_tube_service.h:11610
static const client::MediaUploadSpec SIMPLE_MEDIA_UPLOAD
Definition: you_tube_service.h:14540
string * mutable_channelType()
Definition: you_tube_service.h:11108
Definition: you_tube_service.h:15659
string * mutable_videoDimension()
Definition: you_tube_service.h:12049
void clear_for_username()
Definition: you_tube_service.h:3147
const string & get_hl() const
Definition: you_tube_service.h:3199
void set_id(const string &value)
Definition: you_tube_service.h:1684
void set_auto_levels(bool value)
Definition: you_tube_service.h:14319
void clear_on_behalf_of_content_owner()
Definition: you_tube_service.h:2822
void set_relevance_language(const string &value)
Definition: you_tube_service.h:11763
void clear_max_results()
Definition: you_tube_service.h:14803
string * mutable_pageToken()
Definition: you_tube_service.h:4635
void clear_on_behalf_of_content_owner_channel()
Definition: you_tube_service.h:14413
Definition: you_tube_service.h:1624
bool get_for_content_owner() const
Definition: you_tube_service.h:11184
Definition: you_tube_service.h:12670
string * mutable_hl()
Definition: you_tube_service.h:13337
void set_offset_time_ms(uint64 value)
Definition: you_tube_service.h:5836
void set_id(const string &value)
Definition: you_tube_service.h:8525
const string & get_on_behalf_of_content_owner_channel() const
Definition: you_tube_service.h:8654
bool get_for_mine() const
Definition: you_tube_service.h:11248
uint32 get_max_results() const
Definition: you_tube_service.h:8546
void set_max_results(uint32 value)
Definition: you_tube_service.h:11389
void set_on_behalf_of_content_owner(const string &value)
Definition: you_tube_service.h:15726
string * mutable_onBehalfOf()
Definition: you_tube_service.h:1713
void clear_my_subscribers()
Definition: you_tube_service.h:12992
string * mutable_location()
Definition: you_tube_service.h:11285
const string & get_on_behalf_of_content_owner() const
Definition: you_tube_service.h:10290
void set_max_results(uint32 value)
Definition: you_tube_service.h:3949
string * mutable_pageToken()
Definition: you_tube_service.h:745
string * mutable_onBehalfOfContentOwner()
Definition: you_tube_service.h:13039
void set_on_behalf_of_content_owner(const string &value)
Definition: you_tube_service.h:8343
void clear_published_before()
Definition: you_tube_service.h:802
~LiveChatBansResource()
Definition: you_tube_service.h:16867
const string & get_id() const
Definition: you_tube_service.h:14705
string * mutable_forChannelId()
Definition: you_tube_service.h:12844
util::Status ExecuteAndParseResponse(I18nRegionListResponse *data)
Definition: you_tube_service.h:5480
Definition: super_chat_event_list_response.h:54
void set_on_behalf_of_content_owner(const string &value)
Definition: you_tube_service.h:10202
Definition: playlist_item_list_response.h:54
void clear_region_code()
Definition: you_tube_service.h:11640
void set_on_behalf_of_content_owner(const string &value)
Definition: you_tube_service.h:5579
Definition: comment.h:52
void clear_max_results()
Definition: you_tube_service.h:9130
void clear_on_behalf_of_content_owner()
Definition: you_tube_service.h:1018
string * mutable_onBehalfOfContentOwnerChannel()
Definition: you_tube_service.h:8919
~LiveChatMessagesResource()
Definition: you_tube_service.h:16927
client::DateTime get_published_before() const
Definition: you_tube_service.h:11574
string * mutable_onBehalfOfContentOwner()
Definition: you_tube_service.h:15280
string * mutable_channelId()
Definition: you_tube_service.h:12803
void clear_page_token()
Definition: you_tube_service.h:14956
string * mutable_onBehalfOfContentOwner()
Definition: you_tube_service.h:8610
const string & get_on_behalf_of_content_owner() const
Definition: you_tube_service.h:15696
Definition: you_tube_service.h:12752
void set_for_content_owner(bool value)
Definition: you_tube_service.h:11198
const string & get_on_behalf_of_content_owner() const
Definition: you_tube_service.h:1478
void set_use_media_download(bool use)
Definition: you_tube_service.h:1342
string * mutable_onBehalfOfContentOwner()
Definition: you_tube_service.h:15704
string * mutable_filterByMemberChannelId()
Definition: you_tube_service.h:9061
string * mutable_onBehalfOfContentOwner()
Definition: you_tube_service.h:5864
void set_page_token(const string &value)
Definition: you_tube_service.h:3471
void set_filter_by_member_channel_id(const string &value)
Definition: you_tube_service.h:9076
const string & get_hl() const
Definition: you_tube_service.h:13813
void clear_id()
Definition: you_tube_service.h:3887
void clear_pretty_print()
Definition: you_tube_service.h:323
void set_mode(const string &value)
Definition: you_tube_service.h:9187
void set_my_rating(const string &value)
Definition: you_tube_service.h:14894
void clear_channel_type()
Definition: you_tube_service.h:11089
const string & get_category_id() const
Definition: you_tube_service.h:3116
void set_q(const string &value)
Definition: you_tube_service.h:11630
string * mutable_hl()
Definition: you_tube_service.h:5099
const LiveBroadcastsResource & get_live_broadcasts() const
Definition: you_tube_service.h:18398
~I18nRegionsResource()
Definition: you_tube_service.h:16638
void set_max_height(uint32 value)
Definition: you_tube_service.h:14795
void set_all_threads_related_to_channel_id(const string &value)
Definition: you_tube_service.h:3834
bool get_stabilize() const
Definition: you_tube_service.h:14482
const string & get_id() const
Definition: you_tube_service.h:8505
~ThumbnailsResource()
Definition: you_tube_service.h:17861
Definition: live_broadcast_list_response.h:54
void clear_category_id()
Definition: you_tube_service.h:3105
void set_page_token(const string &value)
Definition: you_tube_service.h:9825
util::Status ExecuteAndParseResponse(VideoListResponse *data)
Definition: you_tube_service.h:15117
~SponsorsResource()
Definition: you_tube_service.h:17648
void clear_published_after()
Definition: you_tube_service.h:11533
void clear_page_token()
Definition: you_tube_service.h:10764
void set_stream_id(const string &value)
Definition: you_tube_service.h:5681
void set_id(const string &value)
Definition: you_tube_service.h:14725
string * mutable_onBehalfOfContentOwner()
Definition: you_tube_service.h:15575
string * mutable_id()
Definition: you_tube_service.h:14712
string * mutable_userIp()
Definition: you_tube_service.h:408
void clear_display_slate()
Definition: you_tube_service.h:5778
void clear_video_id()
Definition: you_tube_service.h:9879
const string & get_on_behalf_of_content_owner() const
Definition: you_tube_service.h:2977
uint32 get_max_height() const
Definition: you_tube_service.h:14786
void set_on_behalf_of_content_owner_channel(const string &value)
Definition: you_tube_service.h:6986
Definition: you_tube_service.h:11022
void clear_region_code()
Definition: you_tube_service.h:13882
const string & get_stream_id() const
Definition: you_tube_service.h:5659
void clear_on_behalf_of_content_owner()
Definition: you_tube_service.h:6253
void set_video_embeddable(const string &value)
Definition: you_tube_service.h:12148
void set_for_mine(bool value)
Definition: you_tube_service.h:11258
const string & get_id() const
Definition: you_tube_service.h:3240
Definition: playlist_list_response.h:54
void clear_on_behalf_of_content_owner_channel()
Definition: you_tube_service.h:8643
void clear_max_results()
Definition: you_tube_service.h:3927
bool get_mine() const
Definition: you_tube_service.h:2805
string * mutable_pageToken()
Definition: you_tube_service.h:11508
string * mutable_broadcastStatus()
Definition: you_tube_service.h:6465
void set_fields(const string &value)
Definition: you_tube_service.h:232
const string & get_my_rating() const
Definition: you_tube_service.h:14873
void set_on_behalf_of(const string &value)
Definition: you_tube_service.h:1007
void clear_mine()
Definition: you_tube_service.h:699
const string & get_id() const
Definition: you_tube_service.h:5132
const CommentsResource & get_comments() const
Definition: you_tube_service.h:18358
void set_id(const string &value)
Definition: you_tube_service.h:12899
void clear_on_behalf_of()
Definition: you_tube_service.h:1694
string * mutable_parentId()
Definition: you_tube_service.h:4681
void set_page_token(const string &value)
Definition: you_tube_service.h:11522
void set_on_behalf_of(const string &value)
Definition: you_tube_service.h:1725
uint32 get_max_results() const
Definition: you_tube_service.h:12920
util::Status ExecuteAndParseResponse(PlaylistItem *data)
Definition: you_tube_service.h:9613
Definition: you_tube_service.h:950
const I18nLanguagesResource & get_i18n_languages() const
Definition: you_tube_service.h:18378
const string & get_video_definition() const
Definition: you_tube_service.h:11995
const string & get_relevance_language() const
Definition: you_tube_service.h:11738
Definition: you_tube_service.h:3557
const VideoCategoriesResource & get_video_categories() const
Definition: you_tube_service.h:18548
const string & get_on_behalf_of_content_owner() const
Definition: you_tube_service.h:11409
Definition: live_stream.h:55
Definition: you_tube_service.h:1844
Definition: you_tube_service.h:15793
void set_video_type(const string &value)
Definition: you_tube_service.h:12279
void clear_on_behalf_of_content_owner_channel()
Definition: you_tube_service.h:5590
Definition: you_tube_service.h:15170
string * mutable_onBehalfOfContentOwner()
Definition: you_tube_service.h:2364
const string & get_on_behalf_of_content_owner() const
Definition: you_tube_service.h:15406
void clear_notify_subscribers()
Definition: you_tube_service.h:14328
void clear_on_behalf_of_content_owner()
Definition: you_tube_service.h:2197
Definition: you_tube_service.h:490
string * mutable_onBehalfOfContentOwnerChannel()
Definition: you_tube_service.h:5609
const string & get_channel_id() const
Definition: you_tube_service.h:614
void clear_on_behalf_of_content_owner()
Definition: you_tube_service.h:11398
void set_on_behalf_of(const string &value)
Definition: you_tube_service.h:1165
bool get_mine() const
Definition: you_tube_service.h:12947
void set_home(bool value)
Definition: you_tube_service.h:664
void clear_alt()
Definition: you_tube_service.h:163
void set_on_behalf_of_content_owner(const string &value)
Definition: you_tube_service.h:2863
void set_page_token(const string &value)
Definition: you_tube_service.h:13426
const string & get_on_behalf_of_content_owner() const
Definition: you_tube_service.h:13031
Definition: you_tube_service.h:14231
void set_video_syndicated(const string &value)
Definition: you_tube_service.h:12237
const I18nRegionsResource & get_i18n_regions() const
Definition: you_tube_service.h:18388
const string & get_page_token() const
Definition: you_tube_service.h:10775
void set_mine(bool value)
Definition: you_tube_service.h:2813
client::DateTime get_published_after() const
Definition: you_tube_service.h:781
void clear_mine()
Definition: you_tube_service.h:8562
const PlaylistItemsResource & get_playlist_items() const
Definition: you_tube_service.h:18468
string * mutable_onBehalfOfContentOwner()
Definition: you_tube_service.h:8321
void clear_tfmt()
Definition: you_tube_service.h:1227
void set_page_token(const string &value)
Definition: you_tube_service.h:4652
string * mutable_topicId()
Definition: you_tube_service.h:11833
const string & get_region_code() const
Definition: you_tube_service.h:13893
void clear_on_behalf_of_content_owner()
Definition: you_tube_service.h:8121
void clear_on_behalf_of_content_owner()
Definition: you_tube_service.h:1467
void set_on_behalf_of_content_owner(const string &value)
Definition: you_tube_service.h:2386
const string & get_on_behalf_of_content_owner_channel() const
Definition: you_tube_service.h:8184
Definition: you_tube_service.h:15881
~LiveBroadcastsResource()
Definition: you_tube_service.h:16681
void set_on_behalf_of_content_owner(const string &value)
Definition: you_tube_service.h:13575
string * mutable_playlistId()
Definition: you_tube_service.h:9854
void set_video_dimension(const string &value)
Definition: you_tube_service.h:12062
void set_published_after(client::DateTime value)
Definition: you_tube_service.h:11554
Definition: activity.h:59
void clear_on_behalf_of_content_owner()
Definition: you_tube_service.h:14361
void clear_video_definition()
Definition: you_tube_service.h:11984
void clear_on_behalf_of()
Definition: you_tube_service.h:1903
static const client::MediaUploadSpec RESUMABLE_MEDIA_UPLOAD
Definition: you_tube_service.h:13629
Definition: video_list_response.h:54
util::Status ExecuteAndParseResponse(VideoCategoryListResponse *data)
Definition: you_tube_service.h:13951
void set_published_before(client::DateTime value)
Definition: you_tube_service.h:825
const string & get_location() const
Definition: you_tube_service.h:11277
const string & get_on_behalf_of_content_owner() const
Definition: you_tube_service.h:3398
void clear_max_results()
Definition: you_tube_service.h:7963
void clear_page_token()
Definition: you_tube_service.h:6736
util::Status ExecuteAndParseResponse(Comment *data)
Definition: you_tube_service.h:4498
void set_channel_id(const string &value)
Definition: you_tube_service.h:2696
void clear_managed_by_me()
Definition: you_tube_service.h:3271
Definition: playlist.h:75
~CommentsResource()
Definition: you_tube_service.h:16414
const GuideCategoriesResource & get_guide_categories() const
Definition: you_tube_service.h:18368
void set_on_behalf_of_content_owner(const string &value)
Definition: you_tube_service.h:14051
void clear_video_type()
Definition: you_tube_service.h:12247
void clear_auto_levels()
Definition: you_tube_service.h:14300
static const client::MediaUploadSpec RESUMABLE_MEDIA_UPLOAD
Definition: you_tube_service.h:15636
void clear_hl()
Definition: you_tube_service.h:5413
util::Status ExecuteAndParseResponse(VideoAbuseReportReasonListResponse *data)
Definition: you_tube_service.h:13747
const string & get_alt() const
Definition: you_tube_service.h:174
void clear_relevance_language()
Definition: you_tube_service.h:11727
const string & get_page_token() const
Definition: you_tube_service.h:6747
const string & get_playlist_id() const
Definition: you_tube_service.h:9846
void set_on_behalf_of_content_owner(const string &value)
Definition: you_tube_service.h:15302
util::Status ExecuteAndParseResponse(LiveStream *data)
Definition: you_tube_service.h:8439
const string & get_on_behalf_of_content_owner() const
Definition: you_tube_service.h:9752
void clear_page_token()
Definition: you_tube_service.h:13393
util::Status ExecuteAndParseResponse(MembershipsLevelListResponse *data)
Definition: you_tube_service.h:9364
~I18nLanguagesResource()
Definition: you_tube_service.h:16595
void clear_on_behalf_of()
Definition: you_tube_service.h:976
void set_event_type(const string &value)
Definition: you_tube_service.h:11162
bool get_home() const
Definition: you_tube_service.h:655
Definition: you_tube_service.h:12407
string * mutable_videoCategoryId()
Definition: you_tube_service.h:15066
const string & get_tlang() const
Definition: you_tube_service.h:1279
const string & get_on_behalf_of_content_owner() const
Definition: you_tube_service.h:7105
void clear_hl()
Definition: you_tube_service.h:10517
const string & get_oauth_token() const
Definition: you_tube_service.h:294
const string & get_on_behalf_of_content_owner() const
Definition: you_tube_service.h:9546
string * mutable_onBehalfOfContentOwner()
Definition: you_tube_service.h:14924
void clear_hl()
Definition: you_tube_service.h:13802
void set_profile_image_size(uint32 value)
Definition: you_tube_service.h:7714
bool get_for_developer() const
Definition: you_tube_service.h:11217
void clear_parent_id()
Definition: you_tube_service.h:4662
Definition: you_tube_service.h:10250
string * mutable_id()
Definition: you_tube_service.h:1671
const string & get_on_behalf_of_content_owner_channel() const
Definition: you_tube_service.h:6689
void clear_mine()
Definition: you_tube_service.h:6597
string * mutable_hl()
Definition: you_tube_service.h:5309
void clear_on_behalf_of_content_owner()
Definition: you_tube_service.h:15395
void set_hl(const string &value)
Definition: you_tube_service.h:7614
const string & get_for_username() const
Definition: you_tube_service.h:3158
util::Status ExecuteAndParseResponse(LiveBroadcastListResponse *data)
Definition: you_tube_service.h:6806
void clear_for_developer()
Definition: you_tube_service.h:11206
string * mutable_hl()
Definition: you_tube_service.h:10535
void set_on_behalf_of_content_owner(const string &value)
Definition: you_tube_service.h:3007
util::Status ExecuteAndParseResponse(CommentThread *data)
Definition: you_tube_service.h:4356
void set_stabilize(bool value)
Definition: you_tube_service.h:14490
void clear_page_token()
Definition: you_tube_service.h:8701
const string & get_on_behalf_of() const
Definition: you_tube_service.h:1145
void set_on_behalf_of_content_owner_channel(const string &value)
Definition: you_tube_service.h:8402
static const client::MediaUploadSpec SIMPLE_MEDIA_UPLOAD
Definition: you_tube_service.h:1594
const string & get_on_behalf_of_content_owner_channel() const
Definition: you_tube_service.h:8365
~ChannelsResource()
Definition: you_tube_service.h:16228
void clear_region_code()
Definition: you_tube_service.h:5163
util::Status ExecuteAndParseResponse(ChannelBannerResource *data)
Definition: you_tube_service.h:2275
void set_text_format(const string &value)
Definition: you_tube_service.h:4173
void set_quota_user(const string &value)
Definition: you_tube_service.h:380
string * mutable_fields()
Definition: you_tube_service.h:220
void set_page_token(const string &value)
Definition: you_tube_service.h:4086
void set_page_token(const string &value)
Definition: you_tube_service.h:759
const string & get_filter_by_member_channel_id() const
Definition: you_tube_service.h:9053
void set_safe_search(const string &value)
Definition: you_tube_service.h:11804
void clear_broadcast_type()
Definition: you_tube_service.h:6487
const string & get_event_type() const
Definition: you_tube_service.h:11141
Definition: subscription.h:57
const string & get_on_behalf_of_content_owner() const
Definition: you_tube_service.h:10665
void set_video_license(const string &value)
Definition: you_tube_service.h:12193
void clear_on_behalf_of_content_owner()
Definition: you_tube_service.h:9535
string * mutable_tfmt()
Definition: you_tube_service.h:1245
void clear_max_results()
Definition: you_tube_service.h:3304
void set_mine(bool value)
Definition: you_tube_service.h:10645
const MembersResource & get_members() const
Definition: you_tube_service.h:18448
const string & get_channel_id() const
Definition: you_tube_service.h:2160
const string & get_channel_type() const
Definition: you_tube_service.h:11100
void clear_home()
Definition: you_tube_service.h:644
const string & get_page_token() const
Definition: you_tube_service.h:13181
void set_on_behalf_of_content_owner_channel(const string &value)
Definition: you_tube_service.h:10754
void set_hl(const string &value)
Definition: you_tube_service.h:13710
const string & get_on_behalf_of_content_owner() const
Definition: you_tube_service.h:2208
void set_broadcast_status(const string &value)
Definition: you_tube_service.h:6477
void set_broadcast_type(const string &value)
Definition: you_tube_service.h:6519
bool get_my_subscribers() const
Definition: you_tube_service.h:13003
void clear_id()
Definition: you_tube_service.h:3229
util::Status ExecuteAndParseResponse(LiveStreamListResponse *data)
Definition: you_tube_service.h:8771
util::Status ExecuteAndParseResponse(LiveChatModerator *data)
Definition: you_tube_service.h:7910
void clear_filter()
Definition: you_tube_service.h:12432
void set_id(const string &value)
Definition: you_tube_service.h:2784
const string & get_page_token() const
Definition: you_tube_service.h:13404
string * mutable_onBehalfOfContentOwner()
Definition: you_tube_service.h:9436
void clear_topic_id()
Definition: you_tube_service.h:11814
void set_max_results(uint32 value)
Definition: you_tube_service.h:9732
void set_hl(const string &value)
Definition: you_tube_service.h:3219
Definition: you_tube_service.h:10134
string * mutable_onBehalfOfContentOwner()
Definition: you_tube_service.h:11417
util::Status ExecuteAndParseResponse(CommentListResponse *data)
Definition: you_tube_service.h:4774
const string & get_on_behalf_of_content_owner() const
Definition: you_tube_service.h:9428
string * mutable_onBehalfOfContentOwner()
Definition: you_tube_service.h:9554
void set_on_behalf_of_content_owner_channel(const string &value)
Definition: you_tube_service.h:8691
void clear_page_token()
Definition: you_tube_service.h:11489
~PlaylistItemsResource()
Definition: you_tube_service.h:17334
string * mutable_videoEmbeddable()
Definition: you_tube_service.h:12134
void set_sync(bool value)
Definition: you_tube_service.h:2020
const string & get_video_id() const
Definition: you_tube_service.h:9890
string * mutable_myRating()
Definition: you_tube_service.h:14881
void clear_id()
Definition: you_tube_service.h:12867
const SponsorsResource & get_sponsors() const
Definition: you_tube_service.h:18498
const string & get_on_behalf_of() const
Definition: you_tube_service.h:987
void clear_on_behalf_of_content_owner()
Definition: you_tube_service.h:5845
void clear_on_behalf_of_content_owner()
Definition: you_tube_service.h:5538
const string & get_page_token() const
Definition: you_tube_service.h:12510
void clear_order()
Definition: you_tube_service.h:11449
void set_on_behalf_of_content_owner_channel(const string &value)
Definition: you_tube_service.h:7194
void set_max_results(uint32 value)
Definition: you_tube_service.h:12928
const string & get_page_token() const
Definition: you_tube_service.h:4627
void set_max_results(uint32 value)
Definition: you_tube_service.h:691
uint32 get_max_results() const
Definition: you_tube_service.h:3315
util::Status ExecuteAndParseResponse(Video *data)
Definition: you_tube_service.h:15473
string * mutable_onBehalfOfContentOwnerChannel()
Definition: you_tube_service.h:6697
void set_on_behalf_of_content_owner(const string &value)
Definition: you_tube_service.h:8162
string * mutable_onBehalfOfContentOwnerChannel()
Definition: you_tube_service.h:13091
const string & get_page_token() const
Definition: you_tube_service.h:11500
const ChannelsResource & get_channels() const
Definition: you_tube_service.h:18338
string * mutable_onBehalfOfContentOwner()
Definition: you_tube_service.h:10047
const string & get_on_behalf_of_content_owner() const
Definition: you_tube_service.h:1747
util::Status ExecuteAndParseResponse(LiveChatMessage *data)
Definition: you_tube_service.h:7524
string * mutable_moderationStatus()
Definition: you_tube_service.h:3977
void set_display_slate(bool value)
Definition: you_tube_service.h:5797
void set_channel_type(const string &value)
Definition: you_tube_service.h:11120
void clear_id()
Definition: you_tube_service.h:14694
util::Status ExecuteAndParseResponse(LiveChatMessageListResponse *data)
Definition: you_tube_service.h:7751
void set_channel_id(const string &value)
Definition: you_tube_service.h:2186
void clear_locale()
Definition: you_tube_service.h:14735
util::Status ExecuteAndParseResponse(LiveBroadcast *data)
Definition: you_tube_service.h:6390
string * mutable_onBehalfOfContentOwner()
Definition: you_tube_service.h:3613
void set_search_terms(const string &value)
Definition: you_tube_service.h:4131
void set_video_id(const string &value)
Definition: you_tube_service.h:9910
void set_mine(bool value)
Definition: you_tube_service.h:12955
const string & get_on_behalf_of_content_owner() const
Definition: you_tube_service.h:14021
static const client::MediaUploadSpec SIMPLE_MEDIA_UPLOAD
Definition: you_tube_service.h:13625
string * mutable_relevanceLanguage()
Definition: you_tube_service.h:11746
Definition: comment_thread.h:55
const SuperChatEventsResource & get_super_chat_events() const
Definition: you_tube_service.h:18518
const string & get_text_format() const
Definition: you_tube_service.h:4152
string * mutable_hl()
Definition: you_tube_service.h:7595
string * mutable_id()
Definition: you_tube_service.h:9691
const string & get_hl() const
Definition: you_tube_service.h:7588
string * mutable_mode()
Definition: you_tube_service.h:9175
void clear_max_results()
Definition: you_tube_service.h:12909
~ActivitiesResource()
Definition: you_tube_service.h:15807
const string & get_page_token() const
Definition: you_tube_service.h:9208
void set_channel_id(const string &value)
Definition: you_tube_service.h:3877
void clear_on_behalf_of_content_owner()
Definition: you_tube_service.h:3594
const string & get_video_duration() const
Definition: you_tube_service.h:12083
void set_on_behalf_of_content_owner(const string &value)
Definition: you_tube_service.h:10069
void set_region_code(const string &value)
Definition: you_tube_service.h:867
const string & get_page_token() const
Definition: you_tube_service.h:737
void set_published_before(client::DateTime value)
Definition: you_tube_service.h:11584
void set_video_caption(const string &value)
Definition: you_tube_service.h:11930
void clear_on_behalf_of_content_owner()
Definition: you_tube_service.h:9417
void set_on_behalf_of_content_owner_channel(const string &value)
Definition: you_tube_service.h:6726
string * mutable_searchTerms()
Definition: you_tube_service.h:4115
void clear_on_behalf_of_content_owner()
Definition: you_tube_service.h:8591
void set_video_definition(const string &value)
Definition: you_tube_service.h:12019
void clear_on_behalf_of_content_owner()
Definition: you_tube_service.h:14010
void clear_max_results()
Definition: you_tube_service.h:10599
const string & get_on_behalf_of_content_owner() const
Definition: you_tube_service.h:8602
void clear_max_results()
Definition: you_tube_service.h:8535
void clear_id()
Definition: you_tube_service.h:6529
string * mutable_pageToken()
Definition: you_tube_service.h:12518
const LiveChatMessagesResource & get_live_chat_messages() const
Definition: you_tube_service.h:18418
void clear_stream_id()
Definition: you_tube_service.h:5648
void clear_text_format()
Definition: you_tube_service.h:4141
void set_on_behalf_of_content_owner(const string &value)
Definition: you_tube_service.h:14402
string * mutable_videoSyndicated()
Definition: you_tube_service.h:12223
util::Status ExecuteAndParseResponse(CommentThread *data)
Definition: you_tube_service.h:3752
const string & get_on_behalf_of_content_owner_channel() const
Definition: you_tube_service.h:10717
const string & get_id() const
Definition: you_tube_service.h:10568
void set_max_results(uint32 value)
Definition: you_tube_service.h:8554
string * mutable_locale()
Definition: you_tube_service.h:14753
void set_related_to_video_id(const string &value)
Definition: you_tube_service.h:11716
~ChannelBannersResource()
Definition: you_tube_service.h:16060
void clear_mine()
Definition: you_tube_service.h:12936
const string & get_channel_id() const
Definition: you_tube_service.h:3855
string * mutable_onBehalfOfContentOwnerChannel()
Definition: you_tube_service.h:8373
const string & get_video_type() const
Definition: you_tube_service.h:12258
void clear_channel_id()
Definition: you_tube_service.h:10476
const string & get_fields() const
Definition: you_tube_service.h:213
Definition: channel_list_response.h:54
void clear_location()
Definition: you_tube_service.h:11266
const string & get_on_behalf_of_content_owner_channel() const
Definition: you_tube_service.h:5908
string * mutable_pageToken()
Definition: you_tube_service.h:13412
void clear_on_behalf_of_content_owner()
Definition: you_tube_service.h:9741
void clear_quota_user()
Definition: you_tube_service.h:349
util::Status ExecuteAndParseResponse(SuperChatEventListResponse *data)
Definition: you_tube_service.h:13463
void clear_page_token()
Definition: you_tube_service.h:4050
string * mutable_videoCategoryId()
Definition: you_tube_service.h:11960
void clear_hl()
Definition: you_tube_service.h:3188
util::Status ExecuteAndParseResponse(ChannelSection *data)
Definition: you_tube_service.h:3044
util::Status ExecuteAndParseResponse(Subscription *data)
Definition: you_tube_service.h:12727
string * mutable_onBehalfOfContentOwner()
Definition: you_tube_service.h:2485
Definition: you_tube_service.h:17222
void set_max_width(uint32 value)
Definition: you_tube_service.h:14854
void clear_on_behalf_of_content_owner()
Definition: you_tube_service.h:2966
void set_on_behalf_of_content_owner(const string &value)
Definition: you_tube_service.h:14946
void set_on_behalf_of_content_owner_channel(const string &value)
Definition: you_tube_service.h:2566
void set_locale(const string &value)
Definition: you_tube_service.h:14765
void clear_max_results()
Definition: you_tube_service.h:6570
util::Status ExecuteAndParseResponse(LiveStream *data)
Definition: you_tube_service.h:8985
util::Status ExecuteAndParseResponse(Caption *data)
Definition: you_tube_service.h:2057
void set_max_results(uint32 value)
Definition: you_tube_service.h:14826
string * mutable_onBehalfOfContentOwner()
Definition: you_tube_service.h:15414
void set_on_behalf_of_content_owner(const string &value)
Definition: you_tube_service.h:10956
const string & get_type() const
Definition: you_tube_service.h:11867
Definition: live_chat_moderator_list_response.h:54
Definition: live_chat_message.h:53
const string & get_on_behalf_of_content_owner() const
Definition: you_tube_service.h:13545
string * mutable_onBehalfOfContentOwnerChannel()
Definition: you_tube_service.h:2537
bool get_mine() const
Definition: you_tube_service.h:6608
void clear_mine()
Definition: you_tube_service.h:3331
void set_id(const string &value)
Definition: you_tube_service.h:3917
const WatermarksResource & get_watermarks() const
Definition: you_tube_service.h:18568
string * mutable_onBehalfOfContentOwner()
Definition: you_tube_service.h:10673
void clear_on_behalf_of_content_owner()
Definition: you_tube_service.h:15685
void clear_on_behalf_of_content_owner_channel()
Definition: you_tube_service.h:5897
void clear_on_behalf_of_content_owner()
Definition: you_tube_service.h:13020
void clear_region_code()
Definition: you_tube_service.h:15003
void set_mine(bool value)
Definition: you_tube_service.h:3350
void clear_location_radius()
Definition: you_tube_service.h:11321
void clear_for_channel_id()
Definition: you_tube_service.h:12825
~SearchResource()
Definition: you_tube_service.h:17591
void set_has_access_to_level(const string &value)
Definition: you_tube_service.h:9120
Definition: channel_banner_resource.h:50
string * mutable_order()
Definition: you_tube_service.h:11467
void set_video_category_id(const string &value)
Definition: you_tube_service.h:15080
Definition: i18n_region_list_response.h:52
string * mutable_pageToken()
Definition: you_tube_service.h:13189
string * mutable_id()
Definition: you_tube_service.h:4563
const string & get_hl() const
Definition: you_tube_service.h:14658
void set_mine(bool value)
Definition: you_tube_service.h:6617
void clear_on_behalf_of_content_owner_channel()
Definition: you_tube_service.h:6678
string * mutable_videoCaption()
Definition: you_tube_service.h:11916
const string & get_video_embeddable() const
Definition: you_tube_service.h:12126
string * mutable_pageToken()
Definition: you_tube_service.h:7670
string * mutable_onBehalfOf()
Definition: you_tube_service.h:1922
~CommentThreadsResource()
Definition: you_tube_service.h:16322
Definition: comment_list_response.h:54
string * mutable_id()
Definition: you_tube_service.h:8512
void set_order(const string &value)
Definition: you_tube_service.h:11479
string * mutable_onBehalfOfContentOwner()
Definition: you_tube_service.h:2216
void clear_for_mine()
Definition: you_tube_service.h:11237
const string & get_broadcast_status() const
Definition: you_tube_service.h:6457
void set_on_behalf_of_content_owner(const string &value)
Definition: you_tube_service.h:9782
void clear_id()
Definition: you_tube_service.h:5121
util::Status ExecuteAndParseResponse(Playlist *data)
Definition: you_tube_service.h:10416
void clear_walltime()
Definition: you_tube_service.h:5955
void clear_order()
Definition: you_tube_service.h:13130
string * mutable_pageToken()
Definition: you_tube_service.h:9811
const string & get_hl() const
Definition: you_tube_service.h:5092
void set_region_code(const string &value)
Definition: you_tube_service.h:13914
Definition: you_tube_service.h:8811
void clear_hl()
Definition: you_tube_service.h:5291
void set_on_behalf_of_content_owner(const string &value)
Definition: you_tube_service.h:13061
Definition: you_tube_service.h:16214
Definition: thumbnail_set_response.h:52
client::DateTime get_published_before() const
Definition: you_tube_service.h:813
const string & get_id() const
Definition: you_tube_service.h:12878
Definition: you_tube_service.h:14576
bool get_notify_subscribers() const
Definition: you_tube_service.h:14339
util::Status ExecuteAndParseResponse(ChannelSectionListResponse *data)
Definition: you_tube_service.h:2900
~VideoCategoriesResource()
Definition: you_tube_service.h:17953
util::Status ExecuteAndParseResponse(Playlist *data)
Definition: you_tube_service.h:10993
void set_id(const string &value)
Definition: you_tube_service.h:4576
const string & get_parent_id() const
Definition: you_tube_service.h:4673
const string & get_for_channel_id() const
Definition: you_tube_service.h:12836
void set_on_behalf_of(const string &value)
Definition: you_tube_service.h:1456
const string & get_on_behalf_of_content_owner_channel() const
Definition: you_tube_service.h:6316
string * mutable_onBehalfOfContentOwner()
Definition: you_tube_service.h:1755
void clear_id()
Definition: you_tube_service.h:13842
const string & get_quota_user() const
Definition: you_tube_service.h:360
string * mutable_onBehalfOfContentOwner()
Definition: you_tube_service.h:10934
string * mutable_onBehalfOfContentOwner()
Definition: you_tube_service.h:6905
void clear_on_behalf_of_content_owner()
Definition: you_tube_service.h:14126
bool get_my_recent_subscribers() const
Definition: you_tube_service.h:12975
string * mutable_onBehalfOfContentOwner()
Definition: you_tube_service.h:1486
const string & get_text_format() const
Definition: you_tube_service.h:4717
string * mutable_forUsername()
Definition: you_tube_service.h:3166
util::Status ExecuteAndParseResponse(LiveBroadcast *data)
Definition: you_tube_service.h:5718
void clear_on_behalf_of_content_owner()
Definition: you_tube_service.h:2466
string * mutable_onBehalfOfContentOwner()
Definition: you_tube_service.h:14029
Definition: live_chat_ban.h:52
Definition: you_tube_service.h:13293
string * mutable_onBehalfOfContentOwnerChannel()
Definition: you_tube_service.h:6143
const string & get_on_behalf_of_content_owner_channel() const
Definition: you_tube_service.h:14424
string * mutable_hl()
Definition: you_tube_service.h:13820
~VideosResource()
Definition: you_tube_service.h:17996
const string & get_id() const
Definition: you_tube_service.h:13853
bool get_mine() const
Definition: you_tube_service.h:8573
void clear_channel_id()
Definition: you_tube_service.h:11048
void clear_video_syndicated()
Definition: you_tube_service.h:12204
~GuideCategoriesResource()
Definition: you_tube_service.h:16552
string * mutable_pageToken()
Definition: you_tube_service.h:3457
string * mutable_hl()
Definition: you_tube_service.h:5431
string * mutable_pageToken()
Definition: you_tube_service.h:10783
const ActivitiesResource & get_activities() const
Definition: you_tube_service.h:18298
void set_published_after(client::DateTime value)
Definition: you_tube_service.h:793
static const client::MediaUploadSpec RESUMABLE_MEDIA_UPLOAD
Definition: you_tube_service.h:1598
uint32 get_profile_image_size() const
Definition: you_tube_service.h:7705
void set_video_category_id(const string &value)
Definition: you_tube_service.h:11973
Definition: you_tube_service.h:5265
util::Status ExecuteAndParseResponse(LiveBroadcast *data)
Definition: you_tube_service.h:7231
bool get_mine() const
Definition: you_tube_service.h:710
void clear_safe_search()
Definition: you_tube_service.h:11773
void set_region_code(const string &value)
Definition: you_tube_service.h:5195
void clear_page_token()
Definition: you_tube_service.h:3438
void clear_max_height()
Definition: you_tube_service.h:14775
void clear_on_behalf_of_content_owner_channel()
Definition: you_tube_service.h:13072
string * mutable_onBehalfOfContentOwner()
Definition: you_tube_service.h:1037
void set_on_behalf_of_content_owner(const string &value)
Definition: you_tube_service.h:11439
void clear_id()
Definition: you_tube_service.h:2752
void clear_on_behalf_of_content_owner()
Definition: you_tube_service.h:3387
void set_on_behalf_of_content_owner(const string &value)
Definition: you_tube_service.h:6113
void set_order(const string &value)
Definition: you_tube_service.h:13160
void set_id(const string &value)
Definition: you_tube_service.h:3261
void set_chart(const string &value)
Definition: you_tube_service.h:14637
util::Status ExecuteAndParseResponse(ChannelListResponse *data)
Definition: you_tube_service.h:3508
void clear_channel_id()
Definition: you_tube_service.h:603
void clear_hl()
Definition: you_tube_service.h:5081
void set_max_results(uint32 value)
Definition: you_tube_service.h:13385
void set_max_results(uint32 value)
Definition: you_tube_service.h:9149
void clear_hl()
Definition: you_tube_service.h:14647
string * mutable_order()
Definition: you_tube_service.h:13148
string * mutable_pageToken()
Definition: you_tube_service.h:8720
void set_region_code(const string &value)
Definition: you_tube_service.h:15036
const string & get_on_behalf_of_content_owner() const
Definition: you_tube_service.h:6264
void set_playlist_id(const string &value)
Definition: you_tube_service.h:9869
const string & get_on_behalf_of_content_owner() const
Definition: you_tube_service.h:3605
const LiveChatBansResource & get_live_chat_bans() const
Definition: you_tube_service.h:18408
string * mutable_onBehalfOfContentOwnerChannel()
Definition: you_tube_service.h:10350
string * mutable_id()
Definition: you_tube_service.h:3905
void set_page_token(const string &value)
Definition: you_tube_service.h:10797
const MembershipsLevelsResource & get_memberships_levels() const
Definition: you_tube_service.h:18458
const string & get_hl() const
Definition: you_tube_service.h:13330
void clear_video_caption()
Definition: you_tube_service.h:11897
void set_location_radius(const string &value)
Definition: you_tube_service.h:11360
void set_on_behalf_of_content_owner_channel(const string &value)
Definition: you_tube_service.h:10379
void set_hl(const string &value)
Definition: you_tube_service.h:5443
static const client::MediaUploadSpec SIMPLE_MEDIA_UPLOAD
Definition: you_tube_service.h:2070
void clear_on_behalf_of()
Definition: you_tube_service.h:1134
Definition: caption.h:53
void set_on_behalf_of_content_owner(const string &value)
Definition: you_tube_service.h:9458
void set_on_behalf_of_content_owner(const string &value)
Definition: you_tube_service.h:2238
void clear_channel_id()
Definition: you_tube_service.h:2149
string * mutable_id()
Definition: you_tube_service.h:5139
Definition: you_tube_service.h:571
~SuperChatEventsResource()
Definition: you_tube_service.h:17804
void set_page_token(const string &value)
Definition: you_tube_service.h:8734
void clear_page_token()
Definition: you_tube_service.h:7651
void set_tfmt(const string &value)
Definition: you_tube_service.h:1258
string * mutable_videoId()
Definition: you_tube_service.h:4202
void set_hl(const string &value)
Definition: you_tube_service.h:14684
Definition: you_tube_service.h:9016
void clear_max_results()
Definition: you_tube_service.h:12472
void clear_on_behalf_of_content_owner()
Definition: you_tube_service.h:7094
void clear_on_behalf_of_content_owner_channel()
Definition: you_tube_service.h:8173
const string & get_video_category_id() const
Definition: you_tube_service.h:15058
void clear_max_results()
Definition: you_tube_service.h:9713
Definition: you_tube_service.h:8467
bool get_mine() const
Definition: you_tube_service.h:10637
void set_for_developer(bool value)
Definition: you_tube_service.h:11229
void clear_on_behalf_of_content_owner_channel()
Definition: you_tube_service.h:6124
void clear_event_type()
Definition: you_tube_service.h:11130
const string & get_on_behalf_of_content_owner() const
Definition: you_tube_service.h:1956
const LiveStreamsResource & get_live_streams() const
Definition: you_tube_service.h:18438
Definition: comment_thread_list_response.h:54
uint32 get_max_results() const
Definition: you_tube_service.h:3938
util::Status ExecuteAndParseResponse(ActivityListResponse *data)
Definition: you_tube_service.h:904
util::Status ExecuteAndParseResponse(Video *data)
Definition: you_tube_service.h:14527
string * mutable_alt()
Definition: you_tube_service.h:181
util::Status ExecuteAndParseResponse(Caption *data)
Definition: you_tube_service.h:1581
void clear_on_behalf_of_content_owner()
Definition: you_tube_service.h:1736
void clear_profile_image_size()
Definition: you_tube_service.h:7694
string * mutable_channelId()
Definition: you_tube_service.h:3863
util::Status ExecuteAndParseResponse(GuideCategoryListResponse *data)
Definition: you_tube_service.h:5232
void clear_channel_id()
Definition: you_tube_service.h:12784
void set_location(const string &value)
Definition: you_tube_service.h:11310
string * mutable_hl()
Definition: you_tube_service.h:14665
void set_parent_id(const string &value)
Definition: you_tube_service.h:4696
const string & get_on_behalf_of_content_owner_channel() const
Definition: you_tube_service.h:13083
uint32 get_max_results() const
Definition: you_tube_service.h:683
string * mutable_streamId()
Definition: you_tube_service.h:5667
Definition: you_tube_service.h:17634
util::Status ExecuteAndParseResponse(SearchListResponse *data)
Definition: you_tube_service.h:12316
void set_id(const string &value)
Definition: you_tube_service.h:5153
Definition: video_abuse_report.h:50
void set_page_token(const string &value)
Definition: you_tube_service.h:14993
bool get_my_subscribers() const
Definition: you_tube_service.h:3369
void set_on_behalf_of_content_owner(const string &value)
Definition: you_tube_service.h:3632
const string & get_all_threads_related_to_channel_id() const
Definition: you_tube_service.h:3812
Definition: you_tube_service.h:15502
string * mutable_tlang()
Definition: you_tube_service.h:1286
bool get_auto_levels() const
Definition: you_tube_service.h:14311
bool get_mine() const
Definition: you_tube_service.h:3342
Definition: activity_list_response.h:54
Definition: you_tube_service.h:1372
const string & get_on_behalf_of_content_owner() const
Definition: you_tube_service.h:1187
Definition: you_tube_service.h:17982
void clear_id()
Definition: you_tube_service.h:1653
string * mutable_allThreadsRelatedToChannelId()
Definition: you_tube_service.h:3820
void set_on_behalf_of_content_owner(const string &value)
Definition: you_tube_service.h:6667
Definition: you_tube_service.h:8270
string * mutable_pageToken()
Definition: you_tube_service.h:4069
uint32 get_max_results() const
Definition: you_tube_service.h:9141
const string & get_video_id() const
Definition: you_tube_service.h:4194
const string & get_related_to_video_id() const
Definition: you_tube_service.h:11694
const string & get_video_syndicated() const
Definition: you_tube_service.h:12215
void set_on_behalf_of_content_owner(const string &value)
Definition: you_tube_service.h:3428
string * mutable_order()
Definition: you_tube_service.h:4020
const string & get_hl() const
Definition: you_tube_service.h:5302
~MembershipsLevelsResource()
Definition: you_tube_service.h:17291
string * mutable_onBehalfOfContentOwner()
Definition: you_tube_service.h:7113
string * mutable_onBehalfOfContentOwner()
Definition: you_tube_service.h:1964
string * mutable_onBehalfOfContentOwner()
Definition: you_tube_service.h:14145
void clear_on_behalf_of_content_owner()
Definition: you_tube_service.h:6626
void set_on_behalf_of_content_owner(const string &value)
Definition: you_tube_service.h:10695
void set_on_behalf_of_content_owner(const string &value)
Definition: you_tube_service.h:9576
void set_text_format(const string &value)
Definition: you_tube_service.h:4737
const string & get_locale() const
Definition: you_tube_service.h:14746
Definition: you_tube_service.h:4380
const string & get_on_behalf_of_content_owner_channel() const
Definition: you_tube_service.h:2529
Definition: you_tube_service.h:12606
const string & get_video_category_id() const
Definition: you_tube_service.h:11952
const string & get_broadcast_type() const
Definition: you_tube_service.h:6498
uint32 get_max_results() const
Definition: you_tube_service.h:11381
static const client::MediaUploadSpec RESUMABLE_MEDIA_UPLOAD
Definition: you_tube_service.h:14544
bool get_ban_author() const
Definition: you_tube_service.h:4911
void set_for_channel_id(const string &value)
Definition: you_tube_service.h:12857
Definition: you_tube_service.h:1108
const string & get_channel_id() const
Definition: you_tube_service.h:10487
void clear_hl()
Definition: you_tube_service.h:7577
void clear_playlist_id()
Definition: you_tube_service.h:9835
const string & get_channel_id() const
Definition: you_tube_service.h:2676
string * mutable_onBehalfOf()
Definition: you_tube_service.h:1444
Definition: guide_category_list_response.h:54
void set_page_token(const string &value)
Definition: you_tube_service.h:7683
string * mutable_regionCode()
Definition: you_tube_service.h:15022
uint32 get_max_results() const
Definition: you_tube_service.h:4597
const string & get_on_behalf_of() const
Definition: you_tube_service.h:1914
string * mutable_onBehalfOfContentOwner()
Definition: you_tube_service.h:3406
string * mutable_textFormat()
Definition: you_tube_service.h:4160
void clear_channel_id()
Definition: you_tube_service.h:2665
void clear_mine()
Definition: you_tube_service.h:10626
void clear_on_behalf_of_content_owner()
Definition: you_tube_service.h:1945
const string & get_order() const
Definition: you_tube_service.h:13141
util::Status ExecuteAndParseResponse(ThumbnailSetResponse *data)
Definition: you_tube_service.h:13612
Definition: you_tube_service.h:10879
void clear_broadcast_status()
Definition: you_tube_service.h:6446
const string & get_on_behalf_of_content_owner_channel() const
Definition: you_tube_service.h:6135
void clear_video_id()
Definition: you_tube_service.h:4183
string * mutable_regionCode()
Definition: you_tube_service.h:13901
void clear_video_category_id()
Definition: you_tube_service.h:11941
Definition: you_tube_service.h:124
const CommentThreadsResource & get_comment_threads() const
Definition: you_tube_service.h:18348
Definition: channel_section_list_response.h:52
void set_page_token(const string &value)
Definition: you_tube_service.h:9230
string * mutable_onBehalfOfContentOwner()
Definition: you_tube_service.h:8140
bool get_use_media_download() const
Definition: you_tube_service.h:1333
string * mutable_pageToken()
Definition: you_tube_service.h:6755
void clear_on_behalf_of_content_owner()
Definition: you_tube_service.h:10028
const string & get_q() const
Definition: you_tube_service.h:11603
const string & get_on_behalf_of_content_owner() const
Definition: you_tube_service.h:14137
string * mutable_hl()
Definition: you_tube_service.h:13698
void clear_fields()
Definition: you_tube_service.h:202
const string & get_has_access_to_level() const
Definition: you_tube_service.h:9098
const string & get_on_behalf_of_content_owner() const
Definition: you_tube_service.h:6897
void clear_id()
Definition: you_tube_service.h:4545
uint32 get_max_results() const
Definition: you_tube_service.h:9724
void set_max_results(uint32 value)
Definition: you_tube_service.h:7982
const string & get_on_behalf_of_content_owner_channel() const
Definition: you_tube_service.h:7157
const string & get_on_behalf_of_content_owner() const
Definition: you_tube_service.h:8132
const string & get_region_code() const
Definition: you_tube_service.h:5174
void clear_on_behalf_of()
Definition: you_tube_service.h:1425
util::Status ExecuteAndParseResponse(VideoGetRatingResponse *data)
Definition: you_tube_service.h:14204
util::Status ExecuteAndParseResponse(Channel *data)
Definition: you_tube_service.h:3669
void clear_my_subscribers()
Definition: you_tube_service.h:3358
static const client::MediaUploadSpec SIMPLE_MEDIA_UPLOAD
Definition: you_tube_service.h:15632
void clear_mode()
Definition: you_tube_service.h:9157
string * mutable_hl()
Definition: you_tube_service.h:3206
string * mutable_onBehalfOfContentOwner()
Definition: you_tube_service.h:14380
static const client::MediaUploadSpec SIMPLE_MEDIA_UPLOAD
Definition: you_tube_service.h:2288
void clear_on_behalf_of_content_owner()
Definition: you_tube_service.h:10654
const string & get_order() const
Definition: you_tube_service.h:4013
util::Status ExecuteAndParseResponse(LiveChatBan *data)
Definition: you_tube_service.h:7380
void set_page_token(const string &value)
Definition: you_tube_service.h:13203
void set_page_token(const string &value)
Definition: you_tube_service.h:8023
Definition: you_tube_service.h:17577
Definition: you_tube_service.h:18200
void clear_region_code()
Definition: you_tube_service.h:833
void set_max_results(uint32 value)
Definition: you_tube_service.h:10618
void set_page_token(const string &value)
Definition: you_tube_service.h:12532
void set_my_recent_subscribers(bool value)
Definition: you_tube_service.h:12984
void set_mine(bool value)
Definition: you_tube_service.h:718
void set_video_id(const string &value)
Definition: you_tube_service.h:4214
void clear_sync()
Definition: you_tube_service.h:1518
static const client::MediaUploadSpec RESUMABLE_MEDIA_UPLOAD
Definition: you_tube_service.h:2074
Definition: you_tube_service.h:13776
void set_order(const string &value)
Definition: you_tube_service.h:4040
const string & get_channel_id() const
Definition: you_tube_service.h:12795
void clear_on_behalf_of_content_owner()
Definition: you_tube_service.h:14905
string * mutable_type()
Definition: you_tube_service.h:11874
void clear_text_format()
Definition: you_tube_service.h:4706
void clear_for_content_owner()
Definition: you_tube_service.h:11173
const string & get_video_dimension() const
Definition: you_tube_service.h:12041
string * mutable_id()
Definition: you_tube_service.h:6547
void set_channel_id(const string &value)
Definition: you_tube_service.h:10507
Definition: video_get_rating_response.h:52
const ChannelBannersResource & get_channel_banners() const
Definition: you_tube_service.h:18318
~WatermarksResource()
Definition: you_tube_service.h:18214
util::Status ExecuteAndParseResponse(CaptionListResponse *data)
Definition: you_tube_service.h:1814