{
  "swagger": "2.0",
  "schemes": ["https"],
  "host": "www.googleapis.com",
  "basePath": "/blogger/v3",
  "info": {
    "contact": {
      "name": "Google",
      "url": "https://google.com"
    },
    "description": "API for access to the data within Blogger.",
    "title": "Blogger",
    "version": "v3",
    "x-apiClientRegistration": {
      "url": "https://console.developers.google.com"
    },
    "x-logo": {
      "url": "https://api.apis.guru/v2/cache/logo/https_www.gstatic.com_images_icons_material_product_2x_blogger_64dp.png"
    },
    "x-origin": {
      "format": "google",
      "url": "https://www.googleapis.com/discovery/v1/apis/blogger/v3/rest",
      "version": "v1"
    },
    "x-preferred": true,
    "x-providerName": "googleapis.com",
    "x-serviceName": "blogger"
  },
  "externalDocs": {
    "url": "https://developers.google.com/blogger/docs/3.0/getting_started"
  },
  "securityDefinitions": {
    "Oauth2": {
      "authorizationUrl": "https://accounts.google.com/o/oauth2/auth",
      "description": "Oauth 2.0 authentication",
      "flow": "implicit",
      "scopes": {
        "https://www.googleapis.com/auth/blogger": "Manage your Blogger account",
        "https://www.googleapis.com/auth/blogger.readonly": "View your Blogger account"
      },
      "type": "oauth2"
    }
  },
  "parameters": {
    "alt": {
      "default": "json",
      "description": "Data format for the response.",
      "enum": ["json"],
      "in": "query",
      "name": "alt",
      "type": "string"
    },
    "fields": {
      "description": "Selector specifying which fields to include in a partial response.",
      "in": "query",
      "name": "fields",
      "type": "string"
    },
    "key": {
      "description": "API key. Your API key identifies your project and provides you with API access, quota, and reports. Required unless you provide an OAuth 2.0 token.",
      "in": "query",
      "name": "key",
      "type": "string"
    },
    "oauth_token": {
      "description": "OAuth 2.0 token for the current user.",
      "in": "query",
      "name": "oauth_token",
      "type": "string"
    },
    "prettyPrint": {
      "default": true,
      "description": "Returns response with indentations and line breaks.",
      "in": "query",
      "name": "prettyPrint",
      "type": "boolean"
    },
    "quotaUser": {
      "description": "Available to use for quota purposes for server-side applications. Can be any arbitrary string assigned to a user, but should not exceed 40 characters. Overrides userIp if both are provided.",
      "in": "query",
      "name": "quotaUser",
      "type": "string"
    },
    "userIp": {
      "description": "IP address of the site where the request originates. Use this if you want to enforce per-user limits.",
      "in": "query",
      "name": "userIp",
      "type": "string"
    }
  },
  "tags": [
    {
      "name": "blogUserInfos"
    },
    {
      "name": "blogs"
    },
    {
      "name": "comments"
    },
    {
      "name": "pageViews"
    },
    {
      "name": "pages"
    },
    {
      "name": "postUserInfos"
    },
    {
      "name": "posts"
    },
    {
      "name": "users"
    }
  ],
  "paths": {
    "/blogs/byurl": {
      "get": {
        "description": "Retrieve a Blog by URL.",
        "operationId": "blogger.blogs.getByUrl",
        "parameters": [
          {
            "description": "The URL of the blog to retrieve.",
            "in": "query",
            "name": "url",
            "required": true,
            "type": "string"
          },
          {
            "description": "Access level with which to view the blog. Note that some fields require elevated access.",
            "enum": ["ADMIN", "AUTHOR", "READER"],
            "in": "query",
            "name": "view",
            "type": "string"
          }
        ],
        "responses": {
          "200": {
            "description": "Successful response",
            "schema": {
              "$ref": "#/definitions/Blog"
            }
          }
        },
        "security": [
          {
            "Oauth2": ["https://www.googleapis.com/auth/blogger"]
          },
          {
            "Oauth2": ["https://www.googleapis.com/auth/blogger.readonly"]
          }
        ],
        "tags": ["blogs"]
      },
      "parameters": [
        {
          "$ref": "#/parameters/alt"
        },
        {
          "$ref": "#/parameters/fields"
        },
        {
          "$ref": "#/parameters/key"
        },
        {
          "$ref": "#/parameters/oauth_token"
        },
        {
          "$ref": "#/parameters/prettyPrint"
        },
        {
          "$ref": "#/parameters/quotaUser"
        },
        {
          "$ref": "#/parameters/userIp"
        }
      ]
    },
    "/blogs/{blogId}": {
      "get": {
        "description": "Gets one blog by ID.",
        "operationId": "blogger.blogs.get",
        "parameters": [
          {
            "description": "The ID of the blog to get.",
            "in": "path",
            "name": "blogId",
            "required": true,
            "type": "string"
          },
          {
            "description": "Maximum number of posts to pull back with the blog.",
            "in": "query",
            "name": "maxPosts",
            "type": "integer"
          },
          {
            "description": "Access level with which to view the blog. Note that some fields require elevated access.",
            "enum": ["ADMIN", "AUTHOR", "READER"],
            "in": "query",
            "name": "view",
            "type": "string"
          }
        ],
        "responses": {
          "200": {
            "description": "Successful response",
            "schema": {
              "$ref": "#/definitions/Blog"
            }
          }
        },
        "security": [
          {
            "Oauth2": ["https://www.googleapis.com/auth/blogger"]
          },
          {
            "Oauth2": ["https://www.googleapis.com/auth/blogger.readonly"]
          }
        ],
        "tags": ["blogs"]
      },
      "parameters": [
        {
          "$ref": "#/parameters/alt"
        },
        {
          "$ref": "#/parameters/fields"
        },
        {
          "$ref": "#/parameters/key"
        },
        {
          "$ref": "#/parameters/oauth_token"
        },
        {
          "$ref": "#/parameters/prettyPrint"
        },
        {
          "$ref": "#/parameters/quotaUser"
        },
        {
          "$ref": "#/parameters/userIp"
        }
      ]
    },
    "/blogs/{blogId}/comments": {
      "get": {
        "description": "Retrieves the comments for a blog, across all posts, possibly filtered.",
        "operationId": "blogger.comments.listByBlog",
        "parameters": [
          {
            "description": "ID of the blog to fetch comments from.",
            "in": "path",
            "name": "blogId",
            "required": true,
            "type": "string"
          },
          {
            "description": "Latest date of comment to fetch, a date-time with RFC 3339 formatting.",
            "in": "query",
            "name": "endDate",
            "type": "string"
          },
          {
            "description": "Whether the body content of the comments is included.",
            "in": "query",
            "name": "fetchBodies",
            "type": "boolean"
          },
          {
            "description": "Maximum number of comments to include in the result.",
            "in": "query",
            "name": "maxResults",
            "type": "integer"
          },
          {
            "description": "Continuation token if request is paged.",
            "in": "query",
            "name": "pageToken",
            "type": "string"
          },
          {
            "description": "Earliest date of comment to fetch, a date-time with RFC 3339 formatting.",
            "in": "query",
            "name": "startDate",
            "type": "string"
          },
          {
            "collectionFormat": "multi",
            "in": "query",
            "items": {
              "enum": ["emptied", "live", "pending", "spam"],
              "type": "string"
            },
            "name": "status",
            "type": "array"
          }
        ],
        "responses": {
          "200": {
            "description": "Successful response",
            "schema": {
              "$ref": "#/definitions/CommentList"
            }
          }
        },
        "security": [
          {
            "Oauth2": ["https://www.googleapis.com/auth/blogger"]
          },
          {
            "Oauth2": ["https://www.googleapis.com/auth/blogger.readonly"]
          }
        ],
        "tags": ["comments"]
      },
      "parameters": [
        {
          "$ref": "#/parameters/alt"
        },
        {
          "$ref": "#/parameters/fields"
        },
        {
          "$ref": "#/parameters/key"
        },
        {
          "$ref": "#/parameters/oauth_token"
        },
        {
          "$ref": "#/parameters/prettyPrint"
        },
        {
          "$ref": "#/parameters/quotaUser"
        },
        {
          "$ref": "#/parameters/userIp"
        }
      ]
    },
    "/blogs/{blogId}/pages": {
      "get": {
        "description": "Retrieves the pages for a blog, optionally including non-LIVE statuses.",
        "operationId": "blogger.pages.list",
        "parameters": [
          {
            "description": "ID of the blog to fetch Pages from.",
            "in": "path",
            "name": "blogId",
            "required": true,
            "type": "string"
          },
          {
            "description": "Whether to retrieve the Page bodies.",
            "in": "query",
            "name": "fetchBodies",
            "type": "boolean"
          },
          {
            "description": "Maximum number of Pages to fetch.",
            "in": "query",
            "name": "maxResults",
            "type": "integer"
          },
          {
            "description": "Continuation token if the request is paged.",
            "in": "query",
            "name": "pageToken",
            "type": "string"
          },
          {
            "collectionFormat": "multi",
            "in": "query",
            "items": {
              "enum": ["draft", "live"],
              "type": "string"
            },
            "name": "status",
            "type": "array"
          },
          {
            "description": "Access level with which to view the returned result. Note that some fields require elevated access.",
            "enum": ["ADMIN", "AUTHOR", "READER"],
            "in": "query",
            "name": "view",
            "type": "string"
          }
        ],
        "responses": {
          "200": {
            "description": "Successful response",
            "schema": {
              "$ref": "#/definitions/PageList"
            }
          }
        },
        "security": [
          {
            "Oauth2": ["https://www.googleapis.com/auth/blogger"]
          },
          {
            "Oauth2": ["https://www.googleapis.com/auth/blogger.readonly"]
          }
        ],
        "tags": ["pages"]
      },
      "parameters": [
        {
          "$ref": "#/parameters/alt"
        },
        {
          "$ref": "#/parameters/fields"
        },
        {
          "$ref": "#/parameters/key"
        },
        {
          "$ref": "#/parameters/oauth_token"
        },
        {
          "$ref": "#/parameters/prettyPrint"
        },
        {
          "$ref": "#/parameters/quotaUser"
        },
        {
          "$ref": "#/parameters/userIp"
        }
      ],
      "post": {
        "description": "Add a page.",
        "operationId": "blogger.pages.insert",
        "parameters": [
          {
            "description": "ID of the blog to add the page to.",
            "in": "path",
            "name": "blogId",
            "required": true,
            "type": "string"
          },
          {
            "description": "Whether to create the page as a draft (default: false).",
            "in": "query",
            "name": "isDraft",
            "type": "boolean"
          },
          {
            "in": "body",
            "name": "body",
            "schema": {
              "$ref": "#/definitions/Page"
            }
          }
        ],
        "responses": {
          "200": {
            "description": "Successful response",
            "schema": {
              "$ref": "#/definitions/Page"
            }
          }
        },
        "security": [
          {
            "Oauth2": ["https://www.googleapis.com/auth/blogger"]
          }
        ],
        "tags": ["pages"]
      }
    },
    "/blogs/{blogId}/pages/{pageId}": {
      "delete": {
        "description": "Delete a page by ID.",
        "operationId": "blogger.pages.delete",
        "parameters": [
          {
            "description": "The ID of the Blog.",
            "in": "path",
            "name": "blogId",
            "required": true,
            "type": "string"
          },
          {
            "description": "The ID of the Page.",
            "in": "path",
            "name": "pageId",
            "required": true,
            "type": "string"
          }
        ],
        "responses": {
          "200": {
            "description": "Successful response"
          }
        },
        "security": [
          {
            "Oauth2": ["https://www.googleapis.com/auth/blogger"]
          }
        ],
        "tags": ["pages"]
      },
      "get": {
        "description": "Gets one blog page by ID.",
        "operationId": "blogger.pages.get",
        "parameters": [
          {
            "description": "ID of the blog containing the page.",
            "in": "path",
            "name": "blogId",
            "required": true,
            "type": "string"
          },
          {
            "description": "The ID of the page to get.",
            "in": "path",
            "name": "pageId",
            "required": true,
            "type": "string"
          },
          {
            "enum": ["ADMIN", "AUTHOR", "READER"],
            "in": "query",
            "name": "view",
            "type": "string"
          }
        ],
        "responses": {
          "200": {
            "description": "Successful response",
            "schema": {
              "$ref": "#/definitions/Page"
            }
          }
        },
        "security": [
          {
            "Oauth2": ["https://www.googleapis.com/auth/blogger"]
          },
          {
            "Oauth2": ["https://www.googleapis.com/auth/blogger.readonly"]
          }
        ],
        "tags": ["pages"]
      },
      "parameters": [
        {
          "$ref": "#/parameters/alt"
        },
        {
          "$ref": "#/parameters/fields"
        },
        {
          "$ref": "#/parameters/key"
        },
        {
          "$ref": "#/parameters/oauth_token"
        },
        {
          "$ref": "#/parameters/prettyPrint"
        },
        {
          "$ref": "#/parameters/quotaUser"
        },
        {
          "$ref": "#/parameters/userIp"
        }
      ],
      "patch": {
        "description": "Update a page. This method supports patch semantics.",
        "operationId": "blogger.pages.patch",
        "parameters": [
          {
            "description": "The ID of the Blog.",
            "in": "path",
            "name": "blogId",
            "required": true,
            "type": "string"
          },
          {
            "description": "The ID of the Page.",
            "in": "path",
            "name": "pageId",
            "required": true,
            "type": "string"
          },
          {
            "description": "Whether a publish action should be performed when the page is updated (default: false).",
            "in": "query",
            "name": "publish",
            "type": "boolean"
          },
          {
            "description": "Whether a revert action should be performed when the page is updated (default: false).",
            "in": "query",
            "name": "revert",
            "type": "boolean"
          },
          {
            "in": "body",
            "name": "body",
            "schema": {
              "$ref": "#/definitions/Page"
            }
          }
        ],
        "responses": {
          "200": {
            "description": "Successful response",
            "schema": {
              "$ref": "#/definitions/Page"
            }
          }
        },
        "security": [
          {
            "Oauth2": ["https://www.googleapis.com/auth/blogger"]
          }
        ],
        "tags": ["pages"]
      },
      "put": {
        "description": "Update a page.",
        "operationId": "blogger.pages.update",
        "parameters": [
          {
            "description": "The ID of the Blog.",
            "in": "path",
            "name": "blogId",
            "required": true,
            "type": "string"
          },
          {
            "description": "The ID of the Page.",
            "in": "path",
            "name": "pageId",
            "required": true,
            "type": "string"
          },
          {
            "description": "Whether a publish action should be performed when the page is updated (default: false).",
            "in": "query",
            "name": "publish",
            "type": "boolean"
          },
          {
            "description": "Whether a revert action should be performed when the page is updated (default: false).",
            "in": "query",
            "name": "revert",
            "type": "boolean"
          },
          {
            "in": "body",
            "name": "body",
            "schema": {
              "$ref": "#/definitions/Page"
            }
          }
        ],
        "responses": {
          "200": {
            "description": "Successful response",
            "schema": {
              "$ref": "#/definitions/Page"
            }
          }
        },
        "security": [
          {
            "Oauth2": ["https://www.googleapis.com/auth/blogger"]
          }
        ],
        "tags": ["pages"]
      }
    },
    "/blogs/{blogId}/pages/{pageId}/publish": {
      "parameters": [
        {
          "$ref": "#/parameters/alt"
        },
        {
          "$ref": "#/parameters/fields"
        },
        {
          "$ref": "#/parameters/key"
        },
        {
          "$ref": "#/parameters/oauth_token"
        },
        {
          "$ref": "#/parameters/prettyPrint"
        },
        {
          "$ref": "#/parameters/quotaUser"
        },
        {
          "$ref": "#/parameters/userIp"
        }
      ],
      "post": {
        "description": "Publishes a draft page.",
        "operationId": "blogger.pages.publish",
        "parameters": [
          {
            "description": "The ID of the blog.",
            "in": "path",
            "name": "blogId",
            "required": true,
            "type": "string"
          },
          {
            "description": "The ID of the page.",
            "in": "path",
            "name": "pageId",
            "required": true,
            "type": "string"
          }
        ],
        "responses": {
          "200": {
            "description": "Successful response",
            "schema": {
              "$ref": "#/definitions/Page"
            }
          }
        },
        "security": [
          {
            "Oauth2": ["https://www.googleapis.com/auth/blogger"]
          }
        ],
        "tags": ["pages"]
      }
    },
    "/blogs/{blogId}/pages/{pageId}/revert": {
      "parameters": [
        {
          "$ref": "#/parameters/alt"
        },
        {
          "$ref": "#/parameters/fields"
        },
        {
          "$ref": "#/parameters/key"
        },
        {
          "$ref": "#/parameters/oauth_token"
        },
        {
          "$ref": "#/parameters/prettyPrint"
        },
        {
          "$ref": "#/parameters/quotaUser"
        },
        {
          "$ref": "#/parameters/userIp"
        }
      ],
      "post": {
        "description": "Revert a published or scheduled page to draft state.",
        "operationId": "blogger.pages.revert",
        "parameters": [
          {
            "description": "The ID of the blog.",
            "in": "path",
            "name": "blogId",
            "required": true,
            "type": "string"
          },
          {
            "description": "The ID of the page.",
            "in": "path",
            "name": "pageId",
            "required": true,
            "type": "string"
          }
        ],
        "responses": {
          "200": {
            "description": "Successful response",
            "schema": {
              "$ref": "#/definitions/Page"
            }
          }
        },
        "security": [
          {
            "Oauth2": ["https://www.googleapis.com/auth/blogger"]
          }
        ],
        "tags": ["pages"]
      }
    },
    "/blogs/{blogId}/pageviews": {
      "get": {
        "description": "Retrieve pageview stats for a Blog.",
        "operationId": "blogger.pageViews.get",
        "parameters": [
          {
            "description": "The ID of the blog to get.",
            "in": "path",
            "name": "blogId",
            "required": true,
            "type": "string"
          },
          {
            "collectionFormat": "multi",
            "in": "query",
            "items": {
              "enum": ["30DAYS", "7DAYS", "all"],
              "type": "string"
            },
            "name": "range",
            "type": "array"
          }
        ],
        "responses": {
          "200": {
            "description": "Successful response",
            "schema": {
              "$ref": "#/definitions/Pageviews"
            }
          }
        },
        "security": [
          {
            "Oauth2": ["https://www.googleapis.com/auth/blogger"]
          }
        ],
        "tags": ["pageViews"]
      },
      "parameters": [
        {
          "$ref": "#/parameters/alt"
        },
        {
          "$ref": "#/parameters/fields"
        },
        {
          "$ref": "#/parameters/key"
        },
        {
          "$ref": "#/parameters/oauth_token"
        },
        {
          "$ref": "#/parameters/prettyPrint"
        },
        {
          "$ref": "#/parameters/quotaUser"
        },
        {
          "$ref": "#/parameters/userIp"
        }
      ]
    },
    "/blogs/{blogId}/posts": {
      "get": {
        "description": "Retrieves a list of posts, possibly filtered.",
        "operationId": "blogger.posts.list",
        "parameters": [
          {
            "description": "ID of the blog to fetch posts from.",
            "in": "path",
            "name": "blogId",
            "required": true,
            "type": "string"
          },
          {
            "description": "Latest post date to fetch, a date-time with RFC 3339 formatting.",
            "in": "query",
            "name": "endDate",
            "type": "string"
          },
          {
            "default": true,
            "description": "Whether the body content of posts is included (default: true). This should be set to false when the post bodies are not required, to help minimize traffic.",
            "in": "query",
            "name": "fetchBodies",
            "type": "boolean"
          },
          {
            "description": "Whether image URL metadata for each post is included.",
            "in": "query",
            "name": "fetchImages",
            "type": "boolean"
          },
          {
            "description": "Comma-separated list of labels to search for.",
            "in": "query",
            "name": "labels",
            "type": "string"
          },
          {
            "description": "Maximum number of posts to fetch.",
            "in": "query",
            "name": "maxResults",
            "type": "integer"
          },
          {
            "default": "published",
            "description": "Sort search results",
            "enum": ["published", "updated"],
            "in": "query",
            "name": "orderBy",
            "type": "string"
          },
          {
            "description": "Continuation token if the request is paged.",
            "in": "query",
            "name": "pageToken",
            "type": "string"
          },
          {
            "description": "Earliest post date to fetch, a date-time with RFC 3339 formatting.",
            "in": "query",
            "name": "startDate",
            "type": "string"
          },
          {
            "collectionFormat": "multi",
            "description": "Statuses to include in the results.",
            "in": "query",
            "items": {
              "enum": ["draft", "live", "scheduled"],
              "type": "string"
            },
            "name": "status",
            "type": "array"
          },
          {
            "description": "Access level with which to view the returned result. Note that some fields require escalated access.",
            "enum": ["ADMIN", "AUTHOR", "READER"],
            "in": "query",
            "name": "view",
            "type": "string"
          }
        ],
        "responses": {
          "200": {
            "description": "Successful response",
            "schema": {
              "$ref": "#/definitions/PostList"
            }
          }
        },
        "security": [
          {
            "Oauth2": ["https://www.googleapis.com/auth/blogger"]
          },
          {
            "Oauth2": ["https://www.googleapis.com/auth/blogger.readonly"]
          }
        ],
        "tags": ["posts"]
      },
      "parameters": [
        {
          "$ref": "#/parameters/alt"
        },
        {
          "$ref": "#/parameters/fields"
        },
        {
          "$ref": "#/parameters/key"
        },
        {
          "$ref": "#/parameters/oauth_token"
        },
        {
          "$ref": "#/parameters/prettyPrint"
        },
        {
          "$ref": "#/parameters/quotaUser"
        },
        {
          "$ref": "#/parameters/userIp"
        }
      ],
      "post": {
        "description": "Add a post.",
        "operationId": "blogger.posts.insert",
        "parameters": [
          {
            "description": "ID of the blog to add the post to.",
            "in": "path",
            "name": "blogId",
            "required": true,
            "type": "string"
          },
          {
            "default": true,
            "description": "Whether the body content of the post is included with the result (default: true).",
            "in": "query",
            "name": "fetchBody",
            "type": "boolean"
          },
          {
            "description": "Whether image URL metadata for each post is included in the returned result (default: false).",
            "in": "query",
            "name": "fetchImages",
            "type": "boolean"
          },
          {
            "description": "Whether to create the post as a draft (default: false).",
            "in": "query",
            "name": "isDraft",
            "type": "boolean"
          },
          {
            "in": "body",
            "name": "body",
            "schema": {
              "$ref": "#/definitions/Post"
            }
          }
        ],
        "responses": {
          "200": {
            "description": "Successful response",
            "schema": {
              "$ref": "#/definitions/Post"
            }
          }
        },
        "security": [
          {
            "Oauth2": ["https://www.googleapis.com/auth/blogger"]
          }
        ],
        "tags": ["posts"]
      }
    },
    "/blogs/{blogId}/posts/bypath": {
      "get": {
        "description": "Retrieve a Post by Path.",
        "operationId": "blogger.posts.getByPath",
        "parameters": [
          {
            "description": "ID of the blog to fetch the post from.",
            "in": "path",
            "name": "blogId",
            "required": true,
            "type": "string"
          },
          {
            "description": "Path of the Post to retrieve.",
            "in": "query",
            "name": "path",
            "required": true,
            "type": "string"
          },
          {
            "description": "Maximum number of comments to pull back on a post.",
            "in": "query",
            "name": "maxComments",
            "type": "integer"
          },
          {
            "description": "Access level with which to view the returned result. Note that some fields require elevated access.",
            "enum": ["ADMIN", "AUTHOR", "READER"],
            "in": "query",
            "name": "view",
            "type": "string"
          }
        ],
        "responses": {
          "200": {
            "description": "Successful response",
            "schema": {
              "$ref": "#/definitions/Post"
            }
          }
        },
        "security": [
          {
            "Oauth2": ["https://www.googleapis.com/auth/blogger"]
          },
          {
            "Oauth2": ["https://www.googleapis.com/auth/blogger.readonly"]
          }
        ],
        "tags": ["posts"]
      },
      "parameters": [
        {
          "$ref": "#/parameters/alt"
        },
        {
          "$ref": "#/parameters/fields"
        },
        {
          "$ref": "#/parameters/key"
        },
        {
          "$ref": "#/parameters/oauth_token"
        },
        {
          "$ref": "#/parameters/prettyPrint"
        },
        {
          "$ref": "#/parameters/quotaUser"
        },
        {
          "$ref": "#/parameters/userIp"
        }
      ]
    },
    "/blogs/{blogId}/posts/search": {
      "get": {
        "description": "Search for a post.",
        "operationId": "blogger.posts.search",
        "parameters": [
          {
            "description": "ID of the blog to fetch the post from.",
            "in": "path",
            "name": "blogId",
            "required": true,
            "type": "string"
          },
          {
            "description": "Query terms to search this blog for matching posts.",
            "in": "query",
            "name": "q",
            "required": true,
            "type": "string"
          },
          {
            "default": true,
            "description": "Whether the body content of posts is included (default: true). This should be set to false when the post bodies are not required, to help minimize traffic.",
            "in": "query",
            "name": "fetchBodies",
            "type": "boolean"
          },
          {
            "default": "published",
            "description": "Sort search results",
            "enum": ["published", "updated"],
            "in": "query",
            "name": "orderBy",
            "type": "string"
          }
        ],
        "responses": {
          "200": {
            "description": "Successful response",
            "schema": {
              "$ref": "#/definitions/PostList"
            }
          }
        },
        "security": [
          {
            "Oauth2": ["https://www.googleapis.com/auth/blogger"]
          },
          {
            "Oauth2": ["https://www.googleapis.com/auth/blogger.readonly"]
          }
        ],
        "tags": ["posts"]
      },
      "parameters": [
        {
          "$ref": "#/parameters/alt"
        },
        {
          "$ref": "#/parameters/fields"
        },
        {
          "$ref": "#/parameters/key"
        },
        {
          "$ref": "#/parameters/oauth_token"
        },
        {
          "$ref": "#/parameters/prettyPrint"
        },
        {
          "$ref": "#/parameters/quotaUser"
        },
        {
          "$ref": "#/parameters/userIp"
        }
      ]
    },
    "/blogs/{blogId}/posts/{postId}": {
      "delete": {
        "description": "Delete a post by ID.",
        "operationId": "blogger.posts.delete",
        "parameters": [
          {
            "description": "The ID of the Blog.",
            "in": "path",
            "name": "blogId",
            "required": true,
            "type": "string"
          },
          {
            "description": "The ID of the Post.",
            "in": "path",
            "name": "postId",
            "required": true,
            "type": "string"
          }
        ],
        "responses": {
          "200": {
            "description": "Successful response"
          }
        },
        "security": [
          {
            "Oauth2": ["https://www.googleapis.com/auth/blogger"]
          }
        ],
        "tags": ["posts"]
      },
      "get": {
        "description": "Get a post by ID.",
        "operationId": "blogger.posts.get",
        "parameters": [
          {
            "description": "ID of the blog to fetch the post from.",
            "in": "path",
            "name": "blogId",
            "required": true,
            "type": "string"
          },
          {
            "description": "The ID of the post",
            "in": "path",
            "name": "postId",
            "required": true,
            "type": "string"
          },
          {
            "default": true,
            "description": "Whether the body content of the post is included (default: true). This should be set to false when the post bodies are not required, to help minimize traffic.",
            "in": "query",
            "name": "fetchBody",
            "type": "boolean"
          },
          {
            "description": "Whether image URL metadata for each post is included (default: false).",
            "in": "query",
            "name": "fetchImages",
            "type": "boolean"
          },
          {
            "description": "Maximum number of comments to pull back on a post.",
            "in": "query",
            "name": "maxComments",
            "type": "integer"
          },
          {
            "description": "Access level with which to view the returned result. Note that some fields require elevated access.",
            "enum": ["ADMIN", "AUTHOR", "READER"],
            "in": "query",
            "name": "view",
            "type": "string"
          }
        ],
        "responses": {
          "200": {
            "description": "Successful response",
            "schema": {
              "$ref": "#/definitions/Post"
            }
          }
        },
        "security": [
          {
            "Oauth2": ["https://www.googleapis.com/auth/blogger"]
          },
          {
            "Oauth2": ["https://www.googleapis.com/auth/blogger.readonly"]
          }
        ],
        "tags": ["posts"]
      },
      "parameters": [
        {
          "$ref": "#/parameters/alt"
        },
        {
          "$ref": "#/parameters/fields"
        },
        {
          "$ref": "#/parameters/key"
        },
        {
          "$ref": "#/parameters/oauth_token"
        },
        {
          "$ref": "#/parameters/prettyPrint"
        },
        {
          "$ref": "#/parameters/quotaUser"
        },
        {
          "$ref": "#/parameters/userIp"
        }
      ],
      "patch": {
        "description": "Update a post. This method supports patch semantics.",
        "operationId": "blogger.posts.patch",
        "parameters": [
          {
            "description": "The ID of the Blog.",
            "in": "path",
            "name": "blogId",
            "required": true,
            "type": "string"
          },
          {
            "description": "The ID of the Post.",
            "in": "path",
            "name": "postId",
            "required": true,
            "type": "string"
          },
          {
            "default": true,
            "description": "Whether the body content of the post is included with the result (default: true).",
            "in": "query",
            "name": "fetchBody",
            "type": "boolean"
          },
          {
            "description": "Whether image URL metadata for each post is included in the returned result (default: false).",
            "in": "query",
            "name": "fetchImages",
            "type": "boolean"
          },
          {
            "description": "Maximum number of comments to retrieve with the returned post.",
            "in": "query",
            "name": "maxComments",
            "type": "integer"
          },
          {
            "description": "Whether a publish action should be performed when the post is updated (default: false).",
            "in": "query",
            "name": "publish",
            "type": "boolean"
          },
          {
            "description": "Whether a revert action should be performed when the post is updated (default: false).",
            "in": "query",
            "name": "revert",
            "type": "boolean"
          },
          {
            "in": "body",
            "name": "body",
            "schema": {
              "$ref": "#/definitions/Post"
            }
          }
        ],
        "responses": {
          "200": {
            "description": "Successful response",
            "schema": {
              "$ref": "#/definitions/Post"
            }
          }
        },
        "security": [
          {
            "Oauth2": ["https://www.googleapis.com/auth/blogger"]
          }
        ],
        "tags": ["posts"]
      },
      "put": {
        "description": "Update a post.",
        "operationId": "blogger.posts.update",
        "parameters": [
          {
            "description": "The ID of the Blog.",
            "in": "path",
            "name": "blogId",
            "required": true,
            "type": "string"
          },
          {
            "description": "The ID of the Post.",
            "in": "path",
            "name": "postId",
            "required": true,
            "type": "string"
          },
          {
            "default": true,
            "description": "Whether the body content of the post is included with the result (default: true).",
            "in": "query",
            "name": "fetchBody",
            "type": "boolean"
          },
          {
            "description": "Whether image URL metadata for each post is included in the returned result (default: false).",
            "in": "query",
            "name": "fetchImages",
            "type": "boolean"
          },
          {
            "description": "Maximum number of comments to retrieve with the returned post.",
            "in": "query",
            "name": "maxComments",
            "type": "integer"
          },
          {
            "description": "Whether a publish action should be performed when the post is updated (default: false).",
            "in": "query",
            "name": "publish",
            "type": "boolean"
          },
          {
            "description": "Whether a revert action should be performed when the post is updated (default: false).",
            "in": "query",
            "name": "revert",
            "type": "boolean"
          },
          {
            "in": "body",
            "name": "body",
            "schema": {
              "$ref": "#/definitions/Post"
            }
          }
        ],
        "responses": {
          "200": {
            "description": "Successful response",
            "schema": {
              "$ref": "#/definitions/Post"
            }
          }
        },
        "security": [
          {
            "Oauth2": ["https://www.googleapis.com/auth/blogger"]
          }
        ],
        "tags": ["posts"]
      }
    },
    "/blogs/{blogId}/posts/{postId}/comments": {
      "get": {
        "description": "Retrieves the comments for a post, possibly filtered.",
        "operationId": "blogger.comments.list",
        "parameters": [
          {
            "description": "ID of the blog to fetch comments from.",
            "in": "path",
            "name": "blogId",
            "required": true,
            "type": "string"
          },
          {
            "description": "ID of the post to fetch posts from.",
            "in": "path",
            "name": "postId",
            "required": true,
            "type": "string"
          },
          {
            "description": "Latest date of comment to fetch, a date-time with RFC 3339 formatting.",
            "in": "query",
            "name": "endDate",
            "type": "string"
          },
          {
            "description": "Whether the body content of the comments is included.",
            "in": "query",
            "name": "fetchBodies",
            "type": "boolean"
          },
          {
            "description": "Maximum number of comments to include in the result.",
            "in": "query",
            "name": "maxResults",
            "type": "integer"
          },
          {
            "description": "Continuation token if request is paged.",
            "in": "query",
            "name": "pageToken",
            "type": "string"
          },
          {
            "description": "Earliest date of comment to fetch, a date-time with RFC 3339 formatting.",
            "in": "query",
            "name": "startDate",
            "type": "string"
          },
          {
            "collectionFormat": "multi",
            "in": "query",
            "items": {
              "enum": ["emptied", "live", "pending", "spam"],
              "type": "string"
            },
            "name": "status",
            "type": "array"
          },
          {
            "description": "Access level with which to view the returned result. Note that some fields require elevated access.",
            "enum": ["ADMIN", "AUTHOR", "READER"],
            "in": "query",
            "name": "view",
            "type": "string"
          }
        ],
        "responses": {
          "200": {
            "description": "Successful response",
            "schema": {
              "$ref": "#/definitions/CommentList"
            }
          }
        },
        "security": [
          {
            "Oauth2": ["https://www.googleapis.com/auth/blogger"]
          },
          {
            "Oauth2": ["https://www.googleapis.com/auth/blogger.readonly"]
          }
        ],
        "tags": ["comments"]
      },
      "parameters": [
        {
          "$ref": "#/parameters/alt"
        },
        {
          "$ref": "#/parameters/fields"
        },
        {
          "$ref": "#/parameters/key"
        },
        {
          "$ref": "#/parameters/oauth_token"
        },
        {
          "$ref": "#/parameters/prettyPrint"
        },
        {
          "$ref": "#/parameters/quotaUser"
        },
        {
          "$ref": "#/parameters/userIp"
        }
      ]
    },
    "/blogs/{blogId}/posts/{postId}/comments/{commentId}": {
      "delete": {
        "description": "Delete a comment by ID.",
        "operationId": "blogger.comments.delete",
        "parameters": [
          {
            "description": "The ID of the Blog.",
            "in": "path",
            "name": "blogId",
            "required": true,
            "type": "string"
          },
          {
            "description": "The ID of the Post.",
            "in": "path",
            "name": "postId",
            "required": true,
            "type": "string"
          },
          {
            "description": "The ID of the comment to delete.",
            "in": "path",
            "name": "commentId",
            "required": true,
            "type": "string"
          }
        ],
        "responses": {
          "200": {
            "description": "Successful response"
          }
        },
        "security": [
          {
            "Oauth2": ["https://www.googleapis.com/auth/blogger"]
          }
        ],
        "tags": ["comments"]
      },
      "get": {
        "description": "Gets one comment by ID.",
        "operationId": "blogger.comments.get",
        "parameters": [
          {
            "description": "ID of the blog to containing the comment.",
            "in": "path",
            "name": "blogId",
            "required": true,
            "type": "string"
          },
          {
            "description": "ID of the post to fetch posts from.",
            "in": "path",
            "name": "postId",
            "required": true,
            "type": "string"
          },
          {
            "description": "The ID of the comment to get.",
            "in": "path",
            "name": "commentId",
            "required": true,
            "type": "string"
          },
          {
            "description": "Access level for the requested comment (default: READER). Note 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.",
            "enum": ["ADMIN", "AUTHOR", "READER"],
            "in": "query",
            "name": "view",
            "type": "string"
          }
        ],
        "responses": {
          "200": {
            "description": "Successful response",
            "schema": {
              "$ref": "#/definitions/Comment"
            }
          }
        },
        "security": [
          {
            "Oauth2": ["https://www.googleapis.com/auth/blogger"]
          },
          {
            "Oauth2": ["https://www.googleapis.com/auth/blogger.readonly"]
          }
        ],
        "tags": ["comments"]
      },
      "parameters": [
        {
          "$ref": "#/parameters/alt"
        },
        {
          "$ref": "#/parameters/fields"
        },
        {
          "$ref": "#/parameters/key"
        },
        {
          "$ref": "#/parameters/oauth_token"
        },
        {
          "$ref": "#/parameters/prettyPrint"
        },
        {
          "$ref": "#/parameters/quotaUser"
        },
        {
          "$ref": "#/parameters/userIp"
        }
      ]
    },
    "/blogs/{blogId}/posts/{postId}/comments/{commentId}/approve": {
      "parameters": [
        {
          "$ref": "#/parameters/alt"
        },
        {
          "$ref": "#/parameters/fields"
        },
        {
          "$ref": "#/parameters/key"
        },
        {
          "$ref": "#/parameters/oauth_token"
        },
        {
          "$ref": "#/parameters/prettyPrint"
        },
        {
          "$ref": "#/parameters/quotaUser"
        },
        {
          "$ref": "#/parameters/userIp"
        }
      ],
      "post": {
        "description": "Marks a comment as not spam.",
        "operationId": "blogger.comments.approve",
        "parameters": [
          {
            "description": "The ID of the Blog.",
            "in": "path",
            "name": "blogId",
            "required": true,
            "type": "string"
          },
          {
            "description": "The ID of the Post.",
            "in": "path",
            "name": "postId",
            "required": true,
            "type": "string"
          },
          {
            "description": "The ID of the comment to mark as not spam.",
            "in": "path",
            "name": "commentId",
            "required": true,
            "type": "string"
          }
        ],
        "responses": {
          "200": {
            "description": "Successful response",
            "schema": {
              "$ref": "#/definitions/Comment"
            }
          }
        },
        "security": [
          {
            "Oauth2": ["https://www.googleapis.com/auth/blogger"]
          }
        ],
        "tags": ["comments"]
      }
    },
    "/blogs/{blogId}/posts/{postId}/comments/{commentId}/removecontent": {
      "parameters": [
        {
          "$ref": "#/parameters/alt"
        },
        {
          "$ref": "#/parameters/fields"
        },
        {
          "$ref": "#/parameters/key"
        },
        {
          "$ref": "#/parameters/oauth_token"
        },
        {
          "$ref": "#/parameters/prettyPrint"
        },
        {
          "$ref": "#/parameters/quotaUser"
        },
        {
          "$ref": "#/parameters/userIp"
        }
      ],
      "post": {
        "description": "Removes the content of a comment.",
        "operationId": "blogger.comments.removeContent",
        "parameters": [
          {
            "description": "The ID of the Blog.",
            "in": "path",
            "name": "blogId",
            "required": true,
            "type": "string"
          },
          {
            "description": "The ID of the Post.",
            "in": "path",
            "name": "postId",
            "required": true,
            "type": "string"
          },
          {
            "description": "The ID of the comment to delete content from.",
            "in": "path",
            "name": "commentId",
            "required": true,
            "type": "string"
          }
        ],
        "responses": {
          "200": {
            "description": "Successful response",
            "schema": {
              "$ref": "#/definitions/Comment"
            }
          }
        },
        "security": [
          {
            "Oauth2": ["https://www.googleapis.com/auth/blogger"]
          }
        ],
        "tags": ["comments"]
      }
    },
    "/blogs/{blogId}/posts/{postId}/comments/{commentId}/spam": {
      "parameters": [
        {
          "$ref": "#/parameters/alt"
        },
        {
          "$ref": "#/parameters/fields"
        },
        {
          "$ref": "#/parameters/key"
        },
        {
          "$ref": "#/parameters/oauth_token"
        },
        {
          "$ref": "#/parameters/prettyPrint"
        },
        {
          "$ref": "#/parameters/quotaUser"
        },
        {
          "$ref": "#/parameters/userIp"
        }
      ],
      "post": {
        "description": "Marks a comment as spam.",
        "operationId": "blogger.comments.markAsSpam",
        "parameters": [
          {
            "description": "The ID of the Blog.",
            "in": "path",
            "name": "blogId",
            "required": true,
            "type": "string"
          },
          {
            "description": "The ID of the Post.",
            "in": "path",
            "name": "postId",
            "required": true,
            "type": "string"
          },
          {
            "description": "The ID of the comment to mark as spam.",
            "in": "path",
            "name": "commentId",
            "required": true,
            "type": "string"
          }
        ],
        "responses": {
          "200": {
            "description": "Successful response",
            "schema": {
              "$ref": "#/definitions/Comment"
            }
          }
        },
        "security": [
          {
            "Oauth2": ["https://www.googleapis.com/auth/blogger"]
          }
        ],
        "tags": ["comments"]
      }
    },
    "/blogs/{blogId}/posts/{postId}/publish": {
      "parameters": [
        {
          "$ref": "#/parameters/alt"
        },
        {
          "$ref": "#/parameters/fields"
        },
        {
          "$ref": "#/parameters/key"
        },
        {
          "$ref": "#/parameters/oauth_token"
        },
        {
          "$ref": "#/parameters/prettyPrint"
        },
        {
          "$ref": "#/parameters/quotaUser"
        },
        {
          "$ref": "#/parameters/userIp"
        }
      ],
      "post": {
        "description": "Publishes a draft post, optionally at the specific time of the given publishDate parameter.",
        "operationId": "blogger.posts.publish",
        "parameters": [
          {
            "description": "The ID of the Blog.",
            "in": "path",
            "name": "blogId",
            "required": true,
            "type": "string"
          },
          {
            "description": "The ID of the Post.",
            "in": "path",
            "name": "postId",
            "required": true,
            "type": "string"
          },
          {
            "description": "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.",
            "in": "query",
            "name": "publishDate",
            "type": "string"
          }
        ],
        "responses": {
          "200": {
            "description": "Successful response",
            "schema": {
              "$ref": "#/definitions/Post"
            }
          }
        },
        "security": [
          {
            "Oauth2": ["https://www.googleapis.com/auth/blogger"]
          }
        ],
        "tags": ["posts"]
      }
    },
    "/blogs/{blogId}/posts/{postId}/revert": {
      "parameters": [
        {
          "$ref": "#/parameters/alt"
        },
        {
          "$ref": "#/parameters/fields"
        },
        {
          "$ref": "#/parameters/key"
        },
        {
          "$ref": "#/parameters/oauth_token"
        },
        {
          "$ref": "#/parameters/prettyPrint"
        },
        {
          "$ref": "#/parameters/quotaUser"
        },
        {
          "$ref": "#/parameters/userIp"
        }
      ],
      "post": {
        "description": "Revert a published or scheduled post to draft state.",
        "operationId": "blogger.posts.revert",
        "parameters": [
          {
            "description": "The ID of the Blog.",
            "in": "path",
            "name": "blogId",
            "required": true,
            "type": "string"
          },
          {
            "description": "The ID of the Post.",
            "in": "path",
            "name": "postId",
            "required": true,
            "type": "string"
          }
        ],
        "responses": {
          "200": {
            "description": "Successful response",
            "schema": {
              "$ref": "#/definitions/Post"
            }
          }
        },
        "security": [
          {
            "Oauth2": ["https://www.googleapis.com/auth/blogger"]
          }
        ],
        "tags": ["posts"]
      }
    },
    "/users/{userId}": {
      "get": {
        "description": "Gets one user by ID.",
        "operationId": "blogger.users.get",
        "parameters": [
          {
            "description": "The ID of the user to get.",
            "in": "path",
            "name": "userId",
            "required": true,
            "type": "string"
          }
        ],
        "responses": {
          "200": {
            "description": "Successful response",
            "schema": {
              "$ref": "#/definitions/User"
            }
          }
        },
        "security": [
          {
            "Oauth2": ["https://www.googleapis.com/auth/blogger"]
          },
          {
            "Oauth2": ["https://www.googleapis.com/auth/blogger.readonly"]
          }
        ],
        "tags": ["users"]
      },
      "parameters": [
        {
          "$ref": "#/parameters/alt"
        },
        {
          "$ref": "#/parameters/fields"
        },
        {
          "$ref": "#/parameters/key"
        },
        {
          "$ref": "#/parameters/oauth_token"
        },
        {
          "$ref": "#/parameters/prettyPrint"
        },
        {
          "$ref": "#/parameters/quotaUser"
        },
        {
          "$ref": "#/parameters/userIp"
        }
      ]
    },
    "/users/{userId}/blogs": {
      "get": {
        "description": "Retrieves a list of blogs, possibly filtered.",
        "operationId": "blogger.blogs.listByUser",
        "parameters": [
          {
            "description": "ID of the user whose blogs are to be fetched. Either the word 'self' (sans quote marks) or the user's profile identifier.",
            "in": "path",
            "name": "userId",
            "required": true,
            "type": "string"
          },
          {
            "description": "Whether the response is a list of blogs with per-user information instead of just blogs.",
            "in": "query",
            "name": "fetchUserInfo",
            "type": "boolean"
          },
          {
            "collectionFormat": "multi",
            "description": "User access types for blogs to include in the results, e.g. AUTHOR will return blogs where the user has author level access. If no roles are specified, defaults to ADMIN and AUTHOR roles.",
            "in": "query",
            "items": {
              "enum": ["ADMIN", "AUTHOR", "READER"],
              "type": "string"
            },
            "name": "role",
            "type": "array"
          },
          {
            "collectionFormat": "multi",
            "description": "Blog statuses to include in the result (default: Live blogs only). Note that ADMIN access is required to view deleted blogs.",
            "in": "query",
            "items": {
              "enum": ["DELETED", "LIVE"],
              "type": "string"
            },
            "name": "status",
            "type": "array"
          },
          {
            "description": "Access level with which to view the blogs. Note that some fields require elevated access.",
            "enum": ["ADMIN", "AUTHOR", "READER"],
            "in": "query",
            "name": "view",
            "type": "string"
          }
        ],
        "responses": {
          "200": {
            "description": "Successful response",
            "schema": {
              "$ref": "#/definitions/BlogList"
            }
          }
        },
        "security": [
          {
            "Oauth2": ["https://www.googleapis.com/auth/blogger"]
          },
          {
            "Oauth2": ["https://www.googleapis.com/auth/blogger.readonly"]
          }
        ],
        "tags": ["blogs"]
      },
      "parameters": [
        {
          "$ref": "#/parameters/alt"
        },
        {
          "$ref": "#/parameters/fields"
        },
        {
          "$ref": "#/parameters/key"
        },
        {
          "$ref": "#/parameters/oauth_token"
        },
        {
          "$ref": "#/parameters/prettyPrint"
        },
        {
          "$ref": "#/parameters/quotaUser"
        },
        {
          "$ref": "#/parameters/userIp"
        }
      ]
    },
    "/users/{userId}/blogs/{blogId}": {
      "get": {
        "description": "Gets one blog and user info pair by blogId and userId.",
        "operationId": "blogger.blogUserInfos.get",
        "parameters": [
          {
            "description": "ID of the user whose blogs are to be fetched. Either the word 'self' (sans quote marks) or the user's profile identifier.",
            "in": "path",
            "name": "userId",
            "required": true,
            "type": "string"
          },
          {
            "description": "The ID of the blog to get.",
            "in": "path",
            "name": "blogId",
            "required": true,
            "type": "string"
          },
          {
            "description": "Maximum number of posts to pull back with the blog.",
            "in": "query",
            "name": "maxPosts",
            "type": "integer"
          }
        ],
        "responses": {
          "200": {
            "description": "Successful response",
            "schema": {
              "$ref": "#/definitions/BlogUserInfo"
            }
          }
        },
        "security": [
          {
            "Oauth2": ["https://www.googleapis.com/auth/blogger"]
          },
          {
            "Oauth2": ["https://www.googleapis.com/auth/blogger.readonly"]
          }
        ],
        "tags": ["blogUserInfos"]
      },
      "parameters": [
        {
          "$ref": "#/parameters/alt"
        },
        {
          "$ref": "#/parameters/fields"
        },
        {
          "$ref": "#/parameters/key"
        },
        {
          "$ref": "#/parameters/oauth_token"
        },
        {
          "$ref": "#/parameters/prettyPrint"
        },
        {
          "$ref": "#/parameters/quotaUser"
        },
        {
          "$ref": "#/parameters/userIp"
        }
      ]
    },
    "/users/{userId}/blogs/{blogId}/posts": {
      "get": {
        "description": "Retrieves a list of post and post user info pairs, possibly filtered. The post user info contains per-user information about the post, such as access rights, specific to the user.",
        "operationId": "blogger.postUserInfos.list",
        "parameters": [
          {
            "description": "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.",
            "in": "path",
            "name": "userId",
            "required": true,
            "type": "string"
          },
          {
            "description": "ID of the blog to fetch posts from.",
            "in": "path",
            "name": "blogId",
            "required": true,
            "type": "string"
          },
          {
            "description": "Latest post date to fetch, a date-time with RFC 3339 formatting.",
            "in": "query",
            "name": "endDate",
            "type": "string"
          },
          {
            "default": false,
            "description": "Whether the body content of posts is included. Default is false.",
            "in": "query",
            "name": "fetchBodies",
            "type": "boolean"
          },
          {
            "description": "Comma-separated list of labels to search for.",
            "in": "query",
            "name": "labels",
            "type": "string"
          },
          {
            "description": "Maximum number of posts to fetch.",
            "in": "query",
            "name": "maxResults",
            "type": "integer"
          },
          {
            "default": "published",
            "description": "Sort order applied to search results. Default is published.",
            "enum": ["published", "updated"],
            "in": "query",
            "name": "orderBy",
            "type": "string"
          },
          {
            "description": "Continuation token if the request is paged.",
            "in": "query",
            "name": "pageToken",
            "type": "string"
          },
          {
            "description": "Earliest post date to fetch, a date-time with RFC 3339 formatting.",
            "in": "query",
            "name": "startDate",
            "type": "string"
          },
          {
            "collectionFormat": "multi",
            "in": "query",
            "items": {
              "enum": ["draft", "live", "scheduled"],
              "type": "string"
            },
            "name": "status",
            "type": "array"
          },
          {
            "description": "Access level with which to view the returned result. Note that some fields require elevated access.",
            "enum": ["ADMIN", "AUTHOR", "READER"],
            "in": "query",
            "name": "view",
            "type": "string"
          }
        ],
        "responses": {
          "200": {
            "description": "Successful response",
            "schema": {
              "$ref": "#/definitions/PostUserInfosList"
            }
          }
        },
        "security": [
          {
            "Oauth2": ["https://www.googleapis.com/auth/blogger"]
          },
          {
            "Oauth2": ["https://www.googleapis.com/auth/blogger.readonly"]
          }
        ],
        "tags": ["postUserInfos"]
      },
      "parameters": [
        {
          "$ref": "#/parameters/alt"
        },
        {
          "$ref": "#/parameters/fields"
        },
        {
          "$ref": "#/parameters/key"
        },
        {
          "$ref": "#/parameters/oauth_token"
        },
        {
          "$ref": "#/parameters/prettyPrint"
        },
        {
          "$ref": "#/parameters/quotaUser"
        },
        {
          "$ref": "#/parameters/userIp"
        }
      ]
    },
    "/users/{userId}/blogs/{blogId}/posts/{postId}": {
      "get": {
        "description": "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.",
        "operationId": "blogger.postUserInfos.get",
        "parameters": [
          {
            "description": "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.",
            "in": "path",
            "name": "userId",
            "required": true,
            "type": "string"
          },
          {
            "description": "The ID of the blog.",
            "in": "path",
            "name": "blogId",
            "required": true,
            "type": "string"
          },
          {
            "description": "The ID of the post to get.",
            "in": "path",
            "name": "postId",
            "required": true,
            "type": "string"
          },
          {
            "description": "Maximum number of comments to pull back on a post.",
            "in": "query",
            "name": "maxComments",
            "type": "integer"
          }
        ],
        "responses": {
          "200": {
            "description": "Successful response",
            "schema": {
              "$ref": "#/definitions/PostUserInfo"
            }
          }
        },
        "security": [
          {
            "Oauth2": ["https://www.googleapis.com/auth/blogger"]
          },
          {
            "Oauth2": ["https://www.googleapis.com/auth/blogger.readonly"]
          }
        ],
        "tags": ["postUserInfos"]
      },
      "parameters": [
        {
          "$ref": "#/parameters/alt"
        },
        {
          "$ref": "#/parameters/fields"
        },
        {
          "$ref": "#/parameters/key"
        },
        {
          "$ref": "#/parameters/oauth_token"
        },
        {
          "$ref": "#/parameters/prettyPrint"
        },
        {
          "$ref": "#/parameters/quotaUser"
        },
        {
          "$ref": "#/parameters/userIp"
        }
      ]
    }
  },
  "definitions": {
    "Blog": {
      "properties": {
        "customMetaData": {
          "description": "The JSON custom meta-data for the Blog",
          "type": "string"
        },
        "description": {
          "description": "The description of this blog. This is displayed underneath the title.",
          "type": "string"
        },
        "id": {
          "description": "The identifier for this resource.",
          "type": "string"
        },
        "kind": {
          "default": "blogger#blog",
          "description": "The kind of this entry. Always blogger#blog",
          "type": "string"
        },
        "locale": {
          "description": "The locale this Blog is set to.",
          "properties": {
            "country": {
              "description": "The country this blog's locale is set to.",
              "type": "string"
            },
            "language": {
              "description": "The language this blog is authored in.",
              "type": "string"
            },
            "variant": {
              "description": "The language variant this blog is authored in.",
              "type": "string"
            }
          },
          "type": "object"
        },
        "name": {
          "description": "The name of this blog. This is displayed as the title.",
          "type": "string"
        },
        "pages": {
          "description": "The container of pages in this blog.",
          "properties": {
            "selfLink": {
              "description": "The URL of the container for pages in this blog.",
              "type": "string"
            },
            "totalItems": {
              "description": "The count of pages in this blog.",
              "format": "int32",
              "type": "integer"
            }
          },
          "type": "object"
        },
        "posts": {
          "description": "The container of posts in this blog.",
          "properties": {
            "items": {
              "description": "The List of Posts for this Blog.",
              "items": {
                "$ref": "#/definitions/Post"
              },
              "type": "array"
            },
            "selfLink": {
              "description": "The URL of the container for posts in this blog.",
              "type": "string"
            },
            "totalItems": {
              "description": "The count of posts in this blog.",
              "format": "int32",
              "type": "integer"
            }
          },
          "type": "object"
        },
        "published": {
          "description": "RFC 3339 date-time when this blog was published.",
          "format": "date-time",
          "type": "string"
        },
        "selfLink": {
          "description": "The API REST URL to fetch this resource from.",
          "type": "string"
        },
        "status": {
          "description": "The status of the blog.",
          "type": "string"
        },
        "updated": {
          "description": "RFC 3339 date-time when this blog was last updated.",
          "format": "date-time",
          "type": "string"
        },
        "url": {
          "description": "The URL where this blog is published.",
          "type": "string"
        }
      },
      "type": "object"
    },
    "BlogList": {
      "properties": {
        "blogUserInfos": {
          "description": "Admin level list of blog per-user information",
          "items": {
            "$ref": "#/definitions/BlogUserInfo"
          },
          "type": "array"
        },
        "items": {
          "description": "The list of Blogs this user has Authorship or Admin rights over.",
          "items": {
            "$ref": "#/definitions/Blog"
          },
          "type": "array"
        },
        "kind": {
          "default": "blogger#blogList",
          "description": "The kind of this entity. Always blogger#blogList",
          "type": "string"
        }
      },
      "type": "object"
    },
    "BlogPerUserInfo": {
      "properties": {
        "blogId": {
          "description": "ID of the Blog resource",
          "type": "string"
        },
        "hasAdminAccess": {
          "description": "True if the user has Admin level access to the blog.",
          "type": "boolean"
        },
        "kind": {
          "default": "blogger#blogPerUserInfo",
          "description": "The kind of this entity. Always blogger#blogPerUserInfo",
          "type": "string"
        },
        "photosAlbumKey": {
          "description": "The Photo Album Key for the user when adding photos to the blog",
          "type": "string"
        },
        "role": {
          "description": "Access permissions that the user has for the blog (ADMIN, AUTHOR, or READER).",
          "type": "string"
        },
        "userId": {
          "description": "ID of the User",
          "type": "string"
        }
      },
      "type": "object"
    },
    "BlogUserInfo": {
      "properties": {
        "blog": {
          "$ref": "#/definitions/Blog",
          "description": "The Blog resource."
        },
        "blog_user_info": {
          "$ref": "#/definitions/BlogPerUserInfo",
          "description": "Information about a User for the Blog."
        },
        "kind": {
          "default": "blogger#blogUserInfo",
          "description": "The kind of this entity. Always blogger#blogUserInfo",
          "type": "string"
        }
      },
      "type": "object"
    },
    "Comment": {
      "properties": {
        "author": {
          "description": "The author of this Comment.",
          "properties": {
            "displayName": {
              "description": "The display name.",
              "type": "string"
            },
            "id": {
              "description": "The identifier of the Comment creator.",
              "type": "string"
            },
            "image": {
              "description": "The comment creator's avatar.",
              "properties": {
                "url": {
                  "description": "The comment creator's avatar URL.",
                  "type": "string"
                }
              },
              "type": "object"
            },
            "url": {
              "description": "The URL of the Comment creator's Profile page.",
              "type": "string"
            }
          },
          "type": "object"
        },
        "blog": {
          "description": "Data about the blog containing this comment.",
          "properties": {
            "id": {
              "description": "The identifier of the blog containing this comment.",
              "type": "string"
            }
          },
          "type": "object"
        },
        "content": {
          "description": "The actual content of the comment. May include HTML markup.",
          "type": "string"
        },
        "id": {
          "description": "The identifier for this resource.",
          "type": "string"
        },
        "inReplyTo": {
          "description": "Data about the comment this is in reply to.",
          "properties": {
            "id": {
              "description": "The identified of the parent of this comment.",
              "type": "string"
            }
          },
          "type": "object"
        },
        "kind": {
          "default": "blogger#comment",
          "description": "The kind of this entry. Always blogger#comment",
          "type": "string"
        },
        "post": {
          "description": "Data about the post containing this comment.",
          "properties": {
            "id": {
              "description": "The identifier of the post containing this comment.",
              "type": "string"
            }
          },
          "type": "object"
        },
        "published": {
          "description": "RFC 3339 date-time when this comment was published.",
          "format": "date-time",
          "type": "string"
        },
        "selfLink": {
          "description": "The API REST URL to fetch this resource from.",
          "type": "string"
        },
        "status": {
          "description": "The status of the comment (only populated for admin users)",
          "type": "string"
        },
        "updated": {
          "description": "RFC 3339 date-time when this comment was last updated.",
          "format": "date-time",
          "type": "string"
        }
      },
      "type": "object"
    },
    "CommentList": {
      "properties": {
        "etag": {
          "description": "Etag of the response.",
          "type": "string"
        },
        "items": {
          "description": "The List of Comments for a Post.",
          "items": {
            "$ref": "#/definitions/Comment"
          },
          "type": "array"
        },
        "kind": {
          "default": "blogger#commentList",
          "description": "The kind of this entry. Always blogger#commentList",
          "type": "string"
        },
        "nextPageToken": {
          "description": "Pagination token to fetch the next page, if one exists.",
          "type": "string"
        },
        "prevPageToken": {
          "description": "Pagination token to fetch the previous page, if one exists.",
          "type": "string"
        }
      },
      "type": "object"
    },
    "Page": {
      "properties": {
        "name": {
          "type": "string"
        },
        "subPage": {
          "$ref": "#/definitions/SubPage"
        },
        "SubPages": {
          "type": "array",
          "items": {
            "$ref": "#/definitions/SubPage"
          }
        }
      },
      "type": "object"
    },
    "SubPage": {
      "properties": {
        "subPageTitle": {
          "type": "string"
        },
        "subPageDate": {
          "type": "number"
        },
        "subSubPage": {
          "$ref": "#/definitions/SubSubPage"
        }
      },
      "type": "object"
    },
    "SubSubPage": {
      "type": "object",
      "properties": {
        "subSubPageName": {
          "type": "string"
        }
      }
    },
    "PageList": {
      "properties": {
        "etag": {
          "description": "Etag of the response.",
          "type": "string"
        },
        "items": {
          "description": "The list of Pages for a Blog.",
          "items": {
            "$ref": "#/definitions/Page"
          },
          "type": "array"
        },
        "kind": {
          "default": "blogger#pageList",
          "description": "The kind of this entity. Always blogger#pageList",
          "type": "string"
        },
        "nextPageToken": {
          "description": "Pagination token to fetch the next page, if one exists.",
          "type": "string"
        }
      },
      "type": "object"
    },
    "Pageviews": {
      "properties": {
        "blogId": {
          "description": "Blog Id",
          "type": "string"
        },
        "counts": {
          "description": "The container of posts in this blog.",
          "items": {
            "properties": {
              "count": {
                "description": "Count of page views for the given time range",
                "format": "int64",
                "type": "string"
              },
              "timeRange": {
                "description": "Time range the given count applies to",
                "type": "string"
              }
            },
            "type": "object"
          },
          "type": "array"
        },
        "kind": {
          "default": "blogger#page_views",
          "description": "The kind of this entry. Always blogger#page_views",
          "type": "string"
        }
      },
      "type": "object"
    },
    "Post": {
      "properties": {
        "author": {
          "description": "The author of this Post.",
          "properties": {
            "displayName": {
              "description": "The display name.",
              "type": "string"
            },
            "id": {
              "description": "The identifier of the Post creator.",
              "type": "string"
            },
            "image": {
              "description": "The Post author's avatar.",
              "properties": {
                "url": {
                  "description": "The Post author's avatar URL.",
                  "type": "string"
                }
              },
              "type": "object"
            },
            "url": {
              "description": "The URL of the Post creator's Profile page.",
              "type": "string"
            }
          },
          "type": "object"
        },
        "blog": {
          "description": "Data about the blog containing this Post.",
          "properties": {
            "id": {
              "description": "The identifier of the Blog that contains this Post.",
              "type": "string"
            }
          },
          "type": "object"
        },
        "content": {
          "description": "The content of the Post. May contain HTML markup.",
          "type": "string"
        },
        "customMetaData": {
          "description": "The JSON meta-data for the Post.",
          "type": "string"
        },
        "etag": {
          "description": "Etag of the resource.",
          "type": "string"
        },
        "id": {
          "description": "The identifier of this Post.",
          "type": "string"
        },
        "images": {
          "description": "Display image for the Post.",
          "items": {
            "properties": {
              "url": {
                "type": "string"
              }
            },
            "type": "object"
          },
          "type": "array"
        },
        "kind": {
          "default": "blogger#post",
          "description": "The kind of this entity. Always blogger#post",
          "type": "string"
        },
        "labels": {
          "description": "The list of labels this Post was tagged with.",
          "items": {
            "type": "string"
          },
          "type": "array"
        },
        "location": {
          "description": "The location for geotagged posts.",
          "properties": {
            "lat": {
              "description": "Location's latitude.",
              "format": "double",
              "type": "number"
            },
            "lng": {
              "description": "Location's longitude.",
              "format": "double",
              "type": "number"
            },
            "name": {
              "description": "Location name.",
              "type": "string"
            },
            "span": {
              "description": "Location's viewport span. Can be used when rendering a map preview.",
              "type": "string"
            }
          },
          "type": "object"
        },
        "published": {
          "description": "RFC 3339 date-time when this Post was published.",
          "format": "date-time",
          "type": "string"
        },
        "readerComments": {
          "description": "Comment control and display setting for readers of this post.",
          "type": "string"
        },
        "replies": {
          "description": "The container of comments on this Post.",
          "properties": {
            "items": {
              "description": "The List of Comments for this Post.",
              "items": {
                "$ref": "#/definitions/Comment"
              },
              "type": "array"
            },
            "selfLink": {
              "description": "The URL of the comments on this post.",
              "type": "string"
            },
            "totalItems": {
              "description": "The count of comments on this post.",
              "format": "int64",
              "type": "string"
            }
          },
          "type": "object"
        },
        "selfLink": {
          "description": "The API REST URL to fetch this resource from.",
          "type": "string"
        },
        "status": {
          "description": "Status of the post. Only set for admin-level requests",
          "type": "string"
        },
        "title": {
          "description": "The title of the Post.",
          "type": "string"
        },
        "titleLink": {
          "description": "The title link URL, similar to atom's related link.",
          "type": "string"
        },
        "updated": {
          "description": "RFC 3339 date-time when this Post was last updated.",
          "format": "date-time",
          "type": "string"
        },
        "url": {
          "description": "The URL where this Post is displayed.",
          "type": "string"
        }
      },
      "type": "object"
    },
    "PostList": {
      "properties": {
        "etag": {
          "description": "Etag of the response.",
          "type": "string"
        },
        "items": {
          "description": "The list of Posts for this Blog.",
          "items": {
            "$ref": "#/definitions/Post"
          },
          "type": "array"
        },
        "kind": {
          "default": "blogger#postList",
          "description": "The kind of this entity. Always blogger#postList",
          "type": "string"
        },
        "nextPageToken": {
          "description": "Pagination token to fetch the next page, if one exists.",
          "type": "string"
        }
      },
      "type": "object"
    },
    "PostPerUserInfo": {
      "properties": {
        "blogId": {
          "description": "ID of the Blog that the post resource belongs to.",
          "type": "string"
        },
        "hasEditAccess": {
          "description": "True if the user has Author level access to the post.",
          "type": "boolean"
        },
        "kind": {
          "default": "blogger#postPerUserInfo",
          "description": "The kind of this entity. Always blogger#postPerUserInfo",
          "type": "string"
        },
        "postId": {
          "description": "ID of the Post resource.",
          "type": "string"
        },
        "userId": {
          "description": "ID of the User.",
          "type": "string"
        }
      },
      "type": "object"
    },
    "PostUserInfo": {
      "properties": {
        "kind": {
          "default": "blogger#postUserInfo",
          "description": "The kind of this entity. Always blogger#postUserInfo",
          "type": "string"
        },
        "post": {
          "$ref": "#/definitions/Post",
          "description": "The Post resource."
        },
        "post_user_info": {
          "$ref": "#/definitions/PostPerUserInfo",
          "description": "Information about a User for the Post."
        }
      },
      "type": "object"
    },
    "PostUserInfosList": {
      "properties": {
        "items": {
          "description": "The list of Posts with User information for the post, for this Blog.",
          "items": {
            "$ref": "#/definitions/PostUserInfo"
          },
          "type": "array"
        },
        "kind": {
          "default": "blogger#postUserInfosList",
          "description": "The kind of this entity. Always blogger#postList",
          "type": "string"
        },
        "nextPageToken": {
          "description": "Pagination token to fetch the next page, if one exists.",
          "type": "string"
        }
      },
      "type": "object"
    },
    "User": {
      "properties": {
        "about": {
          "description": "Profile summary information.",
          "type": "string"
        },
        "blogs": {
          "description": "The container of blogs for this user.",
          "properties": {
            "selfLink": {
              "description": "The URL of the Blogs for this user.",
              "type": "string"
            }
          },
          "type": "object"
        },
        "created": {
          "description": "The timestamp of when this profile was created, in seconds since epoch.",
          "format": "date-time",
          "type": "string"
        },
        "displayName": {
          "description": "The display name.",
          "type": "string"
        },
        "id": {
          "description": "The identifier for this User.",
          "type": "string"
        },
        "kind": {
          "default": "blogger#user",
          "description": "The kind of this entity. Always blogger#user",
          "type": "string"
        },
        "locale": {
          "description": "This user's locale",
          "properties": {
            "country": {
              "description": "The user's country setting.",
              "type": "string"
            },
            "language": {
              "description": "The user's language setting.",
              "type": "string"
            },
            "variant": {
              "description": "The user's language variant setting.",
              "type": "string"
            }
          },
          "type": "object"
        },
        "selfLink": {
          "description": "The API REST URL to fetch this resource from.",
          "type": "string"
        },
        "url": {
          "description": "The user's profile page.",
          "type": "string"
        }
      },
      "type": "object"
    }
  }
}
