Api roll 2: 2014-09-29

generated/googleapis/lib/youtube/v3.dart

 library googleapis.youtube.v3;
 
 import "dart:core" as core;
 import "dart:collection" as collection;
 import "dart:async" as async;
 import "dart:convert" as convert;
 
 import "package:crypto/crypto.dart" as crypto;
 import 'package:http/http.dart' as http;
 import '../src/common_internal.dart' as common_internal;
@@ skipping 6396 matching lines @@
 
 /** JSON template for the status part of a channel. */
 class ChannelStatus {
   /**
    * If true, then the user is linked to either a YouTube username or G+
    * account. Otherwise, the user doesn't have a public YouTube identity.
    */
   core.bool isLinked;
 
   /**
+   * The long uploads status of this channel. See
+   * Possible string values are:
+   * - "allowed"
+   * - "disallowed"
+   * - "eligible"
+   * - "longUploadsUnspecified"
+   */
+  core.String longUploadsStatus;
+
+  /**
    * Privacy status of the channel.
    * Possible string values are:
    * - "private"
    * - "public"
    * - "unlisted"
    */
   core.String privacyStatus;
 
 
   ChannelStatus();
 
   ChannelStatus.fromJson(core.Map _json) {
     if (_json.containsKey("isLinked")) {
       isLinked = _json["isLinked"];
     }
+    if (_json.containsKey("longUploadsStatus")) {
+      longUploadsStatus = _json["longUploadsStatus"];
+    }
     if (_json.containsKey("privacyStatus")) {
       privacyStatus = _json["privacyStatus"];
     }
   }
 
   core.Map toJson() {
     var _json = new core.Map();
     if (isLinked != null) {
       _json["isLinked"] = isLinked;
     }
+    if (longUploadsStatus != null) {
+      _json["longUploadsStatus"] = longUploadsStatus;
+    }
     if (privacyStatus != null) {
       _json["privacyStatus"] = privacyStatus;
     }
     return _json;
   }
 }
 
 
 /** Freebase topic information related to the channel. */
 class ChannelTopicDetails {
@@ skipping 2189 matching lines @@
 
   /** List of promoted items in decreasing priority. */
   core.List<PromotedItem> items;
 
   /**
    * The spatial position within the video where the promoted item will be
    * displayed.
    */
   InvideoPosition position;
 
+  /**
+   * Indicates whether the channel's promotional campaign uses "smart timing."
+   * This feature attempts to show promotions at a point in the video when they
+   * are more likely to be clicked and less likely to disrupt the viewing
+   * experience. This feature also picks up a single promotion to show on each
+   * video.
+   */
+  core.bool useSmartTiming;
+
 
   InvideoPromotion();
 
   InvideoPromotion.fromJson(core.Map _json) {
     if (_json.containsKey("defaultTiming")) {
       defaultTiming = new InvideoTiming.fromJson(_json["defaultTiming"]);
     }
     if (_json.containsKey("items")) {
       items = _json["items"].map((value) => new PromotedItem.fromJson(value)).toList();
     }
     if (_json.containsKey("position")) {
       position = new InvideoPosition.fromJson(_json["position"]);
     }
+    if (_json.containsKey("useSmartTiming")) {
+      useSmartTiming = _json["useSmartTiming"];
+    }
   }
 
   core.Map toJson() {
     var _json = new core.Map();
     if (defaultTiming != null) {
       _json["defaultTiming"] = (defaultTiming).toJson();
     }
     if (items != null) {
       _json["items"] = items.map((value) => (value).toJson()).toList();
     }
     if (position != null) {
       _json["position"] = (position).toJson();
     }
+    if (useSmartTiming != null) {
+      _json["useSmartTiming"] = useSmartTiming;
+    }
     return _json;
   }
 }
 
 
 /** Describes a temporal position of a visual widget inside a video. */
 class InvideoTiming {
   /**
    * Defines the duration in milliseconds for which the promotion should be
    * displayed. If missing, the client should use the default.
@@ skipping 674 matching lines @@
     return _json;
   }
 }
 
 
 /** Detailed settings of a stream. */
 class LiveStreamContentDetails {
   /** The ingestion URL where the closed captions of this stream are sent. */
   core.String closedCaptionsIngestionUrl;
 
+  /**
+   * Indicates whether the stream is reusable, which means that it can be bound
+   * to multiple broadcasts. It is common for broadcasters to reuse the same
+   * stream for many different broadcasts if those broadcasts occur at different
+   * times.
+   *
+   * If you set this value to false, then the stream will not be reusable, which
+   * means that it can only be bound to one broadcast. Non-reusable streams
+   * differ from reusable streams in the following ways:
+   * - A non-reusable stream can only be bound to one broadcast.
+   * - A non-reusable stream might be deleted by an automated process after the
+   * broadcast ends.
+   * - The  liveStreams.list method does not list non-reusable streams if you
+   * call the method and set the mine parameter to true. The only way to use
+   * that method to retrieve the resource for a non-reusable stream is to use
+   * the id parameter to identify the stream.
+   */
+  core.bool isReusable;
+
 
   LiveStreamContentDetails();
 
   LiveStreamContentDetails.fromJson(core.Map _json) {
     if (_json.containsKey("closedCaptionsIngestionUrl")) {
       closedCaptionsIngestionUrl = _json["closedCaptionsIngestionUrl"];
     }
+    if (_json.containsKey("isReusable")) {
+      isReusable = _json["isReusable"];
+    }
   }
 
   core.Map toJson() {
     var _json = new core.Map();
     if (closedCaptionsIngestionUrl != null) {
       _json["closedCaptionsIngestionUrl"] = closedCaptionsIngestionUrl;
     }
+    if (isReusable != null) {
+      _json["isReusable"] = isReusable;
+    }
     return _json;
   }
 }
 
 
 /** Not documented yet. */
 class LiveStreamListResponse {
   /** Etag of this resource. */
   core.String etag;
 
@@ skipping 4386 matching lines @@
       _json["featuredPlaylistId"] = featuredPlaylistId;
     }
     if (textColor != null) {
       _json["textColor"] = textColor;
     }
     return _json;
   }
 }