Roll of googleapis as of 4/7/2015.

generated/googleapis/lib/blogger/v3.dart

+// This is a generated file (see the discoveryapis_generator project).
+
 library googleapis.blogger.v3;
 
-import "dart:core" as core;
-import "dart:collection" as collection;
-import "dart:async" as async;
-import "dart:convert" as convert;
+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:_discoveryapis_commons/_discoveryapis_commons.dart' as commons;
+import 'package:crypto/crypto.dart' as crypto;
 import 'package:http/http.dart' as http;
-import '../src/common_internal.dart' as common_internal;
-import '../common/common.dart' as common;
 
-export '../common/common.dart' show ApiRequestError;
-export '../common/common.dart' show DetailedApiRequestError;
+export 'package:_discoveryapis_commons/_discoveryapis_commons.dart' show
+    ApiRequestError, DetailedApiRequestError;
+
+const core.String USER_AGENT = 'dart-api-client blogger/v3';
 
 /** API for access to the data within Blogger. */
 class BloggerApi {
   /** Manage your Blogger account */
   static const BloggerScope = "https://www.googleapis.com/auth/blogger";
 
   /** View your Blogger account */
   static const BloggerReadonlyScope = "https://www.googleapis.com/auth/blogger.readonly";
 
 
-  final common_internal.ApiRequester _requester;
+  final commons.ApiRequester _requester;
 
   BlogUserInfosResourceApi get blogUserInfos => new BlogUserInfosResourceApi(_requester);
   BlogsResourceApi get blogs => new BlogsResourceApi(_requester);
   CommentsResourceApi get comments => new CommentsResourceApi(_requester);
   PageViewsResourceApi get pageViews => new PageViewsResourceApi(_requester);
   PagesResourceApi get pages => new PagesResourceApi(_requester);
   PostUserInfosResourceApi get postUserInfos => new PostUserInfosResourceApi(_requester);
   PostsResourceApi get posts => new PostsResourceApi(_requester);
   UsersResourceApi get users => new UsersResourceApi(_requester);
 
   BloggerApi(http.Client client, {core.String rootUrl: "https://www.googleapis.com/", core.String servicePath: "blogger/v3/"}) :
-      _requester = new common_internal.ApiRequester(client, rootUrl, servicePath);
+      _requester = new commons.ApiRequester(client, rootUrl, servicePath, USER_AGENT);
 }
 
 
-/** Not documented yet. */
 class BlogUserInfosResourceApi {
-  final common_internal.ApiRequester _requester;
+  final commons.ApiRequester _requester;
 
-  BlogUserInfosResourceApi(common_internal.ApiRequester client) : 
+  BlogUserInfosResourceApi(commons.ApiRequester client) : 
       _requester = client;
 
   /**
    * Gets one blog and user info pair by blogId and userId.
    *
    * Request parameters:
    *
    * [userId] - ID of the user whose blogs are to be fetched. Either the word
    * 'self' (sans quote marks) or the user's profile identifier.
    *
    * [blogId] - The ID of the blog to get.
    *
    * [maxPosts] - Maximum number of posts to pull back with the blog.
    *
    * Completes with a [BlogUserInfo].
    *
-   * Completes with a [common.ApiRequestError] if the API endpoint returned an
+   * Completes with a [commons.ApiRequestError] if the API endpoint returned an
    * error.
    *
    * If the used [http.Client] completes with an error when making a REST call,
    * this method  will complete with the same error.
    */
   async.Future<BlogUserInfo> get(core.String userId, core.String blogId, {core.int maxPosts}) {
     var _url = null;
     var _queryParams = new core.Map();
     var _uploadMedia = null;
     var _uploadOptions = null;
-    var _downloadOptions = common.DownloadOptions.Metadata;
+    var _downloadOptions = commons.DownloadOptions.Metadata;
     var _body = null;
 
     if (userId == null) {
       throw new core.ArgumentError("Parameter userId is required.");
     }
     if (blogId == null) {
       throw new core.ArgumentError("Parameter blogId is required.");
     }
     if (maxPosts != null) {
       _queryParams["maxPosts"] = ["${maxPosts}"];
     }
 
 
-    _url = 'users/' + common_internal.Escaper.ecapeVariable('$userId') + '/blogs/' + common_internal.Escaper.ecapeVariable('$blogId');
+    _url = 'users/' + commons.Escaper.ecapeVariable('$userId') + '/blogs/' + commons.Escaper.ecapeVariable('$blogId');
 
     var _response = _requester.request(_url,
                                        "GET",
                                        body: _body,
                                        queryParams: _queryParams,
                                        uploadOptions: _uploadOptions,
                                        uploadMedia: _uploadMedia,
                                        downloadOptions: _downloadOptions);
     return _response.then((data) => new BlogUserInfo.fromJson(data));
   }
 
 }
 
 
