# generated by fastapi-codegen:
# filename: openapi.yaml
# timestamp: 2025-06-29T11:39:38+00:00
import argparse
import json
import os
from typing import *
from typing import Optional, Union
from autogen.mcp.mcp_proxy import MCPProxy
from autogen.mcp.mcp_proxy.security import (
BaseSecurity,
HTTPBearer,
UnsuportedSecurityStub,
)
from models import (
Album,
Auth,
AuthError,
CategoriesCategoryChannelsGetResponse,
CategoriesCategoryGroupsGetResponse,
CategoriesCategoryVideosGetResponse,
CategoriesGetResponse,
Category,
Channel,
ChannelsChannelIdCategoriesGetResponse,
ChannelsChannelIdCategoriesPutRequest,
ChannelsChannelIdModeratorsDeleteRequest,
ChannelsChannelIdModeratorsGetResponse,
ChannelsChannelIdModeratorsPatchRequest,
ChannelsChannelIdModeratorsPatchResponse,
ChannelsChannelIdModeratorsPutRequest,
ChannelsChannelIdPatchRequest,
ChannelsChannelIdPrivacyUsersGetResponse,
ChannelsChannelIdPrivacyUsersPutRequest,
ChannelsChannelIdPrivacyUsersPutResponse,
ChannelsChannelIdTagsGetResponse,
ChannelsChannelIdTagsPutRequest,
ChannelsChannelIdTagsPutResponse,
ChannelsChannelIdUsersGetResponse,
ChannelsChannelIdVideosDeleteRequest,
ChannelsChannelIdVideosGetResponse,
ChannelsChannelIdVideosPutRequest,
ChannelsChannelIdVideosVideoIdCommentsGetResponse,
ChannelsChannelIdVideosVideoIdCommentsPostRequest,
ChannelsChannelIdVideosVideoIdCreditsGetResponse,
ChannelsChannelIdVideosVideoIdCreditsPostRequest,
ChannelsChannelIdVideosVideoIdLikesGetResponse,
ChannelsChannelIdVideosVideoIdPicturesGetResponse,
ChannelsChannelIdVideosVideoIdPicturesPostRequest,
ChannelsChannelIdVideosVideoIdPrivacyUsersGetResponse,
ChannelsChannelIdVideosVideoIdPrivacyUsersPutResponse,
ChannelsChannelIdVideosVideoIdTexttracksGetResponse,
ChannelsChannelIdVideosVideoIdTexttracksPostRequest,
ChannelsGetResponse,
ChannelsPostRequest,
Comment,
ContentratingsGetResponse,
CreativecommonsGetResponse,
Credit,
Direction,
Endpoint,
Error,
Filter,
Filter2,
Filter4,
Filter6,
Filter8,
Filter10,
Filter12,
Filter14,
Filter16,
Filter20,
Filter22,
Filter24,
Filter26,
Filter28,
Filter30,
Filter32,
Filter34,
Filter36,
Filter38,
Filter40,
Filter42,
Filter44,
Filter48,
Filter50,
Filter54,
Filter56,
Filter58,
Filter60,
Filter62,
Filter64,
Filter66,
Filter68,
Filter70,
Filter72,
Group,
GroupsGetResponse,
GroupsGroupIdUsersGetResponse,
GroupsGroupIdVideosGetResponse,
GroupsPostRequest,
LanguagesGetResponse,
LegacyError,
MeAlbumsAlbumIdPatchRequest,
MeAlbumsAlbumIdVideosGetResponse,
MeAlbumsAlbumIdVideosPutRequest,
MeAlbumsAlbumIdVideosVideoIdSetAlbumThumbnailPostRequest,
MeAlbumsGetResponse,
MeAlbumsPostRequest,
MeAppearancesGetResponse,
MeCategoriesGetResponse,
MeChannelsGetResponse,
MeCustomlogosGetResponse,
MeFeedGetResponse,
MeFollowersGetResponse,
MeFollowingGetResponse,
MeFollowingPostRequest,
MeGroupsGetResponse,
MeLikesGetResponse,
MeOndemandPagesGetResponse,
MeOndemandPagesPostRequest,
MeOndemandPurchasesGetResponse,
MePatchRequest,
MePicturesGetResponse,
MePicturesPortraitsetIdPatchRequest,
MePortfoliosGetResponse,
MePortfoliosPortfolioIdVideosGetResponse,
MePresetsGetResponse,
MePresetsPresetIdPatchRequest,
MePresetsPresetIdVideosGetResponse,
MeProjectsGetResponse,
MeProjectsPostRequest,
MeProjectsProjectIdPatchRequest,
MeProjectsProjectIdVideosGetResponse,
MeVideosGetResponse,
MeVideosPostRequest,
MeWatchedVideosGetResponse,
MeWatchlaterGetResponse,
OauthAccessTokenPostRequest,
OauthAuthorizeClientPostRequest,
OauthAuthorizeVimeoOauth1PostRequest,
OnDemandGenre,
OndemandGenresGenreIdPagesGetResponse,
OndemandGenresGetResponse,
OnDemandPage,
OndemandPagesOndemandIdBackgroundsBackgroundIdPatchRequest,
OndemandPagesOndemandIdBackgroundsGetResponse,
OndemandPagesOndemandIdGenresGetResponse,
OndemandPagesOndemandIdLikesGetResponse,
OndemandPagesOndemandIdPatchRequest,
OndemandPagesOndemandIdPicturesGetResponse,
OndemandPagesOndemandIdPicturesPosterIdPatchRequest,
OndemandPagesOndemandIdPromotionsPostRequest,
OndemandPagesOndemandIdRegionsDeleteRequest,
OndemandPagesOndemandIdRegionsDeleteResponse,
OndemandPagesOndemandIdRegionsGetResponse,
OndemandPagesOndemandIdRegionsPutRequest,
OndemandPagesOndemandIdSeasonsGetResponse,
OndemandPagesOndemandIdSeasonsSeasonIdVideosGetResponse,
OndemandPagesOndemandIdVideosGetResponse,
OndemandPagesOndemandIdVideosVideoIdPutRequest,
OnDemandPromotion,
OnDemandPromotionCode,
OnDemandRegion,
OndemandRegionsGetResponse,
OnDemandSeason,
OnDemandVideo,
Picture,
Portfolio,
Presets,
Project,
Sort2,
Sort4,
Sort6,
Sort8,
Sort10,
Sort12,
Sort16,
Sort18,
Sort22,
Sort24,
Sort26,
Sort28,
Sort32,
Sort34,
Sort36,
Sort38,
Sort40,
Sort44,
Sort46,
Sort48,
Sort50,
Sort52,
Sort54,
Sort56,
Sort58,
Sort60,
Sort62,
Sort64,
Sort66,
Sort68,
Sort70,
Sort72,
Sort74,
Sort76,
Sort78,
Sort82,
Sort84,
Sort86,
Sort88,
Sort90,
Sort94,
Sort96,
Sort98,
Sort100,
Sort102,
Sort104,
Sort106,
Sort108,
Sort110,
Sort112,
Sort114,
Tag,
TagsWordVideosGetResponse,
TextTrack,
Type12,
Type17,
UploadAttempt,
User,
UsersGetResponse,
UsersUserIdAlbumsAlbumIdCustomThumbnailsGetResponse,
UsersUserIdAlbumsAlbumIdCustomThumbnailsThumbnailIdPatchRequest,
UsersUserIdAlbumsAlbumIdLogosGetResponse,
UsersUserIdAlbumsAlbumIdLogosLogoIdPatchRequest,
UsersUserIdAlbumsAlbumIdPatchRequest,
UsersUserIdAlbumsAlbumIdVideosGetResponse,
UsersUserIdAlbumsAlbumIdVideosPutRequest,
UsersUserIdAlbumsAlbumIdVideosVideoIdSetAlbumThumbnailPostRequest,
UsersUserIdAlbumsGetResponse,
UsersUserIdAlbumsPostRequest,
UsersUserIdAppearancesGetResponse,
UsersUserIdCategoriesGetResponse,
UsersUserIdChannelsGetResponse,
UsersUserIdCustomlogosGetResponse,
UsersUserIdFeedGetResponse,
UsersUserIdFollowersGetResponse,
UsersUserIdFollowingGetResponse,
UsersUserIdFollowingPostRequest,
UsersUserIdGroupsGetResponse,
UsersUserIdLikesGetResponse,
UsersUserIdOndemandPagesGetResponse,
UsersUserIdOndemandPagesPostRequest,
UsersUserIdPatchRequest,
UsersUserIdPicturesGetResponse,
UsersUserIdPicturesPortraitsetIdPatchRequest,
UsersUserIdPortfoliosGetResponse,
UsersUserIdPortfoliosPortfolioIdVideosGetResponse,
UsersUserIdPresetsGetResponse,
UsersUserIdPresetsPresetIdPatchRequest,
UsersUserIdPresetsPresetIdVideosGetResponse,
UsersUserIdProjectsGetResponse,
UsersUserIdProjectsPostRequest,
UsersUserIdProjectsProjectIdPatchRequest,
UsersUserIdProjectsProjectIdVideosGetResponse,
UsersUserIdVideosGetResponse,
UsersUserIdVideosPostRequest,
UsersUserIdWatchlaterGetResponse,
Video,
VideosGetResponse,
VideosVideoIdAvailableChannelsGetResponse,
VideosVideoIdCategoriesGetResponse,
VideosVideoIdCategoriesPutRequest,
VideosVideoIdCommentsCommentIdPatchRequest,
VideosVideoIdCommentsCommentIdRepliesGetResponse,
VideosVideoIdCommentsCommentIdRepliesPostRequest,
VideosVideoIdCommentsGetResponse,
VideosVideoIdCommentsPostRequest,
VideosVideoIdCreditsCreditIdPatchRequest,
VideosVideoIdCreditsGetResponse,
VideosVideoIdCreditsPostRequest,
VideosVideoIdLikesGetResponse,
VideosVideoIdPatchRequest,
VideosVideoIdPicturesGetResponse,
VideosVideoIdPicturesPictureIdPatchRequest,
VideosVideoIdPicturesPostRequest,
VideosVideoIdPrivacyDomainsGetResponse,
VideosVideoIdPrivacyUsersGetResponse,
VideosVideoIdPrivacyUsersPutResponse,
VideosVideoIdTagsGetResponse,
VideosVideoIdTagsPutRequest,
VideosVideoIdTagsPutResponse,
VideosVideoIdTexttracksGetResponse,
VideosVideoIdTexttracksPostRequest,
VideosVideoIdTexttracksTexttrackIdPatchRequest,
VideosVideoIdVersionsPostRequest,
VideosVideoIdVideosGetResponse,
VideoVersions,
)
app = MCPProxy(
contact={'url': 'https://developer.vimeo.com/help', 'x-twitter': 'vimeo'},
title='Vimeo',
version='3.4',
servers=[{'description': 'Vimeo.com', 'url': 'https://api.vimeo.com'}],
)
@app.get(
'/#-datamodel-code-generator-#-root-#-special-#',
tags=['api_specification'],
security=[
UnsuportedSecurityStub(name="None"),
],
)
def get_endpoints(openapi: Optional[bool] = None):
"""
Get an API specification
"""
raise RuntimeError("Should be patched by MCPProxy and never executed")
@app.get(
'/categories',
description=""" This method gets all existing categories. """,
tags=['category_management'],
security=[
UnsuportedSecurityStub(name="None"),
],
)
def get_categories(
direction: Optional[Direction] = None,
page: Optional[float] = None,
per_page: Optional[float] = None,
sort: Optional[Sort2] = None,
):
"""
Get all categories
"""
raise RuntimeError("Should be patched by MCPProxy and never executed")
@app.get(
'/categories/{category}',
tags=['category_management', 'channel_category_management'],
security=[
UnsuportedSecurityStub(name="None"),
],
)
def get_category(category: str):
"""
Get a specific category
"""
raise RuntimeError("Should be patched by MCPProxy and never executed")
@app.get(
'/categories/{category}/channels',
tags=['category_management', 'channel_management', 'channel_category_management'],
security=[
UnsuportedSecurityStub(name="None"),
],
)
def get_category_channels(
category: str,
direction: Optional[Direction] = None,
page: Optional[float] = None,
per_page: Optional[float] = None,
query: Optional[str] = None,
sort: Optional[Sort4] = None,
):
"""
Get all the channels in a category
"""
raise RuntimeError("Should be patched by MCPProxy and never executed")
@app.get(
'/categories/{category}/groups',
tags=['category_management', 'group_management'],
security=[
UnsuportedSecurityStub(name="None"),
],
)
def get_category_groups(
category: str,
direction: Optional[Direction] = None,
page: Optional[float] = None,
per_page: Optional[float] = None,
query: Optional[str] = None,
sort: Optional[Sort6] = None,
):
"""
Get all the groups in a category
"""
raise RuntimeError("Should be patched by MCPProxy and never executed")
@app.get(
'/categories/{category}/videos',
tags=['category_management', 'video_management'],
security=[
UnsuportedSecurityStub(name="None"),
],
)
def get_category_videos(
category: str,
direction: Optional[Direction] = None,
filter: Optional[Filter] = None,
filter_embeddable: Optional[bool] = None,
page: Optional[float] = None,
per_page: Optional[float] = None,
query: Optional[str] = None,
sort: Optional[Sort8] = None,
):
"""
Get all the videos in a category
"""
raise RuntimeError("Should be patched by MCPProxy and never executed")
@app.get(
'/categories/{category}/videos/{video_id}',
tags=['category_management', 'channel_category_management', 'video_management'],
security=[
UnsuportedSecurityStub(name="None"),
],
)
def check_category_for_video(category: str, video_id: float = ...):
"""
Check for a video in a category
"""
raise RuntimeError("Should be patched by MCPProxy and never executed")
@app.get(
'/channels',
tags=['channel_management'],
security=[
UnsuportedSecurityStub(name="None"),
],
)
def get_channels(
direction: Optional[Direction] = None,
filter: Optional[Filter2] = None,
page: Optional[float] = None,
per_page: Optional[float] = None,
query: Optional[str] = None,
sort: Optional[Sort10] = None,
):
"""
Get all channels
"""
raise RuntimeError("Should be patched by MCPProxy and never executed")
@app.post(
'/channels',
description=""" This method creates a new channel. """,
tags=['channel_management'],
security=[
UnsuportedSecurityStub(name="None"),
],
)
def create_channel(body: ChannelsPostRequest):
"""
Create a channel
"""
raise RuntimeError("Should be patched by MCPProxy and never executed")
@app.delete(
'/channels/{channel_id}',
tags=['channel_management'],
security=[
UnsuportedSecurityStub(name="None"),
],
)
def delete_channel(channel_id: float):
"""
Delete a channel
"""
raise RuntimeError("Should be patched by MCPProxy and never executed")
@app.get(
'/channels/{channel_id}',
tags=['channel_management'],
security=[
UnsuportedSecurityStub(name="None"),
],
)
def get_channel(channel_id: float):
"""
Get a specific channel
"""
raise RuntimeError("Should be patched by MCPProxy and never executed")
@app.patch(
'/channels/{channel_id}',
description=""" This method edits the specified channel. """,
tags=['channel_management'],
security=[
UnsuportedSecurityStub(name="None"),
],
)
def edit_channel(channel_id: float, body: ChannelsChannelIdPatchRequest = None):
"""
Edit a channel
"""
raise RuntimeError("Should be patched by MCPProxy and never executed")
@app.get(
'/channels/{channel_id}/categories',
description=""" This method gets all the categories in the specified channel. """,
tags=['category_management', 'channel_category_management'],
security=[
UnsuportedSecurityStub(name="None"),
],
)
def get_channel_categories(channel_id: float):
"""
Get all the categories in a channel
"""
raise RuntimeError("Should be patched by MCPProxy and never executed")
@app.put(
'/channels/{channel_id}/categories',
description=""" This method adds multiple categories to the specified channel. """,
tags=['channel_category_management', 'category_management', 'channel_management'],
security=[
UnsuportedSecurityStub(name="None"),
],
)
def add_channel_categories(
channel_id: float, body: ChannelsChannelIdCategoriesPutRequest = ...
):
"""
Add a list of categories to a channel
"""
raise RuntimeError("Should be patched by MCPProxy and never executed")
@app.delete(
'/channels/{channel_id}/categories/{category}',
description=""" This method removes a single category from the specified channel. """,
tags=['category_management', 'channel_management', 'channel_category_management'],
security=[
UnsuportedSecurityStub(name="None"),
],
)
def delete_channel_category(category: str, channel_id: float = ...):
"""
Remove a category from a channel
"""
raise RuntimeError("Should be patched by MCPProxy and never executed")
@app.put(
'/channels/{channel_id}/categories/{category}',
description=""" This method adds a channel to a category. """,
tags=['category_management', 'channel_category_management'],
security=[
UnsuportedSecurityStub(name="None"),
],
)
def categorize_channel(category: str, channel_id: float = ...):
"""
Categorize a channel
"""
raise RuntimeError("Should be patched by MCPProxy and never executed")
@app.delete(
'/channels/{channel_id}/moderators',
tags=['channel_management', 'channel_moderator_management'],
security=[
UnsuportedSecurityStub(name="None"),
],
)
def remove_channel_moderators(
channel_id: float, body: ChannelsChannelIdModeratorsDeleteRequest = ...
):
"""
Remove a list of channel moderators
"""
raise RuntimeError("Should be patched by MCPProxy and never executed")
@app.get(
'/channels/{channel_id}/moderators',
tags=['channel_management', 'channel_moderator_management'],
security=[
UnsuportedSecurityStub(name="None"),
],
)
def get_channel_moderators(
channel_id: float,
direction: Optional[Direction] = None,
page: Optional[float] = None,
per_page: Optional[float] = None,
query: Optional[str] = None,
sort: Optional[Sort12] = None,
):
"""
Get all the moderators in a channel
"""
raise RuntimeError("Should be patched by MCPProxy and never executed")
@app.patch(
'/channels/{channel_id}/moderators',
tags=['channel_management', 'channel_moderator_management'],
security=[
UnsuportedSecurityStub(name="None"),
],
)
def replace_channel_moderators(
channel_id: float, body: ChannelsChannelIdModeratorsPatchRequest = ...
):
"""
Replace the moderators of a channel
"""
raise RuntimeError("Should be patched by MCPProxy and never executed")
@app.put(
'/channels/{channel_id}/moderators',
tags=['channel_management', 'channel_moderator_management'],
security=[
UnsuportedSecurityStub(name="None"),
],
)
def add_channel_moderators(
channel_id: float, body: ChannelsChannelIdModeratorsPutRequest = ...
):
"""
Add a list of channel moderators
"""
raise RuntimeError("Should be patched by MCPProxy and never executed")
@app.delete(
'/channels/{channel_id}/moderators/{user_id}',
tags=['channel_moderator_management', 'channel_management'],
security=[
UnsuportedSecurityStub(name="None"),
],
)
def remove_channel_moderator(channel_id: float, user_id: float = ...):
"""
Remove a specific channel moderator
"""
raise RuntimeError("Should be patched by MCPProxy and never executed")
@app.get(
'/channels/{channel_id}/moderators/{user_id}',
tags=['channel_moderator_management'],
security=[
UnsuportedSecurityStub(name="None"),
],
)
def get_channel_moderator(channel_id: float, user_id: float = ...):
"""
Get a specific channel moderator
"""
raise RuntimeError("Should be patched by MCPProxy and never executed")
@app.put(
'/channels/{channel_id}/moderators/{user_id}',
tags=['channel_moderator_management', 'channel_management'],
security=[
UnsuportedSecurityStub(name="None"),
],
)
def add_channel_moderator(channel_id: float, user_id: float = ...):
"""
Add a specific channel moderator
"""
raise RuntimeError("Should be patched by MCPProxy and never executed")
@app.get(
'/channels/{channel_id}/privacy/users',
description=""" This method gets all the users who have access to the specified private channel. """,
tags=['channel_privacy_management', 'channel_management'],
security=[
UnsuportedSecurityStub(name="None"),
],
)
def get_channel_privacy_users(
channel_id: float,
direction: Optional[Direction] = None,
page: Optional[float] = None,
per_page: Optional[float] = None,
):
"""
Get all the users who can view a private channel
"""
raise RuntimeError("Should be patched by MCPProxy and never executed")
@app.put(
'/channels/{channel_id}/privacy/users',
description=""" This method gives multiple users access to the specified private channel. """,
tags=['channel_privacy_management', 'channel_management'],
security=[
UnsuportedSecurityStub(name="None"),
],
)
def set_channel_privacy_users(
channel_id: float, body: ChannelsChannelIdPrivacyUsersPutRequest = ...
):
"""
Permit a list of users to view a private channel
"""
raise RuntimeError("Should be patched by MCPProxy and never executed")
@app.delete(
'/channels/{channel_id}/privacy/users/{user_id}',
description=""" This method prevents a single user from being able to access the specified private channel. """,
tags=['channel_privacy_management', 'channel_management'],
security=[
UnsuportedSecurityStub(name="None"),
],
)
def delete_channel_privacy_user(channel_id: float, user_id: float = ...):
"""
Restrict a user from viewing a private channel
"""
raise RuntimeError("Should be patched by MCPProxy and never executed")
@app.put(
'/channels/{channel_id}/privacy/users/{user_id}',
description=""" This method gives a single user access to the specified private channel. """,
tags=['channel_privacy_management', 'channel_management'],
security=[
UnsuportedSecurityStub(name="None"),
],
)
def set_channel_privacy_user(channel_id: float, user_id: float = ...):
"""
Permit a specific user to view a private channel
"""
raise RuntimeError("Should be patched by MCPProxy and never executed")
@app.get(
'/channels/{channel_id}/tags',
description=""" This method gets all the tags that have been added to the specified channel. """,
tags=['channel_tag_management', 'channel_management'],
security=[
UnsuportedSecurityStub(name="None"),
],
)
def get_channel_tags(channel_id: float):
"""
Get all the tags that have been added to a channel
"""
raise RuntimeError("Should be patched by MCPProxy and never executed")
@app.put(
'/channels/{channel_id}/tags',
description=""" This method adds multiple tags to the specified channel. """,
tags=['channel_management', 'channel_tag_management'],
security=[
UnsuportedSecurityStub(name="None"),
],
)
def add_tags_to_channel(channel_id: float, body: ChannelsChannelIdTagsPutRequest = ...):
"""
Add a list of tags to a channel
"""
raise RuntimeError("Should be patched by MCPProxy and never executed")
@app.delete(
'/channels/{channel_id}/tags/{word}',
description=""" This method removes a single tag from the specified channel. """,
tags=['channel_tag_management', 'channel_management'],
security=[
UnsuportedSecurityStub(name="None"),
],
)
def delete_tag_from_channel(channel_id: float, word: str = ...):
"""
Remove a tag from a channel
"""
raise RuntimeError("Should be patched by MCPProxy and never executed")
@app.get(
'/channels/{channel_id}/tags/{word}',
description=""" This method determines whether a specific tag has been added to the channel in question. """,
tags=['channel_management', 'channel_tag_management'],
security=[
UnsuportedSecurityStub(name="None"),
],
)
def check_if_channel_has_tag(channel_id: float, word: str = ...):
"""
Check if a tag has been added to a channel
"""
raise RuntimeError("Should be patched by MCPProxy and never executed")
@app.put(
'/channels/{channel_id}/tags/{word}',
description=""" This method adds a single tag to the specified channel. """,
tags=['channel_tag_management', 'channel_management'],
security=[
UnsuportedSecurityStub(name="None"),
],
)
def add_channel_tag(channel_id: float, word: str = ...):
"""
Add a specific tag to a channel
"""
raise RuntimeError("Should be patched by MCPProxy and never executed")
@app.get(
'/channels/{channel_id}/users',
tags=['channel_management', 'user_following_management'],
security=[
UnsuportedSecurityStub(name="None"),
],
)
def get_channel_subscribers(
channel_id: float,
direction: Optional[Direction] = None,
filter: Filter4 = ...,
page: Optional[float] = None,
per_page: Optional[float] = None,
query: Optional[str] = None,
sort: Optional[Sort12] = None,
):
"""
Get all the followers of a channel
"""
raise RuntimeError("Should be patched by MCPProxy and never executed")
@app.delete(
'/channels/{channel_id}/videos',
tags=['channel_management', 'channel_video_management', 'video_management'],
security=[
UnsuportedSecurityStub(name="None"),
],
)
def remove_videos_from_channel(
channel_id: float, body: ChannelsChannelIdVideosDeleteRequest = ...
):
"""
Remove a list of videos from a channel
"""
raise RuntimeError("Should be patched by MCPProxy and never executed")
@app.get(
'/channels/{channel_id}/videos',
tags=['channel_video_management', 'video_management'],
security=[
UnsuportedSecurityStub(name="None"),
],
)
def get_channel_videos(
channel_id: float,
containing_uri: Optional[str] = None,
direction: Optional[Direction] = None,
filter: Optional[Filter6] = None,
filter_embeddable: Optional[bool] = None,
page: Optional[float] = None,
per_page: Optional[float] = None,
query: Optional[str] = None,
sort: Optional[Sort16] = None,
):
"""
Get all the videos in a channel
"""
raise RuntimeError("Should be patched by MCPProxy and never executed")
@app.put(
'/channels/{channel_id}/videos',
tags=['channel_management', 'channel_video_management'],
security=[
UnsuportedSecurityStub(name="None"),
],
)
def add_videos_to_channel(
channel_id: float, body: ChannelsChannelIdVideosPutRequest = ...
):
"""
Add a list of videos to a channel
"""
raise RuntimeError("Should be patched by MCPProxy and never executed")
@app.delete(
'/channels/{channel_id}/videos/{video_id}',
tags=['channel_management', 'channel_video_management', 'video_management'],
security=[
UnsuportedSecurityStub(name="None"),
],
)
def delete_video_from_channel(channel_id: float, video_id: float = ...):
"""
Remove a specific video from a channel
"""
raise RuntimeError("Should be patched by MCPProxy and never executed")
@app.get(
'/channels/{channel_id}/videos/{video_id}',
description=""" This method returns a specific video in a channel. You can use it to determine whether the video is in the channel. """,
tags=['channel_video_management', 'video_details_retrieval'],
security=[
UnsuportedSecurityStub(name="None"),
],
)
def get_channel_video(channel_id: float, video_id: float = ...):
"""
Get a specific video in a channel
"""
raise RuntimeError("Should be patched by MCPProxy and never executed")
@app.put(
'/channels/{channel_id}/videos/{video_id}',
tags=['channel_video_management', 'video_management'],
security=[
UnsuportedSecurityStub(name="None"),
],
)
def add_video_to_channel(channel_id: float, video_id: float = ...):
"""
Add a specific video to a channel
"""
raise RuntimeError("Should be patched by MCPProxy and never executed")
@app.get(
'/channels/{channel_id}/videos/{video_id}/comments',
tags=['video_comment_management', 'video_comment_handling'],
security=[
UnsuportedSecurityStub(name="None"),
],
)
def get_comments_alt1(
channel_id: float,
video_id: float = ...,
direction: Optional[Direction] = None,
page: Optional[float] = None,
per_page: Optional[float] = None,
):
"""
Get all the comments on a video
"""
raise RuntimeError("Should be patched by MCPProxy and never executed")
@app.post(
'/channels/{channel_id}/videos/{video_id}/comments',
tags=['video_comment_management', 'video_comment_handling'],
security=[
UnsuportedSecurityStub(name="None"),
],
)
def create_comment_alt1(
channel_id: float,
video_id: float = ...,
body: ChannelsChannelIdVideosVideoIdCommentsPostRequest = ...,
):
"""
Add a comment to a video
"""
raise RuntimeError("Should be patched by MCPProxy and never executed")
@app.get(
'/channels/{channel_id}/videos/{video_id}/credits',
tags=['video_credit_management', 'channel_video_management'],
security=[
UnsuportedSecurityStub(name="None"),
],
)
def get_video_credits_alt1(
channel_id: float,
video_id: float = ...,
direction: Optional[Direction] = None,
page: Optional[float] = None,
per_page: Optional[float] = None,
query: Optional[str] = None,
sort: Optional[Sort18] = None,
):
"""
Get all the credited users in a video
"""
raise RuntimeError("Should be patched by MCPProxy and never executed")
@app.post(
'/channels/{channel_id}/videos/{video_id}/credits',
tags=['video_credit_management', 'channel_video_management'],
security=[
UnsuportedSecurityStub(name="None"),
],
)
def add_video_credit_alt1(
channel_id: float,
video_id: float = ...,
body: ChannelsChannelIdVideosVideoIdCreditsPostRequest = ...,
):
"""
Credit a user in a video
"""
raise RuntimeError("Should be patched by MCPProxy and never executed")
@app.get(
'/channels/{channel_id}/videos/{video_id}/likes',
tags=['user_video_like_management', 'user_video_interaction', 'video_management'],
security=[
UnsuportedSecurityStub(name="None"),
],
)
def get_video_likes_alt1(
channel_id: float,
video_id: float = ...,
direction: Optional[Direction] = None,
page: Optional[float] = None,
per_page: Optional[float] = None,
sort: Optional[Sort18] = None,
):
"""
Get all the users who have liked a video
"""
raise RuntimeError("Should be patched by MCPProxy and never executed")
@app.get(
'/channels/{channel_id}/videos/{video_id}/pictures',
tags=['video_thumbnail_management', 'channel_video_management'],
security=[
UnsuportedSecurityStub(name="None"),
],
)
def get_video_thumbnails_alt1(
channel_id: float,
video_id: float = ...,
page: Optional[float] = None,
per_page: Optional[float] = None,
):
"""
Get all the thumbnails of a video
"""
raise RuntimeError("Should be patched by MCPProxy and never executed")
@app.post(
'/channels/{channel_id}/videos/{video_id}/pictures',
tags=['video_thumbnail_management', 'channel_video_management'],
security=[
UnsuportedSecurityStub(name="None"),
],
)
def create_video_thumbnail_alt1(
channel_id: float,
video_id: float = ...,
body: ChannelsChannelIdVideosVideoIdPicturesPostRequest = None,
):
"""
Add a video thumbnail
"""
raise RuntimeError("Should be patched by MCPProxy and never executed")
@app.get(
'/channels/{channel_id}/videos/{video_id}/privacy/users',
tags=[
'channel_privacy_management',
'video_privacy_management',
'channel_video_management',
],
security=[
UnsuportedSecurityStub(name="None"),
],
)
def get_video_privacy_users_alt1(
channel_id: float,
video_id: float = ...,
page: Optional[float] = None,
per_page: Optional[float] = None,
):
"""
Get all the users who can view a user's private videos by default
"""
raise RuntimeError("Should be patched by MCPProxy and never executed")
@app.put(
'/channels/{channel_id}/videos/{video_id}/privacy/users',
description=""" The body of this request should follow our
[batch request format](https://developer.vimeo.com/api/common-formats#batch-requests). Each object must contain
a single `URI` field, and the value of this field must be the URI of the user who can view this video. """,
tags=['video_privacy_management', 'channel_privacy_management'],
security=[
UnsuportedSecurityStub(name="None"),
],
)
def add_video_privacy_users_alt1(channel_id: float, video_id: float = ...):
"""
Permit a list of users to view a private video
"""
raise RuntimeError("Should be patched by MCPProxy and never executed")
@app.get(
'/channels/{channel_id}/videos/{video_id}/texttracks',
tags=['video_text_track_management', 'channel_video_management'],
security=[
UnsuportedSecurityStub(name="None"),
],
)
def get_text_tracks_alt1(channel_id: float, video_id: float = ...):
"""
Get all the text tracks of a video
"""
raise RuntimeError("Should be patched by MCPProxy and never executed")
@app.post(
'/channels/{channel_id}/videos/{video_id}/texttracks',
description=""" For additional information, see our [text track upload guide](https://developer.vimeo.com/api/upload/texttracks). """,
tags=['video_text_track_management', 'channel_video_management'],
security=[
UnsuportedSecurityStub(name="None"),
],
)
def create_text_track_alt1(
channel_id: float,
video_id: float = ...,
body: ChannelsChannelIdVideosVideoIdTexttracksPostRequest = ...,
):
"""
Add a text track to a video
"""
raise RuntimeError("Should be patched by MCPProxy and never executed")
@app.get(
'/contentratings',
tags=['category_management'],
security=[
UnsuportedSecurityStub(name="None"),
],
)
def get_content_ratings():
"""
Get all content ratings
"""
raise RuntimeError("Should be patched by MCPProxy and never executed")
@app.get(
'/creativecommons',
tags=['api_specification'],
security=[
UnsuportedSecurityStub(name="None"),
],
)
def get_cc_licenses():
"""
Get all Creative Commons licenses
"""
raise RuntimeError("Should be patched by MCPProxy and never executed")
@app.get(
'/groups',
tags=['group_management', 'user_group_membership_management'],
security=[
UnsuportedSecurityStub(name="None"),
],
)
def get_groups(
direction: Optional[Direction] = None,
filter: Optional[Filter8] = None,
page: Optional[float] = None,
per_page: Optional[float] = None,
query: Optional[str] = None,
sort: Optional[Sort22] = None,
):
"""
Get all groups
"""
raise RuntimeError("Should be patched by MCPProxy and never executed")
@app.post(
'/groups',
tags=['group_management', 'user_group_membership_management'],
security=[
UnsuportedSecurityStub(name="None"),
],
)
def create_group(body: GroupsPostRequest):
"""
Create a group
"""
raise RuntimeError("Should be patched by MCPProxy and never executed")
@app.delete(
'/groups/{group_id}',
tags=['group_management', 'user_group_membership_management'],
security=[
UnsuportedSecurityStub(name="None"),
],
)
def delete_group(group_id: float):
"""
Delete a group
"""
raise RuntimeError("Should be patched by MCPProxy and never executed")
@app.get(
'/groups/{group_id}',
tags=['group_management', 'user_group_membership_management'],
security=[
UnsuportedSecurityStub(name="None"),
],
)
def get_group(group_id: float):
"""
Get a specific group
"""
raise RuntimeError("Should be patched by MCPProxy and never executed")
@app.get(
'/groups/{group_id}/users',
tags=['group_management', 'user_group_membership_management'],
security=[
UnsuportedSecurityStub(name="None"),
],
)
def get_group_members(
group_id: float,
direction: Optional[Direction] = None,
filter: Optional[Filter10] = None,
page: Optional[float] = None,
per_page: Optional[float] = None,
query: Optional[str] = None,
sort: Optional[Sort24] = None,
):
"""
Get all the members of a group
"""
raise RuntimeError("Should be patched by MCPProxy and never executed")
@app.get(
'/groups/{group_id}/videos',
tags=['video_management', 'channel_video_management'],
security=[
UnsuportedSecurityStub(name="None"),
],
)
def get_group_videos(
group_id: float,
direction: Optional[Direction] = None,
filter: Optional[Filter12] = None,
filter_embeddable: Optional[bool] = None,
page: Optional[float] = None,
per_page: Optional[float] = None,
query: Optional[str] = None,
sort: Optional[Sort26] = None,
):
"""
Get all the videos in a group
"""
raise RuntimeError("Should be patched by MCPProxy and never executed")
@app.delete(
'/groups/{group_id}/videos/{video_id}',
tags=['video_management', 'channel_video_management'],
security=[
UnsuportedSecurityStub(name="None"),
],
)
def delete_video_from_group(group_id: float, video_id: float = ...):
"""
Remove a video from a group
"""
raise RuntimeError("Should be patched by MCPProxy and never executed")
@app.get(
'/groups/{group_id}/videos/{video_id}',
description=""" Check if a group has a video. """,
tags=['video_management', 'channel_video_management', 'video_details_retrieval'],
security=[
UnsuportedSecurityStub(name="None"),
],
)
def get_group_video(group_id: float, video_id: float = ...):
"""
Get a specific video in a group
"""
raise RuntimeError("Should be patched by MCPProxy and never executed")
@app.put(
'/groups/{group_id}/videos/{video_id}',
tags=['video_management', 'group_management'],
security=[
UnsuportedSecurityStub(name="None"),
],
)
def add_video_to_group(group_id: float, video_id: float = ...):
"""
Add a video to a group
"""
raise RuntimeError("Should be patched by MCPProxy and never executed")
@app.get(
'/languages',
tags=['language_configuration'],
security=[
UnsuportedSecurityStub(name="None"),
],
)
def get_languages(filter: Optional[Filter14] = None):
"""
Get all languages
"""
raise RuntimeError("Should be patched by MCPProxy and never executed")
@app.get(
'/me',
tags=['user_profile_management', 'user_account_management'],
security=[
UnsuportedSecurityStub(name="None"),
],
)
def get_user_alt1():
"""
Get a user
"""
raise RuntimeError("Should be patched by MCPProxy and never executed")
@app.patch(
'/me',
tags=['user_profile_management', 'user_account_management'],
security=[
UnsuportedSecurityStub(name="None"),
],
)
def edit_user_alt1(body: MePatchRequest = None):
"""
Edit a user
"""
raise RuntimeError("Should be patched by MCPProxy and never executed")
@app.get(
'/me/albums',
tags=['album_management', 'video_management', 'album_video_management'],
security=[
UnsuportedSecurityStub(name="None"),
],
)
def get_albums_alt1(
direction: Optional[Direction] = None,
page: Optional[float] = None,
per_page: Optional[float] = None,
query: Optional[str] = None,
sort: Optional[Sort28] = None,
):
"""
Get all the albums that belong to a user
"""
raise RuntimeError("Should be patched by MCPProxy and never executed")
@app.post(
'/me/albums',
tags=['album_management', 'album_video_management'],
security=[
UnsuportedSecurityStub(name="None"),
],
)
def create_album_alt1(body: MeAlbumsPostRequest):
"""
Create an album
"""
raise RuntimeError("Should be patched by MCPProxy and never executed")
@app.delete(
'/me/albums/{album_id}',
tags=['album_management', 'album_video_operations'],
security=[
UnsuportedSecurityStub(name="None"),
],
)
def delete_album_alt1(album_id: float):
"""
Delete an album
"""
raise RuntimeError("Should be patched by MCPProxy and never executed")
@app.get(
'/me/albums/{album_id}',
tags=['album_management', 'album_video_management'],
security=[
UnsuportedSecurityStub(name="None"),
],
)
def get_album_alt1(album_id: float):
"""
Get a specific album
"""
raise RuntimeError("Should be patched by MCPProxy and never executed")
@app.patch(
'/me/albums/{album_id}',
tags=['album_management', 'album_video_management', 'album_video_operations'],
security=[
UnsuportedSecurityStub(name="None"),
],
)
def edit_album_alt1(album_id: float, body: MeAlbumsAlbumIdPatchRequest = None):
"""
Edit an album
"""
raise RuntimeError("Should be patched by MCPProxy and never executed")
@app.get(
'/me/albums/{album_id}/videos',
tags=['album_video_management', 'album_video_operations', 'video_management'],
security=[
UnsuportedSecurityStub(name="None"),
],
)
def get_album_videos_alt1(
album_id: float,
containing_uri: Optional[str] = None,
direction: Optional[Direction] = None,
filter: Optional[Filter16] = None,
filter_embeddable: Optional[bool] = None,
page: Optional[float] = None,
password: Optional[str] = None,
per_page: Optional[float] = None,
query: Optional[str] = None,
sort: Optional[Sort32] = None,
weak_search: Optional[bool] = None,
):
"""
Get all the videos in an album
"""
raise RuntimeError("Should be patched by MCPProxy and never executed")
@app.put(
'/me/albums/{album_id}/videos',
description=""" This method replaces all the existing videos in an album with one or more videos. """,
tags=[
'album_management',
'album_video_management',
'album_video_operations',
'video_management',
],
security=[
UnsuportedSecurityStub(name="None"),
],
)
def replace_videos_in_album_alt1(
album_id: float, body: MeAlbumsAlbumIdVideosPutRequest = ...
):
"""
Replace all the videos in an album
"""
raise RuntimeError("Should be patched by MCPProxy and never executed")
@app.delete(
'/me/albums/{album_id}/videos/{video_id}',
tags=[
'video_management',
'album_management',
'album_video_management',
'album_video_operations',
],
security=[
UnsuportedSecurityStub(name="None"),
],
)
def remove_video_from_album_alt1(album_id: float, video_id: float = ...):
"""
Remove a video from an album
"""
raise RuntimeError("Should be patched by MCPProxy and never executed")
@app.get(
'/me/albums/{album_id}/videos/{video_id}',
description=""" This method gets a single video from an album. You can use this method to determine whether the album contains the specified video. """,
tags=['album_video_management', 'album_video_operations', 'video_management'],
security=[
UnsuportedSecurityStub(name="None"),
],
)
def get_album_video_alt1(
album_id: float, video_id: float = ..., password: Optional[str] = None
):
"""
Get a specific video in an album
"""
raise RuntimeError("Should be patched by MCPProxy and never executed")
@app.put(
'/me/albums/{album_id}/videos/{video_id}',
tags=['album_video_management', 'album_video_operations', 'video_management'],
security=[
UnsuportedSecurityStub(name="None"),
],
)
def add_video_to_album_alt1(album_id: float, video_id: float = ...):
"""
Add a specific video to an album
"""
raise RuntimeError("Should be patched by MCPProxy and never executed")
@app.post(
'/me/albums/{album_id}/videos/{video_id}/set_album_thumbnail',
tags=[
'album_management',
'album_video_management',
'album_video_operations',
'video_management',
'channel_video_management',
],
security=[
UnsuportedSecurityStub(name="None"),
],
)
def set_video_as_album_thumbnail_alt1(
album_id: float,
video_id: float = ...,
body: MeAlbumsAlbumIdVideosVideoIdSetAlbumThumbnailPostRequest = None,
):
"""
Set a video as the album thumbnail
"""
raise RuntimeError("Should be patched by MCPProxy and never executed")
@app.get(
'/me/appearances',
tags=['user_video_interaction', 'video_management'],
security=[
UnsuportedSecurityStub(name="None"),
],
)
def get_appearances_alt1(
direction: Optional[Direction] = None,
filter: Optional[Filter16] = None,
filter_embeddable: Optional[bool] = None,
page: Optional[float] = None,
per_page: Optional[float] = None,
query: Optional[str] = None,
sort: Optional[Sort34] = None,
):
"""
Get all the videos in which a user appears
"""
raise RuntimeError("Should be patched by MCPProxy and never executed")
@app.get(
'/me/categories',
tags=['user_following_management', 'category_management'],
security=[
UnsuportedSecurityStub(name="None"),
],
)
def get_category_subscriptions_alt1(
direction: Optional[Direction] = None,
page: Optional[float] = None,
per_page: Optional[float] = None,
sort: Optional[Sort36] = None,
):
"""
Get all the categories that a user follows
"""
raise RuntimeError("Should be patched by MCPProxy and never executed")
@app.delete(
'/me/categories/{category}',
tags=['category_management', 'user_subscription_management'],
security=[
UnsuportedSecurityStub(name="None"),
],
)
def unsubscribe_from_category_alt1(category: str):
"""
Unsubscribe a user from a category
"""
raise RuntimeError("Should be patched by MCPProxy and never executed")
@app.get(
'/me/categories/{category}',
tags=['category_management', 'user_following_management'],
security=[
UnsuportedSecurityStub(name="None"),
],
)
def check_if_user_subscribed_to_category_alt1(category: str):
"""
Check if a user follows a category
"""
raise RuntimeError("Should be patched by MCPProxy and never executed")
@app.put(
'/me/categories/{category}',
tags=['user_subscription_management', 'category_management'],
security=[
UnsuportedSecurityStub(name="None"),
],
)
def subscribe_to_category_alt1(category: float):
"""
Subscribe a user to a single category
"""
raise RuntimeError("Should be patched by MCPProxy and never executed")
@app.get(
'/me/channels',
tags=['user_subscription_management', 'user_subscription_management_v2'],
security=[
UnsuportedSecurityStub(name="None"),
],
)
def get_channel_subscriptions_alt1(
direction: Optional[Direction] = None,
filter: Optional[Filter20] = None,
page: Optional[float] = None,
per_page: Optional[float] = None,
query: Optional[str] = None,
sort: Optional[Sort38] = None,
):
"""
Get all the channels to which a user subscribes
"""
raise RuntimeError("Should be patched by MCPProxy and never executed")
@app.delete(
'/me/channels/{channel_id}',
tags=[
'channel_management',
'user_subscription_management',
'user_subscription_management_v2',
],
security=[
UnsuportedSecurityStub(name="None"),
],
)
def unsubscribe_from_channel_alt1(channel_id: float):
"""
Unsubscribe a user from a specific channel
"""
raise RuntimeError("Should be patched by MCPProxy and never executed")
@app.get(
'/me/channels/{channel_id}',
tags=['user_following_management', 'user_subscription_management'],
security=[
UnsuportedSecurityStub(name="None"),
],
)
def check_if_user_subscribed_to_channel_alt1(channel_id: float):
"""
Check if a user follows a channel
"""
raise RuntimeError("Should be patched by MCPProxy and never executed")
@app.put(
'/me/channels/{channel_id}',
tags=[
'user_subscription_management',
'user_subscription_management_v2',
'channel_management',
],
security=[
UnsuportedSecurityStub(name="None"),
],
)
def subscribe_to_channel_alt1(channel_id: float):
"""
Subscribe a user to a specific channel
"""
raise RuntimeError("Should be patched by MCPProxy and never executed")
@app.get(
'/me/customlogos',
tags=['custom_logo_management', 'user_profile_management'],
security=[
UnsuportedSecurityStub(name="None"),
],
)
def get_custom_logos_alt1():
"""
Get all the custom logos that belong to a user
"""
raise RuntimeError("Should be patched by MCPProxy and never executed")
@app.post(
'/me/customlogos',
tags=['custom_logo_management', 'video_customization_management'],
security=[
UnsuportedSecurityStub(name="None"),
],
)
def create_custom_logo_alt1():
"""
Add a custom logo
"""
raise RuntimeError("Should be patched by MCPProxy and never executed")
@app.get(
'/me/customlogos/{logo_id}',
tags=['custom_logo_management', 'video_customization_management'],
security=[
UnsuportedSecurityStub(name="None"),
],
)
def get_custom_logo_alt1(logo_id: float):
"""
Get a specific custom logo
"""
raise RuntimeError("Should be patched by MCPProxy and never executed")
@app.get(
'/me/feed',
tags=['user_feed_management', 'video_management'],
security=[
UnsuportedSecurityStub(name="None"),
],
)
def get_feed_alt1(
offset: Optional[str] = None,
page: Optional[float] = None,
per_page: Optional[float] = None,
type: Optional[Type12] = None,
):
"""
Get all videos in a user's feed
"""
raise RuntimeError("Should be patched by MCPProxy and never executed")
@app.get(
'/me/followers',
tags=['user_following_management', 'user_profile_management'],
security=[
UnsuportedSecurityStub(name="None"),
],
)
def get_followers_alt1(
direction: Optional[Direction] = None,
page: Optional[float] = None,
per_page: Optional[float] = None,
query: Optional[str] = None,
sort: Optional[Sort40] = None,
):
"""
Get all the followers of a user
"""
raise RuntimeError("Should be patched by MCPProxy and never executed")
@app.get(
'/me/following',
tags=['user_following_management', 'user_profile_management'],
security=[
UnsuportedSecurityStub(name="None"),
],
)
def get_user_following_alt1(
direction: Optional[Direction] = None,
filter: Optional[Filter22] = None,
page: Optional[float] = None,
per_page: Optional[float] = None,
query: Optional[str] = None,
sort: Optional[Sort40] = None,
):
"""
Get all the users that a user is following
"""
raise RuntimeError("Should be patched by MCPProxy and never executed")
@app.post(
'/me/following',
tags=['user_following_management'],
security=[
UnsuportedSecurityStub(name="None"),
],
)
def follow_users_alt1(body: MeFollowingPostRequest):
"""
Follow a list of users
"""
raise RuntimeError("Should be patched by MCPProxy and never executed")
@app.delete(
'/me/following/{follow_user_id}',
tags=['user_following_management', 'user_subscription_management'],
security=[
UnsuportedSecurityStub(name="None"),
],
)
def unfollow_user_alt1(follow_user_id: float):
"""
Unfollow a user
"""
raise RuntimeError("Should be patched by MCPProxy and never executed")
@app.get(
'/me/following/{follow_user_id}',
tags=['user_following_management'],
security=[
UnsuportedSecurityStub(name="None"),
],
)
def check_if_user_is_following_alt1(follow_user_id: float):
"""
Check if a user is following another user
"""
raise RuntimeError("Should be patched by MCPProxy and never executed")
@app.put(
'/me/following/{follow_user_id}',
tags=['user_following_management', 'user_profile_management'],
security=[
UnsuportedSecurityStub(name="None"),
],
)
def follow_user_alt1(follow_user_id: float):
"""
Follow a specific user
"""
raise RuntimeError("Should be patched by MCPProxy and never executed")
@app.get(
'/me/groups',
tags=['user_group_membership_management', 'group_management'],
security=[
UnsuportedSecurityStub(name="None"),
],
)
def get_user_groups_alt1(
direction: Optional[Direction] = None,
filter: Optional[Filter24] = None,
page: Optional[float] = None,
per_page: Optional[float] = None,
query: Optional[str] = None,
sort: Optional[Sort44] = None,
):
"""
Get all the groups that a user has joined
"""
raise RuntimeError("Should be patched by MCPProxy and never executed")
@app.delete(
'/me/groups/{group_id}',
tags=['group_management', 'user_group_membership_management'],
security=[
UnsuportedSecurityStub(name="None"),
],
)
def leave_group_alt1(group_id: float):
"""
Remove a user from a group
"""
raise RuntimeError("Should be patched by MCPProxy and never executed")
@app.get(
'/me/groups/{group_id}',
tags=['user_group_membership_management', 'group_management'],
security=[
UnsuportedSecurityStub(name="None"),
],
)
def check_if_user_joined_group_alt1(group_id: float):
"""
Check if a user has joined a group
"""
raise RuntimeError("Should be patched by MCPProxy and never executed")
@app.put(
'/me/groups/{group_id}',
tags=['group_management', 'user_group_membership_management'],
security=[
UnsuportedSecurityStub(name="None"),
],
)
def join_group_alt1(group_id: float):
"""
Add a user to a group
"""
raise RuntimeError("Should be patched by MCPProxy and never executed")
@app.get(
'/me/likes',
tags=[
'user_video_like_management',
'user_activity_management',
'user_profile_management',
],
security=[
UnsuportedSecurityStub(name="None"),
],
)
def get_likes_alt1(
filter: Optional[Filter26] = None,
filter_embeddable: Optional[bool] = None,
page: Optional[float] = None,
per_page: Optional[float] = None,
query: Optional[str] = None,
sort: Optional[Sort46] = None,
):
"""
Get all the videos that a user has liked
"""
raise RuntimeError("Should be patched by MCPProxy and never executed")
@app.delete(
'/me/likes/{video_id}',
tags=['user_video_like_management', 'user_video_interaction'],
security=[
UnsuportedSecurityStub(name="None"),
],
)
def unlike_video_alt1(video_id: float):
"""
Cause a user to unlike a video
"""
raise RuntimeError("Should be patched by MCPProxy and never executed")
@app.get(
'/me/likes/{video_id}',
tags=['user_video_like_management', 'user_video_interaction'],
security=[
UnsuportedSecurityStub(name="None"),
],
)
def check_if_user_liked_video_alt1(video_id: float):
"""
Check if a user has liked a video
"""
raise RuntimeError("Should be patched by MCPProxy and never executed")
@app.put(
'/me/likes/{video_id}',
tags=['user_video_like_management', 'user_video_interaction'],
security=[
UnsuportedSecurityStub(name="None"),
],
)
def like_video_alt1(video_id: float):
"""
Cause a user to like a video
"""
raise RuntimeError("Should be patched by MCPProxy and never executed")
@app.get(
'/me/ondemand/pages',
tags=['user_vod_management', 'vod_management'],
security=[
UnsuportedSecurityStub(name="None"),
],
)
def get_user_vods_alt1(
direction: Optional[Direction] = None,
filter: Optional[Filter28] = None,
page: Optional[float] = None,
per_page: Optional[float] = None,
sort: Optional[Sort48] = None,
):
"""
Get all the On Demand pages of a user
"""
raise RuntimeError("Should be patched by MCPProxy and never executed")
@app.post(
'/me/ondemand/pages',
tags=['vod_management'],
security=[
UnsuportedSecurityStub(name="None"),
],
)
def create_vod_alt1(body: MeOndemandPagesPostRequest):
"""
Create an On Demand page
"""
raise RuntimeError("Should be patched by MCPProxy and never executed")
@app.get(
'/me/ondemand/purchases',
tags=['user_vod_management', 'user_activity_management'],
security=[
UnsuportedSecurityStub(name="None"),
],
)
def get_vod_purchases(
direction: Optional[Direction] = None,
filter: Optional[Filter30] = None,
page: Optional[float] = None,
per_page: Optional[float] = None,
sort: Optional[Sort50] = None,
):
"""
Get all the On Demand purchases and rentals that a user has made
"""
raise RuntimeError("Should be patched by MCPProxy and never executed")
@app.get(
'/me/ondemand/purchases/{ondemand_id}',
tags=['user_vod_management', 'user_activity_management'],
security=[
UnsuportedSecurityStub(name="None"),
],
)
def check_if_vod_was_purchased_alt1(ondemand_id: float):
"""
Check if a user has made a purchase or rental from an On Demand page
"""
raise RuntimeError("Should be patched by MCPProxy and never executed")
@app.get(
'/me/pictures',
tags=['user_picture_management', 'user_activity_management'],
security=[
UnsuportedSecurityStub(name="None"),
],
)
def get_pictures_alt1(page: Optional[float] = None, per_page: Optional[float] = None):
"""
Get all the pictures that belong to a user
"""
raise RuntimeError("Should be patched by MCPProxy and never executed")
@app.post(
'/me/pictures',
tags=[
'user_picture_management',
'user_profile_management',
'user_account_management',
],
security=[
UnsuportedSecurityStub(name="None"),
],
)
def create_picture_alt1():
"""
Add a user picture
"""
raise RuntimeError("Should be patched by MCPProxy and never executed")
@app.delete(
'/me/pictures/{portraitset_id}',
tags=['user_picture_management'],
security=[
UnsuportedSecurityStub(name="None"),
],
)
def delete_picture_alt1(portraitset_id: float):
"""
Delete a user picture
"""
raise RuntimeError("Should be patched by MCPProxy and never executed")
@app.get(
'/me/pictures/{portraitset_id}',
tags=['user_picture_management', 'user_profile_management'],
security=[
UnsuportedSecurityStub(name="None"),
],
)
def get_picture_alt1(portraitset_id: float):
"""
Get a specific user picture
"""
raise RuntimeError("Should be patched by MCPProxy and never executed")
@app.patch(
'/me/pictures/{portraitset_id}',
tags=['user_picture_management', 'user_profile_management'],
security=[
UnsuportedSecurityStub(name="None"),
],
)
def edit_picture_alt1(
portraitset_id: float, body: MePicturesPortraitsetIdPatchRequest = None
):
"""
Edit a user picture
"""
raise RuntimeError("Should be patched by MCPProxy and never executed")
@app.get(
'/me/portfolios',
tags=['user_portfolio_management'],
security=[
UnsuportedSecurityStub(name="None"),
],
)
def get_portfolios_alt1(
direction: Optional[Direction] = None,
page: Optional[float] = None,
per_page: Optional[float] = None,
query: Optional[str] = None,
sort: Optional[Sort52] = None,
):
"""
Get all the portfolios that belong to a user
"""
raise RuntimeError("Should be patched by MCPProxy and never executed")
@app.get(
'/me/portfolios/{portfolio_id}',
tags=['user_portfolio_management'],
security=[
UnsuportedSecurityStub(name="None"),
],
)
def get_portfolio_alt1(portfolio_id: float):
"""
Get a specific portfolio
"""
raise RuntimeError("Should be patched by MCPProxy and never executed")
@app.get(
'/me/portfolios/{portfolio_id}/videos',
tags=['video_management', 'user_portfolio_management'],
security=[
UnsuportedSecurityStub(name="None"),
],
)
def get_portfolio_videos_alt1(
portfolio_id: float,
containing_uri: Optional[str] = None,
filter: Optional[Filter32] = None,
filter_embeddable: Optional[bool] = None,
page: Optional[float] = None,
per_page: Optional[float] = None,
sort: Optional[Sort54] = None,
):
"""
Get all the videos in a portfolio
"""
raise RuntimeError("Should be patched by MCPProxy and never executed")
@app.delete(
'/me/portfolios/{portfolio_id}/videos/{video_id}',
tags=['video_management', 'user_portfolio_management'],
security=[
UnsuportedSecurityStub(name="None"),
],
)
def delete_video_from_portfolio_alt1(portfolio_id: float, video_id: float = ...):
"""
Remove a video from a portfolio
"""
raise RuntimeError("Should be patched by MCPProxy and never executed")
@app.get(
'/me/portfolios/{portfolio_id}/videos/{video_id}',
tags=['user_portfolio_management', 'video_management', 'video_details_retrieval'],
security=[
UnsuportedSecurityStub(name="None"),
],
)
def get_portfolio_video_alt1(portfolio_id: float, video_id: float = ...):
"""
Get a specific video in a portfolio
"""
raise RuntimeError("Should be patched by MCPProxy and never executed")
@app.put(
'/me/portfolios/{portfolio_id}/videos/{video_id}',
tags=['user_portfolio_management', 'video_management'],
security=[
UnsuportedSecurityStub(name="None"),
],
)
def add_video_to_portfolio_alt1(portfolio_id: float, video_id: float = ...):
"""
Add a video to a portfolio
"""
raise RuntimeError("Should be patched by MCPProxy and never executed")
@app.get(
'/me/presets',
tags=['user_embed_presets_management'],
security=[
UnsuportedSecurityStub(name="None"),
],
)
def get_embed_presets_alt1(
page: Optional[float] = None, per_page: Optional[float] = None
):
"""
Get all the embed presets that a user has created
"""
raise RuntimeError("Should be patched by MCPProxy and never executed")
@app.get(
'/me/presets/{preset_id}',
tags=['user_embed_presets_management', 'video_embed_presets_management'],
security=[
UnsuportedSecurityStub(name="None"),
],
)
def get_embed_preset_alt1(preset_id: float):
"""
Get a specific embed preset
"""
raise RuntimeError("Should be patched by MCPProxy and never executed")
@app.patch(
'/me/presets/{preset_id}',
tags=['user_embed_presets_management', 'video_embed_presets_management'],
security=[
UnsuportedSecurityStub(name="None"),
],
)
def edit_embed_preset_alt1(
preset_id: float, body: MePresetsPresetIdPatchRequest = None
):
"""
Edit an embed preset
"""
raise RuntimeError("Should be patched by MCPProxy and never executed")
@app.get(
'/me/presets/{preset_id}/videos',
tags=['user_embed_presets_management', 'video_embed_presets_management'],
security=[
UnsuportedSecurityStub(name="None"),
],
)
def get_embed_preset_videos_alt1(
preset_id: float, page: Optional[float] = None, per_page: Optional[float] = None
):
"""
Get all the videos that have been added to an embed preset
"""
raise RuntimeError("Should be patched by MCPProxy and never executed")
@app.get(
'/me/projects',
description=""" This method gets all the projects that belong to the specified user. """,
tags=['user_project_management', 'project_management'],
security=[
UnsuportedSecurityStub(name="None"),
],
)
def get_projects_alt1(
direction: Optional[Direction] = None,
page: Optional[float] = None,
per_page: Optional[float] = None,
sort: Optional[Sort56] = None,
):
"""
Get all the projects that belong to a user
"""
raise RuntimeError("Should be patched by MCPProxy and never executed")
@app.post(
'/me/projects',
description=""" This method creates a new project for the specified user. """,
tags=['project_management', 'user_project_management'],
security=[
UnsuportedSecurityStub(name="None"),
],
)
def create_project_alt1(body: MeProjectsPostRequest):
"""
Create a project
"""
raise RuntimeError("Should be patched by MCPProxy and never executed")
@app.delete(
'/me/projects/{project_id}',
description=""" This method deletes a project and optionally also the videos that it contains. """,
tags=['project_management', 'user_project_management'],
security=[
UnsuportedSecurityStub(name="None"),
],
)
def delete_project_alt1(project_id: float, should_delete_clips: Optional[bool] = None):
"""
Delete a project
"""
raise RuntimeError("Should be patched by MCPProxy and never executed")
@app.get(
'/me/projects/{project_id}',
description=""" This method gets a single project that belongs to the specified user. """,
tags=['project_management', 'user_project_management'],
security=[
UnsuportedSecurityStub(name="None"),
],
)
def get_project_alt1(project_id: float):
"""
Get a specific project
"""
raise RuntimeError("Should be patched by MCPProxy and never executed")
@app.patch(
'/me/projects/{project_id}',
description=""" This method edits an existing project. """,
tags=['project_management', 'user_project_management'],
security=[
UnsuportedSecurityStub(name="None"),
],
)
def edit_project_alt1(project_id: float, body: MeProjectsProjectIdPatchRequest = ...):
"""
Edit a project
"""
raise RuntimeError("Should be patched by MCPProxy and never executed")
@app.delete(
'/me/projects/{project_id}/videos',
description=""" This method removed multiple videos from the specified project. """,
tags=['project_management', 'video_management'],
security=[
UnsuportedSecurityStub(name="None"),
],
)
def remove_videos_from_project_alt1(
project_id: float, should_delete_clips: Optional[bool] = None, uris: str = ...
):
"""
Remove a list of videos from a project
"""
raise RuntimeError("Should be patched by MCPProxy and never executed")
@app.get(
'/me/projects/{project_id}/videos',
description=""" This method gets all the videos that belong to the specified project. """,
tags=['project_management', 'video_management', 'channel_video_management'],
security=[
UnsuportedSecurityStub(name="None"),
],
)
def get_project_videos_alt1(
project_id: float,
direction: Optional[Direction] = None,
page: Optional[float] = None,
per_page: Optional[float] = None,
sort: Optional[Sort58] = None,
):
"""
Get all the videos in a project
"""
raise RuntimeError("Should be patched by MCPProxy and never executed")
@app.put(
'/me/projects/{project_id}/videos',
description=""" This method adds multiple videos to the specified project. """,
tags=['project_management', 'video_management'],
security=[
UnsuportedSecurityStub(name="None"),
],
)
def add_videos_to_project_alt1(project_id: float, uris: str = ...):
"""
Add a list of videos to a project
"""
raise RuntimeError("Should be patched by MCPProxy and never executed")
@app.delete(
'/me/projects/{project_id}/videos/{video_id}',
description=""" This method removes a single video from the specified project. """,
tags=['project_management', 'video_management'],
security=[
UnsuportedSecurityStub(name="None"),
],
)
def remove_video_from_project_alt1(project_id: float, video_id: float = ...):
"""
Remove a specific video from a project
"""
raise RuntimeError("Should be patched by MCPProxy and never executed")
@app.put(
'/me/projects/{project_id}/videos/{video_id}',
description=""" This method adds a single video to the specified project. """,
tags=['project_management', 'video_management'],
security=[
UnsuportedSecurityStub(name="None"),
],
)
def add_video_to_project_alt1(project_id: float, video_id: float = ...):
"""
Add a specific video to a project
"""
raise RuntimeError("Should be patched by MCPProxy and never executed")
@app.get(
'/me/videos',
tags=['channel_video_management', 'user_upload_management', 'video_management'],
security=[
UnsuportedSecurityStub(name="None"),
],
)
def get_videos_alt1(
containing_uri: Optional[str] = None,
direction: Optional[Direction] = None,
filter: Optional[Filter34] = None,
filter_embeddable: Optional[bool] = None,
filter_playable: Optional[bool] = None,
page: Optional[float] = None,
per_page: Optional[float] = None,
query: Optional[str] = None,
sort: Optional[Sort60] = None,
):
"""
Get all the videos that a user has uploaded
"""
raise RuntimeError("Should be patched by MCPProxy and never executed")
@app.post(
'/me/videos',
description=""" Begin the video upload process. For more information, see our [upload documentation](https://developer.vimeo.com/api/upload/videos). """,
tags=['video_upload_management', 'user_upload_management', 'video_management'],
security=[
UnsuportedSecurityStub(name="None"),
],
)
def upload_video_alt1(body: MeVideosPostRequest):
"""
Upload a video
"""
raise RuntimeError("Should be patched by MCPProxy and never executed")
@app.get(
'/me/videos/{video_id}',
tags=['user_video_interaction', 'video_management'],
security=[
UnsuportedSecurityStub(name="None"),
],
)
def check_if_user_owns_video_alt1(video_id: float):
"""
Check if a user owns a video
"""
raise RuntimeError("Should be patched by MCPProxy and never executed")
@app.delete(
'/me/watched/videos',
tags=['user_watch_history_management', 'user_activity_management'],
security=[
UnsuportedSecurityStub(name="None"),
],
)
def delete_watch_history():
"""
Delete a user's watch history
"""
raise RuntimeError("Should be patched by MCPProxy and never executed")
@app.get(
'/me/watched/videos',
tags=['user_watch_history_management', 'user_activity_management'],
security=[
UnsuportedSecurityStub(name="None"),
],
)
def get_watch_history(page: Optional[float] = None, per_page: Optional[float] = None):
"""
Get all the videos that a user has watched
"""
raise RuntimeError("Should be patched by MCPProxy and never executed")
@app.delete(
'/me/watched/videos/{video_id}',
tags=['user_watch_history_management', 'video_management'],
security=[
UnsuportedSecurityStub(name="None"),
],
)
def delete_from_watch_history(video_id: float):
"""
Delete a specific video from a user's watch history
"""
raise RuntimeError("Should be patched by MCPProxy and never executed")
@app.get(
'/me/watchlater',
tags=['watch_later_management', 'user_video_interaction'],
security=[
UnsuportedSecurityStub(name="None"),
],
)
def get_watch_later_queue_alt1(
direction: Optional[Direction] = None,
filter: Optional[Filter36] = None,
filter_embeddable: Optional[bool] = None,
page: Optional[float] = None,
per_page: Optional[float] = None,
query: Optional[str] = None,
sort: Optional[Sort62] = None,
):
"""
Get all the videos in a user's Watch Later queue
"""
raise RuntimeError("Should be patched by MCPProxy and never executed")
@app.delete(
'/me/watchlater/{video_id}',
tags=['watch_later_management', 'user_activity_management', 'video_management'],
security=[
UnsuportedSecurityStub(name="None"),
],
)
def delete_video_from_watch_later_alt1(video_id: float):
"""
Remove a video from a user's Watch Later queue
"""
raise RuntimeError("Should be patched by MCPProxy and never executed")
@app.get(
'/me/watchlater/{video_id}',
tags=[
'watch_later_management',
'user_activity_management',
'user_video_interaction',
],
security=[
UnsuportedSecurityStub(name="None"),
],
)
def check_watch_later_queue_alt1(video_id: float):
"""
Check if a user has added a specific video to their Watch Later queue
"""
raise RuntimeError("Should be patched by MCPProxy and never executed")
@app.put(
'/me/watchlater/{video_id}',
tags=['watch_later_management', 'user_video_interaction'],
security=[
UnsuportedSecurityStub(name="None"),
],
)
def add_video_to_watch_later_alt1(video_id: float):
"""
Add a video to a user's Watch Later queue
"""
raise RuntimeError("Should be patched by MCPProxy and never executed")
@app.post(
'/oauth/access_token',
tags=['oauth_management'],
security=[
UnsuportedSecurityStub(name="None"),
],
)
def exchange_auth_code(body: OauthAccessTokenPostRequest):
"""
Exchange an authorization code for an access token
"""
raise RuntimeError("Should be patched by MCPProxy and never executed")
@app.post(
'/oauth/authorize/client',
description=""" For information on utilizing OAuth client authorization, see our
[authentication](/api/authentication#generate-unauthenticated-tokens) documentation or the
[Client Credentials Grant](https://tools.ietf.org/html/draft-ietf-oauth-v2-31#section-4.4) section of the
[OAuth spec](https://tools.ietf.org/html/draft-ietf-oauth-v2-31. """,
tags=['oauth_management'],
security=[
UnsuportedSecurityStub(name="None"),
],
)
def client_auth(body: OauthAuthorizeClientPostRequest):
"""
Authorize a client with OAuth
"""
raise RuntimeError("Should be patched by MCPProxy and never executed")
@app.post(
'/oauth/authorize/vimeo_oauth1',
tags=['oauth_management'],
security=[
UnsuportedSecurityStub(name="None"),
],
)
def convert_access_token(body: OauthAuthorizeVimeoOauth1PostRequest):
"""
Convert OAuth 1 access tokens to OAuth 2 access tokens
"""
raise RuntimeError("Should be patched by MCPProxy and never executed")
@app.get(
'/oauth/verify',
tags=['oauth_management'],
security=[
UnsuportedSecurityStub(name="None"),
],
)
def verify_token():
"""
Verify an OAuth 2 token
"""
raise RuntimeError("Should be patched by MCPProxy and never executed")
@app.get(
'/ondemand/genres',
tags=['vod_genre_management'],
security=[
UnsuportedSecurityStub(name="None"),
],
)
def get_vod_genres():
"""
Get all On Demand genres
"""
raise RuntimeError("Should be patched by MCPProxy and never executed")
@app.get(
'/ondemand/genres/{genre_id}',
tags=['vod_genre_management'],
security=[
UnsuportedSecurityStub(name="None"),
],
)
def get_vod_genre(genre_id: str):
"""
Get a specific On Demand genre
"""
raise RuntimeError("Should be patched by MCPProxy and never executed")
@app.get(
'/ondemand/genres/{genre_id}/pages',
tags=['vod_management', 'vod_genre_management'],
security=[
UnsuportedSecurityStub(name="None"),
],
)
def get_genre_vods(
genre_id: str,
direction: Optional[Direction] = None,
filter: Optional[Filter38] = None,
page: Optional[float] = None,
per_page: Optional[float] = None,
query: Optional[str] = None,
sort: Optional[Sort64] = None,
):
"""
Get all the On Demand pages in a genre
"""
raise RuntimeError("Should be patched by MCPProxy and never executed")
@app.get(
'/ondemand/genres/{genre_id}/pages/{ondemand_id}',
description=""" Check whether a genre contains an On Demand page. """,
tags=['vod_management', 'vod_genre_management'],
security=[
UnsuportedSecurityStub(name="None"),
],
)
def get_genre_vod(genre_id: str, ondemand_id: float = ...):
"""
Get a specific On Demand page in a genre
"""
raise RuntimeError("Should be patched by MCPProxy and never executed")
@app.delete(
'/ondemand/pages/{ondemand_id}',
tags=['vod_management'],
security=[
UnsuportedSecurityStub(name="None"),
],
)
def delete_vod_draft(ondemand_id: float):
"""
Delete a draft of an On Demand page
"""
raise RuntimeError("Should be patched by MCPProxy and never executed")
@app.get(
'/ondemand/pages/{ondemand_id}',
tags=['vod_management', 'vod_genre_management', 'vod_video_management'],
security=[
UnsuportedSecurityStub(name="None"),
],
)
def get_vod(ondemand_id: float):
"""
Get a specific On Demand page
"""
raise RuntimeError("Should be patched by MCPProxy and never executed")
@app.patch(
'/ondemand/pages/{ondemand_id}',
description=""" Enable preorders or publish the page. """,
tags=['vod_management'],
security=[
UnsuportedSecurityStub(name="None"),
],
)
def edit_vod(ondemand_id: float, body: OndemandPagesOndemandIdPatchRequest = None):
"""
Edit an On Demand page
"""
raise RuntimeError("Should be patched by MCPProxy and never executed")
@app.get(
'/ondemand/pages/{ondemand_id}/backgrounds',
tags=['vod_background_management'],
security=[
UnsuportedSecurityStub(name="None"),
],
)
def get_vod_backgrounds(
ondemand_id: float, page: Optional[float] = None, per_page: Optional[float] = None
):
"""
Get all the backgrounds of an On Demand page
"""
raise RuntimeError("Should be patched by MCPProxy and never executed")
@app.post(
'/ondemand/pages/{ondemand_id}/backgrounds',
tags=['vod_management', 'vod_background_management'],
security=[
UnsuportedSecurityStub(name="None"),
],
)
def create_vod_background(ondemand_id: float):
"""
Add a background to an On Demand page
"""
raise RuntimeError("Should be patched by MCPProxy and never executed")
@app.delete(
'/ondemand/pages/{ondemand_id}/backgrounds/{background_id}',
tags=['vod_background_management'],
security=[
UnsuportedSecurityStub(name="None"),
],
)
def delete_vod_background(background_id: float, ondemand_id: float = ...):
"""
Remove a background from an On Demand page
"""
raise RuntimeError("Should be patched by MCPProxy and never executed")
@app.get(
'/ondemand/pages/{ondemand_id}/backgrounds/{background_id}',
tags=['vod_background_management'],
security=[
UnsuportedSecurityStub(name="None"),
],
)
def get_vod_background(background_id: float, ondemand_id: float = ...):
"""
Get a specific background of an On Demand page
"""
raise RuntimeError("Should be patched by MCPProxy and never executed")
@app.patch(
'/ondemand/pages/{ondemand_id}/backgrounds/{background_id}',
tags=['vod_background_management'],
security=[
UnsuportedSecurityStub(name="None"),
],
)
def edit_vod_background(
background_id: float,
ondemand_id: float = ...,
body: OndemandPagesOndemandIdBackgroundsBackgroundIdPatchRequest = None,
):
"""
Edit a background of an On Demand page
"""
raise RuntimeError("Should be patched by MCPProxy and never executed")
@app.get(
'/ondemand/pages/{ondemand_id}/genres',
tags=['vod_genre_management'],
security=[
UnsuportedSecurityStub(name="None"),
],
)
def get_vod_genres_by_ondemand_id(ondemand_id: float):
"""
Get all the genres of an On Demand page
"""
raise RuntimeError("Should be patched by MCPProxy and never executed")
@app.delete(
'/ondemand/pages/{ondemand_id}/genres/{genre_id}',
tags=['vod_genre_management', 'vod_management'],
security=[
UnsuportedSecurityStub(name="None"),
],
)
def delete_vod_genre(genre_id: str, ondemand_id: float = ...):
"""
Remove a genre from an On Demand page
"""
raise RuntimeError("Should be patched by MCPProxy and never executed")
@app.get(
'/ondemand/pages/{ondemand_id}/genres/{genre_id}',
tags=['vod_genre_management', 'vod_management'],
security=[
UnsuportedSecurityStub(name="None"),
],
)
def get_vod_genre_by_ondemand_id(genre_id: str, ondemand_id: float = ...):
"""
Check whether an On Demand page belongs to a genre
"""
raise RuntimeError("Should be patched by MCPProxy and never executed")
@app.put(
'/ondemand/pages/{ondemand_id}/genres/{genre_id}',
tags=['vod_genre_management'],
security=[
UnsuportedSecurityStub(name="None"),
],
)
def add_vod_genre(genre_id: str, ondemand_id: float = ...):
"""
Add a genre to an On Demand page
"""
raise RuntimeError("Should be patched by MCPProxy and never executed")
@app.get(
'/ondemand/pages/{ondemand_id}/likes',
description=""" This method gets all the users who have liked a particular video on an On Demand page. """,
tags=['user_video_like_management', 'user_video_interaction'],
security=[
UnsuportedSecurityStub(name="None"),
],
)
def get_vod_likes(
ondemand_id: float,
direction: Optional[Direction] = None,
filter: Optional[Filter40] = None,
page: Optional[float] = None,
per_page: Optional[float] = None,
sort: Optional[Sort66] = None,
):
"""
Get all the users who have liked a video on an On Demand page
"""
raise RuntimeError("Should be patched by MCPProxy and never executed")
@app.get(
'/ondemand/pages/{ondemand_id}/pictures',
tags=['vod_management', 'video_management'],
security=[
UnsuportedSecurityStub(name="None"),
],
)
def get_vod_posters(
ondemand_id: float, page: Optional[float] = None, per_page: Optional[float] = None
):
"""
Get all the posters of an On Demand page
"""
raise RuntimeError("Should be patched by MCPProxy and never executed")
@app.post(
'/ondemand/pages/{ondemand_id}/pictures',
tags=['vod_management', 'vod_background_management'],
security=[
UnsuportedSecurityStub(name="None"),
],
)
def add_vod_poster(ondemand_id: float):
"""
Add a poster to an On Demand page
"""
raise RuntimeError("Should be patched by MCPProxy and never executed")
@app.get(
'/ondemand/pages/{ondemand_id}/pictures/{poster_id}',
tags=['vod_management', 'vod_video_management'],
security=[
UnsuportedSecurityStub(name="None"),
],
)
def get_vod_poster(ondemand_id: float, poster_id: float = ...):
"""
Get a specific poster of an On Demand page
"""
raise RuntimeError("Should be patched by MCPProxy and never executed")
@app.patch(
'/ondemand/pages/{ondemand_id}/pictures/{poster_id}',
tags=['vod_management', 'vod_background_management'],
security=[
UnsuportedSecurityStub(name="None"),
],
)
def edit_vod_poster(
ondemand_id: float,
poster_id: float = ...,
body: OndemandPagesOndemandIdPicturesPosterIdPatchRequest = None,
):
"""
Edit a poster of an On Demand page
"""
raise RuntimeError("Should be patched by MCPProxy and never executed")
@app.get(
'/ondemand/pages/{ondemand_id}/promotions',
tags=['vod_promotions_management'],
security=[
UnsuportedSecurityStub(name="None"),
],
)
def get_vod_promotions(
ondemand_id: float,
filter: Filter42 = ...,
page: Optional[float] = None,
per_page: Optional[float] = None,
):
"""
Get all the promotions on an On Demand page
"""
raise RuntimeError("Should be patched by MCPProxy and never executed")
@app.post(
'/ondemand/pages/{ondemand_id}/promotions',
tags=['vod_promotions_management'],
security=[
UnsuportedSecurityStub(name="None"),
],
)
def create_vod_promotion(
ondemand_id: float, body: OndemandPagesOndemandIdPromotionsPostRequest = ...
):
"""
Add a promotion to an On Demand page
"""
raise RuntimeError("Should be patched by MCPProxy and never executed")
@app.delete(
'/ondemand/pages/{ondemand_id}/promotions/{promotion_id}',
tags=['vod_promotions_management'],
security=[
UnsuportedSecurityStub(name="None"),
],
)
def delete_vod_promotion(ondemand_id: float, promotion_id: float = ...):
"""
Remove a promotion from an On Demand page
"""
raise RuntimeError("Should be patched by MCPProxy and never executed")
@app.get(
'/ondemand/pages/{ondemand_id}/promotions/{promotion_id}',
tags=['vod_promotions_management'],
security=[
UnsuportedSecurityStub(name="None"),
],
)
def get_vod_promotion(ondemand_id: float, promotion_id: float = ...):
"""
Get a specific promotion on an On Demand page
"""
raise RuntimeError("Should be patched by MCPProxy and never executed")
@app.get(
'/ondemand/pages/{ondemand_id}/promotions/{promotion_id}/codes',
tags=['vod_promotions_management'],
security=[
UnsuportedSecurityStub(name="None"),
],
)
def get_vod_promotion_codes(
ondemand_id: float,
promotion_id: float = ...,
page: Optional[float] = None,
per_page: Optional[float] = None,
):
"""
Get all the codes of a promotion on an On Demand page
"""
raise RuntimeError("Should be patched by MCPProxy and never executed")
@app.delete(
'/ondemand/pages/{ondemand_id}/regions',
tags=['vod_region_management'],
security=[
UnsuportedSecurityStub(name="None"),
],
)
def delete_vod_regions(
ondemand_id: float, body: OndemandPagesOndemandIdRegionsDeleteRequest = None
):
"""
Remove a list of regions from an On Demand page
"""
raise RuntimeError("Should be patched by MCPProxy and never executed")
@app.get(
'/ondemand/pages/{ondemand_id}/regions',
tags=['vod_region_management', 'vod_management'],
security=[
UnsuportedSecurityStub(name="None"),
],
)
def get_vod_regions(ondemand_id: float):
"""
Get all the regions of an On Demand page
"""
raise RuntimeError("Should be patched by MCPProxy and never executed")
@app.put(
'/ondemand/pages/{ondemand_id}/regions',
tags=['vod_region_management'],
security=[
UnsuportedSecurityStub(name="None"),
],
)
def set_vod_regions(
ondemand_id: float, body: OndemandPagesOndemandIdRegionsPutRequest = ...
):
"""
Add a list of regions to an On Demand page
"""
raise RuntimeError("Should be patched by MCPProxy and never executed")
@app.delete(
'/ondemand/pages/{ondemand_id}/regions/{country}',
tags=['vod_management', 'vod_region_management'],
security=[
UnsuportedSecurityStub(name="None"),
],
)
def delete_vod_region(country: str, ondemand_id: float = ...):
"""
Remove a specific region from an On Demand page
"""
raise RuntimeError("Should be patched by MCPProxy and never executed")
@app.get(
'/ondemand/pages/{ondemand_id}/regions/{country}',
description=""" Checks whether an On Demand page belongs to a region. """,
tags=['vod_region_management'],
security=[
UnsuportedSecurityStub(name="None"),
],
)
def get_vod_region(country: str, ondemand_id: float = ...):
"""
Get a specific region of an On Demand page
"""
raise RuntimeError("Should be patched by MCPProxy and never executed")
@app.put(
'/ondemand/pages/{ondemand_id}/regions/{country}',
tags=['vod_region_management'],
security=[
UnsuportedSecurityStub(name="None"),
],
)
def add_vod_region(country: str, ondemand_id: float = ...):
"""
Add a specific region to an On Demand page
"""
raise RuntimeError("Should be patched by MCPProxy and never executed")
@app.get(
'/ondemand/pages/{ondemand_id}/seasons',
tags=['vod_season_management', 'vod_management'],
security=[
UnsuportedSecurityStub(name="None"),
],
)
def get_vod_seasons(
ondemand_id: float,
direction: Optional[Direction] = None,
filter: Optional[Filter44] = None,
page: Optional[float] = None,
per_page: Optional[float] = None,
sort: Optional[Sort68] = None,
):
"""
Get all the seasons on an On Demand page
"""
raise RuntimeError("Should be patched by MCPProxy and never executed")
@app.get(
'/ondemand/pages/{ondemand_id}/seasons/{season_id}',
tags=['vod_season_management'],
security=[
UnsuportedSecurityStub(name="None"),
],
)
def get_vod_season(ondemand_id: float, season_id: float = ...):
"""
Get a specific season on an On Demand page
"""
raise RuntimeError("Should be patched by MCPProxy and never executed")
@app.get(
'/ondemand/pages/{ondemand_id}/seasons/{season_id}/videos',
tags=['vod_management', 'vod_video_management', 'vod_season_management'],
security=[
UnsuportedSecurityStub(name="None"),
],
)
def get_vod_season_videos(
ondemand_id: float,
season_id: float = ...,
filter: Optional[Filter44] = None,
page: Optional[float] = None,
per_page: Optional[float] = None,
sort: Optional[Sort70] = None,
):
"""
Get all the videos in a season on an On Demand page
"""
raise RuntimeError("Should be patched by MCPProxy and never executed")
@app.get(
'/ondemand/pages/{ondemand_id}/videos',
tags=['vod_video_management', 'video_management', 'video_details_retrieval'],
security=[
UnsuportedSecurityStub(name="None"),
],
)
def get_vod_videos(
ondemand_id: float,
direction: Optional[Direction] = None,
filter: Optional[Filter48] = None,
page: Optional[float] = None,
per_page: Optional[float] = None,
sort: Optional[Sort72] = None,
):
"""
Get all the videos on an On Demand page
"""
raise RuntimeError("Should be patched by MCPProxy and never executed")
@app.delete(
'/ondemand/pages/{ondemand_id}/videos/{video_id}',
tags=['video_management', 'vod_management', 'vod_video_management'],
security=[
UnsuportedSecurityStub(name="None"),
],
)
def delete_video_from_vod(ondemand_id: float, video_id: float = ...):
"""
Remove a video from an On Demand page
"""
raise RuntimeError("Should be patched by MCPProxy and never executed")
@app.get(
'/ondemand/pages/{ondemand_id}/videos/{video_id}',
tags=['vod_video_management', 'video_details_retrieval', 'video_management'],
security=[
UnsuportedSecurityStub(name="None"),
],
)
def get_vod_video(ondemand_id: float, video_id: float = ...):
"""
Get a specific video on an On Demand page
"""
raise RuntimeError("Should be patched by MCPProxy and never executed")
@app.put(
'/ondemand/pages/{ondemand_id}/videos/{video_id}',
tags=['vod_management', 'video_management', 'channel_video_management'],
security=[
UnsuportedSecurityStub(name="None"),
],
)
def add_video_to_vod(
ondemand_id: float,
video_id: float = ...,
body: OndemandPagesOndemandIdVideosVideoIdPutRequest = ...,
):
"""
Add a video to an On Demand page
"""
raise RuntimeError("Should be patched by MCPProxy and never executed")
@app.get(
'/ondemand/regions',
tags=['vod_region_management'],
security=[
UnsuportedSecurityStub(name="None"),
],
)
def get_regions():
"""
Get all the On Demand regions
"""
raise RuntimeError("Should be patched by MCPProxy and never executed")
@app.get(
'/ondemand/regions/{country}',
tags=['vod_region_management'],
security=[
UnsuportedSecurityStub(name="None"),
],
)
def get_region(country: str):
"""
Get a specific On Demand region
"""
raise RuntimeError("Should be patched by MCPProxy and never executed")
@app.get(
'/tags/{word}',
tags=['channel_tag_management', 'video_tag_management'],
security=[
UnsuportedSecurityStub(name="None"),
],
)
def get_tag(word: str):
"""
Get a specific tag
"""
raise RuntimeError("Should be patched by MCPProxy and never executed")
@app.get(
'/tags/{word}/videos',
tags=['video_tag_management', 'video_management'],
security=[
UnsuportedSecurityStub(name="None"),
],
)
def get_videos_with_tag(
word: str,
direction: Optional[Direction] = None,
page: Optional[float] = None,
per_page: Optional[float] = None,
sort: Optional[Sort74] = None,
):
"""
Get all the videos with a specific tag
"""
raise RuntimeError("Should be patched by MCPProxy and never executed")
@app.delete(
'/tokens',
description=""" This method enables an app to notify the API that it is done with a token and that the token can be discarded. """,
tags=['oauth_management'],
security=[
UnsuportedSecurityStub(name="None"),
],
)
def delete_token():
"""
Revoke the current access token
"""
raise RuntimeError("Should be patched by MCPProxy and never executed")
@app.get(
'/users',
tags=[
'user_profile_management',
'user_activity_management',
'user_account_management',
],
security=[
UnsuportedSecurityStub(name="None"),
],
)
def search_users(
direction: Optional[Direction] = None,
page: Optional[float] = None,
per_page: Optional[float] = None,
query: Optional[str] = None,
sort: Optional[Sort76] = None,
):
"""
Search for users
"""
raise RuntimeError("Should be patched by MCPProxy and never executed")
@app.get(
'/users/{user_id}',
tags=['user_profile_management', 'user_account_management'],
security=[
UnsuportedSecurityStub(name="None"),
],
)
def get_user(user_id: float):
"""
Get a user
"""
raise RuntimeError("Should be patched by MCPProxy and never executed")
@app.patch(
'/users/{user_id}',
tags=['user_profile_management', 'user_account_management'],
security=[
UnsuportedSecurityStub(name="None"),
],
)
def edit_user(user_id: float, body: UsersUserIdPatchRequest = None):
"""
Edit a user
"""
raise RuntimeError("Should be patched by MCPProxy and never executed")
@app.get(
'/users/{user_id}/albums',
tags=['album_management', 'user_profile_management'],
security=[
UnsuportedSecurityStub(name="None"),
],
)
def get_albums(
user_id: float,
direction: Optional[Direction] = None,
page: Optional[float] = None,
per_page: Optional[float] = None,
query: Optional[str] = None,
sort: Optional[Sort78] = None,
):
"""
Get all the albums that belong to a user
"""
raise RuntimeError("Should be patched by MCPProxy and never executed")
@app.post(
'/users/{user_id}/albums',
tags=['album_management', 'album_video_management', 'album_video_operations'],
security=[
UnsuportedSecurityStub(name="None"),
],
)
def create_album(user_id: float, body: UsersUserIdAlbumsPostRequest = ...):
"""
Create an album
"""
raise RuntimeError("Should be patched by MCPProxy and never executed")
@app.delete(
'/users/{user_id}/albums/{album_id}',
tags=['album_management', 'album_video_management'],
security=[
UnsuportedSecurityStub(name="None"),
],
)
def delete_album(album_id: float, user_id: float = ...):
"""
Delete an album
"""
raise RuntimeError("Should be patched by MCPProxy and never executed")
@app.get(
'/users/{user_id}/albums/{album_id}',
tags=['album_management', 'album_video_management', 'album_video_operations'],
security=[
UnsuportedSecurityStub(name="None"),
],
)
def get_album(album_id: float, user_id: float = ...):
"""
Get a specific album
"""
raise RuntimeError("Should be patched by MCPProxy and never executed")
@app.patch(
'/users/{user_id}/albums/{album_id}',
tags=['album_management', 'album_video_management', 'album_video_operations'],
security=[
UnsuportedSecurityStub(name="None"),
],
)
def edit_album(
album_id: float,
user_id: float = ...,
body: UsersUserIdAlbumsAlbumIdPatchRequest = None,
):
"""
Edit an album
"""
raise RuntimeError("Should be patched by MCPProxy and never executed")
@app.get(
'/users/{user_id}/albums/{album_id}/custom_thumbnails',
tags=[
'album_management',
'album_video_management',
'album_video_operations',
'user_upload_management',
'video_thumbnail_management',
],
security=[
UnsuportedSecurityStub(name="None"),
],
)
def get_album_custom_thumbs(
album_id: float,
user_id: float = ...,
page: Optional[float] = None,
per_page: Optional[float] = None,
):
"""
Get all the custom upload thumbnails of an album
"""
raise RuntimeError("Should be patched by MCPProxy and never executed")
@app.post(
'/users/{user_id}/albums/{album_id}/custom_thumbnails',
tags=['album_management', 'video_thumbnail_management'],
security=[
UnsuportedSecurityStub(name="None"),
],
)
def create_album_custom_thumb(album_id: float, user_id: float = ...):
"""
Add a custom uploaded thumbnail
"""
raise RuntimeError("Should be patched by MCPProxy and never executed")
@app.delete(
'/users/{user_id}/albums/{album_id}/custom_thumbnails/{thumbnail_id}',
description=""" This method removes a custom uploaded thumbnail from the specified album. """,
tags=['album_management', 'album_video_management'],
security=[
UnsuportedSecurityStub(name="None"),
],
)
def delete_album_custom_thumbnail(
album_id: float, thumbnail_id: float = ..., user_id: float = ...
):
"""
Remove a custom uploaded album thumbnail
"""
raise RuntimeError("Should be patched by MCPProxy and never executed")
@app.get(
'/users/{user_id}/albums/{album_id}/custom_thumbnails/{thumbnail_id}',
tags=['album_management', 'album_video_management', 'album_video_operations'],
security=[
UnsuportedSecurityStub(name="None"),
],
)
def get_album_custom_thumbnail(
album_id: float, thumbnail_id: float = ..., user_id: float = ...
):
"""
Get a specific custom uploaded album thumbnail
"""
raise RuntimeError("Should be patched by MCPProxy and never executed")
@app.patch(
'/users/{user_id}/albums/{album_id}/custom_thumbnails/{thumbnail_id}',
tags=['album_management', 'album_video_management', 'album_video_operations'],
security=[
UnsuportedSecurityStub(name="None"),
],
)
def replace_album_custom_thumb(
album_id: float,
thumbnail_id: float = ...,
user_id: float = ...,
body: UsersUserIdAlbumsAlbumIdCustomThumbnailsThumbnailIdPatchRequest = None,
):
"""
Replace a custom uploaded album thumbnail
"""
raise RuntimeError("Should be patched by MCPProxy and never executed")
@app.get(
'/users/{user_id}/albums/{album_id}/logos',
tags=['album_management', 'custom_logo_management'],
security=[
UnsuportedSecurityStub(name="None"),
],
)
def get_album_logos(
album_id: float,
user_id: float = ...,
page: Optional[float] = None,
per_page: Optional[float] = None,
):
"""
Get all the custom logos of an album
"""
raise RuntimeError("Should be patched by MCPProxy and never executed")
@app.post(
'/users/{user_id}/albums/{album_id}/logos',
tags=['album_management', 'custom_logo_management', 'album_video_management'],
security=[
UnsuportedSecurityStub(name="None"),
],
)
def create_album_logo(album_id: float, user_id: float = ...):
"""
Add a custom album logo
"""
raise RuntimeError("Should be patched by MCPProxy and never executed")
@app.delete(
'/users/{user_id}/albums/{album_id}/logos/{logo_id}',
description=""" This method removes a custom logo from the specified album. """,
tags=['album_management', 'custom_logo_management'],
security=[
UnsuportedSecurityStub(name="None"),
],
)
def delete_album_logo(album_id: float, logo_id: float = ..., user_id: float = ...):
"""
Remove a custom album logo
"""
raise RuntimeError("Should be patched by MCPProxy and never executed")
@app.get(
'/users/{user_id}/albums/{album_id}/logos/{logo_id}',
tags=['album_management', 'custom_logo_management', 'album_video_management'],
security=[
UnsuportedSecurityStub(name="None"),
],
)
def get_album_logo(album_id: float, logo_id: float = ..., user_id: float = ...):
"""
Get a specific custom album logo
"""
raise RuntimeError("Should be patched by MCPProxy and never executed")
@app.patch(
'/users/{user_id}/albums/{album_id}/logos/{logo_id}',
tags=['album_management', 'custom_logo_management'],
security=[
UnsuportedSecurityStub(name="None"),
],
)
def replace_album_logo(
album_id: float,
logo_id: float = ...,
user_id: float = ...,
body: UsersUserIdAlbumsAlbumIdLogosLogoIdPatchRequest = None,
):
"""
Replace a custom album logo
"""
raise RuntimeError("Should be patched by MCPProxy and never executed")
@app.get(
'/users/{user_id}/albums/{album_id}/videos',
tags=['album_video_management', 'album_video_operations', 'video_management'],
security=[
UnsuportedSecurityStub(name="None"),
],
)
def get_album_videos(
album_id: float,
user_id: float = ...,
containing_uri: Optional[str] = None,
direction: Optional[Direction] = None,
filter: Optional[Filter50] = None,
filter_embeddable: Optional[bool] = None,
page: Optional[float] = None,
password: Optional[str] = None,
per_page: Optional[float] = None,
query: Optional[str] = None,
sort: Optional[Sort82] = None,
weak_search: Optional[bool] = None,
):
"""
Get all the videos in an album
"""
raise RuntimeError("Should be patched by MCPProxy and never executed")
@app.put(
'/users/{user_id}/albums/{album_id}/videos',
description=""" This method replaces all the existing videos in an album with one or more videos. """,
tags=[
'video_management',
'album_management',
'album_video_management',
'album_video_operations',
],
security=[
UnsuportedSecurityStub(name="None"),
],
)
def replace_videos_in_album(
album_id: float,
user_id: float = ...,
body: UsersUserIdAlbumsAlbumIdVideosPutRequest = ...,
):
"""
Replace all the videos in an album
"""
raise RuntimeError("Should be patched by MCPProxy and never executed")
@app.delete(
'/users/{user_id}/albums/{album_id}/videos/{video_id}',
tags=[
'album_management',
'album_video_management',
'album_video_operations',
'video_management',
'channel_video_management',
],
security=[
UnsuportedSecurityStub(name="None"),
],
)
def remove_video_from_album(
album_id: float, user_id: float = ..., video_id: float = ...
):
"""
Remove a video from an album
"""
raise RuntimeError("Should be patched by MCPProxy and never executed")
@app.get(
'/users/{user_id}/albums/{album_id}/videos/{video_id}',
description=""" This method gets a single video from an album. You can use this method to determine whether the album contains the specified video. """,
tags=['album_video_management', 'album_video_operations', 'video_management'],
security=[
UnsuportedSecurityStub(name="None"),
],
)
def get_album_video(
album_id: float,
user_id: float = ...,
video_id: float = ...,
password: Optional[str] = None,
):
"""
Get a specific video in an album
"""
raise RuntimeError("Should be patched by MCPProxy and never executed")
@app.put(
'/users/{user_id}/albums/{album_id}/videos/{video_id}',
tags=[
'album_management',
'album_video_management',
'album_video_operations',
'video_management',
],
security=[
UnsuportedSecurityStub(name="None"),
],
)
def add_video_to_album(album_id: float, user_id: float = ..., video_id: float = ...):
"""
Add a specific video to an album
"""
raise RuntimeError("Should be patched by MCPProxy and never executed")
@app.post(
'/users/{user_id}/albums/{album_id}/videos/{video_id}/set_album_thumbnail',
tags=[
'album_management',
'album_video_management',
'album_video_operations',
'video_management',
],
security=[
UnsuportedSecurityStub(name="None"),
],
)
def set_video_as_album_thumbnail(
album_id: float,
user_id: float = ...,
video_id: float = ...,
body: UsersUserIdAlbumsAlbumIdVideosVideoIdSetAlbumThumbnailPostRequest = None,
):
"""
Set a video as the album thumbnail
"""
raise RuntimeError("Should be patched by MCPProxy and never executed")
@app.get(
'/users/{user_id}/appearances',
tags=['user_video_interaction', 'video_management', 'video_details_retrieval'],
security=[
UnsuportedSecurityStub(name="None"),
],
)
def get_appearances(
user_id: float,
direction: Optional[Direction] = None,
filter: Optional[Filter50] = None,
filter_embeddable: Optional[bool] = None,
page: Optional[float] = None,
per_page: Optional[float] = None,
query: Optional[str] = None,
sort: Optional[Sort84] = None,
):
"""
Get all the videos in which a user appears
"""
raise RuntimeError("Should be patched by MCPProxy and never executed")
@app.get(
'/users/{user_id}/categories',
tags=['category_management', 'user_following_management'],
security=[
UnsuportedSecurityStub(name="None"),
],
)
def get_category_subscriptions(
user_id: float,
direction: Optional[Direction] = None,
page: Optional[float] = None,
per_page: Optional[float] = None,
sort: Optional[Sort86] = None,
):
"""
Get all the categories that a user follows
"""
raise RuntimeError("Should be patched by MCPProxy and never executed")
@app.delete(
'/users/{user_id}/categories/{category}',
tags=[
'user_subscription_management',
'user_subscription_management_v2',
'category_management',
],
security=[
UnsuportedSecurityStub(name="None"),
],
)
def unsubscribe_from_category(category: str, user_id: float = ...):
"""
Unsubscribe a user from a category
"""
raise RuntimeError("Should be patched by MCPProxy and never executed")
@app.get(
'/users/{user_id}/categories/{category}',
tags=['category_management', 'user_following_management'],
security=[
UnsuportedSecurityStub(name="None"),
],
)
def check_if_user_subscribed_to_category(category: str, user_id: float = ...):
"""
Check if a user follows a category
"""
raise RuntimeError("Should be patched by MCPProxy and never executed")
@app.put(
'/users/{user_id}/categories/{category}',
tags=[
'user_subscription_management',
'user_subscription_management_v2',
'category_management',
],
security=[
UnsuportedSecurityStub(name="None"),
],
)
def subscribe_to_category(category: float, user_id: float = ...):
"""
Subscribe a user to a single category
"""
raise RuntimeError("Should be patched by MCPProxy and never executed")
@app.get(
'/users/{user_id}/channels',
tags=['user_subscription_management', 'user_subscription_management_v2'],
security=[
UnsuportedSecurityStub(name="None"),
],
)
def get_channel_subscriptions(
user_id: float,
direction: Optional[Direction] = None,
filter: Optional[Filter54] = None,
page: Optional[float] = None,
per_page: Optional[float] = None,
query: Optional[str] = None,
sort: Optional[Sort88] = None,
):
"""
Get all the channels to which a user subscribes
"""
raise RuntimeError("Should be patched by MCPProxy and never executed")
@app.delete(
'/users/{user_id}/channels/{channel_id}',
tags=['user_subscription_management', 'user_subscription_management_v2'],
security=[
UnsuportedSecurityStub(name="None"),
],
)
def unsubscribe_from_channel(channel_id: float, user_id: float = ...):
"""
Unsubscribe a user from a specific channel
"""
raise RuntimeError("Should be patched by MCPProxy and never executed")
@app.get(
'/users/{user_id}/channels/{channel_id}',
tags=['user_following_management', 'user_subscription_management'],
security=[
UnsuportedSecurityStub(name="None"),
],
)
def check_if_user_subscribed_to_channel(channel_id: float, user_id: float = ...):
"""
Check if a user follows a channel
"""
raise RuntimeError("Should be patched by MCPProxy and never executed")
@app.put(
'/users/{user_id}/channels/{channel_id}',
tags=[
'channel_management',
'user_subscription_management',
'user_subscription_management_v2',
],
security=[
UnsuportedSecurityStub(name="None"),
],
)
def subscribe_to_channel(channel_id: float, user_id: float = ...):
"""
Subscribe a user to a specific channel
"""
raise RuntimeError("Should be patched by MCPProxy and never executed")
@app.get(
'/users/{user_id}/customlogos',
tags=['custom_logo_management', 'user_profile_management'],
security=[
UnsuportedSecurityStub(name="None"),
],
)
def get_custom_logos(user_id: float):
"""
Get all the custom logos that belong to a user
"""
raise RuntimeError("Should be patched by MCPProxy and never executed")
@app.post(
'/users/{user_id}/customlogos',
tags=[
'custom_logo_management',
'user_profile_management',
'video_customization_management',
],
security=[
UnsuportedSecurityStub(name="None"),
],
)
def create_custom_logo(user_id: float):
"""
Add a custom logo
"""
raise RuntimeError("Should be patched by MCPProxy and never executed")
@app.get(
'/users/{user_id}/customlogos/{logo_id}',
tags=['custom_logo_management'],
security=[
UnsuportedSecurityStub(name="None"),
],
)
def get_custom_logo(logo_id: float, user_id: float = ...):
"""
Get a specific custom logo
"""
raise RuntimeError("Should be patched by MCPProxy and never executed")
@app.get(
'/users/{user_id}/feed',
tags=['user_feed_management', 'video_management', 'user_video_interaction'],
security=[
UnsuportedSecurityStub(name="None"),
],
)
def get_feed(
user_id: float,
offset: Optional[str] = None,
page: Optional[float] = None,
per_page: Optional[float] = None,
type: Optional[Type17] = None,
):
"""
Get all videos in a user's feed
"""
raise RuntimeError("Should be patched by MCPProxy and never executed")
@app.get(
'/users/{user_id}/followers',
tags=['user_following_management', 'user_profile_management'],
security=[
UnsuportedSecurityStub(name="None"),
],
)
def get_followers(
user_id: float,
direction: Optional[Direction] = None,
page: Optional[float] = None,
per_page: Optional[float] = None,
query: Optional[str] = None,
sort: Optional[Sort90] = None,
):
"""
Get all the followers of a user
"""
raise RuntimeError("Should be patched by MCPProxy and never executed")
@app.get(
'/users/{user_id}/following',
tags=[
'user_following_management',
'user_profile_management',
'user_activity_management',
],
security=[
UnsuportedSecurityStub(name="None"),
],
)
def get_user_following(
user_id: float,
direction: Optional[Direction] = None,
filter: Optional[Filter56] = None,
page: Optional[float] = None,
per_page: Optional[float] = None,
query: Optional[str] = None,
sort: Optional[Sort90] = None,
):
"""
Get all the users that a user is following
"""
raise RuntimeError("Should be patched by MCPProxy and never executed")
@app.post(
'/users/{user_id}/following',
tags=['user_following_management'],
security=[
UnsuportedSecurityStub(name="None"),
],
)
def follow_users(user_id: float, body: UsersUserIdFollowingPostRequest = ...):
"""
Follow a list of users
"""
raise RuntimeError("Should be patched by MCPProxy and never executed")
@app.delete(
'/users/{user_id}/following/{follow_user_id}',
tags=['user_following_management'],
security=[
UnsuportedSecurityStub(name="None"),
],
)
def unfollow_user(follow_user_id: float, user_id: float = ...):
"""
Unfollow a user
"""
raise RuntimeError("Should be patched by MCPProxy and never executed")
@app.get(
'/users/{user_id}/following/{follow_user_id}',
tags=['user_following_management'],
security=[
UnsuportedSecurityStub(name="None"),
],
)
def check_if_user_is_following(follow_user_id: float, user_id: float = ...):
"""
Check if a user is following another user
"""
raise RuntimeError("Should be patched by MCPProxy and never executed")
@app.put(
'/users/{user_id}/following/{follow_user_id}',
tags=['user_following_management', 'user_activity_management'],
security=[
UnsuportedSecurityStub(name="None"),
],
)
def follow_user(follow_user_id: float, user_id: float = ...):
"""
Follow a specific user
"""
raise RuntimeError("Should be patched by MCPProxy and never executed")
@app.get(
'/users/{user_id}/groups',
tags=['user_group_membership_management'],
security=[
UnsuportedSecurityStub(name="None"),
],
)
def get_user_groups(
user_id: float,
direction: Optional[Direction] = None,
filter: Optional[Filter58] = None,
page: Optional[float] = None,
per_page: Optional[float] = None,
query: Optional[str] = None,
sort: Optional[Sort94] = None,
):
"""
Get all the groups that a user has joined
"""
raise RuntimeError("Should be patched by MCPProxy and never executed")
@app.delete(
'/users/{user_id}/groups/{group_id}',
tags=['group_management', 'user_group_membership_management'],
security=[
UnsuportedSecurityStub(name="None"),
],
)
def leave_group(group_id: float, user_id: float = ...):
"""
Remove a user from a group
"""
raise RuntimeError("Should be patched by MCPProxy and never executed")
@app.get(
'/users/{user_id}/groups/{group_id}',
tags=['user_group_membership_management', 'group_management'],
security=[
UnsuportedSecurityStub(name="None"),
],
)
def check_if_user_joined_group(group_id: float, user_id: float = ...):
"""
Check if a user has joined a group
"""
raise RuntimeError("Should be patched by MCPProxy and never executed")
@app.put(
'/users/{user_id}/groups/{group_id}',
tags=['group_management', 'user_group_membership_management'],
security=[
UnsuportedSecurityStub(name="None"),
],
)
def join_group(group_id: float, user_id: float = ...):
"""
Add a user to a group
"""
raise RuntimeError("Should be patched by MCPProxy and never executed")
@app.get(
'/users/{user_id}/likes',
tags=['user_video_like_management', 'user_activity_management', 'video_management'],
security=[
UnsuportedSecurityStub(name="None"),
],
)
def get_likes(
user_id: float,
filter: Optional[Filter60] = None,
filter_embeddable: Optional[bool] = None,
page: Optional[float] = None,
per_page: Optional[float] = None,
query: Optional[str] = None,
sort: Optional[Sort96] = None,
):
"""
Get all the videos that a user has liked
"""
raise RuntimeError("Should be patched by MCPProxy and never executed")
@app.delete(
'/users/{user_id}/likes/{video_id}',
tags=['user_video_like_management', 'user_video_interaction'],
security=[
UnsuportedSecurityStub(name="None"),
],
)
def unlike_video(user_id: float, video_id: float = ...):
"""
Cause a user to unlike a video
"""
raise RuntimeError("Should be patched by MCPProxy and never executed")
@app.get(
'/users/{user_id}/likes/{video_id}',
tags=['user_video_like_management', 'user_video_interaction'],
security=[
UnsuportedSecurityStub(name="None"),
],
)
def check_if_user_liked_video(user_id: float, video_id: float = ...):
"""
Check if a user has liked a video
"""
raise RuntimeError("Should be patched by MCPProxy and never executed")
@app.put(
'/users/{user_id}/likes/{video_id}',
tags=['user_video_like_management', 'user_video_interaction'],
security=[
UnsuportedSecurityStub(name="None"),
],
)
def like_video(user_id: float, video_id: float = ...):
"""
Cause a user to like a video
"""
raise RuntimeError("Should be patched by MCPProxy and never executed")
@app.get(
'/users/{user_id}/ondemand/pages',
tags=['user_vod_management', 'user_activity_management', 'user_account_management'],
security=[
UnsuportedSecurityStub(name="None"),
],
)
def get_user_vods(
user_id: float,
direction: Optional[Direction] = None,
filter: Optional[Filter62] = None,
page: Optional[float] = None,
per_page: Optional[float] = None,
sort: Optional[Sort98] = None,
):
"""
Get all the On Demand pages of a user
"""
raise RuntimeError("Should be patched by MCPProxy and never executed")
@app.post(
'/users/{user_id}/ondemand/pages',
tags=['user_vod_management', 'vod_management'],
security=[
UnsuportedSecurityStub(name="None"),
],
)
def create_vod(user_id: float, body: UsersUserIdOndemandPagesPostRequest = ...):
"""
Create an On Demand page
"""
raise RuntimeError("Should be patched by MCPProxy and never executed")
@app.get(
'/users/{user_id}/ondemand/purchases',
tags=['user_vod_management', 'user_activity_management'],
security=[
UnsuportedSecurityStub(name="None"),
],
)
def check_if_vod_was_purchased(user_id: float):
"""
Check if a user has made a purchase or rental from an On Demand page
"""
raise RuntimeError("Should be patched by MCPProxy and never executed")
@app.get(
'/users/{user_id}/pictures',
tags=['user_picture_management', 'user_account_management'],
security=[
UnsuportedSecurityStub(name="None"),
],
)
def get_pictures(
user_id: float, page: Optional[float] = None, per_page: Optional[float] = None
):
"""
Get all the pictures that belong to a user
"""
raise RuntimeError("Should be patched by MCPProxy and never executed")
@app.post(
'/users/{user_id}/pictures',
tags=['user_picture_management'],
security=[
UnsuportedSecurityStub(name="None"),
],
)
def create_picture(user_id: float):
"""
Add a user picture
"""
raise RuntimeError("Should be patched by MCPProxy and never executed")
@app.delete(
'/users/{user_id}/pictures/{portraitset_id}',
tags=[
'user_picture_management',
'user_profile_management',
'user_account_management',
],
security=[
UnsuportedSecurityStub(name="None"),
],
)
def delete_picture(portraitset_id: float, user_id: float = ...):
"""
Delete a user picture
"""
raise RuntimeError("Should be patched by MCPProxy and never executed")
@app.get(
'/users/{user_id}/pictures/{portraitset_id}',
tags=['user_picture_management', 'user_profile_management'],
security=[
UnsuportedSecurityStub(name="None"),
],
)
def get_picture(portraitset_id: float, user_id: float = ...):
"""
Get a specific user picture
"""
raise RuntimeError("Should be patched by MCPProxy and never executed")
@app.patch(
'/users/{user_id}/pictures/{portraitset_id}',
tags=['user_picture_management', 'user_profile_management'],
security=[
UnsuportedSecurityStub(name="None"),
],
)
def edit_picture(
portraitset_id: float,
user_id: float = ...,
body: UsersUserIdPicturesPortraitsetIdPatchRequest = None,
):
"""
Edit a user picture
"""
raise RuntimeError("Should be patched by MCPProxy and never executed")
@app.get(
'/users/{user_id}/portfolios',
tags=['user_portfolio_management'],
security=[
UnsuportedSecurityStub(name="None"),
],
)
def get_portfolios(
user_id: float,
direction: Optional[Direction] = None,
page: Optional[float] = None,
per_page: Optional[float] = None,
query: Optional[str] = None,
sort: Optional[Sort100] = None,
):
"""
Get all the portfolios that belong to a user
"""
raise RuntimeError("Should be patched by MCPProxy and never executed")
@app.get(
'/users/{user_id}/portfolios/{portfolio_id}',
tags=['user_portfolio_management'],
security=[
UnsuportedSecurityStub(name="None"),
],
)
def get_portfolio(portfolio_id: float, user_id: float = ...):
"""
Get a specific portfolio
"""
raise RuntimeError("Should be patched by MCPProxy and never executed")
@app.get(
'/users/{user_id}/portfolios/{portfolio_id}/videos',
tags=['video_management', 'user_portfolio_management'],
security=[
UnsuportedSecurityStub(name="None"),
],
)
def get_portfolio_videos(
portfolio_id: float,
user_id: float = ...,
containing_uri: Optional[str] = None,
filter: Optional[Filter64] = None,
filter_embeddable: Optional[bool] = None,
page: Optional[float] = None,
per_page: Optional[float] = None,
sort: Optional[Sort102] = None,
):
"""
Get all the videos in a portfolio
"""
raise RuntimeError("Should be patched by MCPProxy and never executed")
@app.delete(
'/users/{user_id}/portfolios/{portfolio_id}/videos/{video_id}',
tags=['video_management', 'user_portfolio_management', 'channel_video_management'],
security=[
UnsuportedSecurityStub(name="None"),
],
)
def delete_video_from_portfolio(
portfolio_id: float, user_id: float = ..., video_id: float = ...
):
"""
Remove a video from a portfolio
"""
raise RuntimeError("Should be patched by MCPProxy and never executed")
@app.get(
'/users/{user_id}/portfolios/{portfolio_id}/videos/{video_id}',
tags=['user_portfolio_management', 'video_management', 'video_details_retrieval'],
security=[
UnsuportedSecurityStub(name="None"),
],
)
def get_portfolio_video(
portfolio_id: float, user_id: float = ..., video_id: float = ...
):
"""
Get a specific video in a portfolio
"""
raise RuntimeError("Should be patched by MCPProxy and never executed")
@app.put(
'/users/{user_id}/portfolios/{portfolio_id}/videos/{video_id}',
tags=['user_portfolio_management', 'video_management'],
security=[
UnsuportedSecurityStub(name="None"),
],
)
def add_video_to_portfolio(
portfolio_id: float, user_id: float = ..., video_id: float = ...
):
"""
Add a video to a portfolio
"""
raise RuntimeError("Should be patched by MCPProxy and never executed")
@app.get(
'/users/{user_id}/presets',
tags=['user_embed_presets_management'],
security=[
UnsuportedSecurityStub(name="None"),
],
)
def get_embed_presets(
user_id: float, page: Optional[float] = None, per_page: Optional[float] = None
):
"""
Get all the embed presets that a user has created
"""
raise RuntimeError("Should be patched by MCPProxy and never executed")
@app.get(
'/users/{user_id}/presets/{preset_id}',
tags=['user_embed_presets_management', 'user_embed_preset_management_v2'],
security=[
UnsuportedSecurityStub(name="None"),
],
)
def get_embed_preset(preset_id: float, user_id: float = ...):
"""
Get a specific embed preset
"""
raise RuntimeError("Should be patched by MCPProxy and never executed")
@app.patch(
'/users/{user_id}/presets/{preset_id}',
tags=['user_embed_presets_management'],
security=[
UnsuportedSecurityStub(name="None"),
],
)
def edit_embed_preset(
preset_id: float,
user_id: float = ...,
body: UsersUserIdPresetsPresetIdPatchRequest = None,
):
"""
Edit an embed preset
"""
raise RuntimeError("Should be patched by MCPProxy and never executed")
@app.get(
'/users/{user_id}/presets/{preset_id}/videos',
tags=[
'user_embed_presets_management',
'video_embed_presets_management',
'video_management',
],
security=[
UnsuportedSecurityStub(name="None"),
],
)
def get_embed_preset_videos(
preset_id: float,
user_id: float = ...,
page: Optional[float] = None,
per_page: Optional[float] = None,
):
"""
Get all the videos that have been added to an embed preset
"""
raise RuntimeError("Should be patched by MCPProxy and never executed")
@app.get(
'/users/{user_id}/projects',
description=""" This method gets all the projects that belong to the specified user. """,
tags=['user_project_management', 'project_management'],
security=[
UnsuportedSecurityStub(name="None"),
],
)
def get_projects(
user_id: float,
direction: Optional[Direction] = None,
page: Optional[float] = None,
per_page: Optional[float] = None,
sort: Optional[Sort104] = None,
):
"""
Get all the projects that belong to a user
"""
raise RuntimeError("Should be patched by MCPProxy and never executed")
@app.post(
'/users/{user_id}/projects',
description=""" This method creates a new project for the specified user. """,
tags=['project_management', 'user_project_management'],
security=[
UnsuportedSecurityStub(name="None"),
],
)
def create_project(user_id: float, body: UsersUserIdProjectsPostRequest = ...):
"""
Create a project
"""
raise RuntimeError("Should be patched by MCPProxy and never executed")
@app.delete(
'/users/{user_id}/projects/{project_id}',
description=""" This method deletes a project and optionally also the videos that it contains. """,
tags=['project_management', 'user_project_management'],
security=[
UnsuportedSecurityStub(name="None"),
],
)
def delete_project(
project_id: float, user_id: float = ..., should_delete_clips: Optional[bool] = None
):
"""
Delete a project
"""
raise RuntimeError("Should be patched by MCPProxy and never executed")
@app.get(
'/users/{user_id}/projects/{project_id}',
description=""" This method gets a single project that belongs to the specified user. """,
tags=['project_management', 'user_project_management'],
security=[
UnsuportedSecurityStub(name="None"),
],
)
def get_project(project_id: float, user_id: float = ...):
"""
Get a specific project
"""
raise RuntimeError("Should be patched by MCPProxy and never executed")
@app.patch(
'/users/{user_id}/projects/{project_id}',
description=""" This method edits an existing project. """,
tags=['project_management', 'user_project_management'],
security=[
UnsuportedSecurityStub(name="None"),
],
)
def edit_project(
project_id: float,
user_id: float = ...,
body: UsersUserIdProjectsProjectIdPatchRequest = ...,
):
"""
Edit a project
"""
raise RuntimeError("Should be patched by MCPProxy and never executed")
@app.delete(
'/users/{user_id}/projects/{project_id}/videos',
description=""" This method removed multiple videos from the specified project. """,
tags=['project_management', 'video_management', 'channel_video_management'],
security=[
UnsuportedSecurityStub(name="None"),
],
)
def remove_videos_from_project(
project_id: float,
user_id: float = ...,
should_delete_clips: Optional[bool] = None,
uris: str = ...,
):
"""
Remove a list of videos from a project
"""
raise RuntimeError("Should be patched by MCPProxy and never executed")
@app.get(
'/users/{user_id}/projects/{project_id}/videos',
description=""" This method gets all the videos that belong to the specified project. """,
tags=['project_management', 'video_management', 'user_project_management'],
security=[
UnsuportedSecurityStub(name="None"),
],
)
def get_project_videos(
project_id: float,
user_id: float = ...,
direction: Optional[Direction] = None,
page: Optional[float] = None,
per_page: Optional[float] = None,
sort: Optional[Sort106] = None,
):
"""
Get all the videos in a project
"""
raise RuntimeError("Should be patched by MCPProxy and never executed")
@app.put(
'/users/{user_id}/projects/{project_id}/videos',
description=""" This method adds multiple videos to the specified project. """,
tags=['project_management', 'video_management', 'user_project_management'],
security=[
UnsuportedSecurityStub(name="None"),
],
)
def add_videos_to_project(project_id: float, user_id: float = ..., uris: str = ...):
"""
Add a list of videos to a project
"""
raise RuntimeError("Should be patched by MCPProxy and never executed")
@app.delete(
'/users/{user_id}/projects/{project_id}/videos/{video_id}',
description=""" This method removes a single video from the specified project. """,
tags=['video_management', 'project_management'],
security=[
UnsuportedSecurityStub(name="None"),
],
)
def remove_video_from_project(
project_id: float, user_id: float = ..., video_id: float = ...
):
"""
Remove a specific video from a project
"""
raise RuntimeError("Should be patched by MCPProxy and never executed")
@app.put(
'/users/{user_id}/projects/{project_id}/videos/{video_id}',
description=""" This method adds a single video to the specified project. """,
tags=['project_management', 'video_management'],
security=[
UnsuportedSecurityStub(name="None"),
],
)
def add_video_to_project(
project_id: float, user_id: float = ..., video_id: float = ...
):
"""
Add a specific video to a project
"""
raise RuntimeError("Should be patched by MCPProxy and never executed")
@app.delete(
'/users/{user_id}/uploads/{upload}',
tags=['video_upload_management', 'user_upload_management'],
security=[
UnsuportedSecurityStub(name="None"),
],
)
def complete_streaming_upload(
upload: float,
user_id: float = ...,
signature: str = ...,
video_file_id: float = ...,
):
"""
Complete a user's streaming upload
"""
raise RuntimeError("Should be patched by MCPProxy and never executed")
@app.get(
'/users/{user_id}/uploads/{upload}',
tags=['user_upload_management', 'video_upload_management'],
security=[
UnsuportedSecurityStub(name="None"),
],
)
def get_upload_attempt(upload: float, user_id: float = ...):
"""
Get a user's upload attempt
"""
raise RuntimeError("Should be patched by MCPProxy and never executed")
@app.get(
'/users/{user_id}/videos',
tags=['user_upload_management', 'channel_video_management', 'video_management'],
security=[
UnsuportedSecurityStub(name="None"),
],
)
def get_videos(
user_id: float,
containing_uri: Optional[str] = None,
direction: Optional[Direction] = None,
filter: Optional[Filter66] = None,
filter_embeddable: Optional[bool] = None,
filter_playable: Optional[bool] = None,
page: Optional[float] = None,
per_page: Optional[float] = None,
query: Optional[str] = None,
sort: Optional[Sort108] = None,
):
"""
Get all the videos that a user has uploaded
"""
raise RuntimeError("Should be patched by MCPProxy and never executed")
@app.post(
'/users/{user_id}/videos',
description=""" Begin the video upload process. For more information, see our [upload documentation](https://developer.vimeo.com/api/upload/videos). """,
tags=['video_upload_management', 'user_upload_management', 'video_management'],
security=[
UnsuportedSecurityStub(name="None"),
],
)
def upload_video(user_id: float, body: UsersUserIdVideosPostRequest = ...):
"""
Upload a video
"""
raise RuntimeError("Should be patched by MCPProxy and never executed")
@app.get(
'/users/{user_id}/videos/{video_id}',
tags=['user_video_interaction', 'video_management'],
security=[
UnsuportedSecurityStub(name="None"),
],
)
def check_if_user_owns_video(user_id: float, video_id: float = ...):
"""
Check if a user owns a video
"""
raise RuntimeError("Should be patched by MCPProxy and never executed")
@app.get(
'/users/{user_id}/watchlater',
tags=['watch_later_management', 'user_video_interaction', 'video_management'],
security=[
UnsuportedSecurityStub(name="None"),
],
)
def get_watch_later_queue(
user_id: float,
direction: Optional[Direction] = None,
filter: Optional[Filter68] = None,
filter_embeddable: Optional[bool] = None,
page: Optional[float] = None,
per_page: Optional[float] = None,
query: Optional[str] = None,
sort: Optional[Sort110] = None,
):
"""
Get all the videos in a user's Watch Later queue
"""
raise RuntimeError("Should be patched by MCPProxy and never executed")
@app.delete(
'/users/{user_id}/watchlater/{video_id}',
tags=['watch_later_management', 'user_video_interaction'],
security=[
UnsuportedSecurityStub(name="None"),
],
)
def delete_video_from_watch_later(user_id: float, video_id: float = ...):
"""
Remove a video from a user's Watch Later queue
"""
raise RuntimeError("Should be patched by MCPProxy and never executed")
@app.get(
'/users/{user_id}/watchlater/{video_id}',
tags=['user_activity_management', 'watch_later_management'],
security=[
UnsuportedSecurityStub(name="None"),
],
)
def check_watch_later_queue(user_id: float, video_id: float = ...):
"""
Check if a user has added a specific video to their Watch Later queue
"""
raise RuntimeError("Should be patched by MCPProxy and never executed")
@app.put(
'/users/{user_id}/watchlater/{video_id}',
tags=['watch_later_management', 'user_video_interaction'],
security=[
UnsuportedSecurityStub(name="None"),
],
)
def add_video_to_watch_later(user_id: float, video_id: float = ...):
"""
Add a video to a user's Watch Later queue
"""
raise RuntimeError("Should be patched by MCPProxy and never executed")
@app.get(
'/videos',
tags=[
'video_management',
'video_details_retrieval',
'video_related_content_management',
],
security=[
UnsuportedSecurityStub(name="None"),
],
)
def search_videos(
direction: Optional[Direction] = None,
filter: Optional[Filter70] = None,
links: Optional[str] = None,
page: Optional[float] = None,
per_page: Optional[float] = None,
query: str = ...,
sort: Optional[Sort112] = None,
uris: Optional[str] = None,
):
"""
Search for videos
"""
raise RuntimeError("Should be patched by MCPProxy and never executed")
@app.delete(
'/videos/{video_id}',
tags=['channel_video_management', 'video_management', 'vod_video_management'],
security=[
UnsuportedSecurityStub(name="None"),
],
)
def delete_video(video_id: float):
"""
Delete a video
"""
raise RuntimeError("Should be patched by MCPProxy and never executed")
@app.get(
'/videos/{video_id}',
tags=['video_management', 'video_details_retrieval'],
security=[
UnsuportedSecurityStub(name="None"),
],
)
def get_video(video_id: float):
"""
Get a specific video
"""
raise RuntimeError("Should be patched by MCPProxy and never executed")
@app.patch(
'/videos/{video_id}',
tags=[
'video_management',
'channel_video_management',
'video_customization_management',
],
security=[
UnsuportedSecurityStub(name="None"),
],
)
def edit_video(video_id: float, body: VideosVideoIdPatchRequest = ...):
"""
Edit a video
"""
raise RuntimeError("Should be patched by MCPProxy and never executed")
@app.get(
'/videos/{video_id}/available_channels',
tags=['channel_management', 'channel_video_management', 'video_management'],
security=[
UnsuportedSecurityStub(name="None"),
],
)
def get_available_video_channels(video_id: float):
"""
Get all the channels to which a user can add or remove a specific video
"""
raise RuntimeError("Should be patched by MCPProxy and never executed")
@app.get(
'/videos/{video_id}/categories',
tags=['category_management', 'video_management', 'video_details_retrieval'],
security=[
UnsuportedSecurityStub(name="None"),
],
)
def get_video_categories(video_id: float):
"""
Get all the categories to which a video belongs
"""
raise RuntimeError("Should be patched by MCPProxy and never executed")
@app.put(
'/videos/{video_id}/categories',
description=""" With this method, you can suggest up to two categories and one subcategory for a video. Vimeo makes the final determination about whether the video
belongs in these categories. """,
tags=['category_management', 'channel_category_management', 'video_management'],
security=[
UnsuportedSecurityStub(name="None"),
],
)
def suggest_video_category(
video_id: float, body: VideosVideoIdCategoriesPutRequest = ...
):
"""
Suggest categories for a video
"""
raise RuntimeError("Should be patched by MCPProxy and never executed")
@app.get(
'/videos/{video_id}/comments',
tags=['video_comment_management', 'video_comment_handling'],
security=[
UnsuportedSecurityStub(name="None"),
],
)
def get_comments(
video_id: float,
direction: Optional[Direction] = None,
page: Optional[float] = None,
per_page: Optional[float] = None,
):
"""
Get all the comments on a video
"""
raise RuntimeError("Should be patched by MCPProxy and never executed")
@app.post(
'/videos/{video_id}/comments',
tags=['video_comment_management', 'video_comment_handling'],
security=[
UnsuportedSecurityStub(name="None"),
],
)
def create_comment(video_id: float, body: VideosVideoIdCommentsPostRequest = ...):
"""
Add a comment to a video
"""
raise RuntimeError("Should be patched by MCPProxy and never executed")
@app.delete(
'/videos/{video_id}/comments/{comment_id}',
tags=['video_comment_management', 'video_comment_handling'],
security=[
UnsuportedSecurityStub(name="None"),
],
)
def delete_comment(comment_id: float, video_id: float = ...):
"""
Delete a video comment
"""
raise RuntimeError("Should be patched by MCPProxy and never executed")
@app.get(
'/videos/{video_id}/comments/{comment_id}',
tags=['video_comment_management', 'video_comment_handling'],
security=[
UnsuportedSecurityStub(name="None"),
],
)
def get_comment(comment_id: float, video_id: float = ...):
"""
Get a specific video comment
"""
raise RuntimeError("Should be patched by MCPProxy and never executed")
@app.patch(
'/videos/{video_id}/comments/{comment_id}',
tags=['video_comment_management', 'video_comment_handling'],
security=[
UnsuportedSecurityStub(name="None"),
],
)
def edit_comment(
comment_id: float,
video_id: float = ...,
body: VideosVideoIdCommentsCommentIdPatchRequest = ...,
):
"""
Edit a video comment
"""
raise RuntimeError("Should be patched by MCPProxy and never executed")
@app.get(
'/videos/{video_id}/comments/{comment_id}/replies',
tags=['video_comment_management', 'video_comment_handling'],
security=[
UnsuportedSecurityStub(name="None"),
],
)
def get_comment_replies(
comment_id: float,
video_id: float = ...,
page: Optional[float] = None,
per_page: Optional[float] = None,
):
"""
Get all the replies to a video comment
"""
raise RuntimeError("Should be patched by MCPProxy and never executed")
@app.post(
'/videos/{video_id}/comments/{comment_id}/replies',
tags=['video_comment_management', 'video_comment_handling'],
security=[
UnsuportedSecurityStub(name="None"),
],
)
def create_comment_reply(
comment_id: float,
video_id: float = ...,
body: VideosVideoIdCommentsCommentIdRepliesPostRequest = ...,
):
"""
Add a reply to a video comment
"""
raise RuntimeError("Should be patched by MCPProxy and never executed")
@app.get(
'/videos/{video_id}/credits',
tags=['video_credit_management', 'video_management'],
security=[
UnsuportedSecurityStub(name="None"),
],
)
def get_video_credits(
video_id: float,
direction: Optional[Direction] = None,
page: Optional[float] = None,
per_page: Optional[float] = None,
query: Optional[str] = None,
sort: Optional[Sort114] = None,
):
"""
Get all the credited users in a video
"""
raise RuntimeError("Should be patched by MCPProxy and never executed")
@app.post(
'/videos/{video_id}/credits',
tags=['video_credit_management'],
security=[
UnsuportedSecurityStub(name="None"),
],
)
def add_video_credit(video_id: float, body: VideosVideoIdCreditsPostRequest = ...):
"""
Credit a user in a video
"""
raise RuntimeError("Should be patched by MCPProxy and never executed")
@app.delete(
'/videos/{video_id}/credits/{credit_id}',
tags=['video_credit_management', 'channel_video_management'],
security=[
UnsuportedSecurityStub(name="None"),
],
)
def delete_video_credit(credit_id: float, video_id: float = ...):
"""
Delete a credit for a user in a video
"""
raise RuntimeError("Should be patched by MCPProxy and never executed")
@app.get(
'/videos/{video_id}/credits/{credit_id}',
tags=['video_credit_management'],
security=[
UnsuportedSecurityStub(name="None"),
],
)
def get_video_credit(credit_id: float, video_id: float = ...):
"""
Get a specific credited user in a video
"""
raise RuntimeError("Should be patched by MCPProxy and never executed")
@app.patch(
'/videos/{video_id}/credits/{credit_id}',
tags=['video_credit_management', 'channel_video_management', 'video_management'],
security=[
UnsuportedSecurityStub(name="None"),
],
)
def edit_video_credit(
credit_id: float,
video_id: float = ...,
body: VideosVideoIdCreditsCreditIdPatchRequest = None,
):
"""
Edit a credit for a user in a video
"""
raise RuntimeError("Should be patched by MCPProxy and never executed")
@app.get(
'/videos/{video_id}/likes',
tags=['user_video_like_management', 'user_video_interaction', 'video_management'],
security=[
UnsuportedSecurityStub(name="None"),
],
)
def get_video_likes(
video_id: float,
direction: Optional[Direction] = None,
page: Optional[float] = None,
per_page: Optional[float] = None,
sort: Optional[Sort114] = None,
):
"""
Get all the users who have liked a video
"""
raise RuntimeError("Should be patched by MCPProxy and never executed")
@app.get(
'/videos/{video_id}/pictures',
tags=['video_thumbnail_management', 'video_management'],
security=[
UnsuportedSecurityStub(name="None"),
],
)
def get_video_thumbnails(
video_id: float, page: Optional[float] = None, per_page: Optional[float] = None
):
"""
Get all the thumbnails of a video
"""
raise RuntimeError("Should be patched by MCPProxy and never executed")
@app.post(
'/videos/{video_id}/pictures',
tags=['video_thumbnail_management', 'video_management'],
security=[
UnsuportedSecurityStub(name="None"),
],
)
def create_video_thumbnail(
video_id: float, body: VideosVideoIdPicturesPostRequest = None
):
"""
Add a video thumbnail
"""
raise RuntimeError("Should be patched by MCPProxy and never executed")
@app.delete(
'/videos/{video_id}/pictures/{picture_id}',
tags=['video_thumbnail_management', 'video_management'],
security=[
UnsuportedSecurityStub(name="None"),
],
)
def delete_video_thumbnail(picture_id: float, video_id: float = ...):
"""
Delete a video thumbnail
"""
raise RuntimeError("Should be patched by MCPProxy and never executed")
@app.get(
'/videos/{video_id}/pictures/{picture_id}',
tags=['video_thumbnail_management'],
security=[
UnsuportedSecurityStub(name="None"),
],
)
def get_video_thumbnail(picture_id: float, video_id: float = ...):
"""
Get a video thumbnail
"""
raise RuntimeError("Should be patched by MCPProxy and never executed")
@app.patch(
'/videos/{video_id}/pictures/{picture_id}',
tags=['video_thumbnail_management', 'video_management'],
security=[
UnsuportedSecurityStub(name="None"),
],
)
def edit_video_thumbnail(
picture_id: float,
video_id: float = ...,
body: VideosVideoIdPicturesPictureIdPatchRequest = None,
):
"""
Edit a video thumbnail
"""
raise RuntimeError("Should be patched by MCPProxy and never executed")
@app.delete(
'/videos/{video_id}/presets/{preset_id}',
tags=['user_embed_presets_management', 'video_embed_presets_management'],
security=[
UnsuportedSecurityStub(name="None"),
],
)
def delete_video_embed_preset(preset_id: float, video_id: float = ...):
"""
Remove an embed preset from a video
"""
raise RuntimeError("Should be patched by MCPProxy and never executed")
@app.get(
'/videos/{video_id}/presets/{preset_id}',
tags=[
'video_embed_presets_management',
'user_embed_presets_management',
'video_management',
],
security=[
UnsuportedSecurityStub(name="None"),
],
)
def get_video_embed_preset(preset_id: float, video_id: float = ...):
"""
Check if an embed preset has been added to a video
"""
raise RuntimeError("Should be patched by MCPProxy and never executed")
@app.put(
'/videos/{video_id}/presets/{preset_id}',
tags=['user_embed_presets_management', 'video_embed_presets_management'],
security=[
UnsuportedSecurityStub(name="None"),
],
)
def add_video_embed_preset(preset_id: float, video_id: float = ...):
"""
Add an embed preset to a video
"""
raise RuntimeError("Should be patched by MCPProxy and never executed")
@app.get(
'/videos/{video_id}/privacy/domains',
tags=['video_management', 'video_embed_presets_management'],
security=[
UnsuportedSecurityStub(name="None"),
],
)
def get_video_privacy_domains(
video_id: float, page: Optional[float] = None, per_page: Optional[float] = None
):
"""
Get all the domains on which a video can be embedded
"""
raise RuntimeError("Should be patched by MCPProxy and never executed")
@app.delete(
'/videos/{video_id}/privacy/domains/{domain}',
tags=[
'video_privacy_management',
'video_management',
'video_embed_presets_management',
],
security=[
UnsuportedSecurityStub(name="None"),
],
)
def delete_video_privacy_domain(domain: str, video_id: float = ...):
"""
Restrict a video from being embedded on a domain
"""
raise RuntimeError("Should be patched by MCPProxy and never executed")
@app.put(
'/videos/{video_id}/privacy/domains/{domain}',
description=""" If domain privacy is enabled for this video, this method permits the video to be embedded on the specified domain. """,
tags=['video_embed_presets_management', 'video_management'],
security=[
UnsuportedSecurityStub(name="None"),
],
)
def add_video_privacy_domain(domain: str, video_id: float = ...):
"""
Permit a video to be embedded on a domain
"""
raise RuntimeError("Should be patched by MCPProxy and never executed")
@app.get(
'/videos/{video_id}/privacy/users',
tags=[
'video_privacy_management',
'user_subscription_management',
'user_video_interaction',
],
security=[
UnsuportedSecurityStub(name="None"),
],
)
def get_video_privacy_users(
video_id: float, page: Optional[float] = None, per_page: Optional[float] = None
):
"""
Get all the users who can view a user's private videos by default
"""
raise RuntimeError("Should be patched by MCPProxy and never executed")
@app.put(
'/videos/{video_id}/privacy/users',
description=""" The body of this request should follow our
[batch request format](https://developer.vimeo.com/api/common-formats#batch-requests). Each object must contain
a single `URI` field, and the value of this field must be the URI of the user who can view this video. """,
tags=['video_privacy_management', 'video_management'],
security=[
UnsuportedSecurityStub(name="None"),
],
)
def add_video_privacy_users(video_id: float):
"""
Permit a list of users to view a private video
"""
raise RuntimeError("Should be patched by MCPProxy and never executed")
@app.delete(
'/videos/{video_id}/privacy/users/{user_id}',
tags=['video_privacy_management', 'video_management'],
security=[
UnsuportedSecurityStub(name="None"),
],
)
def delete_video_privacy_user(user_id: float, video_id: float = ...):
"""
Restrict a user from viewing a private video
"""
raise RuntimeError("Should be patched by MCPProxy and never executed")
@app.put(
'/videos/{video_id}/privacy/users/{user_id}',
tags=['video_privacy_management', 'user_video_interaction'],
security=[
UnsuportedSecurityStub(name="None"),
],
)
def add_video_privacy_user(user_id: float, video_id: float = ...):
"""
Permit a specific user to view a private video
"""
raise RuntimeError("Should be patched by MCPProxy and never executed")
@app.get(
'/videos/{video_id}/tags',
tags=['video_tag_management', 'video_details_retrieval'],
security=[
UnsuportedSecurityStub(name="None"),
],
)
def get_video_tags(video_id: float):
"""
Get all the tags of a video
"""
raise RuntimeError("Should be patched by MCPProxy and never executed")
@app.put(
'/videos/{video_id}/tags',
tags=['video_tag_management', 'channel_video_management'],
security=[
UnsuportedSecurityStub(name="None"),
],
)
def add_video_tags(video_id: float, body: VideosVideoIdTagsPutRequest = ...):
"""
Add a list of tags to a video
"""
raise RuntimeError("Should be patched by MCPProxy and never executed")
@app.delete(
'/videos/{video_id}/tags/{word}',
tags=['video_tag_management', 'channel_video_management'],
security=[
UnsuportedSecurityStub(name="None"),
],
)
def delete_video_tag(video_id: float, word: str = ...):
"""
Remove a tag from a video
"""
raise RuntimeError("Should be patched by MCPProxy and never executed")
@app.get(
'/videos/{video_id}/tags/{word}',
tags=['video_tag_management', 'video_management'],
security=[
UnsuportedSecurityStub(name="None"),
],
)
def check_video_for_tag(video_id: float, word: str = ...):
"""
Check if a tag has been added to a video
"""
raise RuntimeError("Should be patched by MCPProxy and never executed")
@app.put(
'/videos/{video_id}/tags/{word}',
tags=['video_tag_management', 'channel_video_management'],
security=[
UnsuportedSecurityStub(name="None"),
],
)
def add_video_tag(video_id: float, word: str = ...):
"""
Add a specific tag to a video
"""
raise RuntimeError("Should be patched by MCPProxy and never executed")
@app.get(
'/videos/{video_id}/texttracks',
tags=['video_text_track_management', 'video_management', 'video_details_retrieval'],
security=[
UnsuportedSecurityStub(name="None"),
],
)
def get_text_tracks(video_id: float):
"""
Get all the text tracks of a video
"""
raise RuntimeError("Should be patched by MCPProxy and never executed")
@app.post(
'/videos/{video_id}/texttracks',
description=""" For additional information, see our [text track upload guide](https://developer.vimeo.com/api/upload/texttracks). """,
tags=['video_text_track_management', 'channel_video_management'],
security=[
UnsuportedSecurityStub(name="None"),
],
)
def create_text_track(video_id: float, body: VideosVideoIdTexttracksPostRequest = ...):
"""
Add a text track to a video
"""
raise RuntimeError("Should be patched by MCPProxy and never executed")
@app.delete(
'/videos/{video_id}/texttracks/{texttrack_id}',
tags=['video_text_track_management'],
security=[
UnsuportedSecurityStub(name="None"),
],
)
def delete_text_track(texttrack_id: float, video_id: float = ...):
"""
Delete a text track
"""
raise RuntimeError("Should be patched by MCPProxy and never executed")
@app.get(
'/videos/{video_id}/texttracks/{texttrack_id}',
tags=['video_text_track_management'],
security=[
UnsuportedSecurityStub(name="None"),
],
)
def get_text_track(texttrack_id: float, video_id: float = ...):
"""
Get a specific text track
"""
raise RuntimeError("Should be patched by MCPProxy and never executed")
@app.patch(
'/videos/{video_id}/texttracks/{texttrack_id}',
tags=['video_text_track_management'],
security=[
UnsuportedSecurityStub(name="None"),
],
)
def edit_text_track(
texttrack_id: float,
video_id: float = ...,
body: VideosVideoIdTexttracksTexttrackIdPatchRequest = None,
):
"""
Edit a text track
"""
raise RuntimeError("Should be patched by MCPProxy and never executed")
@app.post(
'/videos/{video_id}/timelinethumbnails',
tags=['video_customization_management', 'custom_logo_management'],
security=[
UnsuportedSecurityStub(name="None"),
],
)
def create_video_custom_logo(video_id: float):
"""
Add a new custom logo to a video
"""
raise RuntimeError("Should be patched by MCPProxy and never executed")
@app.get(
'/videos/{video_id}/timelinethumbnails/{thumbnail_id}',
tags=['custom_logo_management', 'video_customization_management'],
security=[
UnsuportedSecurityStub(name="None"),
],
)
def get_video_custom_logo(thumbnail_id: float, video_id: float = ...):
"""
Get a custom video logo
"""
raise RuntimeError("Should be patched by MCPProxy and never executed")
@app.post(
'/videos/{video_id}/versions',
tags=['video_management', 'video_version_management'],
security=[
UnsuportedSecurityStub(name="None"),
],
)
def create_video_version(video_id: float, body: VideosVideoIdVersionsPostRequest = ...):
"""
Add a version to a video
"""
raise RuntimeError("Should be patched by MCPProxy and never executed")
@app.get(
'/videos/{video_id}/videos',
tags=['video_related_content_management', 'video_management'],
security=[
UnsuportedSecurityStub(name="None"),
],
)
def get_related_videos(
video_id: float,
filter: Optional[Filter72] = None,
page: Optional[float] = None,
per_page: Optional[float] = None,
):
"""
Get all the related videos of a video
"""
raise RuntimeError("Should be patched by MCPProxy and never executed")
if __name__ == "__main__":
parser = argparse.ArgumentParser(description="MCP Server")
parser.add_argument(
"transport",
choices=["stdio", "sse", "streamable-http"],
help="Transport mode (stdio, sse or streamable-http)",
)
args = parser.parse_args()
if "CONFIG_PATH" in os.environ:
config_path = os.environ["CONFIG_PATH"]
app.load_configuration(config_path)
if "CONFIG" in os.environ:
config = os.environ["CONFIG"]
app.load_configuration_from_string(config)
if "SECURITY" in os.environ:
security_params = BaseSecurity.parse_security_parameters_from_env(
os.environ,
)
app.set_security_params(security_params)
mcp_settings = json.loads(os.environ.get("MCP_SETTINGS", "{}"))
app.get_mcp(**mcp_settings).run(transport=args.transport)