func (v Video) Report(params VideoReportParams) (bool, error) {
	r, err := v.API.Request("video.report", params)
	if err != nil {
		return false, err
	}
	return decodeBoolIntResponse(r)
}
Report Reports (submits a complaint about) a video.
package vkapi
import (
	"encoding/json"
	"strconv"
	"github.com/stek29/vk"
)
type Video struct {
	API vk.API
}
type VideoGetParams struct {
	OwnerID int `url:"owner_id,omitempty"`
	Videos CSVStringSlice `url:"videos,omitempty"`
	AlbumID int `url:"album_id,omitempty"`
	Count int `url:"count,omitempty"`
	Offset int `url:"offset,omitempty"`
	Extended bool `url:"extended,omitempty"`
}
type VideoGetResponse interface {
	isVideoGet()
}
type VideoGetResponseNormal struct {
	Count int        `json:"count,omitempty"`
	Items []vk.Video `json:"items,omitempty"`
}
func (VideoGetResponseNormal) isVideoGet() {}
type VideoGetResponseExtended struct {
	Count    int        `json:"count,omitempty"`
	Items    []vk.Video `json:"items,omitempty"`
	Profiles []vk.User  `json:"profiles,omitempty"`
	Groups   []vk.Group `json:"groups,omitempty"`
}
func (VideoGetResponseExtended) isVideoGet() {}
func (v Video) Get(params VideoGetParams) (VideoGetResponse, error) {
	r, err := v.API.Request("video.get", params)
	if err != nil {
		return nil, err
	}
	var resp VideoGetResponse
	if params.Extended {
		var tmp VideoGetResponseExtended
		err = json.Unmarshal(r, &tmp)
		resp = &tmp
	} else {
		var tmp VideoGetResponseNormal
		err = json.Unmarshal(r, &tmp)
		resp = &tmp
	}
	if err != nil {
		return nil, err
	}
	return resp, nil
}
type VideoEditParams struct {
	OwnerID int `url:"owner_id,omitempty"`
	VideoID int `url:"video_id"`
	Name string `url:"name,omitempty"`
	Desc string `url:"desc,omitempty"`
	PrivacyView CSVStringSlice `url:"privacy_view,omitempty"`
	PrivacyComment CSVStringSlice `url:"privacy_comment,omitempty"`
	NoComments bool `url:"no_comments,omitempty"`
	Repeat bool `url:"repeat,omitempty"`
}
func (v Video) Edit(params VideoEditParams) (bool, error) {
	r, err := v.API.Request("video.edit", params)
	if err != nil {
		return false, err
	}
	return decodeBoolIntResponse(r)
}
type VideoAddParams struct {
	TargetID int `url:"target_id,omitempty"`
	VideoID int `url:"video_id"`
	OwnerID int `url:"owner_id"`
}
func (v Video) Add(params VideoAddParams) (bool, error) {
	r, err := v.API.Request("video.add", params)
	if err != nil {
		return false, err
	}
	return decodeBoolIntResponse(r)
}
type VideoSaveParams struct {
	Name string `url:"name,omitempty"`
	Description string `url:"description,omitempty"`
	IsPrivate bool `url:"is_private,omitempty"`
	Wallpost bool `url:"wallpost,omitempty"`
	Link string `url:"link,omitempty"`
	GroupID int `url:"group_id,omitempty"`
	AlbumID        int            `url:"album_id,omitempty"`
	PrivacyView    CSVStringSlice `url:"privacy_view,omitempty"`
	PrivacyComment CSVStringSlice `url:"privacy_comment,omitempty"`
	NoComments     bool           `url:"no_comments,omitempty"`
	Repeat      bool `url:"repeat,omitempty"`
	Compression bool `url:"compression,omitempty"`
}
type VideoSaveResponse struct {
	UploadURL string `json:"upload_url,omitempty"`
	VideoID int `json:"video_id,omitempty"`
	OwnerID int `json:"owner_id,omitempty"`
	Title string `json:"title,omitempty"`
	Description string `json:"description,omitempty"`
}
func (v Video) Save(params VideoSaveParams) (*VideoSaveResponse, error) {
	r, err := v.API.Request("video.save", params)
	if err != nil {
		return nil, err
	}
	var resp VideoSaveResponse
	err = json.Unmarshal(r, &resp)
	if err != nil {
		return nil, err
	}
	return &resp, nil
}
type VideoDeleteParams struct {
	VideoID int `url:"video_id"`
	OwnerID  int `url:"owner_id,omitempty"`
	TargetID int `url:"target_id,omitempty"`
}
func (v Video) Delete(params VideoDeleteParams) (bool, error) {
	r, err := v.API.Request("video.delete", params)
	if err != nil {
		return false, err
	}
	return decodeBoolIntResponse(r)
}
type VideoRestoreParams struct {
	VideoID int `url:"video_id"`
	OwnerID int `url:"owner_id,omitempty"`
}
func (v Video) Restore(params VideoRestoreParams) (bool, error) {
	r, err := v.API.Request("video.restore", params)
	if err != nil {
		return false, err
	}
	return decodeBoolIntResponse(r)
}
type VideoSearchParams struct {
	Q string `url:"q"`
	Sort int `url:"sort,omitempty"`
	Hd int `url:"hd,omitempty"`
	Adult bool `url:"adult,omitempty"`
	Filters   CSVStringSlice `url:"filters,omitempty"`
	SearchOwn bool           `url:"search_own,omitempty"`
	Offset  int `url:"offset,omitempty"`
	Longer  int `url:"longer,omitempty"`
	Shorter int `url:"shorter,omitempty"`
	Count    int  `url:"count,omitempty"`
	Extended bool `url:"extended,omitempty"`
}
type VideoSearchResponse interface {
	isVideoSearch()
}
type VideoSearchResponseNormal struct {
	Count int        `json:"count,omitempty"`
	Items []vk.Video `json:"items,omitempty"`
}
func (VideoSearchResponseNormal) isVideoSearch() {}
type VideoSearchResponseExtended struct {
	Count    int        `json:"count,omitempty"`
	Items    []vk.Video `json:"items,omitempty"`
	Profiles []vk.User  `json:"profiles,omitempty"`
	Groups   []vk.Group `json:"groups,omitempty"`
}
func (VideoSearchResponseExtended) isVideoSearch() {}
func (v Video) Search(params VideoSearchParams) (VideoSearchResponse, error) {
	r, err := v.API.Request("video.search", params)
	if err != nil {
		return nil, err
	}
	var resp VideoSearchResponse
	if params.Extended {
		var tmp VideoSearchResponseExtended
		err = json.Unmarshal(r, &tmp)
		resp = &tmp
	} else {
		var tmp VideoSearchResponseNormal
		err = json.Unmarshal(r, &tmp)
		resp = &tmp
	}
	if err != nil {
		return nil, err
	}
	return resp, nil
}
type VideoGetAlbumsParams struct {
	OwnerID int `url:"owner_id,omitempty"`
	Offset int `url:"offset,omitempty"`
	Count int `url:"count,omitempty"`
	Extended   bool `url:"extended,omitempty"`
	NeedSystem bool `url:"need_system,omitempty"`
}
type VideoGetAlbumsResponse interface {
	isVideoGetAlbums()
}
type VideoGetAlbumsResponseNormal struct {
	Count int `json:"count,omitempty"`
	Items []genTODOType  `json:"items,omitempty"`
}
func (VideoGetAlbumsResponseNormal) isVideoGetAlbums() {}
type VideoGetAlbumsResponseExtended struct {
	Count int `json:"count,omitempty"`
	Items []genTODOType  `json:"items,omitempty"`
}
func (VideoGetAlbumsResponseExtended) isVideoGetAlbums() {}
func (v Video) GetAlbums(params VideoGetAlbumsParams) (VideoGetAlbumsResponse, error) {
	r, err := v.API.Request("video.getAlbums", params)
	if err != nil {
		return nil, err
	}
	var resp VideoGetAlbumsResponse
	if params.Extended {
		var tmp VideoGetAlbumsResponseExtended
		err = json.Unmarshal(r, &tmp)
		resp = &tmp
	} else {
		var tmp VideoGetAlbumsResponseNormal
		err = json.Unmarshal(r, &tmp)
		resp = &tmp
	}
	if err != nil {
		return nil, err
	}
	return resp, nil
}
type VideoGetAlbumByIDParams struct {
	OwnerID int `url:"owner_id,omitempty"`
	AlbumID int `url:"album_id"`
}
type VideoGetAlbumByIDResponse genTODOType  
func (v Video) GetAlbumByID(params VideoGetAlbumByIDParams) (*VideoGetAlbumByIDResponse, error) {
	r, err := v.API.Request("video.getAlbumById", params)
	if err != nil {
		return nil, err
	}
	var resp VideoGetAlbumByIDResponse
	err = json.Unmarshal(r, &resp)
	if err != nil {
		return nil, err
	}
	return &resp, nil
}
type VideoAddAlbumParams struct {
	GroupID int `url:"group_id,omitempty"`
	Title string `url:"title,omitempty"`
	Privacy CSVStringSlice `url:"privacy,omitempty"`
}
type VideoAddAlbumResponse struct {
	AlbumID int `json:"album_id,omitempty"`
}
func (v Video) AddAlbum(params VideoAddAlbumParams) (*VideoAddAlbumResponse, error) {
	r, err := v.API.Request("video.addAlbum", params)
	if err != nil {
		return nil, err
	}
	var resp VideoAddAlbumResponse
	err = json.Unmarshal(r, &resp)
	if err != nil {
		return nil, err
	}
	return &resp, nil
}
type VideoEditAlbumParams struct {
	GroupID int `url:"group_id,omitempty"`
	AlbumID int `url:"album_id"`
	Title string `url:"title"`
	Privacy CSVStringSlice `url:"privacy,omitempty"`
}
func (v Video) EditAlbum(params VideoEditAlbumParams) (bool, error) {
	r, err := v.API.Request("video.editAlbum", params)
	if err != nil {
		return false, err
	}
	return decodeBoolIntResponse(r)
}
type VideoDeleteAlbumParams struct {
	GroupID int `url:"group_id,omitempty"`
	AlbumID int `url:"album_id"`
}
func (v Video) DeleteAlbum(params VideoDeleteAlbumParams) (bool, error) {
	r, err := v.API.Request("video.deleteAlbum", params)
	if err != nil {
		return false, err
	}
	return decodeBoolIntResponse(r)
}
type VideoReorderAlbumsParams struct {
	OwnerID int `url:"owner_id,omitempty"`
	AlbumID int `url:"album_id"`
	Before int `url:"before,omitempty"`
	After int `url:"after,omitempty"`
}
func (v Video) ReorderAlbums(params VideoReorderAlbumsParams) (bool, error) {
	r, err := v.API.Request("video.reorderAlbums", params)
	if err != nil {
		return false, err
	}
	return decodeBoolIntResponse(r)
}
type VideoReorderVideosParams struct {
	TargetID int `url:"target_id,omitempty"`
	AlbumID int `url:"album_id,omitempty"`
	OwnerID int `url:"owner_id"`
	VideoID int `url:"video_id"`
	BeforeOwnerID int `url:"before_owner_id,omitempty"`
	BeforeVideoID int `url:"before_video_id,omitempty"`
	AfterOwnerID int `url:"after_owner_id,omitempty"`
	AfterVideoID int `url:"after_video_id,omitempty"`
}
func (v Video) ReorderVideos(params VideoReorderVideosParams) (bool, error) {
	r, err := v.API.Request("video.reorderVideos", params)
	if err != nil {
		return false, err
	}
	return decodeBoolIntResponse(r)
}
type VideoAddToAlbumParams struct {
	TargetID int         `url:"target_id,omitempty"`
	AlbumID  int         `url:"album_id,omitempty"`
	AlbumIDs CSVIntSlice `url:"album_ids,omitempty"`
	OwnerID  int         `url:"owner_id"`
	VideoID  int         `url:"video_id"`
}
func (v Video) AddToAlbum(params VideoAddToAlbumParams) (bool, error) {
	r, err := v.API.Request("video.addToAlbum", params)
	if err != nil {
		return false, err
	}
	return decodeBoolIntResponse(r)
}
type VideoRemoveFromAlbumParams struct {
	TargetID int         `url:"target_id,omitempty"`
	AlbumID  int         `url:"album_id,omitempty"`
	AlbumIDs CSVIntSlice `url:"album_ids,omitempty"`
	OwnerID  int         `url:"owner_id"`
	VideoID  int         `url:"video_id"`
}
func (v Video) RemoveFromAlbum(params VideoRemoveFromAlbumParams) (bool, error) {
	r, err := v.API.Request("video.removeFromAlbum", params)
	if err != nil {
		return false, err
	}
	return decodeBoolIntResponse(r)
}
type VideoGetAlbumsByVideoParams struct {
	TargetID int  `url:"target_id,omitempty"`
	OwnerID  int  `url:"owner_id"`
	VideoID  int  `url:"video_id"`
	Extended bool `url:"extended,omitempty"`
}
type VideoGetAlbumsByVideoResponse interface {
	isVideoGetAlbumsByVideo()
}
type VideoGetAlbumsByVideoResponseNormal []int
func (VideoGetAlbumsByVideoResponseNormal) isVideoGetAlbumsByVideo() {}
type VideoGetAlbumsByVideoResponseExtended struct {
	Count int `json:"count,omitempty"`
	Items []genTODOType  `json:"items,omitempty"`
}
func (VideoGetAlbumsByVideoResponseExtended) isVideoGetAlbumsByVideo() {}
func (v Video) GetAlbumsByVideo(params VideoGetAlbumsByVideoParams) (VideoGetAlbumsByVideoResponse, error) {
	r, err := v.API.Request("video.getAlbumsByVideo", params)
	if err != nil {
		return nil, err
	}
	var resp VideoGetAlbumsByVideoResponse
	if params.Extended {
		var tmp VideoGetAlbumsByVideoResponseExtended
		err = json.Unmarshal(r, &tmp)
		resp = &tmp
	} else {
		var tmp VideoGetAlbumsByVideoResponseNormal
		err = json.Unmarshal(r, &tmp)
		resp = &tmp
	}
	if err != nil {
		return nil, err
	}
	return resp, nil
}
type VideoGetCommentsParams struct {
	OwnerID int `url:"owner_id,omitempty"`
	VideoID int `url:"video_id"`
	NeedLikes      bool `url:"need_likes,omitempty"`
	StartCommentID int  `url:"start_comment_id,omitempty"`
	Offset int `url:"offset,omitempty"`
	Count int `url:"count,omitempty"`
	Sort     string         `url:"sort,omitempty"`
	Extended bool           `url:"extended,omitempty"`
	Fields   CSVStringSlice `url:"fields,omitempty"`
}
type VideoGetCommentsResponse interface {
	isVideoGetComments()
}
type VideoGetCommentsResponseNormal struct {
	Count    int          `json:"count,omitempty"`
	Items    []vk.Comment `json:"items,omitempty"`
	Profiles []vk.User    `json:"profiles,omitempty"`
	Groups   []vk.Group   `json:"groups,omitempty"`
}
func (VideoGetCommentsResponseNormal) isVideoGetComments() {}
type VideoGetCommentsResponseExtended struct {
	Count int          `json:"count,omitempty"`
	Items []vk.Comment `json:"items,omitempty"`
}
func (VideoGetCommentsResponseExtended) isVideoGetComments() {}
func (v Video) GetComments(params VideoGetCommentsParams) (VideoGetCommentsResponse, error) {
	r, err := v.API.Request("video.getComments", params)
	if err != nil {
		return nil, err
	}
	var resp VideoGetCommentsResponse
	if params.Extended {
		var tmp VideoGetCommentsResponseExtended
		err = json.Unmarshal(r, &tmp)
		resp = &tmp
	} else {
		var tmp VideoGetCommentsResponseNormal
		err = json.Unmarshal(r, &tmp)
		resp = &tmp
	}
	if err != nil {
		return nil, err
	}
	return resp, nil
}
type VideoCreateCommentParams struct {
	OwnerID int `url:"owner_id,omitempty"`
	VideoID int `url:"video_id"`
	Message string `url:"message,omitempty"`
	Attachments CSVStringSlice `url:"attachments,omitempty"`
	FromGroup      bool   `url:"from_group,omitempty"`
	ReplyToComment int    `url:"reply_to_comment,omitempty"`
	StickerID      int    `url:"sticker_id,omitempty"`
	GUID           string `url:"guid,omitempty"`
}
type VideoCreateCommentResponse int
func (v Video) CreateComment(params VideoCreateCommentParams) (VideoCreateCommentResponse, error) {
	r, err := v.API.Request("video.createComment", params)
	if err != nil {
		return 0, err
	}
	var resp VideoCreateCommentResponse
	var cnv int
	cnv, err = strconv.Atoi(string(r))
	resp = VideoCreateCommentResponse(cnv)
	if err != nil {
		return 0, err
	}
	return resp, nil
}
type VideoDeleteCommentParams struct {
	OwnerID int `url:"owner_id,omitempty"`
	CommentID int `url:"comment_id"`
}
func (v Video) DeleteComment(params VideoDeleteCommentParams) (bool, error) {
	r, err := v.API.Request("video.deleteComment", params)
	if err != nil {
		return false, err
	}
	return decodeBoolIntResponse(r)
}
type VideoRestoreCommentParams struct {
	OwnerID int `url:"owner_id,omitempty"`
	CommentID int `url:"comment_id"`
}
func (v Video) RestoreComment(params VideoRestoreCommentParams) (bool, error) {
	r, err := v.API.Request("video.restoreComment", params)
	if err != nil {
		return false, err
	}
	return decodeBoolIntResponse(r)
}
type VideoEditCommentParams struct {
	OwnerID int `url:"owner_id,omitempty"`
	CommentID int `url:"comment_id"`
	Message string `url:"message,omitempty"`
	Attachments CSVStringSlice `url:"attachments,omitempty"`
}
func (v Video) EditComment(params VideoEditCommentParams) (bool, error) {
	r, err := v.API.Request("video.editComment", params)
	if err != nil {
		return false, err
	}
	return decodeBoolIntResponse(r)
}
type VideoReportParams struct {
	OwnerID int `url:"owner_id"`
	VideoID int `url:"video_id"`
	Reason int `url:"reason,omitempty"`
	Comment string `url:"comment,omitempty"`
	SearchQuery string `url:"search_query,omitempty"`
}