-/** Not documented yet. */
 class BlogsResourceApi {
-  final common_internal.ApiRequester _requester;
+  final commons.ApiRequester _requester;
 
-  BlogsResourceApi(common_internal.ApiRequester client) : 
+  BlogsResourceApi(commons.ApiRequester client) : 
       _requester = client;
 
   /**
    * Gets one blog by ID.
    *
    * Request parameters:
    *
    * [blogId] - The ID of the blog to get.
    *
    * [maxPosts] - Maximum number of posts to pull back with the blog.
    *
    * [view] - Access level with which to view the blog. Note that some fields
    * require elevated access.
    * Possible string values are:
    * - "ADMIN" : Admin level detail.
    * - "AUTHOR" : Author level detail.
    * - "READER" : Reader level detail.
    *
    * Completes with a [Blog].
    *
-   * Completes with a [common.ApiRequestError] if the API endpoint returned an
+   * Completes with a [commons.ApiRequestError] if the API endpoint returned an
    * error.
    *
    * If the used [http.Client] completes with an error when making a REST call,
    * this method  will complete with the same error.
    */
   async.Future<Blog> get(core.String blogId, {core.int maxPosts, core.String view}) {
     var _url = null;
     var _queryParams = new core.Map();
     var _uploadMedia = null;
     var _uploadOptions = null;
-    var _downloadOptions = common.DownloadOptions.Metadata;
+    var _downloadOptions = commons.DownloadOptions.Metadata;
     var _body = null;
 
     if (blogId == null) {
       throw new core.ArgumentError("Parameter blogId is required.");
     }
     if (maxPosts != null) {
       _queryParams["maxPosts"] = ["${maxPosts}"];
     }
     if (view != null) {
       _queryParams["view"] = [view];
     }
 
 
-    _url = 'blogs/' + common_internal.Escaper.ecapeVariable('$blogId');
+    _url = 'blogs/' + commons.Escaper.ecapeVariable('$blogId');
 
     var _response = _requester.request(_url,
                                        "GET",
                                        body: _body,
                                        queryParams: _queryParams,
                                        uploadOptions: _uploadOptions,
                                        uploadMedia: _uploadMedia,
                                        downloadOptions: _downloadOptions);
     return _response.then((data) => new Blog.fromJson(data));
   }
 
   /**
    * Retrieve a Blog by URL.
    *
    * Request parameters:
    *
    * [url] - The URL of the blog to retrieve.
    *
    * [view] - Access level with which to view the blog. Note that some fields
    * require elevated access.
    * Possible string values are:
    * - "ADMIN" : Admin level detail.
    * - "AUTHOR" : Author level detail.
    * - "READER" : Reader level detail.
    *
    * Completes with a [Blog].
    *
-   * Completes with a [common.ApiRequestError] if the API endpoint returned an
+   * Completes with a [commons.ApiRequestError] if the API endpoint returned an
    * error.
    *
    * If the used [http.Client] completes with an error when making a REST call,
    * this method  will complete with the same error.
    */
   async.Future<Blog> getByUrl(core.String url, {core.String view}) {
     var _url = null;
     var _queryParams = new core.Map();
     var _uploadMedia = null;
     var _uploadOptions = null;
-    var _downloadOptions = common.DownloadOptions.Metadata;
+    var _downloadOptions = commons.DownloadOptions.Metadata;
     var _body = null;
 
     if (url == null) {
       throw new core.ArgumentError("Parameter url is required.");
     }
     _queryParams["url"] = [url];
     if (view != null) {
       _queryParams["view"] = [view];
     }
 
@@ skipping 30 matching lines @@
    *
    * [view] - Access level with which to view the blogs. Note that some fields
    * require elevated access.
    * Possible string values are:
    * - "ADMIN" : Admin level detail.
    * - "AUTHOR" : Author level detail.
    * - "READER" : Reader level detail.
    *
    * Completes with a [BlogList].
    *
-   * Completes with a [common.ApiRequestError] if the API endpoint returned an
+   * Completes with a [commons.ApiRequestError] if the API endpoint returned an
    * error.
    *
    * If the used [http.Client] completes with an error when making a REST call,
    * this method  will complete with the same error.
    */
   async.Future<BlogList> listByUser(core.String userId, {core.bool fetchUserInfo, core.List<core.String> role, core.List<core.String> status, core.String view}) {
     var _url = null;
     var _queryParams = new core.Map();
     var _uploadMedia = null;
     var _uploadOptions = null;
-    var _downloadOptions = common.DownloadOptions.Metadata;
+    var _downloadOptions = commons.DownloadOptions.Metadata;
     var _body = null;
 
     if (userId == null) {
       throw new core.ArgumentError("Parameter userId is required.");
     }
     if (fetchUserInfo != null) {
       _queryParams["fetchUserInfo"] = ["${fetchUserInfo}"];
     }
     if (role != null) {
       _queryParams["role"] = role;
     }
     if (status != null) {
       _queryParams["status"] = status;
     }
     if (view != null) {
       _queryParams["view"] = [view];
     }
 
 
-    _url = 'users/' + common_internal.Escaper.ecapeVariable('$userId') + '/blogs';
+    _url = 'users/' + commons.Escaper.ecapeVariable('$userId') + '/blogs';
 
     var _response = _requester.request(_url,
                                        "GET",
                                        body: _body,
                                        queryParams: _queryParams,
                                        uploadOptions: _uploadOptions,
                                        uploadMedia: _uploadMedia,
                                        downloadOptions: _downloadOptions);
     return _response.then((data) => new BlogList.fromJson(data));
   }
 
 }
 
 
-/** Not documented yet. */
 class CommentsResourceApi {
-  final common_internal.ApiRequester _requester;
+  final commons.ApiRequester _requester;
 
-  CommentsResourceApi(common_internal.ApiRequester client) : 
+  CommentsResourceApi(commons.ApiRequester client) : 
       _requester = client;
 
   /**
    * Marks a comment as not spam.
    *
    * Request parameters:
    *
    * [blogId] - The ID of the Blog.
    *
    * [postId] - The ID of the Post.
    *
    * [commentId] - The ID of the comment to mark as not spam.
    *
    * Completes with a [Comment].
    *
-   * Completes with a [common.ApiRequestError] if the API endpoint returned an
+   * Completes with a [commons.ApiRequestError] if the API endpoint returned an
    * error.
    *
    * If the used [http.Client] completes with an error when making a REST call,
    * this method  will complete with the same error.
    */
   async.Future<Comment> approve(core.String blogId, core.String postId, core.String commentId) {
     var _url = null;
     var _queryParams = new core.Map();
     var _uploadMedia = null;
     var _uploadOptions = null;
-    var _downloadOptions = common.DownloadOptions.Metadata;
+    var _downloadOptions = commons.DownloadOptions.Metadata;
     var _body = null;
 
     if (blogId == null) {
       throw new core.ArgumentError("Parameter blogId is required.");
     }
     if (postId == null) {
       throw new core.ArgumentError("Parameter postId is required.");
     }
     if (commentId == null) {
       throw new core.ArgumentError("Parameter commentId is required.");
     }
 
 
-    _url = 'blogs/' + common_internal.Escaper.ecapeVariable('$blogId') + '/posts/' + common_internal.Escaper.ecapeVariable('$postId') + '/comments/' + common_internal.Escaper.ecapeVariable('$commentId') + '/approve';
+    _url = 'blogs/' + commons.Escaper.ecapeVariable('$blogId') + '/posts/' + commons.Escaper.ecapeVariable('$postId') + '/comments/' + commons.Escaper.ecapeVariable('$commentId') + '/approve';
 
     var _response = _requester.request(_url,
                                        "POST",
                                        body: _body,
                                        queryParams: _queryParams,
                                        uploadOptions: _uploadOptions,
                                        uploadMedia: _uploadMedia,
                                        downloadOptions: _downloadOptions);
     return _response.then((data) => new Comment.fromJson(data));
   }
 
   /**
    * Delete a comment by ID.
    *
    * Request parameters:
    *
    * [blogId] - The ID of the Blog.
    *
    * [postId] - The ID of the Post.
    *
    * [commentId] - The ID of the comment to delete.
    *
-   * Completes with a [common.ApiRequestError] if the API endpoint returned an
+   * Completes with a [commons.ApiRequestError] if the API endpoint returned an
    * error.
    *
    * If the used [http.Client] completes with an error when making a REST call,
    * this method  will complete with the same error.
    */
   async.Future delete(core.String blogId, core.String postId, core.String commentId) {
     var _url = null;
     var _queryParams = new core.Map();
     var _uploadMedia = null;
     var _uploadOptions = null;
-    var _downloadOptions = common.DownloadOptions.Metadata;
+    var _downloadOptions = commons.DownloadOptions.Metadata;
     var _body = null;
 
     if (blogId == null) {
       throw new core.ArgumentError("Parameter blogId is required.");
     }
     if (postId == null) {
       throw new core.ArgumentError("Parameter postId is required.");
     }
     if (commentId == null) {
       throw new core.ArgumentError("Parameter commentId is required.");
     }
 
     _downloadOptions = null;
 
-    _url = 'blogs/' + common_internal.Escaper.ecapeVariable('$blogId') + '/posts/' + common_internal.Escaper.ecapeVariable('$postId') + '/comments/' + common_internal.Escaper.ecapeVariable('$commentId');
+    _url = 'blogs/' + commons.Escaper.ecapeVariable('$blogId') + '/posts/' + commons.Escaper.ecapeVariable('$postId') + '/comments/' + commons.Escaper.ecapeVariable('$commentId');
 
     var _response = _requester.request(_url,
                                        "DELETE",
                                        body: _body,
                                        queryParams: _queryParams,
                                        uploadOptions: _uploadOptions,
                                        uploadMedia: _uploadMedia,
                                        downloadOptions: _downloadOptions);
     return _response.then((data) => null);
   }
@@ skipping 13 matching lines @@
    * that some comments will require elevated permissions, for example comments
    * where the parent posts which is in a draft state, or comments that are
    * pending moderation.
    * Possible string values are:
    * - "ADMIN" : Admin level detail
    * - "AUTHOR" : Author level detail
    * - "READER" : Admin level detail
    *
    * Completes with a [Comment].
    *
-   * Completes with a [common.ApiRequestError] if the API endpoint returned an
+   * Completes with a [commons.ApiRequestError] if the API endpoint returned an
    * error.
    *
    * If the used [http.Client] completes with an error when making a REST call,
    * this method  will complete with the same error.
    */
   async.Future<Comment> get(core.String blogId, core.String postId, core.String commentId, {core.String view}) {
     var _url = null;
     var _queryParams = new core.Map();
     var _uploadMedia = null;
     var _uploadOptions = null;
-    var _downloadOptions = common.DownloadOptions.Metadata;
+    var _downloadOptions = commons.DownloadOptions.Metadata;
     var _body = null;
 
     if (blogId == null) {
       throw new core.ArgumentError("Parameter blogId is required.");
     }
     if (postId == null) {
       throw new core.ArgumentError("Parameter postId is required.");
     }
     if (commentId == null) {
       throw new core.ArgumentError("Parameter commentId is required.");
     }
     if (view != null) {
       _queryParams["view"] = [view];
     }
 
 
-    _url = 'blogs/' + common_internal.Escaper.ecapeVariable('$blogId') + '/posts/' + common_internal.Escaper.ecapeVariable('$postId') + '/comments/' + common_internal.Escaper.ecapeVariable('$commentId');
+    _url = 'blogs/' + commons.Escaper.ecapeVariable('$blogId') + '/posts/' + commons.Escaper.ecapeVariable('$postId') + '/comments/' + commons.Escaper.ecapeVariable('$commentId');
 
     var _response = _requester.request(_url,
                                        "GET",
                                        body: _body,
                                        queryParams: _queryParams,
                                        uploadOptions: _uploadOptions,
                                        uploadMedia: _uploadMedia,
                                        downloadOptions: _downloadOptions);
     return _response.then((data) => new Comment.fromJson(data));
   }
@@ skipping 23 matching lines @@
    *
    * [view] - Access level with which to view the returned result. Note that
    * some fields require elevated access.
    * Possible string values are:
    * - "ADMIN" : Admin level detail
    * - "AUTHOR" : Author level detail
    * - "READER" : Reader level detail
    *
    * Completes with a [CommentList].
    *
-   * Completes with a [common.ApiRequestError] if the API endpoint returned an
+   * Completes with a [commons.ApiRequestError] if the API endpoint returned an
    * error.
    *
    * If the used [http.Client] completes with an error when making a REST call,
    * this method  will complete with the same error.
    */
   async.Future<CommentList> list(core.String blogId, core.String postId, {core.DateTime endDate, core.bool fetchBodies, core.int maxResults, core.String pageToken, core.DateTime startDate, core.List<core.String> status, core.String view}) {
     var _url = null;
     var _queryParams = new core.Map();
     var _uploadMedia = null;
     var _uploadOptions = null;
-    var _downloadOptions = common.DownloadOptions.Metadata;
+    var _downloadOptions = commons.DownloadOptions.Metadata;
     var _body = null;
 
     if (blogId == null) {
       throw new core.ArgumentError("Parameter blogId is required.");
     }
     if (postId == null) {
       throw new core.ArgumentError("Parameter postId is required.");
     }
     if (endDate != null) {
       _queryParams["endDate"] = [(endDate).toIso8601String()];
@@ skipping 11 matching lines @@
       _queryParams["startDate"] = [(startDate).toIso8601String()];
     }
     if (status != null) {
       _queryParams["status"] = status;
     }
     if (view != null) {
       _queryParams["view"] = [view];
     }
 
 
-    _url = 'blogs/' + common_internal.Escaper.ecapeVariable('$blogId') + '/posts/' + common_internal.Escaper.ecapeVariable('$postId') + '/comments';
+    _url = 'blogs/' + commons.Escaper.ecapeVariable('$blogId') + '/posts/' + commons.Escaper.ecapeVariable('$postId') + '/comments';
 
     var _response = _requester.request(_url,
                                        "GET",
                                        body: _body,
                                        queryParams: _queryParams,
                                        uploadOptions: _uploadOptions,
                                        uploadMedia: _uploadMedia,
                                        downloadOptions: _downloadOptions);
     return _response.then((data) => new CommentList.fromJson(data));
   }
@@ skipping 14 matching lines @@
    *
    * [pageToken] - Continuation token if request is paged.
    *
    * [startDate] - Earliest date of comment to fetch, a date-time with RFC 3339
    * formatting.
    *
    * [status] - null
    *
    * Completes with a [CommentList].
    *
-   * Completes with a [common.ApiRequestError] if the API endpoint returned an
+   * Completes with a [commons.ApiRequestError] if the API endpoint returned an
    * error.
    *
    * If the used [http.Client] completes with an error when making a REST call,
    * this method  will complete with the same error.
    */
   async.Future<CommentList> listByBlog(core.String blogId, {core.DateTime endDate, core.bool fetchBodies, core.int maxResults, core.String pageToken, core.DateTime startDate, core.List<core.String> status}) {
     var _url = null;
     var _queryParams = new core.Map();
     var _uploadMedia = null;
     var _uploadOptions = null;
-    var _downloadOptions = common.DownloadOptions.Metadata;
+    var _downloadOptions = commons.DownloadOptions.Metadata;
     var _body = null;
 
     if (blogId == null) {
       throw new core.ArgumentError("Parameter blogId is required.");
     }
     if (endDate != null) {
       _queryParams["endDate"] = [(endDate).toIso8601String()];
     }
     if (fetchBodies != null) {
       _queryParams["fetchBodies"] = ["${fetchBodies}"];
     }
     if (maxResults != null) {
       _queryParams["maxResults"] = ["${maxResults}"];
     }
     if (pageToken != null) {
       _queryParams["pageToken"] = [pageToken];
     }
     if (startDate != null) {
       _queryParams["startDate"] = [(startDate).toIso8601String()];
     }
     if (status != null) {
       _queryParams["status"] = status;
     }
 
 
-    _url = 'blogs/' + common_internal.Escaper.ecapeVariable('$blogId') + '/comments';
+    _url = 'blogs/' + commons.Escaper.ecapeVariable('$blogId') + '/comments';
 
     var _response = _requester.request(_url,
                                        "GET",
                                        body: _body,
                                        queryParams: _queryParams,
                                        uploadOptions: _uploadOptions,
                                        uploadMedia: _uploadMedia,
                                        downloadOptions: _downloadOptions);
     return _response.then((data) => new CommentList.fromJson(data));
   }
 
   /**
    * Marks a comment as spam.
    *
    * Request parameters:
    *
    * [blogId] - The ID of the Blog.
    *
    * [postId] - The ID of the Post.
    *
    * [commentId] - The ID of the comment to mark as spam.
    *
    * Completes with a [Comment].
    *
-   * Completes with a [common.ApiRequestError] if the API endpoint returned an
+   * Completes with a [commons.ApiRequestError] if the API endpoint returned an
    * error.
    *
    * If the used [http.Client] completes with an error when making a REST call,
    * this method  will complete with the same error.
    */
   async.Future<Comment> markAsSpam(core.String blogId, core.String postId, core.String commentId) {
     var _url = null;
     var _queryParams = new core.Map();
     var _uploadMedia = null;
     var _uploadOptions = null;
-    var _downloadOptions = common.DownloadOptions.Metadata;
+    var _downloadOptions = commons.DownloadOptions.Metadata;
     var _body = null;
 
     if (blogId == null) {
       throw new core.ArgumentError("Parameter blogId is required.");
     }
     if (postId == null) {
       throw new core.ArgumentError("Parameter postId is required.");
     }
     if (commentId == null) {
       throw new core.ArgumentError("Parameter commentId is required.");
     }
 
 
-    _url = 'blogs/' + common_internal.Escaper.ecapeVariable('$blogId') + '/posts/' + common_internal.Escaper.ecapeVariable('$postId') + '/comments/' + common_internal.Escaper.ecapeVariable('$commentId') + '/spam';
+    _url = 'blogs/' + commons.Escaper.ecapeVariable('$blogId') + '/posts/' + commons.Escaper.ecapeVariable('$postId') + '/comments/' + commons.Escaper.ecapeVariable('$commentId') + '/spam';
 
     var _response = _requester.request(_url,
                                        "POST",
                                        body: _body,
                                        queryParams: _queryParams,
                                        uploadOptions: _uploadOptions,
                                        uploadMedia: _uploadMedia,
                                        downloadOptions: _downloadOptions);
     return _response.then((data) => new Comment.fromJson(data));
   }
 
   /**
    * Removes the content of a comment.
    *
    * Request parameters:
    *
    * [blogId] - The ID of the Blog.
    *
    * [postId] - The ID of the Post.
    *
    * [commentId] - The ID of the comment to delete content from.
    *
    * Completes with a [Comment].
    *
-   * Completes with a [common.ApiRequestError] if the API endpoint returned an
+   * Completes with a [commons.ApiRequestError] if the API endpoint returned an
    * error.
    *
    * If the used [http.Client] completes with an error when making a REST call,
    * this method  will complete with the same error.
    */
   async.Future<Comment> removeContent(core.String blogId, core.String postId, core.String commentId) {
     var _url = null;
     var _queryParams = new core.Map();
     var _uploadMedia = null;
     var _uploadOptions = null;
-    var _downloadOptions = common.DownloadOptions.Metadata;
+    var _downloadOptions = commons.DownloadOptions.Metadata;
     var _body = null;
 
     if (blogId == null) {
       throw new core.ArgumentError("Parameter blogId is required.");
     }
     if (postId == null) {
       throw new core.ArgumentError("Parameter postId is required.");
     }
     if (commentId == null) {
       throw new core.ArgumentError("Parameter commentId is required.");
     }
 
 
-    _url = 'blogs/' + common_internal.Escaper.ecapeVariable('$blogId') + '/posts/' + common_internal.Escaper.ecapeVariable('$postId') + '/comments/' + common_internal.Escaper.ecapeVariable('$commentId') + '/removecontent';
+    _url = 'blogs/' + commons.Escaper.ecapeVariable('$blogId') + '/posts/' + commons.Escaper.ecapeVariable('$postId') + '/comments/' + commons.Escaper.ecapeVariable('$commentId') + '/removecontent';
 
     var _response = _requester.request(_url,
                                        "POST",
                                        body: _body,
                                        queryParams: _queryParams,
                                        uploadOptions: _uploadOptions,
                                        uploadMedia: _uploadMedia,
                                        downloadOptions: _downloadOptions);
     return _response.then((data) => new Comment.fromJson(data));
   }
 
 }
 
 
-/** Not documented yet. */
 class PageViewsResourceApi {
-  final common_internal.ApiRequester _requester;
+  final commons.ApiRequester _requester;
 
-  PageViewsResourceApi(common_internal.ApiRequester client) : 
+  PageViewsResourceApi(commons.ApiRequester client) : 
       _requester = client;
 
   /**
    * Retrieve pageview stats for a Blog.
    *
    * Request parameters:
    *
    * [blogId] - The ID of the blog to get.
    *
    * [range] - null
    *
    * Completes with a [Pageviews].
    *
-   * Completes with a [common.ApiRequestError] if the API endpoint returned an
+   * Completes with a [commons.ApiRequestError] if the API endpoint returned an
    * error.
    *
    * If the used [http.Client] completes with an error when making a REST call,
    * this method  will complete with the same error.
    */
   async.Future<Pageviews> get(core.String blogId, {core.List<core.String> range}) {
     var _url = null;
     var _queryParams = new core.Map();
     var _uploadMedia = null;
     var _uploadOptions = null;
-    var _downloadOptions = common.DownloadOptions.Metadata;
+    var _downloadOptions = commons.DownloadOptions.Metadata;
     var _body = null;
 
     if (blogId == null) {
       throw new core.ArgumentError("Parameter blogId is required.");
     }
     if (range != null) {
       _queryParams["range"] = range;
     }
 
 
-    _url = 'blogs/' + common_internal.Escaper.ecapeVariable('$blogId') + '/pageviews';
+    _url = 'blogs/' + commons.Escaper.ecapeVariable('$blogId') + '/pageviews';
 
     var _response = _requester.request(_url,
                                        "GET",
                                        body: _body,
                                        queryParams: _queryParams,
                                        uploadOptions: _uploadOptions,
                                        uploadMedia: _uploadMedia,
                                        downloadOptions: _downloadOptions);
     return _response.then((data) => new Pageviews.fromJson(data));
   }
 
 }
 
 
-/** Not documented yet. */
 class PagesResourceApi {
-  final common_internal.ApiRequester _requester;
+  final commons.ApiRequester _requester;
 
-  PagesResourceApi(common_internal.ApiRequester client) : 
+  PagesResourceApi(commons.ApiRequester client) : 
       _requester = client;
 
   /**
    * Delete a page by ID.
    *
    * Request parameters:
    *
    * [blogId] - The ID of the Blog.
    *
    * [pageId] - The ID of the Page.
    *
-   * Completes with a [common.ApiRequestError] if the API endpoint returned an
+   * Completes with a [commons.ApiRequestError] if the API endpoint returned an
    * error.
    *
    * If the used [http.Client] completes with an error when making a REST call,
    * this method  will complete with the same error.
    */
   async.Future delete(core.String blogId, core.String pageId) {
     var _url = null;
     var _queryParams = new core.Map();
     var _uploadMedia = null;
     var _uploadOptions = null;
-    var _downloadOptions = common.DownloadOptions.Metadata;
+    var _downloadOptions = commons.DownloadOptions.Metadata;
     var _body = null;
 
     if (blogId == null) {
       throw new core.ArgumentError("Parameter blogId is required.");
     }
     if (pageId == null) {
       throw new core.ArgumentError("Parameter pageId is required.");
     }
 
     _downloadOptions = null;
 
-    _url = 'blogs/' + common_internal.Escaper.ecapeVariable('$blogId') + '/pages/' + common_internal.Escaper.ecapeVariable('$pageId');
+    _url = 'blogs/' + commons.Escaper.ecapeVariable('$blogId') + '/pages/' + commons.Escaper.ecapeVariable('$pageId');
 
     var _response = _requester.request(_url,
                                        "DELETE",
                                        body: _body,
                                        queryParams: _queryParams,
                                        uploadOptions: _uploadOptions,
                                        uploadMedia: _uploadMedia,
                                        downloadOptions: _downloadOptions);
     return _response.then((data) => null);
   }
 
   /**
    * Gets one blog page by ID.
    *
    * Request parameters:
    *
    * [blogId] - ID of the blog containing the page.
    *
    * [pageId] - The ID of the page to get.
    *
    * [view] - null
    * Possible string values are:
    * - "ADMIN" : Admin level detail
    * - "AUTHOR" : Author level detail
    * - "READER" : Reader level detail
    *
    * Completes with a [Page].
    *
-   * Completes with a [common.ApiRequestError] if the API endpoint returned an
+   * Completes with a [commons.ApiRequestError] if the API endpoint returned an
    * error.
    *
    * If the used [http.Client] completes with an error when making a REST call,
    * this method  will complete with the same error.
    */
   async.Future<Page> get(core.String blogId, core.String pageId, {core.String view}) {
     var _url = null;
     var _queryParams = new core.Map();
     var _uploadMedia = null;
     var _uploadOptions = null;
-    var _downloadOptions = common.DownloadOptions.Metadata;
+    var _downloadOptions = commons.DownloadOptions.Metadata;
     var _body = null;
 
     if (blogId == null) {
       throw new core.ArgumentError("Parameter blogId is required.");
     }
     if (pageId == null) {
       throw new core.ArgumentError("Parameter pageId is required.");
     }
     if (view != null) {
       _queryParams["view"] = [view];
     }
 
 
-    _url = 'blogs/' + common_internal.Escaper.ecapeVariable('$blogId') + '/pages/' + common_internal.Escaper.ecapeVariable('$pageId');
+    _url = 'blogs/' + commons.Escaper.ecapeVariable('$blogId') + '/pages/' + commons.Escaper.ecapeVariable('$pageId');
 
     var _response = _requester.request(_url,
                                        "GET",
                                        body: _body,
                                        queryParams: _queryParams,
                                        uploadOptions: _uploadOptions,
                                        uploadMedia: _uploadMedia,
                                        downloadOptions: _downloadOptions);
     return _response.then((data) => new Page.fromJson(data));
   }
 
   /**
    * Add a page.
    *
    * [request] - The metadata request object.
    *
    * Request parameters:
    *
    * [blogId] - ID of the blog to add the page to.
    *
    * [isDraft] - Whether to create the page as a draft (default: false).
    *
    * Completes with a [Page].
    *
-   * Completes with a [common.ApiRequestError] if the API endpoint returned an
+   * Completes with a [commons.ApiRequestError] if the API endpoint returned an
    * error.
    *
    * If the used [http.Client] completes with an error when making a REST call,
    * this method  will complete with the same error.
    */
   async.Future<Page> insert(Page request, core.String blogId, {core.bool isDraft}) {
     var _url = null;
     var _queryParams = new core.Map();
     var _uploadMedia = null;
     var _uploadOptions = null;
-    var _downloadOptions = common.DownloadOptions.Metadata;
+    var _downloadOptions = commons.DownloadOptions.Metadata;
     var _body = null;
 
     if (request != null) {
       _body = convert.JSON.encode((request).toJson());
     }
     if (blogId == null) {
       throw new core.ArgumentError("Parameter blogId is required.");
     }
     if (isDraft != null) {
       _queryParams["isDraft"] = ["${isDraft}"];
     }
 
 
-    _url = 'blogs/' + common_internal.Escaper.ecapeVariable('$blogId') + '/pages';
+    _url = 'blogs/' + commons.Escaper.ecapeVariable('$blogId') + '/pages';
 
     var _response = _requester.request(_url,
                                        "POST",
                                        body: _body,
                                        queryParams: _queryParams,
                                        uploadOptions: _uploadOptions,
                                        uploadMedia: _uploadMedia,
                                        downloadOptions: _downloadOptions);
     return _response.then((data) => new Page.fromJson(data));
   }
@@ skipping 15 matching lines @@
    *
    * [view] - Access level with which to view the returned result. Note that
    * some fields require elevated access.
    * Possible string values are:
    * - "ADMIN" : Admin level detail
    * - "AUTHOR" : Author level detail
    * - "READER" : Reader level detail
    *
    * Completes with a [PageList].
    *
-   * Completes with a [common.ApiRequestError] if the API endpoint returned an
+   * Completes with a [commons.ApiRequestError] if the API endpoint returned an
    * error.
    *
    * If the used [http.Client] completes with an error when making a REST call,
    * this method  will complete with the same error.
    */
   async.Future<PageList> list(core.String blogId, {core.bool fetchBodies, core.int maxResults, core.String pageToken, core.List<core.String> status, core.String view}) {
     var _url = null;
     var _queryParams = new core.Map();
     var _uploadMedia = null;
     var _uploadOptions = null;
-    var _downloadOptions = common.DownloadOptions.Metadata;
+    var _downloadOptions = commons.DownloadOptions.Metadata;
     var _body = null;
 
     if (blogId == null) {
       throw new core.ArgumentError("Parameter blogId is required.");
     }
     if (fetchBodies != null) {
       _queryParams["fetchBodies"] = ["${fetchBodies}"];
     }
     if (maxResults != null) {
       _queryParams["maxResults"] = ["${maxResults}"];
     }
     if (pageToken != null) {
       _queryParams["pageToken"] = [pageToken];
     }
     if (status != null) {
       _queryParams["status"] = status;
     }
     if (view != null) {
       _queryParams["view"] = [view];
     }
 
 
-    _url = 'blogs/' + common_internal.Escaper.ecapeVariable('$blogId') + '/pages';
+    _url = 'blogs/' + commons.Escaper.ecapeVariable('$blogId') + '/pages';
 
     var _response = _requester.request(_url,
                                        "GET",
                                        body: _body,
                                        queryParams: _queryParams,
                                        uploadOptions: _uploadOptions,
                                        uploadMedia: _uploadMedia,
                                        downloadOptions: _downloadOptions);
     return _response.then((data) => new PageList.fromJson(data));
   }
@@ skipping 10 matching lines @@
    * [pageId] - The ID of the Page.
    *
    * [publish_1] - Whether a publish action should be performed when the page is
    * updated (default: false).
    *
    * [revert_1] - Whether a revert action should be performed when the page is
    * updated (default: false).
    *
    * Completes with a [Page].
    *
-   * Completes with a [common.ApiRequestError] if the API endpoint returned an
+   * Completes with a [commons.ApiRequestError] if the API endpoint returned an
    * error.
    *
    * If the used [http.Client] completes with an error when making a REST call,
    * this method  will complete with the same error.
    */
   async.Future<Page> patch(Page request, core.String blogId, core.String pageId, {core.bool publish_1, core.bool revert_1}) {
     var _url = null;
     var _queryParams = new core.Map();
     var _uploadMedia = null;
     var _uploadOptions = null;
-    var _downloadOptions = common.DownloadOptions.Metadata;
+    var _downloadOptions = commons.DownloadOptions.Metadata;
     var _body = null;
 
     if (request != null) {
       _body = convert.JSON.encode((request).toJson());
     }
     if (blogId == null) {
       throw new core.ArgumentError("Parameter blogId is required.");
     }
     if (pageId == null) {
       throw new core.ArgumentError("Parameter pageId is required.");
     }
     if (publish_1 != null) {
       _queryParams["publish"] = ["${publish_1}"];
     }
     if (revert_1 != null) {
       _queryParams["revert"] = ["${revert_1}"];
     }
 
 
-    _url = 'blogs/' + common_internal.Escaper.ecapeVariable('$blogId') + '/pages/' + common_internal.Escaper.ecapeVariable('$pageId');
+    _url = 'blogs/' + commons.Escaper.ecapeVariable('$blogId') + '/pages/' + commons.Escaper.ecapeVariable('$pageId');
 
     var _response = _requester.request(_url,
                                        "PATCH",
                                        body: _body,
                                        queryParams: _queryParams,
                                        uploadOptions: _uploadOptions,
                                        uploadMedia: _uploadMedia,
                                        downloadOptions: _downloadOptions);
     return _response.then((data) => new Page.fromJson(data));
   }
 
   /**
    * Publishes a draft page.
    *
    * Request parameters:
    *
    * [blogId] - The ID of the blog.
    *
    * [pageId] - The ID of the page.
    *
    * Completes with a [Page].
    *
-   * Completes with a [common.ApiRequestError] if the API endpoint returned an
+   * Completes with a [commons.ApiRequestError] if the API endpoint returned an
    * error.
    *
    * If the used [http.Client] completes with an error when making a REST call,
    * this method  will complete with the same error.
    */
   async.Future<Page> publish(core.String blogId, core.String pageId) {
     var _url = null;
     var _queryParams = new core.Map();
     var _uploadMedia = null;
     var _uploadOptions = null;
-    var _downloadOptions = common.DownloadOptions.Metadata;
+    var _downloadOptions = commons.DownloadOptions.Metadata;
     var _body = null;
 
     if (blogId == null) {
       throw new core.ArgumentError("Parameter blogId is required.");
     }
     if (pageId == null) {
       throw new core.ArgumentError("Parameter pageId is required.");
     }
 
 
-    _url = 'blogs/' + common_internal.Escaper.ecapeVariable('$blogId') + '/pages/' + common_internal.Escaper.ecapeVariable('$pageId') + '/publish';
+    _url = 'blogs/' + commons.Escaper.ecapeVariable('$blogId') + '/pages/' + commons.Escaper.ecapeVariable('$pageId') + '/publish';
 
     var _response = _requester.request(_url,
                                        "POST",
                                        body: _body,
                                        queryParams: _queryParams,
                                        uploadOptions: _uploadOptions,
                                        uploadMedia: _uploadMedia,
                                        downloadOptions: _downloadOptions);
     return _response.then((data) => new Page.fromJson(data));
   }
 
   /**
    * Revert a published or scheduled page to draft state.
    *
    * Request parameters:
    *
    * [blogId] - The ID of the blog.
    *
    * [pageId] - The ID of the page.
    *
    * Completes with a [Page].
    *
-   * Completes with a [common.ApiRequestError] if the API endpoint returned an
+   * Completes with a [commons.ApiRequestError] if the API endpoint returned an
    * error.
    *
    * If the used [http.Client] completes with an error when making a REST call,
    * this method  will complete with the same error.
    */
   async.Future<Page> revert(core.String blogId, core.String pageId) {
     var _url = null;
     var _queryParams = new core.Map();
     var _uploadMedia = null;
     var _uploadOptions = null;
-    var _downloadOptions = common.DownloadOptions.Metadata;
+    var _downloadOptions = commons.DownloadOptions.Metadata;
     var _body = null;
 
     if (blogId == null) {
       throw new core.ArgumentError("Parameter blogId is required.");
     }
     if (pageId == null) {
       throw new core.ArgumentError("Parameter pageId is required.");
     }
 
 
-    _url = 'blogs/' + common_internal.Escaper.ecapeVariable('$blogId') + '/pages/' + common_internal.Escaper.ecapeVariable('$pageId') + '/revert';
+    _url = 'blogs/' + commons.Escaper.ecapeVariable('$blogId') + '/pages/' + commons.Escaper.ecapeVariable('$pageId') + '/revert';
 
     var _response = _requester.request(_url,
                                        "POST",
                                        body: _body,
                                        queryParams: _queryParams,
                                        uploadOptions: _uploadOptions,
                                        uploadMedia: _uploadMedia,
                                        downloadOptions: _downloadOptions);
     return _response.then((data) => new Page.fromJson(data));
   }
@@ skipping 10 matching lines @@
    * [pageId] - The ID of the Page.
    *
    * [publish_1] - Whether a publish action should be performed when the page is
    * updated (default: false).
    *
    * [revert_1] - Whether a revert action should be performed when the page is
    * updated (default: false).
    *
    * Completes with a [Page].
    *
-   * Completes with a [common.ApiRequestError] if the API endpoint returned an
+   * Completes with a [commons.ApiRequestError] if the API endpoint returned an
    * error.
    *
    * If the used [http.Client] completes with an error when making a REST call,
    * this method  will complete with the same error.
    */
   async.Future<Page> update(Page request, core.String blogId, core.String pageId, {core.bool publish_1, core.bool revert_1}) {
     var _url = null;
     var _queryParams = new core.Map();
     var _uploadMedia = null;
     var _uploadOptions = null;
-    var _downloadOptions = common.DownloadOptions.Metadata;
+    var _downloadOptions = commons.DownloadOptions.Metadata;
     var _body = null;
 
     if (request != null) {
       _body = convert.JSON.encode((request).toJson());
     }
     if (blogId == null) {
       throw new core.ArgumentError("Parameter blogId is required.");
     }
     if (pageId == null) {
       throw new core.ArgumentError("Parameter pageId is required.");
     }
     if (publish_1 != null) {
       _queryParams["publish"] = ["${publish_1}"];
     }
     if (revert_1 != null) {
       _queryParams["revert"] = ["${revert_1}"];
     }
 
 
-    _url = 'blogs/' + common_internal.Escaper.ecapeVariable('$blogId') + '/pages/' + common_internal.Escaper.ecapeVariable('$pageId');
+    _url = 'blogs/' + commons.Escaper.ecapeVariable('$blogId') + '/pages/' + commons.Escaper.ecapeVariable('$pageId');
 
     var _response = _requester.request(_url,
                                        "PUT",
                                        body: _body,
                                        queryParams: _queryParams,
                                        uploadOptions: _uploadOptions,
                                        uploadMedia: _uploadMedia,
                                        downloadOptions: _downloadOptions);
     return _response.then((data) => new Page.fromJson(data));
   }
 
 }
 
 
-/** Not documented yet. */
 class PostUserInfosResourceApi {
-  final common_internal.ApiRequester _requester;
+  final commons.ApiRequester _requester;
 
-  PostUserInfosResourceApi(common_internal.ApiRequester client) : 
+  PostUserInfosResourceApi(commons.ApiRequester client) : 
       _requester = client;
 
   /**
    * Gets one post and user info pair, by post ID and user ID. The post user
    * info contains per-user information about the post, such as access rights,
    * specific to the user.
    *
    * Request parameters:
    *
    * [userId] - ID of the user for the per-user information to be fetched.
    * Either the word 'self' (sans quote marks) or the user's profile identifier.
    *
    * [blogId] - The ID of the blog.
    *
    * [postId] - The ID of the post to get.
    *
    * [maxComments] - Maximum number of comments to pull back on a post.
    *
    * Completes with a [PostUserInfo].
    *
-   * Completes with a [common.ApiRequestError] if the API endpoint returned an
+   * Completes with a [commons.ApiRequestError] if the API endpoint returned an
    * error.
    *
    * If the used [http.Client] completes with an error when making a REST call,
    * this method  will complete with the same error.
    */
   async.Future<PostUserInfo> get(core.String userId, core.String blogId, core.String postId, {core.int maxComments}) {
     var _url = null;
     var _queryParams = new core.Map();
     var _uploadMedia = null;
     var _uploadOptions = null;
-    var _downloadOptions = common.DownloadOptions.Metadata;
+    var _downloadOptions = commons.DownloadOptions.Metadata;
     var _body = null;
 
     if (userId == null) {
       throw new core.ArgumentError("Parameter userId is required.");
     }
     if (blogId == null) {
       throw new core.ArgumentError("Parameter blogId is required.");
     }
     if (postId == null) {
       throw new core.ArgumentError("Parameter postId is required.");
     }
     if (maxComments != null) {
       _queryParams["maxComments"] = ["${maxComments}"];
     }
 
 
-    _url = 'users/' + common_internal.Escaper.ecapeVariable('$userId') + '/blogs/' + common_internal.Escaper.ecapeVariable('$blogId') + '/posts/' + common_internal.Escaper.ecapeVariable('$postId');
+    _url = 'users/' + commons.Escaper.ecapeVariable('$userId') + '/blogs/' + commons.Escaper.ecapeVariable('$blogId') + '/posts/' + commons.Escaper.ecapeVariable('$postId');
 
     var _response = _requester.request(_url,
                                        "GET",
                                        body: _body,
                                        queryParams: _queryParams,
                                        uploadOptions: _uploadOptions,
                                        uploadMedia: _uploadMedia,
                                        downloadOptions: _downloadOptions);
     return _response.then((data) => new PostUserInfo.fromJson(data));
   }
@@ skipping 34 matching lines @@
    *
    * [view] - Access level with which to view the returned result. Note that
    * some fields require elevated access.
    * Possible string values are:
    * - "ADMIN" : Admin level detail
    * - "AUTHOR" : Author level detail
    * - "READER" : Reader level detail
    *
    * Completes with a [PostUserInfosList].
    *
-   * Completes with a [common.ApiRequestError] if the API endpoint returned an
+   * Completes with a [commons.ApiRequestError] if the API endpoint returned an
    * error.
    *
    * If the used [http.Client] completes with an error when making a REST call,
    * this method  will complete with the same error.
    */
   async.Future<PostUserInfosList> list(core.String userId, core.String blogId, {core.DateTime endDate, core.bool fetchBodies, core.String labels, core.int maxResults, core.String orderBy, core.String pageToken, core.DateTime startDate, core.List<core.String> status, core.String view}) {
     var _url = null;
     var _queryParams = new core.Map();
     var _uploadMedia = null;
     var _uploadOptions = null;
-    var _downloadOptions = common.DownloadOptions.Metadata;
+    var _downloadOptions = commons.DownloadOptions.Metadata;
     var _body = null;
 
     if (userId == null) {
       throw new core.ArgumentError("Parameter userId is required.");
     }
     if (blogId == null) {
       throw new core.ArgumentError("Parameter blogId is required.");
     }
     if (endDate != null) {
       _queryParams["endDate"] = [(endDate).toIso8601String()];
@@ skipping 17 matching lines @@
       _queryParams["startDate"] = [(startDate).toIso8601String()];
     }
     if (status != null) {
       _queryParams["status"] = status;
     }
     if (view != null) {
       _queryParams["view"] = [view];
     }
 
 
-    _url = 'users/' + common_internal.Escaper.ecapeVariable('$userId') + '/blogs/' + common_internal.Escaper.ecapeVariable('$blogId') + '/posts';
+    _url = 'users/' + commons.Escaper.ecapeVariable('$userId') + '/blogs/' + commons.Escaper.ecapeVariable('$blogId') + '/posts';
 
     var _response = _requester.request(_url,
                                        "GET",
                                        body: _body,
                                        queryParams: _queryParams,
                                        uploadOptions: _uploadOptions,
                                        uploadMedia: _uploadMedia,
                                        downloadOptions: _downloadOptions);
     return _response.then((data) => new PostUserInfosList.fromJson(data));
   }
 
 }
 
 
-/** Not documented yet. */
 class PostsResourceApi {
-  final common_internal.ApiRequester _requester;
+  final commons.ApiRequester _requester;
 
-  PostsResourceApi(common_internal.ApiRequester client) : 
+  PostsResourceApi(commons.ApiRequester client) : 
       _requester = client;
 
   /**
    * Delete a post by ID.
    *
    * Request parameters:
    *
    * [blogId] - The ID of the Blog.
    *
    * [postId] - The ID of the Post.
    *
-   * Completes with a [common.ApiRequestError] if the API endpoint returned an
+   * Completes with a [commons.ApiRequestError] if the API endpoint returned an
    * error.
    *
    * If the used [http.Client] completes with an error when making a REST call,
    * this method  will complete with the same error.
    */
   async.Future delete(core.String blogId, core.String postId) {
     var _url = null;
     var _queryParams = new core.Map();
     var _uploadMedia = null;
     var _uploadOptions = null;
-    var _downloadOptions = common.DownloadOptions.Metadata;
+    var _downloadOptions = commons.DownloadOptions.Metadata;
     var _body = null;
 
     if (blogId == null) {
       throw new core.ArgumentError("Parameter blogId is required.");
     }
     if (postId == null) {
       throw new core.ArgumentError("Parameter postId is required.");
     }
 
     _downloadOptions = null;
 
-    _url = 'blogs/' + common_internal.Escaper.ecapeVariable('$blogId') + '/posts/' + common_internal.Escaper.ecapeVariable('$postId');
+    _url = 'blogs/' + commons.Escaper.ecapeVariable('$blogId') + '/posts/' + commons.Escaper.ecapeVariable('$postId');
 
     var _response = _requester.request(_url,
                                        "DELETE",
                                        body: _body,
                                        queryParams: _queryParams,
                                        uploadOptions: _uploadOptions,
                                        uploadMedia: _uploadMedia,
                                        downloadOptions: _downloadOptions);
     return _response.then((data) => null);
   }
@@ skipping 18 matching lines @@
    *
    * [view] - Access level with which to view the returned result. Note that
    * some fields require elevated access.
    * Possible string values are:
    * - "ADMIN" : Admin level detail
    * - "AUTHOR" : Author level detail
    * - "READER" : Reader level detail
    *
    * Completes with a [Post].
    *
-   * Completes with a [common.ApiRequestError] if the API endpoint returned an
+   * Completes with a [commons.ApiRequestError] if the API endpoint returned an
    * error.
    *
    * If the used [http.Client] completes with an error when making a REST call,
    * this method  will complete with the same error.
    */
   async.Future<Post> get(core.String blogId, core.String postId, {core.bool fetchBody, core.bool fetchImages, core.int maxComments, core.String view}) {
     var _url = null;
     var _queryParams = new core.Map();
     var _uploadMedia = null;
     var _uploadOptions = null;
-    var _downloadOptions = common.DownloadOptions.Metadata;
+    var _downloadOptions = commons.DownloadOptions.Metadata;
     var _body = null;
 
     if (blogId == null) {
       throw new core.ArgumentError("Parameter blogId is required.");
     }
     if (postId == null) {
       throw new core.ArgumentError("Parameter postId is required.");
     }
     if (fetchBody != null) {
       _queryParams["fetchBody"] = ["${fetchBody}"];
     }
     if (fetchImages != null) {
       _queryParams["fetchImages"] = ["${fetchImages}"];
     }
     if (maxComments != null) {
       _queryParams["maxComments"] = ["${maxComments}"];
     }
     if (view != null) {
       _queryParams["view"] = [view];
     }
 
 
-    _url = 'blogs/' + common_internal.Escaper.ecapeVariable('$blogId') + '/posts/' + common_internal.Escaper.ecapeVariable('$postId');
+    _url = 'blogs/' + commons.Escaper.ecapeVariable('$blogId') + '/posts/' + commons.Escaper.ecapeVariable('$postId');
 
     var _response = _requester.request(_url,
                                        "GET",
                                        body: _body,
                                        queryParams: _queryParams,
                                        uploadOptions: _uploadOptions,
                                        uploadMedia: _uploadMedia,
                                        downloadOptions: _downloadOptions);
     return _response.then((data) => new Post.fromJson(data));
   }
@@ skipping 11 matching lines @@
    *
    * [view] - Access level with which to view the returned result. Note that
    * some fields require elevated access.
    * Possible string values are:
    * - "ADMIN" : Admin level detail
    * - "AUTHOR" : Author level detail
    * - "READER" : Reader level detail
    *
    * Completes with a [Post].
    *
-   * Completes with a [common.ApiRequestError] if the API endpoint returned an
+   * Completes with a [commons.ApiRequestError] if the API endpoint returned an
    * error.
    *
    * If the used [http.Client] completes with an error when making a REST call,
    * this method  will complete with the same error.
    */
   async.Future<Post> getByPath(core.String blogId, core.String path, {core.int maxComments, core.String view}) {
     var _url = null;
     var _queryParams = new core.Map();
     var _uploadMedia = null;
     var _uploadOptions = null;
-    var _downloadOptions = common.DownloadOptions.Metadata;
+    var _downloadOptions = commons.DownloadOptions.Metadata;
     var _body = null;
 
     if (blogId == null) {
       throw new core.ArgumentError("Parameter blogId is required.");
     }
     if (path == null) {
       throw new core.ArgumentError("Parameter path is required.");
     }
     _queryParams["path"] = [path];
     if (maxComments != null) {
       _queryParams["maxComments"] = ["${maxComments}"];
     }
     if (view != null) {
       _queryParams["view"] = [view];
     }
 
 
-    _url = 'blogs/' + common_internal.Escaper.ecapeVariable('$blogId') + '/posts/bypath';
+    _url = 'blogs/' + commons.Escaper.ecapeVariable('$blogId') + '/posts/bypath';
 
     var _response = _requester.request(_url,
                                        "GET",
                                        body: _body,
                                        queryParams: _queryParams,
                                        uploadOptions: _uploadOptions,
                                        uploadMedia: _uploadMedia,
                                        downloadOptions: _downloadOptions);
     return _response.then((data) => new Post.fromJson(data));
   }
@@ skipping 10 matching lines @@
    * [fetchBody] - Whether the body content of the post is included with the
    * result (default: true).
    *
    * [fetchImages] - Whether image URL metadata for each post is included in the
    * returned result (default: false).
    *
    * [isDraft] - Whether to create the post as a draft (default: false).
    *
    * Completes with a [Post].
    *
-   * Completes with a [common.ApiRequestError] if the API endpoint returned an
+   * Completes with a [commons.ApiRequestError] if the API endpoint returned an
    * error.
    *
    * If the used [http.Client] completes with an error when making a REST call,
    * this method  will complete with the same error.
    */
   async.Future<Post> insert(Post request, core.String blogId, {core.bool fetchBody, core.bool fetchImages, core.bool isDraft}) {
     var _url = null;
     var _queryParams = new core.Map();
     var _uploadMedia = null;
     var _uploadOptions = null;
-    var _downloadOptions = common.DownloadOptions.Metadata;
+    var _downloadOptions = commons.DownloadOptions.Metadata;
     var _body = null;
 
     if (request != null) {
       _body = convert.JSON.encode((request).toJson());
     }
     if (blogId == null) {
       throw new core.ArgumentError("Parameter blogId is required.");
     }
     if (fetchBody != null) {
       _queryParams["fetchBody"] = ["${fetchBody}"];
     }
     if (fetchImages != null) {
       _queryParams["fetchImages"] = ["${fetchImages}"];
     }
     if (isDraft != null) {
       _queryParams["isDraft"] = ["${isDraft}"];
     }
 
 
-    _url = 'blogs/' + common_internal.Escaper.ecapeVariable('$blogId') + '/posts';
+    _url = 'blogs/' + commons.Escaper.ecapeVariable('$blogId') + '/posts';
 
     var _response = _requester.request(_url,
                                        "POST",
                                        body: _body,
                                        queryParams: _queryParams,
                                        uploadOptions: _uploadOptions,
                                        uploadMedia: _uploadMedia,
                                        downloadOptions: _downloadOptions);
     return _response.then((data) => new Post.fromJson(data));
   }
@@ skipping 32 matching lines @@
    *
    * [view] - Access level with which to view the returned result. Note that
    * some fields require escalated access.
    * Possible string values are:
    * - "ADMIN" : Admin level detail
    * - "AUTHOR" : Author level detail
    * - "READER" : Reader level detail
    *
    * Completes with a [PostList].
    *
-   * Completes with a [common.ApiRequestError] if the API endpoint returned an
+   * Completes with a [commons.ApiRequestError] if the API endpoint returned an
    * error.
    *
    * If the used [http.Client] completes with an error when making a REST call,
    * this method  will complete with the same error.
    */
   async.Future<PostList> list(core.String blogId, {core.DateTime endDate, core.bool fetchBodies, core.bool fetchImages, core.String labels, core.int maxResults, core.String orderBy, core.String pageToken, core.DateTime startDate, core.List<core.String> status, core.String view}) {
     var _url = null;
     var _queryParams = new core.Map();
     var _uploadMedia = null;
     var _uploadOptions = null;
-    var _downloadOptions = common.DownloadOptions.Metadata;
+    var _downloadOptions = commons.DownloadOptions.Metadata;
     var _body = null;
 
     if (blogId == null) {
       throw new core.ArgumentError("Parameter blogId is required.");
     }
     if (endDate != null) {
       _queryParams["endDate"] = [(endDate).toIso8601String()];
     }
     if (fetchBodies != null) {
       _queryParams["fetchBodies"] = ["${fetchBodies}"];
@@ skipping 17 matching lines @@
       _queryParams["startDate"] = [(startDate).toIso8601String()];
     }
     if (status != null) {
       _queryParams["status"] = status;
     }
     if (view != null) {
       _queryParams["view"] = [view];
     }
 
 
-    _url = 'blogs/' + common_internal.Escaper.ecapeVariable('$blogId') + '/posts';
+    _url = 'blogs/' + commons.Escaper.ecapeVariable('$blogId') + '/posts';
 
     var _response = _requester.request(_url,
                                        "GET",
                                        body: _body,
                                        queryParams: _queryParams,
                                        uploadOptions: _uploadOptions,
                                        uploadMedia: _uploadMedia,
                                        downloadOptions: _downloadOptions);
     return _response.then((data) => new PostList.fromJson(data));
   }
@@ skipping 19 matching lines @@
    * post.
    *
    * [publish_1] - Whether a publish action should be performed when the post is
    * updated (default: false).
    *
    * [revert_1] - Whether a revert action should be performed when the post is
    * updated (default: false).
    *
    * Completes with a [Post].
    *
-   * Completes with a [common.ApiRequestError] if the API endpoint returned an
+   * Completes with a [commons.ApiRequestError] if the API endpoint returned an
    * error.
    *
    * If the used [http.Client] completes with an error when making a REST call,
    * this method  will complete with the same error.
    */
   async.Future<Post> patch(Post request, core.String blogId, core.String postId, {core.bool fetchBody, core.bool fetchImages, core.int maxComments, core.bool publish_1, core.bool revert_1}) {
     var _url = null;
     var _queryParams = new core.Map();
     var _uploadMedia = null;
     var _uploadOptions = null;
-    var _downloadOptions = common.DownloadOptions.Metadata;
+    var _downloadOptions = commons.DownloadOptions.Metadata;
     var _body = null;
 
     if (request != null) {
       _body = convert.JSON.encode((request).toJson());
     }
     if (blogId == null) {
       throw new core.ArgumentError("Parameter blogId is required.");
     }
     if (postId == null) {
       throw new core.ArgumentError("Parameter postId is required.");
     }
     if (fetchBody != null) {
       _queryParams["fetchBody"] = ["${fetchBody}"];
     }
     if (fetchImages != null) {
       _queryParams["fetchImages"] = ["${fetchImages}"];
     }
     if (maxComments != null) {
       _queryParams["maxComments"] = ["${maxComments}"];
     }
     if (publish_1 != null) {
       _queryParams["publish"] = ["${publish_1}"];
     }
     if (revert_1 != null) {
       _queryParams["revert"] = ["${revert_1}"];
     }
 
 
-    _url = 'blogs/' + common_internal.Escaper.ecapeVariable('$blogId') + '/posts/' + common_internal.Escaper.ecapeVariable('$postId');
+    _url = 'blogs/' + commons.Escaper.ecapeVariable('$blogId') + '/posts/' + commons.Escaper.ecapeVariable('$postId');
 
     var _response = _requester.request(_url,
                                        "PATCH",
                                        body: _body,
                                        queryParams: _queryParams,
                                        uploadOptions: _uploadOptions,
                                        uploadMedia: _uploadMedia,
                                        downloadOptions: _downloadOptions);
     return _response.then((data) => new Post.fromJson(data));
   }
 
   /**
    * Publishes a draft post, optionally at the specific time of the given
    * publishDate parameter.
    *
    * Request parameters:
    *
    * [blogId] - The ID of the Blog.
    *
    * [postId] - The ID of the Post.
    *
    * [publishDate] - Optional date and time to schedule the publishing of the
    * Blog. If no publishDate parameter is given, the post is either published at
    * the a previously saved schedule date (if present), or the current time. If
    * a future date is given, the post will be scheduled to be published.
    *
    * Completes with a [Post].
    *
-   * Completes with a [common.ApiRequestError] if the API endpoint returned an
+   * Completes with a [commons.ApiRequestError] if the API endpoint returned an
    * error.
    *
    * If the used [http.Client] completes with an error when making a REST call,
    * this method  will complete with the same error.
    */
   async.Future<Post> publish(core.String blogId, core.String postId, {core.DateTime publishDate}) {
     var _url = null;
     var _queryParams = new core.Map();
     var _uploadMedia = null;
     var _uploadOptions = null;
-    var _downloadOptions = common.DownloadOptions.Metadata;
+    var _downloadOptions = commons.DownloadOptions.Metadata;
     var _body = null;
 
     if (blogId == null) {
       throw new core.ArgumentError("Parameter blogId is required.");
     }
     if (postId == null) {
       throw new core.ArgumentError("Parameter postId is required.");
     }
     if (publishDate != null) {
       _queryParams["publishDate"] = [(publishDate).toIso8601String()];
     }
 
 
-    _url = 'blogs/' + common_internal.Escaper.ecapeVariable('$blogId') + '/posts/' + common_internal.Escaper.ecapeVariable('$postId') + '/publish';
+    _url = 'blogs/' + commons.Escaper.ecapeVariable('$blogId') + '/posts/' + commons.Escaper.ecapeVariable('$postId') + '/publish';
 
     var _response = _requester.request(_url,
                                        "POST",
                                        body: _body,
                                        queryParams: _queryParams,
                                        uploadOptions: _uploadOptions,
                                        uploadMedia: _uploadMedia,
                                        downloadOptions: _downloadOptions);
     return _response.then((data) => new Post.fromJson(data));
   }
 
   /**
    * Revert a published or scheduled post to draft state.
    *
    * Request parameters:
    *
    * [blogId] - The ID of the Blog.
    *
    * [postId] - The ID of the Post.
    *
    * Completes with a [Post].
    *
-   * Completes with a [common.ApiRequestError] if the API endpoint returned an
+   * Completes with a [commons.ApiRequestError] if the API endpoint returned an
    * error.
    *
    * If the used [http.Client] completes with an error when making a REST call,
    * this method  will complete with the same error.
    */
   async.Future<Post> revert(core.String blogId, core.String postId) {
     var _url = null;
     var _queryParams = new core.Map();
     var _uploadMedia = null;
     var _uploadOptions = null;
-    var _downloadOptions = common.DownloadOptions.Metadata;
+    var _downloadOptions = commons.DownloadOptions.Metadata;
     var _body = null;
 
     if (blogId == null) {
       throw new core.ArgumentError("Parameter blogId is required.");
     }
     if (postId == null) {
       throw new core.ArgumentError("Parameter postId is required.");
     }
 
 
-    _url = 'blogs/' + common_internal.Escaper.ecapeVariable('$blogId') + '/posts/' + common_internal.Escaper.ecapeVariable('$postId') + '/revert';
+    _url = 'blogs/' + commons.Escaper.ecapeVariable('$blogId') + '/posts/' + commons.Escaper.ecapeVariable('$postId') + '/revert';
 
     var _response = _requester.request(_url,
                                        "POST",
                                        body: _body,
                                        queryParams: _queryParams,
                                        uploadOptions: _uploadOptions,
                                        uploadMedia: _uploadMedia,
                                        downloadOptions: _downloadOptions);
     return _response.then((data) => new Post.fromJson(data));
   }
@@ skipping 11 matching lines @@
    * true). This should be set to false when the post bodies are not required,
    * to help minimize traffic.
    *
    * [orderBy] - Sort search results
    * Possible string values are:
    * - "published" : Order by the date the post was published
    * - "updated" : Order by the date the post was last updated
    *
    * Completes with a [PostList].
    *
-   * Completes with a [common.ApiRequestError] if the API endpoint returned an
+   * Completes with a [commons.ApiRequestError] if the API endpoint returned an
    * error.
    *
    * If the used [http.Client] completes with an error when making a REST call,
    * this method  will complete with the same error.
    */
   async.Future<PostList> search(core.String blogId, core.String q, {core.bool fetchBodies, core.String orderBy}) {
     var _url = null;
     var _queryParams = new core.Map();
     var _uploadMedia = null;
     var _uploadOptions = null;
-    var _downloadOptions = common.DownloadOptions.Metadata;
+    var _downloadOptions = commons.DownloadOptions.Metadata;
     var _body = null;
 
     if (blogId == null) {
       throw new core.ArgumentError("Parameter blogId is required.");
     }
     if (q == null) {
       throw new core.ArgumentError("Parameter q is required.");
     }
     _queryParams["q"] = [q];
     if (fetchBodies != null) {
       _queryParams["fetchBodies"] = ["${fetchBodies}"];
     }
     if (orderBy != null) {
       _queryParams["orderBy"] = [orderBy];
     }
 
 
-    _url = 'blogs/' + common_internal.Escaper.ecapeVariable('$blogId') + '/posts/search';
+    _url = 'blogs/' + commons.Escaper.ecapeVariable('$blogId') + '/posts/search';
 
     var _response = _requester.request(_url,
                                        "GET",
                                        body: _body,
                                        queryParams: _queryParams,
                                        uploadOptions: _uploadOptions,
                                        uploadMedia: _uploadMedia,
                                        downloadOptions: _downloadOptions);
     return _response.then((data) => new PostList.fromJson(data));
   }
@@ skipping 19 matching lines @@
    * post.
    *
    * [publish_1] - Whether a publish action should be performed when the post is
    * updated (default: false).
    *
    * [revert_1] - Whether a revert action should be performed when the post is
    * updated (default: false).
    *
    * Completes with a [Post].
    *
-   * Completes with a [common.ApiRequestError] if the API endpoint returned an
+   * Completes with a [commons.ApiRequestError] if the API endpoint returned an
    * error.
    *
    * If the used [http.Client] completes with an error when making a REST call,
    * this method  will complete with the same error.
    */
   async.Future<Post> update(Post request, core.String blogId, core.String postId, {core.bool fetchBody, core.bool fetchImages, core.int maxComments, core.bool publish_1, core.bool revert_1}) {
     var _url = null;
     var _queryParams = new core.Map();
     var _uploadMedia = null;
     var _uploadOptions = null;
-    var _downloadOptions = common.DownloadOptions.Metadata;
+    var _downloadOptions = commons.DownloadOptions.Metadata;
     var _body = null;
 
     if (request != null) {
       _body = convert.JSON.encode((request).toJson());
     }
     if (blogId == null) {
       throw new core.ArgumentError("Parameter blogId is required.");
     }
     if (postId == null) {
       throw new core.ArgumentError("Parameter postId is required.");
     }
     if (fetchBody != null) {
       _queryParams["fetchBody"] = ["${fetchBody}"];
     }
     if (fetchImages != null) {
       _queryParams["fetchImages"] = ["${fetchImages}"];
     }
     if (maxComments != null) {
       _queryParams["maxComments"] = ["${maxComments}"];
     }
     if (publish_1 != null) {
       _queryParams["publish"] = ["${publish_1}"];
     }
     if (revert_1 != null) {
       _queryParams["revert"] = ["${revert_1}"];
     }
 
 
-    _url = 'blogs/' + common_internal.Escaper.ecapeVariable('$blogId') + '/posts/' + common_internal.Escaper.ecapeVariable('$postId');
+    _url = 'blogs/' + commons.Escaper.ecapeVariable('$blogId') + '/posts/' + commons.Escaper.ecapeVariable('$postId');
 
     var _response = _requester.request(_url,
                                        "PUT",
                                        body: _body,
                                        queryParams: _queryParams,
                                        uploadOptions: _uploadOptions,
                                        uploadMedia: _uploadMedia,
                                        downloadOptions: _downloadOptions);
     return _response.then((data) => new Post.fromJson(data));
   }
 
 }
 
 
