openapi-snippet/test/blogger_swagger.json

Generates code snippets from Open API (previously Swagger) documents.

{
  "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