-/** Not documented yet. */
 class UsersResourceApi {
-  final common_internal.ApiRequester _requester;
+  final commons.ApiRequester _requester;
 
-  UsersResourceApi(common_internal.ApiRequester client) : 
+  UsersResourceApi(commons.ApiRequester client) : 
       _requester = client;
 
   /**
    * Gets one user by ID.
    *
    * Request parameters:
    *
    * [userId] - The ID of the user to get.
    *
    * Completes with a [User].
    *
-   * Completes with a [common.ApiRequestError] if the API endpoint returned an
+   * Completes with a [commons.ApiRequestError] if the API endpoint returned an
    * error.
    *
    * If the used [http.Client] completes with an error when making a REST call,
    * this method  will complete with the same error.
    */
   async.Future<User> get(core.String userId) {
     var _url = null;
     var _queryParams = new core.Map();
     var _uploadMedia = null;
     var _uploadOptions = null;
-    var _downloadOptions = common.DownloadOptions.Metadata;
+    var _downloadOptions = commons.DownloadOptions.Metadata;
     var _body = null;
 
     if (userId == null) {
       throw new core.ArgumentError("Parameter userId is required.");
     }
 
 
-    _url = 'users/' + common_internal.Escaper.ecapeVariable('$userId');
+    _url = 'users/' + commons.Escaper.ecapeVariable('$userId');
 
     var _response = _requester.request(_url,
                                        "GET",
                                        body: _body,
                                        queryParams: _queryParams,
                                        uploadOptions: _uploadOptions,
                                        uploadMedia: _uploadMedia,
                                        downloadOptions: _downloadOptions);
     return _response.then((data) => new User.fromJson(data));
   }
@@ skipping 112 matching lines @@
       _json["selfLink"] = selfLink;
     }
     if (totalItems != null) {
       _json["totalItems"] = totalItems;
     }
     return _json;
   }
 }
 
 
-/** Not documented yet. */
 class Blog {
   /** The JSON custom meta-data for the Blog */
   core.String customMetaData;
 
   /** The description of this blog. This is displayed underneath the title. */
   core.String description;
 
   /** The identifier for this resource. */
   core.String id;
 
@@ skipping 111 matching lines @@
       _json["updated"] = (updated).toIso8601String();
     }
     if (url != null) {
       _json["url"] = url;
     }
     return _json;
   }
 }
 
 
-/** Not documented yet. */
 class BlogList {
   /** Admin level list of blog per-user information */
   core.List<BlogUserInfo> blogUserInfos;
 
   /** The list of Blogs this user has Authorship or Admin rights over. */
   core.List<Blog> items;
 
   /** The kind of this entity. Always blogger#blogList */
   core.String kind;
 
@@ skipping 21 matching lines @@
       _json["items"] = items.map((value) => (value).toJson()).toList();
     }
     if (kind != null) {
       _json["kind"] = kind;
     }
     return _json;
   }
 }
 
 
-/** Not documented yet. */
 class BlogPerUserInfo {
   /** ID of the Blog resource */
   core.String blogId;
 
   /** True if the user has Admin level access to the blog. */
   core.bool hasAdminAccess;
 
   /** The kind of this entity. Always blogger#blogPerUserInfo */
   core.String kind;
 
@@ skipping 51 matching lines @@
       _json["role"] = role;
     }
     if (userId != null) {
       _json["userId"] = userId;
     }
     return _json;
   }
 }
 
 
-/** Not documented yet. */
 class BlogUserInfo {
   /** The Blog resource. */
   Blog blog;
 
   /** Information about a User for the Blog. */
   BlogPerUserInfo blogUserInfo;
 
   /** The kind of this entity. Always blogger#blogUserInfo */
   core.String kind;
 
@@ skipping 168 matching lines @@
   core.Map toJson() {
     var _json = new core.Map();
     if (id != null) {
       _json["id"] = id;
     }
     return _json;
   }
 }
 
 
-/** Not documented yet. */
 class Comment {
   /** The author of this Comment. */
   CommentAuthor author;
 
   /** Data about the blog containing this comment. */
   CommentBlog blog;
 
   /** The actual content of the comment. May include HTML markup. */
   core.String content;
 
@@ skipping 93 matching lines @@
       _json["status"] = status;
     }
     if (updated != null) {
       _json["updated"] = (updated).toIso8601String();
     }
     return _json;
   }
 }
 
 
-/** Not documented yet. */
 class CommentList {
   /** The List of Comments for a Post. */
   core.List<Comment> items;
 
   /** The kind of this entry. Always blogger#commentList */
   core.String kind;
 
   /** Pagination token to fetch the next page, if one exists. */
   core.String nextPageToken;
 
@@ skipping 129 matching lines @@
   core.Map toJson() {
     var _json = new core.Map();
     if (id != null) {
       _json["id"] = id;
     }
     return _json;
   }
 }
 
 
-/** Not documented yet. */
 class Page {
   /** The author of this Page. */
   PageAuthor author;
 
   /** Data about the blog containing this Page. */
   PageBlog blog;
 
   /** The body content of this Page, in HTML. */
   core.String content;
 
@@ skipping 105 matching lines @@
       _json["updated"] = (updated).toIso8601String();
     }
     if (url != null) {
       _json["url"] = url;
     }
     return _json;
   }
 }
 
 
-/** Not documented yet. */
 class PageList {
   /** The list of Pages for a Blog. */
   core.List<Page> items;
 
   /** The kind of this entity. Always blogger#pageList */
   core.String kind;
 
   /** Pagination token to fetch the next page, if one exists. */
   core.String nextPageToken;
 
@@ skipping 21 matching lines @@
       _json["kind"] = kind;
     }
     if (nextPageToken != null) {
       _json["nextPageToken"] = nextPageToken;
     }
     return _json;
   }
 }
 
 
-/** Not documented yet. */
 class PageviewsCounts {
   /** Count of page views for the given time range */
   core.String count;
 
   /** Time range the given count applies to */
   core.String timeRange;
 
 
   PageviewsCounts();
 
@@ skipping 12 matching lines @@
       _json["count"] = count;
     }
     if (timeRange != null) {
       _json["timeRange"] = timeRange;
     }
     return _json;
   }
 }
 
 
-/** Not documented yet. */
 class Pageviews {
   /** Blog Id */
   core.String blogId;
 
   /** The container of posts in this blog. */
   core.List<PageviewsCounts> counts;
 
   /** The kind of this entry. Always blogger#page_views */
   core.String kind;
 
@@ skipping 120 matching lines @@
   core.Map toJson() {
     var _json = new core.Map();
     if (id != null) {
       _json["id"] = id;
     }
     return _json;
   }
 }
 
 
-/** Not documented yet. */
 class PostImages {
-  /** Not documented yet. */
   core.String url;
 
 
   PostImages();
 
   PostImages.fromJson(core.Map _json) {
     if (_json.containsKey("url")) {
       url = _json["url"];
     }
   }
@@ skipping 94 matching lines @@
       _json["selfLink"] = selfLink;
     }
     if (totalItems != null) {
       _json["totalItems"] = totalItems;
     }
     return _json;
   }
 }
 
 
-/** Not documented yet. */
 class Post {
   /** The author of this Post. */
   PostAuthor author;
 
   /** Data about the blog containing this Post. */
   PostBlog blog;
 
   /** The content of the Post. May contain HTML markup. */
   core.String content;
 
@@ skipping 165 matching lines @@
       _json["updated"] = (updated).toIso8601String();
     }
     if (url != null) {
       _json["url"] = url;
     }
     return _json;
   }
 }
 
 
-/** Not documented yet. */
 class PostList {
   /** The list of Posts for this Blog. */
   core.List<Post> items;
 
   /** The kind of this entity. Always blogger#postList */
   core.String kind;
 
   /** Pagination token to fetch the next page, if one exists. */
   core.String nextPageToken;
 
@@ skipping 21 matching lines @@
       _json["kind"] = kind;
     }
     if (nextPageToken != null) {
       _json["nextPageToken"] = nextPageToken;
     }
     return _json;
   }
 }
 
 
-/** Not documented yet. */
 class PostPerUserInfo {
   /** ID of the Blog that the post resource belongs to. */
   core.String blogId;
 
   /** True if the user has Author level access to the post. */
   core.bool hasEditAccess;
 
   /** The kind of this entity. Always blogger#postPerUserInfo */
   core.String kind;
 
@@ skipping 39 matching lines @@
       _json["postId"] = postId;
     }
     if (userId != null) {
       _json["userId"] = userId;
     }
     return _json;
   }
 }
 
 
-/** Not documented yet. */
 class PostUserInfo {
   /** The kind of this entity. Always blogger#postUserInfo */
   core.String kind;
 
   /** The Post resource. */
   Post post;
 
   /** Information about a User for the Post. */
   PostPerUserInfo postUserInfo;
 
@@ skipping 21 matching lines @@
       _json["post"] = (post).toJson();
     }
     if (postUserInfo != null) {
       _json["post_user_info"] = (postUserInfo).toJson();
     }
     return _json;
   }
 }
 
 
-/** Not documented yet. */
 class PostUserInfosList {
   /** The list of Posts with User information for the post, for this Blog. */
   core.List<PostUserInfo> items;
 
   /** The kind of this entity. Always blogger#postList */
   core.String kind;
 
   /** Pagination token to fetch the next page, if one exists. */
   core.String nextPageToken;
 
@@ skipping 87 matching lines @@
       _json["language"] = language;
     }
     if (variant != null) {
       _json["variant"] = variant;
     }
     return _json;
   }
 }
 
 
-/** Not documented yet. */
 class User {
   /** Profile summary information. */
   core.String about;
 
   /** The container of blogs for this user. */
   UserBlogs blogs;
 
   /**
    * The timestamp of when this profile was created, in seconds since epoch.
    */
@@ skipping 75 matching lines @@
     }
     if (selfLink != null) {
       _json["selfLink"] = selfLink;
     }
     if (url != null) {
       _json["url"] = url;
     }
     return _json;
   }
 }
-
-