/* tslint:disable */
/* eslint-disable */
/**
 * ELEMENTS API
 * No description provided (generated by Openapi Generator https://github.com/openapitools/openapi-generator)
 *
 * The version of the OpenAPI document: 2
 * 
 *
 * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).
 * https://openapi-generator.tech
 * Do not edit the class manually.
 */


import * as runtime from '../runtime';
import {
    AllMediaFilesForBundlesRequest,
    AllMediaFilesForBundlesRequestFromJSON,
    AllMediaFilesForBundlesRequestToJSON,
    Asset,
    AssetFromJSON,
    AssetToJSON,
    AssetBackup,
    AssetBackupFromJSON,
    AssetBackupToJSON,
    AssetCloudLink,
    AssetCloudLinkFromJSON,
    AssetCloudLinkToJSON,
    AssetPartialUpdate,
    AssetPartialUpdateFromJSON,
    AssetPartialUpdateToJSON,
    AssetProjectLink,
    AssetProjectLinkFromJSON,
    AssetProjectLinkToJSON,
    AssetRating,
    AssetRatingFromJSON,
    AssetRatingToJSON,
    AssetRatingPartialUpdate,
    AssetRatingPartialUpdateFromJSON,
    AssetRatingPartialUpdateToJSON,
    AssetRatingUpdate,
    AssetRatingUpdateFromJSON,
    AssetRatingUpdateToJSON,
    AssetSubtitleLink,
    AssetSubtitleLinkFromJSON,
    AssetSubtitleLinkToJSON,
    AssetSubtitleLinkPartialUpdate,
    AssetSubtitleLinkPartialUpdateFromJSON,
    AssetSubtitleLinkPartialUpdateToJSON,
    AssetSubtitleLinkUpdate,
    AssetSubtitleLinkUpdateFromJSON,
    AssetSubtitleLinkUpdateToJSON,
    AssetUpdate,
    AssetUpdateFromJSON,
    AssetUpdateToJSON,
    Comment,
    CommentFromJSON,
    CommentToJSON,
    CommentPartialUpdate,
    CommentPartialUpdateFromJSON,
    CommentPartialUpdateToJSON,
    CommentUpdate,
    CommentUpdateFromJSON,
    CommentUpdateToJSON,
    CustomField,
    CustomFieldFromJSON,
    CustomFieldToJSON,
    CustomFieldPartialUpdate,
    CustomFieldPartialUpdateFromJSON,
    CustomFieldPartialUpdateToJSON,
    CustomFieldUpdate,
    CustomFieldUpdateFromJSON,
    CustomFieldUpdateToJSON,
    EditorProject,
    EditorProjectFromJSON,
    EditorProjectToJSON,
    EditorProjectPartialUpdate,
    EditorProjectPartialUpdateFromJSON,
    EditorProjectPartialUpdateToJSON,
    EditorProjectUpdate,
    EditorProjectUpdateFromJSON,
    EditorProjectUpdateToJSON,
    EditorSubtitle,
    EditorSubtitleFromJSON,
    EditorSubtitleToJSON,
    EditorSubtitlePartialUpdate,
    EditorSubtitlePartialUpdateFromJSON,
    EditorSubtitlePartialUpdateToJSON,
    EditorSubtitleUpdate,
    EditorSubtitleUpdateFromJSON,
    EditorSubtitleUpdateToJSON,
    ExternalTranscoder,
    ExternalTranscoderFromJSON,
    ExternalTranscoderToJSON,
    ExternalTranscoderPartialUpdate,
    ExternalTranscoderPartialUpdateFromJSON,
    ExternalTranscoderPartialUpdateToJSON,
    ExternalTranscoderUpdate,
    ExternalTranscoderUpdateFromJSON,
    ExternalTranscoderUpdateToJSON,
    ExtractRequest,
    ExtractRequestFromJSON,
    ExtractRequestToJSON,
    GenerateProxiesRequest,
    GenerateProxiesRequestFromJSON,
    GenerateProxiesRequestToJSON,
    GetMultipleBundlesRequest,
    GetMultipleBundlesRequestFromJSON,
    GetMultipleBundlesRequestToJSON,
    GetMultipleFilesRequest,
    GetMultipleFilesRequestFromJSON,
    GetMultipleFilesRequestToJSON,
    InstantiateFileTemplateRequest,
    InstantiateFileTemplateRequestFromJSON,
    InstantiateFileTemplateRequestToJSON,
    LocateResult,
    LocateResultFromJSON,
    LocateResultToJSON,
    Marker,
    MarkerFromJSON,
    MarkerToJSON,
    MarkerPartialUpdate,
    MarkerPartialUpdateFromJSON,
    MarkerPartialUpdateToJSON,
    MarkerUpdate,
    MarkerUpdateFromJSON,
    MarkerUpdateToJSON,
    MediaFile,
    MediaFileFromJSON,
    MediaFileToJSON,
    MediaFileBundle,
    MediaFileBundleFromJSON,
    MediaFileBundleToJSON,
    MediaFileContents,
    MediaFileContentsFromJSON,
    MediaFileContentsToJSON,
    MediaFilePartialUpdate,
    MediaFilePartialUpdateFromJSON,
    MediaFilePartialUpdateToJSON,
    MediaFileTemplate,
    MediaFileTemplateFromJSON,
    MediaFileTemplateToJSON,
    MediaFileTemplatePartialUpdate,
    MediaFileTemplatePartialUpdateFromJSON,
    MediaFileTemplatePartialUpdateToJSON,
    MediaFileTemplateUpdate,
    MediaFileTemplateUpdateFromJSON,
    MediaFileTemplateUpdateToJSON,
    MediaFileUpdate,
    MediaFileUpdateFromJSON,
    MediaFileUpdateToJSON,
    MediaFilesLookupRequest,
    MediaFilesLookupRequestFromJSON,
    MediaFilesLookupRequestToJSON,
    MediaLibraryDeleteRequest,
    MediaLibraryDeleteRequestFromJSON,
    MediaLibraryDeleteRequestToJSON,
    MediaLibraryShareRequest,
    MediaLibraryShareRequestFromJSON,
    MediaLibraryShareRequestToJSON,
    MediaRoot,
    MediaRootFromJSON,
    MediaRootToJSON,
    MediaRootDetail,
    MediaRootDetailFromJSON,
    MediaRootDetailToJSON,
    MediaRootDetailPartialUpdate,
    MediaRootDetailPartialUpdateFromJSON,
    MediaRootDetailPartialUpdateToJSON,
    MediaRootDetailUpdate,
    MediaRootDetailUpdateFromJSON,
    MediaRootDetailUpdateToJSON,
    MediaRootPermission,
    MediaRootPermissionFromJSON,
    MediaRootPermissionToJSON,
    MediaRootPermissionPartialUpdate,
    MediaRootPermissionPartialUpdateFromJSON,
    MediaRootPermissionPartialUpdateToJSON,
    MediaRootPermissionUpdate,
    MediaRootPermissionUpdateFromJSON,
    MediaRootPermissionUpdateToJSON,
    MediaUpdate,
    MediaUpdateFromJSON,
    MediaUpdateToJSON,
    MultipleAssetsRequest,
    MultipleAssetsRequestFromJSON,
    MultipleAssetsRequestToJSON,
    OneTimeAccessToken,
    OneTimeAccessTokenFromJSON,
    OneTimeAccessTokenToJSON,
    Proxy,
    ProxyFromJSON,
    ProxyToJSON,
    ProxyCount,
    ProxyCountFromJSON,
    ProxyCountToJSON,
    ProxyGenerator,
    ProxyGeneratorFromJSON,
    ProxyGeneratorToJSON,
    ProxyProfile,
    ProxyProfileFromJSON,
    ProxyProfileToJSON,
    ProxyProfilePartialUpdate,
    ProxyProfilePartialUpdateFromJSON,
    ProxyProfilePartialUpdateToJSON,
    ProxyProfileUpdate,
    ProxyProfileUpdateFromJSON,
    ProxyProfileUpdateToJSON,
    RenameCustomFieldRequest,
    RenameCustomFieldRequestFromJSON,
    RenameCustomFieldRequestToJSON,
    RenderEndpointRequest,
    RenderEndpointRequestFromJSON,
    RenderEndpointRequestToJSON,
    RenderRequest,
    RenderRequestFromJSON,
    RenderRequestToJSON,
    SavedSearch,
    SavedSearchFromJSON,
    SavedSearchToJSON,
    SavedSearchPartialUpdate,
    SavedSearchPartialUpdateFromJSON,
    SavedSearchPartialUpdateToJSON,
    SavedSearchUpdate,
    SavedSearchUpdateFromJSON,
    SavedSearchUpdateToJSON,
    ScannerDiscoverEndpointRequest,
    ScannerDiscoverEndpointRequestFromJSON,
    ScannerDiscoverEndpointRequestToJSON,
    ScannerScanEndpointRequest,
    ScannerScanEndpointRequestFromJSON,
    ScannerScanEndpointRequestToJSON,
    Subclip,
    SubclipFromJSON,
    SubclipToJSON,
    SubclipClipboardEntry,
    SubclipClipboardEntryFromJSON,
    SubclipClipboardEntryToJSON,
    SubclipClipboardEntryUpdate,
    SubclipClipboardEntryUpdateFromJSON,
    SubclipClipboardEntryUpdateToJSON,
    SubclipPartialUpdate,
    SubclipPartialUpdateFromJSON,
    SubclipPartialUpdateToJSON,
    SubclipUpdate,
    SubclipUpdateFromJSON,
    SubclipUpdateToJSON,
    SubtitleClipboardEntry,
    SubtitleClipboardEntryFromJSON,
    SubtitleClipboardEntryToJSON,
    SubtitleClipboardEntryUpdate,
    SubtitleClipboardEntryUpdateFromJSON,
    SubtitleClipboardEntryUpdateToJSON,
    TagMediaDirectoryRequest,
    TagMediaDirectoryRequestFromJSON,
    TagMediaDirectoryRequestToJSON,
    TaskInfo,
    TaskInfoFromJSON,
    TaskInfoToJSON,
    TestExternalTranscoderConnectionRequest,
    TestExternalTranscoderConnectionRequestFromJSON,
    TestExternalTranscoderConnectionRequestToJSON,
    TestExternalTranscoderConnectionResponse,
    TestExternalTranscoderConnectionResponseFromJSON,
    TestExternalTranscoderConnectionResponseToJSON,
    TimelineExportRequest,
    TimelineExportRequestFromJSON,
    TimelineExportRequestToJSON,
    TranscoderProfile,
    TranscoderProfileFromJSON,
    TranscoderProfileToJSON,
    UnfilteredTag,
    UnfilteredTagFromJSON,
    UnfilteredTagToJSON,
    UnfilteredTagPartialUpdate,
    UnfilteredTagPartialUpdateFromJSON,
    UnfilteredTagPartialUpdateToJSON,
    UnfilteredTagUpdate,
    UnfilteredTagUpdateFromJSON,
    UnfilteredTagUpdateToJSON,
    VantageWorkflows,
    VantageWorkflowsFromJSON,
    VantageWorkflowsToJSON,
    WorkflowTransitionRequest,
    WorkflowTransitionRequestFromJSON,
    WorkflowTransitionRequestToJSON,
    WorkflowTransitionResponse,
    WorkflowTransitionResponseFromJSON,
    WorkflowTransitionResponseToJSON,
} from '../models';

export interface BookmarkMediaDirectoryRequest {
    id: number;
}

export interface CombineAssetsIntoSetRequest {
    multipleAssetsRequest: MultipleAssetsRequest;
}

export interface CreateAssetRequest {
    assetUpdate: AssetUpdate;
}

export interface CreateAssetRatingRequest {
    assetRatingUpdate: AssetRatingUpdate;
    root?: number;
}

export interface CreateAssetSubtitleLinkRequest {
    assetSubtitleLinkUpdate: AssetSubtitleLinkUpdate;
}

export interface CreateCommentRequest {
    commentUpdate: CommentUpdate;
    root?: number;
    bundle?: number;
}

export interface CreateCustomFieldRequest {
    customFieldUpdate: CustomFieldUpdate;
}

export interface CreateEditorProjectRequest {
    editorProjectUpdate: EditorProjectUpdate;
}

export interface CreateEditorSubtitleRequest {
    editorSubtitleUpdate: EditorSubtitleUpdate;
}

export interface CreateExternalTranscoderRequest {
    externalTranscoderUpdate: ExternalTranscoderUpdate;
}

export interface CreateMarkerRequest {
    markerUpdate: MarkerUpdate;
}

export interface CreateMediaFileTemplateRequest {
    mediaFileTemplateUpdate: MediaFileTemplateUpdate;
}

export interface CreateMediaRootRequest {
    mediaRootDetailUpdate: MediaRootDetailUpdate;
}

export interface CreateMediaRootPermissionRequest {
    mediaRootPermissionUpdate: MediaRootPermissionUpdate;
}

export interface CreateMediaTagRequest {
    unfilteredTagUpdate: UnfilteredTagUpdate;
}

export interface CreateProxyProfileRequest {
    proxyProfileUpdate: ProxyProfileUpdate;
}

export interface CreateSavedSearchRequest {
    savedSearchUpdate: SavedSearchUpdate;
}

export interface CreateSubclipRequest {
    subclipUpdate: SubclipUpdate;
}

export interface CreateSubclipClipboardEntryRequest {
    subclipClipboardEntryUpdate: SubclipClipboardEntryUpdate;
}

export interface CreateSubtitleClipboardEntryRequest {
    subtitleClipboardEntryUpdate: SubtitleClipboardEntryUpdate;
}

export interface DeleteAssetRequest {
    id: number;
}

export interface DeleteAssetRatingRequest {
    id: number;
    root?: number;
}

export interface DeleteAssetSubtitleLinkRequest {
    id: number;
}

export interface DeleteCommentRequest {
    id: number;
}

export interface DeleteCustomFieldRequest {
    id: number;
}

export interface DeleteEasySharingTokenForBundleRequest {
    id: number;
}

export interface DeleteEasySharingTokenForDirectoryRequest {
    id: number;
}

export interface DeleteExternalTranscoderRequest {
    id: number;
}

export interface DeleteMarkerRequest {
    id: number;
}

export interface DeleteMediaFileTemplateRequest {
    id: number;
}

export interface DeleteMediaLibraryObjectsRequest {
    mediaLibraryDeleteRequest: MediaLibraryDeleteRequest;
}

export interface DeleteMediaRootRequest {
    id: number;
}

export interface DeleteMediaRootPermissionRequest {
    id: number;
}

export interface DeleteMediaTagRequest {
    id: number;
}

export interface DeleteMediaUpdateRequest {
    id: number;
}

export interface DeleteProxyRequest {
    id: number;
}

export interface DeleteProxyProfileRequest {
    id: number;
}

export interface DeleteSavedSearchRequest {
    id: number;
}

export interface DeleteSubclipRequest {
    id: number;
}

export interface DeleteSubclipClipboardEntryRequest {
    id: number;
}

export interface DeleteSubtitleClipboardEntryRequest {
    id: number;
}

export interface DiscoverMediaRequest {
    scannerDiscoverEndpointRequest: ScannerDiscoverEndpointRequest;
}

export interface DownloadAssetProxyFileRequest {
    filename: string;
    id: number;
}

export interface DownloadMediaFileRequest {
    id: number;
}

export interface DownloadProxyRequest {
    id: number;
}

export interface EditorExportXMLForAsssetRequest {
    assetIds: string;
    ordering?: string;
    limit?: number;
    offset?: number;
}

export interface EditorExportXMLForBundleRequest {
    bundleIds: string;
    ordering?: string;
    limit?: number;
    offset?: number;
}

export interface EditorExportXMLForProjectRequest {
    id: number;
}

export interface ExportCommentsForAvidRequest {
    assetId: string;
    exportFormat: string;
    ordering?: string;
    limit?: number;
    offset?: number;
}

export interface ExportEditorTimelineRequest {
    timelineExportRequest: TimelineExportRequest;
}

export interface ExtractStreamRequest {
    id: number;
    extractRequest: ExtractRequest;
}

export interface ForgetDeletedMediaFilesRequest {
    id: number;
}

export interface GenerateProxiesOperationRequest {
    generateProxiesRequest: GenerateProxiesRequest;
}

export interface GetAllAssetProjectLinksRequest {
    asset?: number;
    project?: number;
    ordering?: string;
    limit?: number;
    offset?: number;
}

export interface GetAllAssetRatingsRequest {
    user?: number;
    asset?: number;
    ordering?: string;
    limit?: number;
    offset?: number;
}

export interface GetAllAssetSubtitleLinksRequest {
    asset?: number;
    subtitle?: number;
    ordering?: string;
    limit?: number;
    offset?: number;
}

export interface GetAllAssetTapeBackupsRequest {
    asset?: number;
    ordering?: string;
    limit?: number;
    offset?: number;
    includeAsset?: boolean;
    advancedSearch?: string;
}

export interface GetAllAssetsRequest {
    syncId?: string;
    displayName?: string;
    set?: number;
    ordering?: string;
    limit?: number;
    offset?: number;
    includeProxies?: boolean;
    includeModifiedBy?: boolean;
    resolveAssetPermission?: boolean;
    forRoot?: number;
}

export interface GetAllBundlesForMediaRootRequest {
    root: string;
    asset?: number;
    location?: number;
    sharedViaTokens?: string;
    sharedViaTokensToken?: string;
    name?: string;
    ordering?: string;
    limit?: number;
    offset?: number;
}

export interface GetAllBundlesInSubtreeRequest {
    file: string;
    asset?: number;
    location?: number;
    sharedViaTokens?: string;
    sharedViaTokensToken?: string;
    name?: string;
    ordering?: string;
    limit?: number;
    offset?: number;
}

export interface GetAllClickLinksRequest {
    asset?: number;
    connection?: number;
    ordering?: string;
    limit?: number;
    offset?: number;
}

export interface GetAllCommentsRequest {
    asset?: number;
    root?: number;
    user?: number;
    ordering?: string;
    limit?: number;
    offset?: number;
    forRoot?: number;
    tasksForUser?: number;
    includeFullAsset?: boolean;
    advancedSearch?: string;
}

export interface GetAllCustomFieldsRequest {
    ordering?: string;
    limit?: number;
    offset?: number;
}

export interface GetAllExternalTranscodersRequest {
    name?: string;
    id?: number;
    ordering?: string;
    limit?: number;
    offset?: number;
}

export interface GetAllMarkersRequest {
    asset?: number;
    user?: number;
    ordering?: string;
    limit?: number;
    offset?: number;
}

export interface GetAllMediaFileBundlesRequest {
    asset?: number;
    location?: number;
    sharedViaTokens?: string;
    sharedViaTokensToken?: string;
    name?: string;
    ordering?: string;
    limit?: number;
    offset?: number;
    excludeDeleted?: boolean;
    excludeUnrecognized?: boolean;
    includeProxies?: boolean;
    includeParents?: boolean;
    advancedSearch?: string;
}

export interface GetAllMediaFileTemplatesRequest {
    ordering?: string;
    limit?: number;
    offset?: number;
}

export interface GetAllMediaFilesRequest {
    bundle?: number;
    bundleIn?: string;
    parent?: number;
    path?: string;
    name?: string;
    isDir?: string;
    isShowroom?: string;
    present?: string;
    volume?: number;
    sharedViaTokens?: string;
    sharedViaTokensToken?: string;
    ordering?: string;
    limit?: number;
    offset?: number;
    resolveFilePermission?: boolean;
    includeModifiedBy?: boolean;
    includeEffectiveCustomFields?: boolean;
    includeRoot?: boolean;
    includeParents?: boolean;
    advancedSearch?: string;
}

export interface GetAllMediaFilesForBundlesRequest {
    allMediaFilesForBundlesRequest: AllMediaFilesForBundlesRequest;
}

export interface GetAllMediaFilesForMediaRootRequest {
    root: string;
    bundle?: number;
    bundleIn?: string;
    parent?: number;
    path?: string;
    name?: string;
    isDir?: string;
    isShowroom?: string;
    present?: string;
    volume?: number;
    sharedViaTokens?: string;
    sharedViaTokensToken?: string;
    ordering?: string;
    limit?: number;
    offset?: number;
}

export interface GetAllMediaFilesInSubtreeRequest {
    file: string;
    bundle?: number;
    bundleIn?: string;
    parent?: number;
    path?: string;
    name?: string;
    isDir?: string;
    isShowroom?: string;
    present?: string;
    volume?: number;
    sharedViaTokens?: string;
    sharedViaTokensToken?: string;
    ordering?: string;
    limit?: number;
    offset?: number;
}

export interface GetAllMediaRootPermissionsRequest {
    root?: number;
    id?: number;
    ordering?: string;
    limit?: number;
    offset?: number;
}

export interface GetAllMediaRootsRequest {
    path?: string;
    volume?: number;
    name?: string;
    ordering?: string;
    limit?: number;
    offset?: number;
    resolvePermissions?: boolean;
}

export interface GetAllMediaTagsRequest {
    name?: string;
    nameIcontains?: string;
    roots?: string;
    rootsIsnull?: string;
    shared?: string;
    ordering?: string;
    limit?: number;
    offset?: number;
    forRoot?: number;
}

export interface GetAllMediaUpdatesRequest {
    asset?: number;
    user?: number;
    root?: number;
    ordering?: string;
    limit?: number;
    offset?: number;
}

export interface GetAllProxyGeneratorsRequest {
    ordering?: string;
    limit?: number;
    offset?: number;
}

export interface GetAllProxyProfilesRequest {
    name?: string;
    ordering?: string;
    limit?: number;
    offset?: number;
    forRoot?: number;
}

export interface GetAllSavedSearchesRequest {
    shared?: string;
    name?: string;
    root?: number;
    user?: number;
    ordering?: string;
    limit?: number;
    offset?: number;
}

export interface GetAllSubclipClipboardEntriesRequest {
    cut?: number;
    ordering?: string;
    limit?: number;
    offset?: number;
}

export interface GetAllSubclipsRequest {
    asset?: number;
    assetIn?: string;
    root?: number;
    name?: string;
    ordering?: string;
    limit?: number;
    offset?: number;
}

export interface GetAllSubtitleClipboardEntriesRequest {
    subtitle?: number;
    ordering?: string;
    limit?: number;
    offset?: number;
}

export interface GetAllTranscoderProfilesRequest {
    ordering?: string;
    limit?: number;
    offset?: number;
}

export interface GetAssetRequest {
    id: number;
    includeProxies?: boolean;
    includeModifiedBy?: boolean;
    resolveAssetPermission?: boolean;
    forRoot?: number;
}

export interface GetAssetRatingRequest {
    id: number;
}

export interface GetAssetSubtitleLinkRequest {
    id: number;
}

export interface GetBookmarkedMediaFilesDirectoriesRequest {
    bundle?: number;
    bundleIn?: string;
    parent?: number;
    path?: string;
    name?: string;
    isDir?: string;
    isShowroom?: string;
    present?: string;
    volume?: number;
    sharedViaTokens?: string;
    sharedViaTokensToken?: string;
    ordering?: string;
    limit?: number;
    offset?: number;
}

export interface GetCommentRequest {
    id: number;
    forRoot?: number;
    tasksForUser?: number;
    includeFullAsset?: boolean;
    advancedSearch?: string;
}

export interface GetCustomFieldRequest {
    id: number;
}

export interface GetEasySharingTokenForBundleRequest {
    id: number;
}

export interface GetEasySharingTokenForDirectoryRequest {
    id: number;
}

export interface GetEditorProjectRequest {
    id: number;
}

export interface GetEditorSubtitleRequest {
    id: number;
}

export interface GetExternalTranscoderRequest {
    id: number;
}

export interface GetFrameRequest {
    frame: string;
    id: number;
}

export interface GetLatestMediaUpdateRequest {
    asset?: number;
    user?: number;
    root?: number;
    ordering?: string;
    limit?: number;
    offset?: number;
}

export interface GetMarkerRequest {
    id: number;
}

export interface GetMediaFileRequest {
    id: number;
    resolveFilePermission?: boolean;
    includeModifiedBy?: boolean;
    includeEffectiveCustomFields?: boolean;
    includeRoot?: boolean;
    includeParents?: boolean;
    advancedSearch?: string;
}

export interface GetMediaFileBundleRequest {
    id: number;
    excludeDeleted?: boolean;
    excludeUnrecognized?: boolean;
    includeProxies?: boolean;
    includeParents?: boolean;
    offset?: number;
    limit?: number;
    advancedSearch?: string;
}

export interface GetMediaFileContentsRequest {
    id: number;
    excludeDeleted?: boolean;
    excludeUnrecognized?: boolean;
    offset?: number;
    limit?: number;
}

export interface GetMediaFileTemplateRequest {
    id: number;
}

export interface GetMediaRootRequest {
    id: number;
    resolvePermissions?: boolean;
}

export interface GetMediaRootPermissionRequest {
    id: number;
}

export interface GetMediaTagRequest {
    id: number;
    forRoot?: number;
}

export interface GetMultipleAssetsRequest {
    multipleAssetsRequest: MultipleAssetsRequest;
}

export interface GetMultipleBundlesOperationRequest {
    getMultipleBundlesRequest: GetMultipleBundlesRequest;
}

export interface GetMultipleFilesOperationRequest {
    getMultipleFilesRequest: GetMultipleFilesRequest;
}

export interface GetMyMediaRootPermissionsRequest {
    root?: number;
    id?: number;
    ordering?: string;
    limit?: number;
    offset?: number;
}

export interface GetMyResolvedMediaRootPermissionsRequest {
    root?: number;
    id?: number;
    ordering?: string;
    limit?: number;
    offset?: number;
}

export interface GetProxyRequest {
    id: number;
}

export interface GetProxyGeneratorRequest {
    id: string;
}

export interface GetProxyProfileRequest {
    id: number;
    forRoot?: number;
}

export interface GetProxyProfileProxyCountRequest {
    id: number;
}

export interface GetSavedSearchRequest {
    id: number;
}

export interface GetSubclipRequest {
    id: number;
}

export interface GetSubtitlesRequest {
    id: number;
    title: string;
}

export interface GetTranscoderProfileRequest {
    id: number;
}

export interface GetVantageWorkflowsRequest {
    id: number;
}

export interface InstantiateMediaFileTemplateRequest {
    id: number;
    instantiateFileTemplateRequest: InstantiateFileTemplateRequest;
}

export interface LocateEditorProjectPathsRequest {
    id: number;
}

export interface LookupMediaFilesRequest {
    mediaFilesLookupRequest: MediaFilesLookupRequest;
}

export interface MarkMediaDirectoryAsShowroomRequest {
    id: number;
}

export interface PatchAssetRequest {
    id: number;
    assetPartialUpdate: AssetPartialUpdate;
    root?: number;
}

export interface PatchAssetRatingRequest {
    id: number;
    assetRatingPartialUpdate: AssetRatingPartialUpdate;
}

export interface PatchAssetSubtitleLinkRequest {
    id: number;
    assetSubtitleLinkPartialUpdate: AssetSubtitleLinkPartialUpdate;
}

export interface PatchCommentRequest {
    id: number;
    commentPartialUpdate: CommentPartialUpdate;
}

export interface PatchCustomFieldRequest {
    id: number;
    customFieldPartialUpdate: CustomFieldPartialUpdate;
}

export interface PatchEditorProjectRequest {
    id: number;
    editorProjectPartialUpdate: EditorProjectPartialUpdate;
}

export interface PatchEditorSubtitleRequest {
    id: number;
    editorSubtitlePartialUpdate: EditorSubtitlePartialUpdate;
}

export interface PatchExternalTranscoderRequest {
    id: number;
    externalTranscoderPartialUpdate: ExternalTranscoderPartialUpdate;
}

export interface PatchMarkerRequest {
    id: number;
    markerPartialUpdate: MarkerPartialUpdate;
}

export interface PatchMediaFileRequest {
    id: number;
    mediaFilePartialUpdate: MediaFilePartialUpdate;
    root?: number;
}

export interface PatchMediaFileTemplateRequest {
    id: number;
    mediaFileTemplatePartialUpdate: MediaFileTemplatePartialUpdate;
}

export interface PatchMediaRootRequest {
    id: number;
    mediaRootDetailPartialUpdate: MediaRootDetailPartialUpdate;
}

export interface PatchMediaRootPermissionRequest {
    id: number;
    mediaRootPermissionPartialUpdate: MediaRootPermissionPartialUpdate;
}

export interface PatchMediaTagRequest {
    id: number;
    unfilteredTagPartialUpdate: UnfilteredTagPartialUpdate;
}

export interface PatchProxyProfileRequest {
    id: number;
    proxyProfilePartialUpdate: ProxyProfilePartialUpdate;
}

export interface PatchSavedSearchRequest {
    id: number;
    savedSearchPartialUpdate: SavedSearchPartialUpdate;
}

export interface PatchSubclipRequest {
    id: number;
    subclipPartialUpdate: SubclipPartialUpdate;
}

export interface RecursivelyTagMediaDirectoryRequest {
    id: number;
    tagMediaDirectoryRequest: TagMediaDirectoryRequest;
}

export interface ReindexMediaDirectoryRequest {
    id: number;
}

export interface RenameCustomFieldOperationRequest {
    id: number;
    renameCustomFieldRequest: RenameCustomFieldRequest;
}

export interface RenderSequenceRequest {
    renderEndpointRequest: RenderEndpointRequest;
}

export interface RenderSubclipRequest {
    id: number;
    renderRequest: RenderRequest;
}

export interface RequestMediaScanRequest {
    scannerScanEndpointRequest: ScannerScanEndpointRequest;
}

export interface ResolveCommentRequest {
    id: number;
}

export interface ShareMediaLibraryObjectsRequest {
    mediaLibraryShareRequest: MediaLibraryShareRequest;
}

export interface TestExternalTranscoderConnectionOperationRequest {
    testExternalTranscoderConnectionRequest: TestExternalTranscoderConnectionRequest;
}

export interface TransitionWorkflowRequest {
    workflowTransitionRequest: WorkflowTransitionRequest;
}

export interface UnbookmarkMediaDirectoryRequest {
    id: number;
}

export interface UnmarkMediaDirectoryAsShowroomRequest {
    id: number;
}

export interface UnresolveCommentRequest {
    id: number;
}

export interface UpdateAssetRequest {
    id: number;
    assetUpdate: AssetUpdate;
    root?: number;
}

export interface UpdateAssetRatingRequest {
    id: number;
    assetRatingUpdate: AssetRatingUpdate;
}

export interface UpdateAssetSubtitleLinkRequest {
    id: number;
    assetSubtitleLinkUpdate: AssetSubtitleLinkUpdate;
}

export interface UpdateCommentRequest {
    id: number;
    commentUpdate: CommentUpdate;
}

export interface UpdateCustomFieldRequest {
    id: number;
    customFieldUpdate: CustomFieldUpdate;
}

export interface UpdateEditorProjectRequest {
    id: number;
    editorProjectUpdate: EditorProjectUpdate;
}

export interface UpdateEditorSubtitleRequest {
    id: number;
    editorSubtitleUpdate: EditorSubtitleUpdate;
}

export interface UpdateExternalTranscoderRequest {
    id: number;
    externalTranscoderUpdate: ExternalTranscoderUpdate;
}

export interface UpdateMarkerRequest {
    id: number;
    markerUpdate: MarkerUpdate;
}

export interface UpdateMediaFileRequest {
    id: number;
    mediaFileUpdate: MediaFileUpdate;
    root?: number;
}

export interface UpdateMediaFileTemplateRequest {
    id: number;
    mediaFileTemplateUpdate: MediaFileTemplateUpdate;
}

export interface UpdateMediaRootRequest {
    id: number;
    mediaRootDetailUpdate: MediaRootDetailUpdate;
}

export interface UpdateMediaRootPermissionRequest {
    id: number;
    mediaRootPermissionUpdate: MediaRootPermissionUpdate;
}

export interface UpdateMediaTagRequest {
    id: number;
    unfilteredTagUpdate: UnfilteredTagUpdate;
}

export interface UpdateProxyProfileRequest {
    id: number;
    proxyProfileUpdate: ProxyProfileUpdate;
}

export interface UpdateSavedSearchRequest {
    id: number;
    savedSearchUpdate: SavedSearchUpdate;
}

export interface UpdateSubclipRequest {
    id: number;
    subclipUpdate: SubclipUpdate;
}

/**
 * 
 */
export class MediaLibraryApi extends runtime.BaseAPI {

    /**
     * ### Required permissions    * User account permission: `media:access`   * License component: media 
     */
    async bookmarkMediaDirectoryRaw(requestParameters: BookmarkMediaDirectoryRequest, initOverrides?: RequestInit): Promise<runtime.ApiResponse<void>> {
        if (requestParameters.id === null || requestParameters.id === undefined) {
            throw new runtime.RequiredError('id','Required parameter requestParameters.id was null or undefined when calling bookmarkMediaDirectory.');
        }

        const queryParameters: any = {};

        const headerParameters: runtime.HTTPHeaders = {};

        if (this.configuration && this.configuration.apiKey) {
            headerParameters["Authorization"] = this.configuration.apiKey("Authorization"); // Bearer authentication
        }

        const response = await this.request({
            path: `/api/2/media/files/{id}/bookmark`.replace(`{${"id"}}`, encodeURIComponent(String(requestParameters.id))),
            method: 'POST',
            headers: headerParameters,
            query: queryParameters,
        }, initOverrides);

        return new runtime.VoidApiResponse(response);
    }

    /**
     * ### Required permissions    * User account permission: `media:access`   * License component: media 
     */
    async bookmarkMediaDirectory(requestParameters: BookmarkMediaDirectoryRequest, initOverrides?: RequestInit): Promise<void> {
        await this.bookmarkMediaDirectoryRaw(requestParameters, initOverrides);
    }

    /**
     * ### Required permissions    * User account permission: `media:access`   * License component: media 
     */
    async clearSubclipClipboardRaw(initOverrides?: RequestInit): Promise<runtime.ApiResponse<void>> {
        const queryParameters: any = {};

        const headerParameters: runtime.HTTPHeaders = {};

        if (this.configuration && this.configuration.apiKey) {
            headerParameters["Authorization"] = this.configuration.apiKey("Authorization"); // Bearer authentication
        }

        const response = await this.request({
            path: `/api/2/media/subclips/clipboard/clear`,
            method: 'DELETE',
            headers: headerParameters,
            query: queryParameters,
        }, initOverrides);

        return new runtime.VoidApiResponse(response);
    }

    /**
     * ### Required permissions    * User account permission: `media:access`   * License component: media 
     */
    async clearSubclipClipboard(initOverrides?: RequestInit): Promise<void> {
        await this.clearSubclipClipboardRaw(initOverrides);
    }

    /**
     * ### Required permissions    * User account permission: `media:access`   * License component: media 
     */
    async clearSubtitleClipboardRaw(initOverrides?: RequestInit): Promise<runtime.ApiResponse<void>> {
        const queryParameters: any = {};

        const headerParameters: runtime.HTTPHeaders = {};

        if (this.configuration && this.configuration.apiKey) {
            headerParameters["Authorization"] = this.configuration.apiKey("Authorization"); // Bearer authentication
        }

        const response = await this.request({
            path: `/api/2/media/subtitles/clipboard/clear`,
            method: 'DELETE',
            headers: headerParameters,
            query: queryParameters,
        }, initOverrides);

        return new runtime.VoidApiResponse(response);
    }

    /**
     * ### Required permissions    * User account permission: `media:access`   * License component: media 
     */
    async clearSubtitleClipboard(initOverrides?: RequestInit): Promise<void> {
        await this.clearSubtitleClipboardRaw(initOverrides);
    }

    /**
     * ### Required permissions    * User account permission: `media:access`   * License component: media 
     */
    async combineAssetsIntoSetRaw(requestParameters: CombineAssetsIntoSetRequest, initOverrides?: RequestInit): Promise<runtime.ApiResponse<void>> {
        if (requestParameters.multipleAssetsRequest === null || requestParameters.multipleAssetsRequest === undefined) {
            throw new runtime.RequiredError('multipleAssetsRequest','Required parameter requestParameters.multipleAssetsRequest was null or undefined when calling combineAssetsIntoSet.');
        }

        const queryParameters: any = {};

        const headerParameters: runtime.HTTPHeaders = {};

        headerParameters['Content-Type'] = 'application/json';

        if (this.configuration && this.configuration.apiKey) {
            headerParameters["Authorization"] = this.configuration.apiKey("Authorization"); // Bearer authentication
        }

        const response = await this.request({
            path: `/api/2/media/assets/combine`,
            method: 'POST',
            headers: headerParameters,
            query: queryParameters,
            body: MultipleAssetsRequestToJSON(requestParameters.multipleAssetsRequest),
        }, initOverrides);

        return new runtime.VoidApiResponse(response);
    }

    /**
     * ### Required permissions    * User account permission: `media:access`   * License component: media 
     */
    async combineAssetsIntoSet(requestParameters: CombineAssetsIntoSetRequest, initOverrides?: RequestInit): Promise<void> {
        await this.combineAssetsIntoSetRaw(requestParameters, initOverrides);
    }

    /**
     * ### Required permissions    * User account permission: `media:access`   * License component: media 
     */
    async createAssetRaw(requestParameters: CreateAssetRequest, initOverrides?: RequestInit): Promise<runtime.ApiResponse<Asset>> {
        if (requestParameters.assetUpdate === null || requestParameters.assetUpdate === undefined) {
            throw new runtime.RequiredError('assetUpdate','Required parameter requestParameters.assetUpdate was null or undefined when calling createAsset.');
        }

        const queryParameters: any = {};

        const headerParameters: runtime.HTTPHeaders = {};

        headerParameters['Content-Type'] = 'application/json';

        if (this.configuration && this.configuration.apiKey) {
            headerParameters["Authorization"] = this.configuration.apiKey("Authorization"); // Bearer authentication
        }

        const response = await this.request({
            path: `/api/2/media/assets`,
            method: 'POST',
            headers: headerParameters,
            query: queryParameters,
            body: AssetUpdateToJSON(requestParameters.assetUpdate),
        }, initOverrides);

        return new runtime.JSONApiResponse(response, (jsonValue) => AssetFromJSON(jsonValue));
    }

    /**
     * ### Required permissions    * User account permission: `media:access`   * License component: media 
     */
    async createAsset(requestParameters: CreateAssetRequest, initOverrides?: RequestInit): Promise<Asset> {
        const response = await this.createAssetRaw(requestParameters, initOverrides);
        return await response.value();
    }

    /**
     * ### Required permissions    * User account permission: `media:access`   * License component: media 
     */
    async createAssetRatingRaw(requestParameters: CreateAssetRatingRequest, initOverrides?: RequestInit): Promise<runtime.ApiResponse<AssetRating>> {
        if (requestParameters.assetRatingUpdate === null || requestParameters.assetRatingUpdate === undefined) {
            throw new runtime.RequiredError('assetRatingUpdate','Required parameter requestParameters.assetRatingUpdate was null or undefined when calling createAssetRating.');
        }

        const queryParameters: any = {};

        if (requestParameters.root !== undefined) {
            queryParameters['root'] = requestParameters.root;
        }

        const headerParameters: runtime.HTTPHeaders = {};

        headerParameters['Content-Type'] = 'application/json';

        if (this.configuration && this.configuration.apiKey) {
            headerParameters["Authorization"] = this.configuration.apiKey("Authorization"); // Bearer authentication
        }

        const response = await this.request({
            path: `/api/2/media/ratings`,
            method: 'POST',
            headers: headerParameters,
            query: queryParameters,
            body: AssetRatingUpdateToJSON(requestParameters.assetRatingUpdate),
        }, initOverrides);

        return new runtime.JSONApiResponse(response, (jsonValue) => AssetRatingFromJSON(jsonValue));
    }

    /**
     * ### Required permissions    * User account permission: `media:access`   * License component: media 
     */
    async createAssetRating(requestParameters: CreateAssetRatingRequest, initOverrides?: RequestInit): Promise<AssetRating> {
        const response = await this.createAssetRatingRaw(requestParameters, initOverrides);
        return await response.value();
    }

    /**
     * ### Required permissions    * User account permission: `media:access`   * License component: media 
     */
    async createAssetSubtitleLinkRaw(requestParameters: CreateAssetSubtitleLinkRequest, initOverrides?: RequestInit): Promise<runtime.ApiResponse<AssetSubtitleLink>> {
        if (requestParameters.assetSubtitleLinkUpdate === null || requestParameters.assetSubtitleLinkUpdate === undefined) {
            throw new runtime.RequiredError('assetSubtitleLinkUpdate','Required parameter requestParameters.assetSubtitleLinkUpdate was null or undefined when calling createAssetSubtitleLink.');
        }

        const queryParameters: any = {};

        const headerParameters: runtime.HTTPHeaders = {};

        headerParameters['Content-Type'] = 'application/json';

        if (this.configuration && this.configuration.apiKey) {
            headerParameters["Authorization"] = this.configuration.apiKey("Authorization"); // Bearer authentication
        }

        const response = await this.request({
            path: `/api/2/media/assets/subtitle-links`,
            method: 'POST',
            headers: headerParameters,
            query: queryParameters,
            body: AssetSubtitleLinkUpdateToJSON(requestParameters.assetSubtitleLinkUpdate),
        }, initOverrides);

        return new runtime.JSONApiResponse(response, (jsonValue) => AssetSubtitleLinkFromJSON(jsonValue));
    }

    /**
     * ### Required permissions    * User account permission: `media:access`   * License component: media 
     */
    async createAssetSubtitleLink(requestParameters: CreateAssetSubtitleLinkRequest, initOverrides?: RequestInit): Promise<AssetSubtitleLink> {
        const response = await this.createAssetSubtitleLinkRaw(requestParameters, initOverrides);
        return await response.value();
    }

    /**
     * ### Required permissions    * User account permission: `media:access`   * License component: media 
     */
    async createCommentRaw(requestParameters: CreateCommentRequest, initOverrides?: RequestInit): Promise<runtime.ApiResponse<Comment>> {
        if (requestParameters.commentUpdate === null || requestParameters.commentUpdate === undefined) {
            throw new runtime.RequiredError('commentUpdate','Required parameter requestParameters.commentUpdate was null or undefined when calling createComment.');
        }

        const queryParameters: any = {};

        if (requestParameters.root !== undefined) {
            queryParameters['root'] = requestParameters.root;
        }

        if (requestParameters.bundle !== undefined) {
            queryParameters['bundle'] = requestParameters.bundle;
        }

        const headerParameters: runtime.HTTPHeaders = {};

        headerParameters['Content-Type'] = 'application/json';

        if (this.configuration && this.configuration.apiKey) {
            headerParameters["Authorization"] = this.configuration.apiKey("Authorization"); // Bearer authentication
        }

        const response = await this.request({
            path: `/api/2/media/comments`,
            method: 'POST',
            headers: headerParameters,
            query: queryParameters,
            body: CommentUpdateToJSON(requestParameters.commentUpdate),
        }, initOverrides);

        return new runtime.JSONApiResponse(response, (jsonValue) => CommentFromJSON(jsonValue));
    }

    /**
     * ### Required permissions    * User account permission: `media:access`   * License component: media 
     */
    async createComment(requestParameters: CreateCommentRequest, initOverrides?: RequestInit): Promise<Comment> {
        const response = await this.createCommentRaw(requestParameters, initOverrides);
        return await response.value();
    }

    /**
     * ### Required permissions    * User account permission: `media:access` (read) / `media:roots:manage` (write)   * License component: media 
     */
    async createCustomFieldRaw(requestParameters: CreateCustomFieldRequest, initOverrides?: RequestInit): Promise<runtime.ApiResponse<CustomField>> {
        if (requestParameters.customFieldUpdate === null || requestParameters.customFieldUpdate === undefined) {
            throw new runtime.RequiredError('customFieldUpdate','Required parameter requestParameters.customFieldUpdate was null or undefined when calling createCustomField.');
        }

        const queryParameters: any = {};

        const headerParameters: runtime.HTTPHeaders = {};

        headerParameters['Content-Type'] = 'application/json';

        if (this.configuration && this.configuration.apiKey) {
            headerParameters["Authorization"] = this.configuration.apiKey("Authorization"); // Bearer authentication
        }

        const response = await this.request({
            path: `/api/2/media/custom-fields`,
            method: 'POST',
            headers: headerParameters,
            query: queryParameters,
            body: CustomFieldUpdateToJSON(requestParameters.customFieldUpdate),
        }, initOverrides);

        return new runtime.JSONApiResponse(response, (jsonValue) => CustomFieldFromJSON(jsonValue));
    }

    /**
     * ### Required permissions    * User account permission: `media:access` (read) / `media:roots:manage` (write)   * License component: media 
     */
    async createCustomField(requestParameters: CreateCustomFieldRequest, initOverrides?: RequestInit): Promise<CustomField> {
        const response = await this.createCustomFieldRaw(requestParameters, initOverrides);
        return await response.value();
    }

    /**
     * ### Required permissions    * User account permission: `media:access` 
     */
    async createEditorProjectRaw(requestParameters: CreateEditorProjectRequest, initOverrides?: RequestInit): Promise<runtime.ApiResponse<EditorProject>> {
        if (requestParameters.editorProjectUpdate === null || requestParameters.editorProjectUpdate === undefined) {
            throw new runtime.RequiredError('editorProjectUpdate','Required parameter requestParameters.editorProjectUpdate was null or undefined when calling createEditorProject.');
        }

        const queryParameters: any = {};

        const headerParameters: runtime.HTTPHeaders = {};

        headerParameters['Content-Type'] = 'application/json';

        if (this.configuration && this.configuration.apiKey) {
            headerParameters["Authorization"] = this.configuration.apiKey("Authorization"); // Bearer authentication
        }

        const response = await this.request({
            path: `/api/2/media/editor`,
            method: 'POST',
            headers: headerParameters,
            query: queryParameters,
            body: EditorProjectUpdateToJSON(requestParameters.editorProjectUpdate),
        }, initOverrides);

        return new runtime.JSONApiResponse(response, (jsonValue) => EditorProjectFromJSON(jsonValue));
    }

    /**
     * ### Required permissions    * User account permission: `media:access` 
     */
    async createEditorProject(requestParameters: CreateEditorProjectRequest, initOverrides?: RequestInit): Promise<EditorProject> {
        const response = await this.createEditorProjectRaw(requestParameters, initOverrides);
        return await response.value();
    }

    /**
     * ### Required permissions    * User account permission: `media:access` 
     */
    async createEditorSubtitleRaw(requestParameters: CreateEditorSubtitleRequest, initOverrides?: RequestInit): Promise<runtime.ApiResponse<EditorSubtitle>> {
        if (requestParameters.editorSubtitleUpdate === null || requestParameters.editorSubtitleUpdate === undefined) {
            throw new runtime.RequiredError('editorSubtitleUpdate','Required parameter requestParameters.editorSubtitleUpdate was null or undefined when calling createEditorSubtitle.');
        }

        const queryParameters: any = {};

        const headerParameters: runtime.HTTPHeaders = {};

        headerParameters['Content-Type'] = 'application/json';

        if (this.configuration && this.configuration.apiKey) {
            headerParameters["Authorization"] = this.configuration.apiKey("Authorization"); // Bearer authentication
        }

        const response = await this.request({
            path: `/api/2/media/subtitles`,
            method: 'POST',
            headers: headerParameters,
            query: queryParameters,
            body: EditorSubtitleUpdateToJSON(requestParameters.editorSubtitleUpdate),
        }, initOverrides);

        return new runtime.JSONApiResponse(response, (jsonValue) => EditorSubtitleFromJSON(jsonValue));
    }

    /**
     * ### Required permissions    * User account permission: `media:access` 
     */
    async createEditorSubtitle(requestParameters: CreateEditorSubtitleRequest, initOverrides?: RequestInit): Promise<EditorSubtitle> {
        const response = await this.createEditorSubtitleRaw(requestParameters, initOverrides);
        return await response.value();
    }

    /**
     * ### Required permissions    * User account permission: `media:access` (read) / `system:admin-access` (write) 
     */
    async createExternalTranscoderRaw(requestParameters: CreateExternalTranscoderRequest, initOverrides?: RequestInit): Promise<runtime.ApiResponse<ExternalTranscoder>> {
        if (requestParameters.externalTranscoderUpdate === null || requestParameters.externalTranscoderUpdate === undefined) {
            throw new runtime.RequiredError('externalTranscoderUpdate','Required parameter requestParameters.externalTranscoderUpdate was null or undefined when calling createExternalTranscoder.');
        }

        const queryParameters: any = {};

        const headerParameters: runtime.HTTPHeaders = {};

        headerParameters['Content-Type'] = 'application/json';

        if (this.configuration && this.configuration.apiKey) {
            headerParameters["Authorization"] = this.configuration.apiKey("Authorization"); // Bearer authentication
        }

        const response = await this.request({
            path: `/api/2/media/external-transcoders`,
            method: 'POST',
            headers: headerParameters,
            query: queryParameters,
            body: ExternalTranscoderUpdateToJSON(requestParameters.externalTranscoderUpdate),
        }, initOverrides);

        return new runtime.JSONApiResponse(response, (jsonValue) => ExternalTranscoderFromJSON(jsonValue));
    }

    /**
     * ### Required permissions    * User account permission: `media:access` (read) / `system:admin-access` (write) 
     */
    async createExternalTranscoder(requestParameters: CreateExternalTranscoderRequest, initOverrides?: RequestInit): Promise<ExternalTranscoder> {
        const response = await this.createExternalTranscoderRaw(requestParameters, initOverrides);
        return await response.value();
    }

    /**
     * ### Required permissions    * User account permission: `media:access`   * License component: media 
     */
    async createMarkerRaw(requestParameters: CreateMarkerRequest, initOverrides?: RequestInit): Promise<runtime.ApiResponse<Marker>> {
        if (requestParameters.markerUpdate === null || requestParameters.markerUpdate === undefined) {
            throw new runtime.RequiredError('markerUpdate','Required parameter requestParameters.markerUpdate was null or undefined when calling createMarker.');
        }

        const queryParameters: any = {};

        const headerParameters: runtime.HTTPHeaders = {};

        headerParameters['Content-Type'] = 'application/json';

        if (this.configuration && this.configuration.apiKey) {
            headerParameters["Authorization"] = this.configuration.apiKey("Authorization"); // Bearer authentication
        }

        const response = await this.request({
            path: `/api/2/media/markers`,
            method: 'POST',
            headers: headerParameters,
            query: queryParameters,
            body: MarkerUpdateToJSON(requestParameters.markerUpdate),
        }, initOverrides);

        return new runtime.JSONApiResponse(response, (jsonValue) => MarkerFromJSON(jsonValue));
    }

    /**
     * ### Required permissions    * User account permission: `media:access`   * License component: media 
     */
    async createMarker(requestParameters: CreateMarkerRequest, initOverrides?: RequestInit): Promise<Marker> {
        const response = await this.createMarkerRaw(requestParameters, initOverrides);
        return await response.value();
    }

    /**
     * ### Required permissions    * User account permission: `media:access`   * License component: media 
     */
    async createMediaFileTemplateRaw(requestParameters: CreateMediaFileTemplateRequest, initOverrides?: RequestInit): Promise<runtime.ApiResponse<MediaFileTemplate>> {
        if (requestParameters.mediaFileTemplateUpdate === null || requestParameters.mediaFileTemplateUpdate === undefined) {
            throw new runtime.RequiredError('mediaFileTemplateUpdate','Required parameter requestParameters.mediaFileTemplateUpdate was null or undefined when calling createMediaFileTemplate.');
        }

        const queryParameters: any = {};

        const headerParameters: runtime.HTTPHeaders = {};

        headerParameters['Content-Type'] = 'application/json';

        if (this.configuration && this.configuration.apiKey) {
            headerParameters["Authorization"] = this.configuration.apiKey("Authorization"); // Bearer authentication
        }

        const response = await this.request({
            path: `/api/2/media/files/templates`,
            method: 'POST',
            headers: headerParameters,
            query: queryParameters,
            body: MediaFileTemplateUpdateToJSON(requestParameters.mediaFileTemplateUpdate),
        }, initOverrides);

        return new runtime.JSONApiResponse(response, (jsonValue) => MediaFileTemplateFromJSON(jsonValue));
    }

    /**
     * ### Required permissions    * User account permission: `media:access`   * License component: media 
     */
    async createMediaFileTemplate(requestParameters: CreateMediaFileTemplateRequest, initOverrides?: RequestInit): Promise<MediaFileTemplate> {
        const response = await this.createMediaFileTemplateRaw(requestParameters, initOverrides);
        return await response.value();
    }

    /**
     * ### Required permissions    * User account permission: `media:access` (read) / `media:roots:manage` (write)   * License component: media 
     */
    async createMediaRootRaw(requestParameters: CreateMediaRootRequest, initOverrides?: RequestInit): Promise<runtime.ApiResponse<MediaRootDetail>> {
        if (requestParameters.mediaRootDetailUpdate === null || requestParameters.mediaRootDetailUpdate === undefined) {
            throw new runtime.RequiredError('mediaRootDetailUpdate','Required parameter requestParameters.mediaRootDetailUpdate was null or undefined when calling createMediaRoot.');
        }

        const queryParameters: any = {};

        const headerParameters: runtime.HTTPHeaders = {};

        headerParameters['Content-Type'] = 'application/json';

        if (this.configuration && this.configuration.apiKey) {
            headerParameters["Authorization"] = this.configuration.apiKey("Authorization"); // Bearer authentication
        }

        const response = await this.request({
            path: `/api/2/media/roots`,
            method: 'POST',
            headers: headerParameters,
            query: queryParameters,
            body: MediaRootDetailUpdateToJSON(requestParameters.mediaRootDetailUpdate),
        }, initOverrides);

        return new runtime.JSONApiResponse(response, (jsonValue) => MediaRootDetailFromJSON(jsonValue));
    }

    /**
     * ### Required permissions    * User account permission: `media:access` (read) / `media:roots:manage` (write)   * License component: media 
     */
    async createMediaRoot(requestParameters: CreateMediaRootRequest, initOverrides?: RequestInit): Promise<MediaRootDetail> {
        const response = await this.createMediaRootRaw(requestParameters, initOverrides);
        return await response.value();
    }

    /**
     * ### Required permissions    * User account permission: `media:access` (read) / `media:roots:manage` (write)   * License component: media 
     */
    async createMediaRootPermissionRaw(requestParameters: CreateMediaRootPermissionRequest, initOverrides?: RequestInit): Promise<runtime.ApiResponse<MediaRootPermission>> {
        if (requestParameters.mediaRootPermissionUpdate === null || requestParameters.mediaRootPermissionUpdate === undefined) {
            throw new runtime.RequiredError('mediaRootPermissionUpdate','Required parameter requestParameters.mediaRootPermissionUpdate was null or undefined when calling createMediaRootPermission.');
        }

        const queryParameters: any = {};

        const headerParameters: runtime.HTTPHeaders = {};

        headerParameters['Content-Type'] = 'application/json';

        if (this.configuration && this.configuration.apiKey) {
            headerParameters["Authorization"] = this.configuration.apiKey("Authorization"); // Bearer authentication
        }

        const response = await this.request({
            path: `/api/2/media/root-permissions`,
            method: 'POST',
            headers: headerParameters,
            query: queryParameters,
            body: MediaRootPermissionUpdateToJSON(requestParameters.mediaRootPermissionUpdate),
        }, initOverrides);

        return new runtime.JSONApiResponse(response, (jsonValue) => MediaRootPermissionFromJSON(jsonValue));
    }

    /**
     * ### Required permissions    * User account permission: `media:access` (read) / `media:roots:manage` (write)   * License component: media 
     */
    async createMediaRootPermission(requestParameters: CreateMediaRootPermissionRequest, initOverrides?: RequestInit): Promise<MediaRootPermission> {
        const response = await this.createMediaRootPermissionRaw(requestParameters, initOverrides);
        return await response.value();
    }

    /**
     * ### Required permissions    * User account permission: `media:access`   * License component: media 
     */
    async createMediaTagRaw(requestParameters: CreateMediaTagRequest, initOverrides?: RequestInit): Promise<runtime.ApiResponse<UnfilteredTag>> {
        if (requestParameters.unfilteredTagUpdate === null || requestParameters.unfilteredTagUpdate === undefined) {
            throw new runtime.RequiredError('unfilteredTagUpdate','Required parameter requestParameters.unfilteredTagUpdate was null or undefined when calling createMediaTag.');
        }

        const queryParameters: any = {};

        const headerParameters: runtime.HTTPHeaders = {};

        headerParameters['Content-Type'] = 'application/json';

        if (this.configuration && this.configuration.apiKey) {
            headerParameters["Authorization"] = this.configuration.apiKey("Authorization"); // Bearer authentication
        }

        const response = await this.request({
            path: `/api/2/media/tags`,
            method: 'POST',
            headers: headerParameters,
            query: queryParameters,
            body: UnfilteredTagUpdateToJSON(requestParameters.unfilteredTagUpdate),
        }, initOverrides);

        return new runtime.JSONApiResponse(response, (jsonValue) => UnfilteredTagFromJSON(jsonValue));
    }

    /**
     * ### Required permissions    * User account permission: `media:access`   * License component: media 
     */
    async createMediaTag(requestParameters: CreateMediaTagRequest, initOverrides?: RequestInit): Promise<UnfilteredTag> {
        const response = await this.createMediaTagRaw(requestParameters, initOverrides);
        return await response.value();
    }

    /**
     * ### Required permissions    * User account permission: `media:access` (read) / `media:roots:manage` (write)   * License component: media 
     */
    async createProxyProfileRaw(requestParameters: CreateProxyProfileRequest, initOverrides?: RequestInit): Promise<runtime.ApiResponse<ProxyProfile>> {
        if (requestParameters.proxyProfileUpdate === null || requestParameters.proxyProfileUpdate === undefined) {
            throw new runtime.RequiredError('proxyProfileUpdate','Required parameter requestParameters.proxyProfileUpdate was null or undefined when calling createProxyProfile.');
        }

        const queryParameters: any = {};

        const headerParameters: runtime.HTTPHeaders = {};

        headerParameters['Content-Type'] = 'application/json';

        if (this.configuration && this.configuration.apiKey) {
            headerParameters["Authorization"] = this.configuration.apiKey("Authorization"); // Bearer authentication
        }

        const response = await this.request({
            path: `/api/2/media/proxy-profiles`,
            method: 'POST',
            headers: headerParameters,
            query: queryParameters,
            body: ProxyProfileUpdateToJSON(requestParameters.proxyProfileUpdate),
        }, initOverrides);

        return new runtime.JSONApiResponse(response, (jsonValue) => ProxyProfileFromJSON(jsonValue));
    }

    /**
     * ### Required permissions    * User account permission: `media:access` (read) / `media:roots:manage` (write)   * License component: media 
     */
    async createProxyProfile(requestParameters: CreateProxyProfileRequest, initOverrides?: RequestInit): Promise<ProxyProfile> {
        const response = await this.createProxyProfileRaw(requestParameters, initOverrides);
        return await response.value();
    }

    /**
     * ### Required permissions    * User account permission: `media:access`   * License component: media 
     */
    async createSavedSearchRaw(requestParameters: CreateSavedSearchRequest, initOverrides?: RequestInit): Promise<runtime.ApiResponse<SavedSearch>> {
        if (requestParameters.savedSearchUpdate === null || requestParameters.savedSearchUpdate === undefined) {
            throw new runtime.RequiredError('savedSearchUpdate','Required parameter requestParameters.savedSearchUpdate was null or undefined when calling createSavedSearch.');
        }

        const queryParameters: any = {};

        const headerParameters: runtime.HTTPHeaders = {};

        headerParameters['Content-Type'] = 'application/json';

        if (this.configuration && this.configuration.apiKey) {
            headerParameters["Authorization"] = this.configuration.apiKey("Authorization"); // Bearer authentication
        }

        const response = await this.request({
            path: `/api/2/media/saved-searches`,
            method: 'POST',
            headers: headerParameters,
            query: queryParameters,
            body: SavedSearchUpdateToJSON(requestParameters.savedSearchUpdate),
        }, initOverrides);

        return new runtime.JSONApiResponse(response, (jsonValue) => SavedSearchFromJSON(jsonValue));
    }

    /**
     * ### Required permissions    * User account permission: `media:access`   * License component: media 
     */
    async createSavedSearch(requestParameters: CreateSavedSearchRequest, initOverrides?: RequestInit): Promise<SavedSearch> {
        const response = await this.createSavedSearchRaw(requestParameters, initOverrides);
        return await response.value();
    }

    /**
     * ### Required permissions    * User account permission: `media:access`   * License component: media 
     */
    async createSubclipRaw(requestParameters: CreateSubclipRequest, initOverrides?: RequestInit): Promise<runtime.ApiResponse<Subclip>> {
        if (requestParameters.subclipUpdate === null || requestParameters.subclipUpdate === undefined) {
            throw new runtime.RequiredError('subclipUpdate','Required parameter requestParameters.subclipUpdate was null or undefined when calling createSubclip.');
        }

        const queryParameters: any = {};

        const headerParameters: runtime.HTTPHeaders = {};

        headerParameters['Content-Type'] = 'application/json';

        if (this.configuration && this.configuration.apiKey) {
            headerParameters["Authorization"] = this.configuration.apiKey("Authorization"); // Bearer authentication
        }

        const response = await this.request({
            path: `/api/2/media/subclips`,
            method: 'POST',
            headers: headerParameters,
            query: queryParameters,
            body: SubclipUpdateToJSON(requestParameters.subclipUpdate),
        }, initOverrides);

        return new runtime.JSONApiResponse(response, (jsonValue) => SubclipFromJSON(jsonValue));
    }

    /**
     * ### Required permissions    * User account permission: `media:access`   * License component: media 
     */
    async createSubclip(requestParameters: CreateSubclipRequest, initOverrides?: RequestInit): Promise<Subclip> {
        const response = await this.createSubclipRaw(requestParameters, initOverrides);
        return await response.value();
    }

    /**
     * ### Required permissions    * User account permission: `media:access`   * License component: media 
     */
    async createSubclipClipboardEntryRaw(requestParameters: CreateSubclipClipboardEntryRequest, initOverrides?: RequestInit): Promise<runtime.ApiResponse<SubclipClipboardEntry>> {
        if (requestParameters.subclipClipboardEntryUpdate === null || requestParameters.subclipClipboardEntryUpdate === undefined) {
            throw new runtime.RequiredError('subclipClipboardEntryUpdate','Required parameter requestParameters.subclipClipboardEntryUpdate was null or undefined when calling createSubclipClipboardEntry.');
        }

        const queryParameters: any = {};

        const headerParameters: runtime.HTTPHeaders = {};

        headerParameters['Content-Type'] = 'application/json';

        if (this.configuration && this.configuration.apiKey) {
            headerParameters["Authorization"] = this.configuration.apiKey("Authorization"); // Bearer authentication
        }

        const response = await this.request({
            path: `/api/2/media/subclips/clipboard`,
            method: 'POST',
            headers: headerParameters,
            query: queryParameters,
            body: SubclipClipboardEntryUpdateToJSON(requestParameters.subclipClipboardEntryUpdate),
        }, initOverrides);

        return new runtime.JSONApiResponse(response, (jsonValue) => SubclipClipboardEntryFromJSON(jsonValue));
    }

    /**
     * ### Required permissions    * User account permission: `media:access`   * License component: media 
     */
    async createSubclipClipboardEntry(requestParameters: CreateSubclipClipboardEntryRequest, initOverrides?: RequestInit): Promise<SubclipClipboardEntry> {
        const response = await this.createSubclipClipboardEntryRaw(requestParameters, initOverrides);
        return await response.value();
    }

    /**
     * ### Required permissions    * User account permission: `media:access`   * License component: media 
     */
    async createSubtitleClipboardEntryRaw(requestParameters: CreateSubtitleClipboardEntryRequest, initOverrides?: RequestInit): Promise<runtime.ApiResponse<SubtitleClipboardEntry>> {
        if (requestParameters.subtitleClipboardEntryUpdate === null || requestParameters.subtitleClipboardEntryUpdate === undefined) {
            throw new runtime.RequiredError('subtitleClipboardEntryUpdate','Required parameter requestParameters.subtitleClipboardEntryUpdate was null or undefined when calling createSubtitleClipboardEntry.');
        }

        const queryParameters: any = {};

        const headerParameters: runtime.HTTPHeaders = {};

        headerParameters['Content-Type'] = 'application/json';

        if (this.configuration && this.configuration.apiKey) {
            headerParameters["Authorization"] = this.configuration.apiKey("Authorization"); // Bearer authentication
        }

        const response = await this.request({
            path: `/api/2/media/subtitles/clipboard`,
            method: 'POST',
            headers: headerParameters,
            query: queryParameters,
            body: SubtitleClipboardEntryUpdateToJSON(requestParameters.subtitleClipboardEntryUpdate),
        }, initOverrides);

        return new runtime.JSONApiResponse(response, (jsonValue) => SubtitleClipboardEntryFromJSON(jsonValue));
    }

    /**
     * ### Required permissions    * User account permission: `media:access`   * License component: media 
     */
    async createSubtitleClipboardEntry(requestParameters: CreateSubtitleClipboardEntryRequest, initOverrides?: RequestInit): Promise<SubtitleClipboardEntry> {
        const response = await this.createSubtitleClipboardEntryRaw(requestParameters, initOverrides);
        return await response.value();
    }

    /**
     * ### Required permissions    * User account permission: `media:access`   * License component: media 
     */
    async deleteAssetRaw(requestParameters: DeleteAssetRequest, initOverrides?: RequestInit): Promise<runtime.ApiResponse<void>> {
        if (requestParameters.id === null || requestParameters.id === undefined) {
            throw new runtime.RequiredError('id','Required parameter requestParameters.id was null or undefined when calling deleteAsset.');
        }

        const queryParameters: any = {};

        const headerParameters: runtime.HTTPHeaders = {};

        if (this.configuration && this.configuration.apiKey) {
            headerParameters["Authorization"] = this.configuration.apiKey("Authorization"); // Bearer authentication
        }

        const response = await this.request({
            path: `/api/2/media/assets/{id}`.replace(`{${"id"}}`, encodeURIComponent(String(requestParameters.id))),
            method: 'DELETE',
            headers: headerParameters,
            query: queryParameters,
        }, initOverrides);

        return new runtime.VoidApiResponse(response);
    }

    /**
     * ### Required permissions    * User account permission: `media:access`   * License component: media 
     */
    async deleteAsset(requestParameters: DeleteAssetRequest, initOverrides?: RequestInit): Promise<void> {
        await this.deleteAssetRaw(requestParameters, initOverrides);
    }

    /**
     * ### Required permissions    * User account permission: `media:access`   * License component: media 
     */
    async deleteAssetRatingRaw(requestParameters: DeleteAssetRatingRequest, initOverrides?: RequestInit): Promise<runtime.ApiResponse<void>> {
        if (requestParameters.id === null || requestParameters.id === undefined) {
            throw new runtime.RequiredError('id','Required parameter requestParameters.id was null or undefined when calling deleteAssetRating.');
        }

        const queryParameters: any = {};

        if (requestParameters.root !== undefined) {
            queryParameters['root'] = requestParameters.root;
        }

        const headerParameters: runtime.HTTPHeaders = {};

        if (this.configuration && this.configuration.apiKey) {
            headerParameters["Authorization"] = this.configuration.apiKey("Authorization"); // Bearer authentication
        }

        const response = await this.request({
            path: `/api/2/media/ratings/{id}`.replace(`{${"id"}}`, encodeURIComponent(String(requestParameters.id))),
            method: 'DELETE',
            headers: headerParameters,
            query: queryParameters,
        }, initOverrides);

        return new runtime.VoidApiResponse(response);
    }

    /**
     * ### Required permissions    * User account permission: `media:access`   * License component: media 
     */
    async deleteAssetRating(requestParameters: DeleteAssetRatingRequest, initOverrides?: RequestInit): Promise<void> {
        await this.deleteAssetRatingRaw(requestParameters, initOverrides);
    }

    /**
     * ### Required permissions    * User account permission: `media:access`   * License component: media 
     */
    async deleteAssetSubtitleLinkRaw(requestParameters: DeleteAssetSubtitleLinkRequest, initOverrides?: RequestInit): Promise<runtime.ApiResponse<void>> {
        if (requestParameters.id === null || requestParameters.id === undefined) {
            throw new runtime.RequiredError('id','Required parameter requestParameters.id was null or undefined when calling deleteAssetSubtitleLink.');
        }

        const queryParameters: any = {};

        const headerParameters: runtime.HTTPHeaders = {};

        if (this.configuration && this.configuration.apiKey) {
            headerParameters["Authorization"] = this.configuration.apiKey("Authorization"); // Bearer authentication
        }

        const response = await this.request({
            path: `/api/2/media/assets/subtitle-links/{id}`.replace(`{${"id"}}`, encodeURIComponent(String(requestParameters.id))),
            method: 'DELETE',
            headers: headerParameters,
            query: queryParameters,
        }, initOverrides);

        return new runtime.VoidApiResponse(response);
    }

    /**
     * ### Required permissions    * User account permission: `media:access`   * License component: media 
     */
    async deleteAssetSubtitleLink(requestParameters: DeleteAssetSubtitleLinkRequest, initOverrides?: RequestInit): Promise<void> {
        await this.deleteAssetSubtitleLinkRaw(requestParameters, initOverrides);
    }

    /**
     * ### Required permissions    * User account permission: `media:access`   * License component: media 
     */
    async deleteCommentRaw(requestParameters: DeleteCommentRequest, initOverrides?: RequestInit): Promise<runtime.ApiResponse<void>> {
        if (requestParameters.id === null || requestParameters.id === undefined) {
            throw new runtime.RequiredError('id','Required parameter requestParameters.id was null or undefined when calling deleteComment.');
        }

        const queryParameters: any = {};

        const headerParameters: runtime.HTTPHeaders = {};

        if (this.configuration && this.configuration.apiKey) {
            headerParameters["Authorization"] = this.configuration.apiKey("Authorization"); // Bearer authentication
        }

        const response = await this.request({
            path: `/api/2/media/comments/{id}`.replace(`{${"id"}}`, encodeURIComponent(String(requestParameters.id))),
            method: 'DELETE',
            headers: headerParameters,
            query: queryParameters,
        }, initOverrides);

        return new runtime.VoidApiResponse(response);
    }

    /**
     * ### Required permissions    * User account permission: `media:access`   * License component: media 
     */
    async deleteComment(requestParameters: DeleteCommentRequest, initOverrides?: RequestInit): Promise<void> {
        await this.deleteCommentRaw(requestParameters, initOverrides);
    }

    /**
     * ### Required permissions    * User account permission: `media:access` (read) / `media:roots:manage` (write)   * License component: media 
     */
    async deleteCustomFieldRaw(requestParameters: DeleteCustomFieldRequest, initOverrides?: RequestInit): Promise<runtime.ApiResponse<void>> {
        if (requestParameters.id === null || requestParameters.id === undefined) {
            throw new runtime.RequiredError('id','Required parameter requestParameters.id was null or undefined when calling deleteCustomField.');
        }

        const queryParameters: any = {};

        const headerParameters: runtime.HTTPHeaders = {};

        if (this.configuration && this.configuration.apiKey) {
            headerParameters["Authorization"] = this.configuration.apiKey("Authorization"); // Bearer authentication
        }

        const response = await this.request({
            path: `/api/2/media/custom-fields/{id}`.replace(`{${"id"}}`, encodeURIComponent(String(requestParameters.id))),
            method: 'DELETE',
            headers: headerParameters,
            query: queryParameters,
        }, initOverrides);

        return new runtime.VoidApiResponse(response);
    }

    /**
     * ### Required permissions    * User account permission: `media:access` (read) / `media:roots:manage` (write)   * License component: media 
     */
    async deleteCustomField(requestParameters: DeleteCustomFieldRequest, initOverrides?: RequestInit): Promise<void> {
        await this.deleteCustomFieldRaw(requestParameters, initOverrides);
    }

    /**
     * ### Required permissions    * <class \'rest_framework.permissions.AllowAny\'> 
     */
    async deleteEasySharingTokenForBundleRaw(requestParameters: DeleteEasySharingTokenForBundleRequest, initOverrides?: RequestInit): Promise<runtime.ApiResponse<void>> {
        if (requestParameters.id === null || requestParameters.id === undefined) {
            throw new runtime.RequiredError('id','Required parameter requestParameters.id was null or undefined when calling deleteEasySharingTokenForBundle.');
        }

        const queryParameters: any = {};

        const headerParameters: runtime.HTTPHeaders = {};

        if (this.configuration && this.configuration.apiKey) {
            headerParameters["Authorization"] = this.configuration.apiKey("Authorization"); // Bearer authentication
        }

        const response = await this.request({
            path: `/api/2/media/bundles/{id}/easy-sharing-token`.replace(`{${"id"}}`, encodeURIComponent(String(requestParameters.id))),
            method: 'DELETE',
            headers: headerParameters,
            query: queryParameters,
        }, initOverrides);

        return new runtime.VoidApiResponse(response);
    }

    /**
     * ### Required permissions    * <class \'rest_framework.permissions.AllowAny\'> 
     */
    async deleteEasySharingTokenForBundle(requestParameters: DeleteEasySharingTokenForBundleRequest, initOverrides?: RequestInit): Promise<void> {
        await this.deleteEasySharingTokenForBundleRaw(requestParameters, initOverrides);
    }

    /**
     * ### Required permissions    * User account permission: `media:access`   * License component: media 
     */
    async deleteEasySharingTokenForDirectoryRaw(requestParameters: DeleteEasySharingTokenForDirectoryRequest, initOverrides?: RequestInit): Promise<runtime.ApiResponse<void>> {
        if (requestParameters.id === null || requestParameters.id === undefined) {
            throw new runtime.RequiredError('id','Required parameter requestParameters.id was null or undefined when calling deleteEasySharingTokenForDirectory.');
        }

        const queryParameters: any = {};

        const headerParameters: runtime.HTTPHeaders = {};

        if (this.configuration && this.configuration.apiKey) {
            headerParameters["Authorization"] = this.configuration.apiKey("Authorization"); // Bearer authentication
        }

        const response = await this.request({
            path: `/api/2/media/files/{id}/easy-sharing-token`.replace(`{${"id"}}`, encodeURIComponent(String(requestParameters.id))),
            method: 'DELETE',
            headers: headerParameters,
            query: queryParameters,
        }, initOverrides);

        return new runtime.VoidApiResponse(response);
    }

    /**
     * ### Required permissions    * User account permission: `media:access`   * License component: media 
     */
    async deleteEasySharingTokenForDirectory(requestParameters: DeleteEasySharingTokenForDirectoryRequest, initOverrides?: RequestInit): Promise<void> {
        await this.deleteEasySharingTokenForDirectoryRaw(requestParameters, initOverrides);
    }

    /**
     * ### Required permissions    * User account permission: `media:access` (read) / `system:admin-access` (write) 
     */
    async deleteExternalTranscoderRaw(requestParameters: DeleteExternalTranscoderRequest, initOverrides?: RequestInit): Promise<runtime.ApiResponse<void>> {
        if (requestParameters.id === null || requestParameters.id === undefined) {
            throw new runtime.RequiredError('id','Required parameter requestParameters.id was null or undefined when calling deleteExternalTranscoder.');
        }

        const queryParameters: any = {};

        const headerParameters: runtime.HTTPHeaders = {};

        if (this.configuration && this.configuration.apiKey) {
            headerParameters["Authorization"] = this.configuration.apiKey("Authorization"); // Bearer authentication
        }

        const response = await this.request({
            path: `/api/2/media/external-transcoders/{id}`.replace(`{${"id"}}`, encodeURIComponent(String(requestParameters.id))),
            method: 'DELETE',
            headers: headerParameters,
            query: queryParameters,
        }, initOverrides);

        return new runtime.VoidApiResponse(response);
    }

    /**
     * ### Required permissions    * User account permission: `media:access` (read) / `system:admin-access` (write) 
     */
    async deleteExternalTranscoder(requestParameters: DeleteExternalTranscoderRequest, initOverrides?: RequestInit): Promise<void> {
        await this.deleteExternalTranscoderRaw(requestParameters, initOverrides);
    }

    /**
     * ### Required permissions    * User account permission: `media:access`   * License component: media 
     */
    async deleteMarkerRaw(requestParameters: DeleteMarkerRequest, initOverrides?: RequestInit): Promise<runtime.ApiResponse<void>> {
        if (requestParameters.id === null || requestParameters.id === undefined) {
            throw new runtime.RequiredError('id','Required parameter requestParameters.id was null or undefined when calling deleteMarker.');
        }

        const queryParameters: any = {};

        const headerParameters: runtime.HTTPHeaders = {};

        if (this.configuration && this.configuration.apiKey) {
            headerParameters["Authorization"] = this.configuration.apiKey("Authorization"); // Bearer authentication
        }

        const response = await this.request({
            path: `/api/2/media/markers/{id}`.replace(`{${"id"}}`, encodeURIComponent(String(requestParameters.id))),
            method: 'DELETE',
            headers: headerParameters,
            query: queryParameters,
        }, initOverrides);

        return new runtime.VoidApiResponse(response);
    }

    /**
     * ### Required permissions    * User account permission: `media:access`   * License component: media 
     */
    async deleteMarker(requestParameters: DeleteMarkerRequest, initOverrides?: RequestInit): Promise<void> {
        await this.deleteMarkerRaw(requestParameters, initOverrides);
    }

    /**
     * ### Required permissions    * User account permission: `media:access`   * License component: media 
     */
    async deleteMediaFileTemplateRaw(requestParameters: DeleteMediaFileTemplateRequest, initOverrides?: RequestInit): Promise<runtime.ApiResponse<void>> {
        if (requestParameters.id === null || requestParameters.id === undefined) {
            throw new runtime.RequiredError('id','Required parameter requestParameters.id was null or undefined when calling deleteMediaFileTemplate.');
        }

        const queryParameters: any = {};

        const headerParameters: runtime.HTTPHeaders = {};

        if (this.configuration && this.configuration.apiKey) {
            headerParameters["Authorization"] = this.configuration.apiKey("Authorization"); // Bearer authentication
        }

        const response = await this.request({
            path: `/api/2/media/files/templates/{id}`.replace(`{${"id"}}`, encodeURIComponent(String(requestParameters.id))),
            method: 'DELETE',
            headers: headerParameters,
            query: queryParameters,
        }, initOverrides);

        return new runtime.VoidApiResponse(response);
    }

    /**
     * ### Required permissions    * User account permission: `media:access`   * License component: media 
     */
    async deleteMediaFileTemplate(requestParameters: DeleteMediaFileTemplateRequest, initOverrides?: RequestInit): Promise<void> {
        await this.deleteMediaFileTemplateRaw(requestParameters, initOverrides);
    }

    /**
     * ### Required permissions    * User account permission: `media:access` 
     */
    async deleteMediaLibraryObjectsRaw(requestParameters: DeleteMediaLibraryObjectsRequest, initOverrides?: RequestInit): Promise<runtime.ApiResponse<Array<TaskInfo>>> {
        if (requestParameters.mediaLibraryDeleteRequest === null || requestParameters.mediaLibraryDeleteRequest === undefined) {
            throw new runtime.RequiredError('mediaLibraryDeleteRequest','Required parameter requestParameters.mediaLibraryDeleteRequest was null or undefined when calling deleteMediaLibraryObjects.');
        }

        const queryParameters: any = {};

        const headerParameters: runtime.HTTPHeaders = {};

        headerParameters['Content-Type'] = 'application/json';

        if (this.configuration && this.configuration.apiKey) {
            headerParameters["Authorization"] = this.configuration.apiKey("Authorization"); // Bearer authentication
        }

        const response = await this.request({
            path: `/api/2/media/delete`,
            method: 'POST',
            headers: headerParameters,
            query: queryParameters,
            body: MediaLibraryDeleteRequestToJSON(requestParameters.mediaLibraryDeleteRequest),
        }, initOverrides);

        return new runtime.JSONApiResponse(response, (jsonValue) => jsonValue.map(TaskInfoFromJSON));
    }

    /**
     * ### Required permissions    * User account permission: `media:access` 
     */
    async deleteMediaLibraryObjects(requestParameters: DeleteMediaLibraryObjectsRequest, initOverrides?: RequestInit): Promise<Array<TaskInfo>> {
        const response = await this.deleteMediaLibraryObjectsRaw(requestParameters, initOverrides);
        return await response.value();
    }

    /**
     * ### Required permissions    * User account permission: `media:access` (read) / `media:roots:manage` (write)   * License component: media 
     */
    async deleteMediaRootRaw(requestParameters: DeleteMediaRootRequest, initOverrides?: RequestInit): Promise<runtime.ApiResponse<void>> {
        if (requestParameters.id === null || requestParameters.id === undefined) {
            throw new runtime.RequiredError('id','Required parameter requestParameters.id was null or undefined when calling deleteMediaRoot.');
        }

        const queryParameters: any = {};

        const headerParameters: runtime.HTTPHeaders = {};

        if (this.configuration && this.configuration.apiKey) {
            headerParameters["Authorization"] = this.configuration.apiKey("Authorization"); // Bearer authentication
        }

        const response = await this.request({
            path: `/api/2/media/roots/{id}`.replace(`{${"id"}}`, encodeURIComponent(String(requestParameters.id))),
            method: 'DELETE',
            headers: headerParameters,
            query: queryParameters,
        }, initOverrides);

        return new runtime.VoidApiResponse(response);
    }

    /**
     * ### Required permissions    * User account permission: `media:access` (read) / `media:roots:manage` (write)   * License component: media 
     */
    async deleteMediaRoot(requestParameters: DeleteMediaRootRequest, initOverrides?: RequestInit): Promise<void> {
        await this.deleteMediaRootRaw(requestParameters, initOverrides);
    }

    /**
     * ### Required permissions    * User account permission: `media:access` (read) / `media:roots:manage` (write)   * License component: media 
     */
    async deleteMediaRootPermissionRaw(requestParameters: DeleteMediaRootPermissionRequest, initOverrides?: RequestInit): Promise<runtime.ApiResponse<void>> {
        if (requestParameters.id === null || requestParameters.id === undefined) {
            throw new runtime.RequiredError('id','Required parameter requestParameters.id was null or undefined when calling deleteMediaRootPermission.');
        }

        const queryParameters: any = {};

        const headerParameters: runtime.HTTPHeaders = {};

        if (this.configuration && this.configuration.apiKey) {
            headerParameters["Authorization"] = this.configuration.apiKey("Authorization"); // Bearer authentication
        }

        const response = await this.request({
            path: `/api/2/media/root-permissions/{id}`.replace(`{${"id"}}`, encodeURIComponent(String(requestParameters.id))),
            method: 'DELETE',
            headers: headerParameters,
            query: queryParameters,
        }, initOverrides);

        return new runtime.VoidApiResponse(response);
    }

    /**
     * ### Required permissions    * User account permission: `media:access` (read) / `media:roots:manage` (write)   * License component: media 
     */
    async deleteMediaRootPermission(requestParameters: DeleteMediaRootPermissionRequest, initOverrides?: RequestInit): Promise<void> {
        await this.deleteMediaRootPermissionRaw(requestParameters, initOverrides);
    }

    /**
     * ### Required permissions    * User account permission: `media:access`   * License component: media 
     */
    async deleteMediaTagRaw(requestParameters: DeleteMediaTagRequest, initOverrides?: RequestInit): Promise<runtime.ApiResponse<void>> {
        if (requestParameters.id === null || requestParameters.id === undefined) {
            throw new runtime.RequiredError('id','Required parameter requestParameters.id was null or undefined when calling deleteMediaTag.');
        }

        const queryParameters: any = {};

        const headerParameters: runtime.HTTPHeaders = {};

        if (this.configuration && this.configuration.apiKey) {
            headerParameters["Authorization"] = this.configuration.apiKey("Authorization"); // Bearer authentication
        }

        const response = await this.request({
            path: `/api/2/media/tags/{id}`.replace(`{${"id"}}`, encodeURIComponent(String(requestParameters.id))),
            method: 'DELETE',
            headers: headerParameters,
            query: queryParameters,
        }, initOverrides);

        return new runtime.VoidApiResponse(response);
    }

    /**
     * ### Required permissions    * User account permission: `media:access`   * License component: media 
     */
    async deleteMediaTag(requestParameters: DeleteMediaTagRequest, initOverrides?: RequestInit): Promise<void> {
        await this.deleteMediaTagRaw(requestParameters, initOverrides);
    }

    /**
     * ### Required permissions    * User account permission: `media:access` (read) / `media:updates:manage` (write)   * License component: media 
     */
    async deleteMediaUpdateRaw(requestParameters: DeleteMediaUpdateRequest, initOverrides?: RequestInit): Promise<runtime.ApiResponse<void>> {
        if (requestParameters.id === null || requestParameters.id === undefined) {
            throw new runtime.RequiredError('id','Required parameter requestParameters.id was null or undefined when calling deleteMediaUpdate.');
        }

        const queryParameters: any = {};

        const headerParameters: runtime.HTTPHeaders = {};

        if (this.configuration && this.configuration.apiKey) {
            headerParameters["Authorization"] = this.configuration.apiKey("Authorization"); // Bearer authentication
        }

        const response = await this.request({
            path: `/api/2/media/updates/{id}`.replace(`{${"id"}}`, encodeURIComponent(String(requestParameters.id))),
            method: 'DELETE',
            headers: headerParameters,
            query: queryParameters,
        }, initOverrides);

        return new runtime.VoidApiResponse(response);
    }

    /**
     * ### Required permissions    * User account permission: `media:access` (read) / `media:updates:manage` (write)   * License component: media 
     */
    async deleteMediaUpdate(requestParameters: DeleteMediaUpdateRequest, initOverrides?: RequestInit): Promise<void> {
        await this.deleteMediaUpdateRaw(requestParameters, initOverrides);
    }

    /**
     * ### Required permissions    * User account permission: `media:access`   * License component: media 
     */
    async deleteProxyRaw(requestParameters: DeleteProxyRequest, initOverrides?: RequestInit): Promise<runtime.ApiResponse<void>> {
        if (requestParameters.id === null || requestParameters.id === undefined) {
            throw new runtime.RequiredError('id','Required parameter requestParameters.id was null or undefined when calling deleteProxy.');
        }

        const queryParameters: any = {};

        const headerParameters: runtime.HTTPHeaders = {};

        if (this.configuration && this.configuration.apiKey) {
            headerParameters["Authorization"] = this.configuration.apiKey("Authorization"); // Bearer authentication
        }

        const response = await this.request({
            path: `/api/2/media/proxies/{id}`.replace(`{${"id"}}`, encodeURIComponent(String(requestParameters.id))),
            method: 'DELETE',
            headers: headerParameters,
            query: queryParameters,
        }, initOverrides);

        return new runtime.VoidApiResponse(response);
    }

    /**
     * ### Required permissions    * User account permission: `media:access`   * License component: media 
     */
    async deleteProxy(requestParameters: DeleteProxyRequest, initOverrides?: RequestInit): Promise<void> {
        await this.deleteProxyRaw(requestParameters, initOverrides);
    }

    /**
     * ### Required permissions    * User account permission: `media:access` (read) / `media:roots:manage` (write)   * License component: media 
     */
    async deleteProxyProfileRaw(requestParameters: DeleteProxyProfileRequest, initOverrides?: RequestInit): Promise<runtime.ApiResponse<void>> {
        if (requestParameters.id === null || requestParameters.id === undefined) {
            throw new runtime.RequiredError('id','Required parameter requestParameters.id was null or undefined when calling deleteProxyProfile.');
        }

        const queryParameters: any = {};

        const headerParameters: runtime.HTTPHeaders = {};

        if (this.configuration && this.configuration.apiKey) {
            headerParameters["Authorization"] = this.configuration.apiKey("Authorization"); // Bearer authentication
        }

        const response = await this.request({
            path: `/api/2/media/proxy-profiles/{id}`.replace(`{${"id"}}`, encodeURIComponent(String(requestParameters.id))),
            method: 'DELETE',
            headers: headerParameters,
            query: queryParameters,
        }, initOverrides);

        return new runtime.VoidApiResponse(response);
    }

    /**
     * ### Required permissions    * User account permission: `media:access` (read) / `media:roots:manage` (write)   * License component: media 
     */
    async deleteProxyProfile(requestParameters: DeleteProxyProfileRequest, initOverrides?: RequestInit): Promise<void> {
        await this.deleteProxyProfileRaw(requestParameters, initOverrides);
    }

    /**
     * ### Required permissions    * User account permission: `media:access`   * License component: media 
     */
    async deleteSavedSearchRaw(requestParameters: DeleteSavedSearchRequest, initOverrides?: RequestInit): Promise<runtime.ApiResponse<void>> {
        if (requestParameters.id === null || requestParameters.id === undefined) {
            throw new runtime.RequiredError('id','Required parameter requestParameters.id was null or undefined when calling deleteSavedSearch.');
        }

        const queryParameters: any = {};

        const headerParameters: runtime.HTTPHeaders = {};

        if (this.configuration && this.configuration.apiKey) {
            headerParameters["Authorization"] = this.configuration.apiKey("Authorization"); // Bearer authentication
        }

        const response = await this.request({
            path: `/api/2/media/saved-searches/{id}`.replace(`{${"id"}}`, encodeURIComponent(String(requestParameters.id))),
            method: 'DELETE',
            headers: headerParameters,
            query: queryParameters,
        }, initOverrides);

        return new runtime.VoidApiResponse(response);
    }

    /**
     * ### Required permissions    * User account permission: `media:access`   * License component: media 
     */
    async deleteSavedSearch(requestParameters: DeleteSavedSearchRequest, initOverrides?: RequestInit): Promise<void> {
        await this.deleteSavedSearchRaw(requestParameters, initOverrides);
    }

    /**
     * ### Required permissions    * User account permission: `media:access`   * License component: media 
     */
    async deleteSubclipRaw(requestParameters: DeleteSubclipRequest, initOverrides?: RequestInit): Promise<runtime.ApiResponse<void>> {
        if (requestParameters.id === null || requestParameters.id === undefined) {
            throw new runtime.RequiredError('id','Required parameter requestParameters.id was null or undefined when calling deleteSubclip.');
        }

        const queryParameters: any = {};

        const headerParameters: runtime.HTTPHeaders = {};

        if (this.configuration && this.configuration.apiKey) {
            headerParameters["Authorization"] = this.configuration.apiKey("Authorization"); // Bearer authentication
        }

        const response = await this.request({
            path: `/api/2/media/subclips/{id}`.replace(`{${"id"}}`, encodeURIComponent(String(requestParameters.id))),
            method: 'DELETE',
            headers: headerParameters,
            query: queryParameters,
        }, initOverrides);

        return new runtime.VoidApiResponse(response);
    }

    /**
     * ### Required permissions    * User account permission: `media:access`   * License component: media 
     */
    async deleteSubclip(requestParameters: DeleteSubclipRequest, initOverrides?: RequestInit): Promise<void> {
        await this.deleteSubclipRaw(requestParameters, initOverrides);
    }

    /**
     * ### Required permissions    * User account permission: `media:access`   * License component: media 
     */
    async deleteSubclipClipboardEntryRaw(requestParameters: DeleteSubclipClipboardEntryRequest, initOverrides?: RequestInit): Promise<runtime.ApiResponse<void>> {
        if (requestParameters.id === null || requestParameters.id === undefined) {
            throw new runtime.RequiredError('id','Required parameter requestParameters.id was null or undefined when calling deleteSubclipClipboardEntry.');
        }

        const queryParameters: any = {};

        const headerParameters: runtime.HTTPHeaders = {};

        if (this.configuration && this.configuration.apiKey) {
            headerParameters["Authorization"] = this.configuration.apiKey("Authorization"); // Bearer authentication
        }

        const response = await this.request({
            path: `/api/2/media/subclips/clipboard/{id}`.replace(`{${"id"}}`, encodeURIComponent(String(requestParameters.id))),
            method: 'DELETE',
            headers: headerParameters,
            query: queryParameters,
        }, initOverrides);

        return new runtime.VoidApiResponse(response);
    }

    /**
     * ### Required permissions    * User account permission: `media:access`   * License component: media 
     */
    async deleteSubclipClipboardEntry(requestParameters: DeleteSubclipClipboardEntryRequest, initOverrides?: RequestInit): Promise<void> {
        await this.deleteSubclipClipboardEntryRaw(requestParameters, initOverrides);
    }

    /**
     * ### Required permissions    * User account permission: `media:access`   * License component: media 
     */
    async deleteSubtitleClipboardEntryRaw(requestParameters: DeleteSubtitleClipboardEntryRequest, initOverrides?: RequestInit): Promise<runtime.ApiResponse<void>> {
        if (requestParameters.id === null || requestParameters.id === undefined) {
            throw new runtime.RequiredError('id','Required parameter requestParameters.id was null or undefined when calling deleteSubtitleClipboardEntry.');
        }

        const queryParameters: any = {};

        const headerParameters: runtime.HTTPHeaders = {};

        if (this.configuration && this.configuration.apiKey) {
            headerParameters["Authorization"] = this.configuration.apiKey("Authorization"); // Bearer authentication
        }

        const response = await this.request({
            path: `/api/2/media/subtitles/clipboard/{id}`.replace(`{${"id"}}`, encodeURIComponent(String(requestParameters.id))),
            method: 'DELETE',
            headers: headerParameters,
            query: queryParameters,
        }, initOverrides);

        return new runtime.VoidApiResponse(response);
    }

    /**
     * ### Required permissions    * User account permission: `media:access`   * License component: media 
     */
    async deleteSubtitleClipboardEntry(requestParameters: DeleteSubtitleClipboardEntryRequest, initOverrides?: RequestInit): Promise<void> {
        await this.deleteSubtitleClipboardEntryRaw(requestParameters, initOverrides);
    }

    /**
     * ### Required permissions    * User account permission: `media:access` 
     */
    async discoverMediaRaw(requestParameters: DiscoverMediaRequest, initOverrides?: RequestInit): Promise<runtime.ApiResponse<MediaFile>> {
        if (requestParameters.scannerDiscoverEndpointRequest === null || requestParameters.scannerDiscoverEndpointRequest === undefined) {
            throw new runtime.RequiredError('scannerDiscoverEndpointRequest','Required parameter requestParameters.scannerDiscoverEndpointRequest was null or undefined when calling discoverMedia.');
        }

        const queryParameters: any = {};

        const headerParameters: runtime.HTTPHeaders = {};

        headerParameters['Content-Type'] = 'application/json';

        if (this.configuration && this.configuration.apiKey) {
            headerParameters["Authorization"] = this.configuration.apiKey("Authorization"); // Bearer authentication
        }

        const response = await this.request({
            path: `/api/2/scanner/discover`,
            method: 'POST',
            headers: headerParameters,
            query: queryParameters,
            body: ScannerDiscoverEndpointRequestToJSON(requestParameters.scannerDiscoverEndpointRequest),
        }, initOverrides);

        return new runtime.JSONApiResponse(response, (jsonValue) => MediaFileFromJSON(jsonValue));
    }

    /**
     * ### Required permissions    * User account permission: `media:access` 
     */
    async discoverMedia(requestParameters: DiscoverMediaRequest, initOverrides?: RequestInit): Promise<MediaFile> {
        const response = await this.discoverMediaRaw(requestParameters, initOverrides);
        return await response.value();
    }

    /**
     * ### Required permissions    * User account permission: `media:access`   * License component: media 
     */
    async downloadAssetProxyFileRaw(requestParameters: DownloadAssetProxyFileRequest, initOverrides?: RequestInit): Promise<runtime.ApiResponse<void>> {
        if (requestParameters.filename === null || requestParameters.filename === undefined) {
            throw new runtime.RequiredError('filename','Required parameter requestParameters.filename was null or undefined when calling downloadAssetProxyFile.');
        }

        if (requestParameters.id === null || requestParameters.id === undefined) {
            throw new runtime.RequiredError('id','Required parameter requestParameters.id was null or undefined when calling downloadAssetProxyFile.');
        }

        const queryParameters: any = {};

        const headerParameters: runtime.HTTPHeaders = {};

        if (this.configuration && this.configuration.apiKey) {
            headerParameters["Authorization"] = this.configuration.apiKey("Authorization"); // Bearer authentication
        }

        const response = await this.request({
            path: `/api/2/media/assets/{id}/proxy-files/{filename}`.replace(`{${"filename"}}`, encodeURIComponent(String(requestParameters.filename))).replace(`{${"id"}}`, encodeURIComponent(String(requestParameters.id))),
            method: 'GET',
            headers: headerParameters,
            query: queryParameters,
        }, initOverrides);

        return new runtime.VoidApiResponse(response);
    }

    /**
     * ### Required permissions    * User account permission: `media:access`   * License component: media 
     */
    async downloadAssetProxyFile(requestParameters: DownloadAssetProxyFileRequest, initOverrides?: RequestInit): Promise<void> {
        await this.downloadAssetProxyFileRaw(requestParameters, initOverrides);
    }

    /**
     * ### Required permissions    * User account permission: `media:access`   * License component: media 
     */
    async downloadMediaFileRaw(requestParameters: DownloadMediaFileRequest, initOverrides?: RequestInit): Promise<runtime.ApiResponse<void>> {
        if (requestParameters.id === null || requestParameters.id === undefined) {
            throw new runtime.RequiredError('id','Required parameter requestParameters.id was null or undefined when calling downloadMediaFile.');
        }

        const queryParameters: any = {};

        const headerParameters: runtime.HTTPHeaders = {};

        if (this.configuration && this.configuration.apiKey) {
            headerParameters["Authorization"] = this.configuration.apiKey("Authorization"); // Bearer authentication
        }

        const response = await this.request({
            path: `/api/2/media/files/{id}/download`.replace(`{${"id"}}`, encodeURIComponent(String(requestParameters.id))),
            method: 'GET',
            headers: headerParameters,
            query: queryParameters,
        }, initOverrides);

        return new runtime.VoidApiResponse(response);
    }

    /**
     * ### Required permissions    * User account permission: `media:access`   * License component: media 
     */
    async downloadMediaFile(requestParameters: DownloadMediaFileRequest, initOverrides?: RequestInit): Promise<void> {
        await this.downloadMediaFileRaw(requestParameters, initOverrides);
    }

    /**
     * ### Required permissions    * User account permission: `media:access`   * License component: media 
     */
    async downloadProxyRaw(requestParameters: DownloadProxyRequest, initOverrides?: RequestInit): Promise<runtime.ApiResponse<void>> {
        if (requestParameters.id === null || requestParameters.id === undefined) {
            throw new runtime.RequiredError('id','Required parameter requestParameters.id was null or undefined when calling downloadProxy.');
        }

        const queryParameters: any = {};

        const headerParameters: runtime.HTTPHeaders = {};

        if (this.configuration && this.configuration.apiKey) {
            headerParameters["Authorization"] = this.configuration.apiKey("Authorization"); // Bearer authentication
        }

        const response = await this.request({
            path: `/api/2/media/proxies/{id}/download`.replace(`{${"id"}}`, encodeURIComponent(String(requestParameters.id))),
            method: 'GET',
            headers: headerParameters,
            query: queryParameters,
        }, initOverrides);

        return new runtime.VoidApiResponse(response);
    }

    /**
     * ### Required permissions    * User account permission: `media:access`   * License component: media 
     */
    async downloadProxy(requestParameters: DownloadProxyRequest, initOverrides?: RequestInit): Promise<void> {
        await this.downloadProxyRaw(requestParameters, initOverrides);
    }

    /**
     * ### Required permissions    * User account permission: `media:access` 
     */
    async editorExportXMLForAsssetRaw(requestParameters: EditorExportXMLForAsssetRequest, initOverrides?: RequestInit): Promise<runtime.ApiResponse<void>> {
        if (requestParameters.assetIds === null || requestParameters.assetIds === undefined) {
            throw new runtime.RequiredError('assetIds','Required parameter requestParameters.assetIds was null or undefined when calling editorExportXMLForAssset.');
        }

        const queryParameters: any = {};

        if (requestParameters.ordering !== undefined) {
            queryParameters['ordering'] = requestParameters.ordering;
        }

        if (requestParameters.limit !== undefined) {
            queryParameters['limit'] = requestParameters.limit;
        }

        if (requestParameters.offset !== undefined) {
            queryParameters['offset'] = requestParameters.offset;
        }

        const headerParameters: runtime.HTTPHeaders = {};

        if (this.configuration && this.configuration.apiKey) {
            headerParameters["Authorization"] = this.configuration.apiKey("Authorization"); // Bearer authentication
        }

        const response = await this.request({
            path: `/api/2/media/editor/asset/{asset_ids}/xml-export`.replace(`{${"asset_ids"}}`, encodeURIComponent(String(requestParameters.assetIds))),
            method: 'GET',
            headers: headerParameters,
            query: queryParameters,
        }, initOverrides);

        return new runtime.VoidApiResponse(response);
    }

    /**
     * ### Required permissions    * User account permission: `media:access` 
     */
    async editorExportXMLForAssset(requestParameters: EditorExportXMLForAsssetRequest, initOverrides?: RequestInit): Promise<void> {
        await this.editorExportXMLForAsssetRaw(requestParameters, initOverrides);
    }

    /**
     * ### Required permissions    * User account permission: `media:access` 
     */
    async editorExportXMLForBundleRaw(requestParameters: EditorExportXMLForBundleRequest, initOverrides?: RequestInit): Promise<runtime.ApiResponse<void>> {
        if (requestParameters.bundleIds === null || requestParameters.bundleIds === undefined) {
            throw new runtime.RequiredError('bundleIds','Required parameter requestParameters.bundleIds was null or undefined when calling editorExportXMLForBundle.');
        }

        const queryParameters: any = {};

        if (requestParameters.ordering !== undefined) {
            queryParameters['ordering'] = requestParameters.ordering;
        }

        if (requestParameters.limit !== undefined) {
            queryParameters['limit'] = requestParameters.limit;
        }

        if (requestParameters.offset !== undefined) {
            queryParameters['offset'] = requestParameters.offset;
        }

        const headerParameters: runtime.HTTPHeaders = {};

        if (this.configuration && this.configuration.apiKey) {
            headerParameters["Authorization"] = this.configuration.apiKey("Authorization"); // Bearer authentication
        }

        const response = await this.request({
            path: `/api/2/media/editor/bundle/{bundle_ids}/xml-export`.replace(`{${"bundle_ids"}}`, encodeURIComponent(String(requestParameters.bundleIds))),
            method: 'GET',
            headers: headerParameters,
            query: queryParameters,
        }, initOverrides);

        return new runtime.VoidApiResponse(response);
    }

    /**
     * ### Required permissions    * User account permission: `media:access` 
     */
    async editorExportXMLForBundle(requestParameters: EditorExportXMLForBundleRequest, initOverrides?: RequestInit): Promise<void> {
        await this.editorExportXMLForBundleRaw(requestParameters, initOverrides);
    }

    /**
     * ### Required permissions    * User account permission: `media:access` 
     */
    async editorExportXMLForProjectRaw(requestParameters: EditorExportXMLForProjectRequest, initOverrides?: RequestInit): Promise<runtime.ApiResponse<void>> {
        if (requestParameters.id === null || requestParameters.id === undefined) {
            throw new runtime.RequiredError('id','Required parameter requestParameters.id was null or undefined when calling editorExportXMLForProject.');
        }

        const queryParameters: any = {};

        const headerParameters: runtime.HTTPHeaders = {};

        if (this.configuration && this.configuration.apiKey) {
            headerParameters["Authorization"] = this.configuration.apiKey("Authorization"); // Bearer authentication
        }

        const response = await this.request({
            path: `/api/2/media/editor/{id}/xml-export`.replace(`{${"id"}}`, encodeURIComponent(String(requestParameters.id))),
            method: 'GET',
            headers: headerParameters,
            query: queryParameters,
        }, initOverrides);

        return new runtime.VoidApiResponse(response);
    }

    /**
     * ### Required permissions    * User account permission: `media:access` 
     */
    async editorExportXMLForProject(requestParameters: EditorExportXMLForProjectRequest, initOverrides?: RequestInit): Promise<void> {
        await this.editorExportXMLForProjectRaw(requestParameters, initOverrides);
    }

    /**
     * ### Required permissions    * User account permission: `media:access` 
     */
    async exportCommentsForAvidRaw(requestParameters: ExportCommentsForAvidRequest, initOverrides?: RequestInit): Promise<runtime.ApiResponse<void>> {
        if (requestParameters.assetId === null || requestParameters.assetId === undefined) {
            throw new runtime.RequiredError('assetId','Required parameter requestParameters.assetId was null or undefined when calling exportCommentsForAvid.');
        }

        if (requestParameters.exportFormat === null || requestParameters.exportFormat === undefined) {
            throw new runtime.RequiredError('exportFormat','Required parameter requestParameters.exportFormat was null or undefined when calling exportCommentsForAvid.');
        }

        const queryParameters: any = {};

        if (requestParameters.ordering !== undefined) {
            queryParameters['ordering'] = requestParameters.ordering;
        }

        if (requestParameters.limit !== undefined) {
            queryParameters['limit'] = requestParameters.limit;
        }

        if (requestParameters.offset !== undefined) {
            queryParameters['offset'] = requestParameters.offset;
        }

        const headerParameters: runtime.HTTPHeaders = {};

        if (this.configuration && this.configuration.apiKey) {
            headerParameters["Authorization"] = this.configuration.apiKey("Authorization"); // Bearer authentication
        }

        const response = await this.request({
            path: `/api/2/media/editor/asset/{asset_id}/{export_format}-export/avid-comments`.replace(`{${"asset_id"}}`, encodeURIComponent(String(requestParameters.assetId))).replace(`{${"export_format"}}`, encodeURIComponent(String(requestParameters.exportFormat))),
            method: 'GET',
            headers: headerParameters,
            query: queryParameters,
        }, initOverrides);

        return new runtime.VoidApiResponse(response);
    }

    /**
     * ### Required permissions    * User account permission: `media:access` 
     */
    async exportCommentsForAvid(requestParameters: ExportCommentsForAvidRequest, initOverrides?: RequestInit): Promise<void> {
        await this.exportCommentsForAvidRaw(requestParameters, initOverrides);
    }

    /**
     * ### Required permissions    * User account permission: `media:access` 
     */
    async exportEditorTimelineRaw(requestParameters: ExportEditorTimelineRequest, initOverrides?: RequestInit): Promise<runtime.ApiResponse<void>> {
        if (requestParameters.timelineExportRequest === null || requestParameters.timelineExportRequest === undefined) {
            throw new runtime.RequiredError('timelineExportRequest','Required parameter requestParameters.timelineExportRequest was null or undefined when calling exportEditorTimeline.');
        }

        const queryParameters: any = {};

        const headerParameters: runtime.HTTPHeaders = {};

        headerParameters['Content-Type'] = 'application/json';

        if (this.configuration && this.configuration.apiKey) {
            headerParameters["Authorization"] = this.configuration.apiKey("Authorization"); // Bearer authentication
        }

        const response = await this.request({
            path: `/api/2/media/editor/timeline-export`,
            method: 'POST',
            headers: headerParameters,
            query: queryParameters,
            body: TimelineExportRequestToJSON(requestParameters.timelineExportRequest),
        }, initOverrides);

        return new runtime.VoidApiResponse(response);
    }

    /**
     * ### Required permissions    * User account permission: `media:access` 
     */
    async exportEditorTimeline(requestParameters: ExportEditorTimelineRequest, initOverrides?: RequestInit): Promise<void> {
        await this.exportEditorTimelineRaw(requestParameters, initOverrides);
    }

    /**
     * ### Required permissions    * User account permission: `media:access`   * License component: media 
     */
    async extractStreamRaw(requestParameters: ExtractStreamRequest, initOverrides?: RequestInit): Promise<runtime.ApiResponse<TaskInfo>> {
        if (requestParameters.id === null || requestParameters.id === undefined) {
            throw new runtime.RequiredError('id','Required parameter requestParameters.id was null or undefined when calling extractStream.');
        }

        if (requestParameters.extractRequest === null || requestParameters.extractRequest === undefined) {
            throw new runtime.RequiredError('extractRequest','Required parameter requestParameters.extractRequest was null or undefined when calling extractStream.');
        }

        const queryParameters: any = {};

        const headerParameters: runtime.HTTPHeaders = {};

        headerParameters['Content-Type'] = 'application/json';

        if (this.configuration && this.configuration.apiKey) {
            headerParameters["Authorization"] = this.configuration.apiKey("Authorization"); // Bearer authentication
        }

        const response = await this.request({
            path: `/api/2/media/assets/{id}/extract-stream`.replace(`{${"id"}}`, encodeURIComponent(String(requestParameters.id))),
            method: 'POST',
            headers: headerParameters,
            query: queryParameters,
            body: ExtractRequestToJSON(requestParameters.extractRequest),
        }, initOverrides);

        return new runtime.JSONApiResponse(response, (jsonValue) => TaskInfoFromJSON(jsonValue));
    }

    /**
     * ### Required permissions    * User account permission: `media:access`   * License component: media 
     */
    async extractStream(requestParameters: ExtractStreamRequest, initOverrides?: RequestInit): Promise<TaskInfo> {
        const response = await this.extractStreamRaw(requestParameters, initOverrides);
        return await response.value();
    }

    /**
     * ### Required permissions    * User account permission: `media:access`   * License component: media 
     */
    async forgetDeletedMediaFilesRaw(requestParameters: ForgetDeletedMediaFilesRequest, initOverrides?: RequestInit): Promise<runtime.ApiResponse<void>> {
        if (requestParameters.id === null || requestParameters.id === undefined) {
            throw new runtime.RequiredError('id','Required parameter requestParameters.id was null or undefined when calling forgetDeletedMediaFiles.');
        }

        const queryParameters: any = {};

        const headerParameters: runtime.HTTPHeaders = {};

        if (this.configuration && this.configuration.apiKey) {
            headerParameters["Authorization"] = this.configuration.apiKey("Authorization"); // Bearer authentication
        }

        const response = await this.request({
            path: `/api/2/media/files/{id}/forget-deleted`.replace(`{${"id"}}`, encodeURIComponent(String(requestParameters.id))),
            method: 'POST',
            headers: headerParameters,
            query: queryParameters,
        }, initOverrides);

        return new runtime.VoidApiResponse(response);
    }

    /**
     * ### Required permissions    * User account permission: `media:access`   * License component: media 
     */
    async forgetDeletedMediaFiles(requestParameters: ForgetDeletedMediaFilesRequest, initOverrides?: RequestInit): Promise<void> {
        await this.forgetDeletedMediaFilesRaw(requestParameters, initOverrides);
    }

    /**
     * ### Required permissions    * <class \'rest_framework.permissions.AllowAny\'> 
     */
    async generateProxiesRaw(requestParameters: GenerateProxiesOperationRequest, initOverrides?: RequestInit): Promise<runtime.ApiResponse<Array<TaskInfo>>> {
        if (requestParameters.generateProxiesRequest === null || requestParameters.generateProxiesRequest === undefined) {
            throw new runtime.RequiredError('generateProxiesRequest','Required parameter requestParameters.generateProxiesRequest was null or undefined when calling generateProxies.');
        }

        const queryParameters: any = {};

        const headerParameters: runtime.HTTPHeaders = {};

        headerParameters['Content-Type'] = 'application/json';

        if (this.configuration && this.configuration.apiKey) {
            headerParameters["Authorization"] = this.configuration.apiKey("Authorization"); // Bearer authentication
        }

        const response = await this.request({
            path: `/api/2/media/proxies`,
            method: 'POST',
            headers: headerParameters,
            query: queryParameters,
            body: GenerateProxiesRequestToJSON(requestParameters.generateProxiesRequest),
        }, initOverrides);

        return new runtime.JSONApiResponse(response, (jsonValue) => jsonValue.map(TaskInfoFromJSON));
    }

    /**
     * ### Required permissions    * <class \'rest_framework.permissions.AllowAny\'> 
     */
    async generateProxies(requestParameters: GenerateProxiesOperationRequest, initOverrides?: RequestInit): Promise<Array<TaskInfo>> {
        const response = await this.generateProxiesRaw(requestParameters, initOverrides);
        return await response.value();
    }

    /**
     * ### Required permissions    * User account permission: `media:access`   * License component: media 
     */
    async getAllAssetProjectLinksRaw(requestParameters: GetAllAssetProjectLinksRequest, initOverrides?: RequestInit): Promise<runtime.ApiResponse<Array<AssetProjectLink>>> {
        const queryParameters: any = {};

        if (requestParameters.asset !== undefined) {
            queryParameters['asset'] = requestParameters.asset;
        }

        if (requestParameters.project !== undefined) {
            queryParameters['project'] = requestParameters.project;
        }

        if (requestParameters.ordering !== undefined) {
            queryParameters['ordering'] = requestParameters.ordering;
        }

        if (requestParameters.limit !== undefined) {
            queryParameters['limit'] = requestParameters.limit;
        }

        if (requestParameters.offset !== undefined) {
            queryParameters['offset'] = requestParameters.offset;
        }

        const headerParameters: runtime.HTTPHeaders = {};

        if (this.configuration && this.configuration.apiKey) {
            headerParameters["Authorization"] = this.configuration.apiKey("Authorization"); // Bearer authentication
        }

        const response = await this.request({
            path: `/api/2/media/assets/project-links`,
            method: 'GET',
            headers: headerParameters,
            query: queryParameters,
        }, initOverrides);

        return new runtime.JSONApiResponse(response, (jsonValue) => jsonValue.map(AssetProjectLinkFromJSON));
    }

    /**
     * ### Required permissions    * User account permission: `media:access`   * License component: media 
     */
    async getAllAssetProjectLinks(requestParameters: GetAllAssetProjectLinksRequest, initOverrides?: RequestInit): Promise<Array<AssetProjectLink>> {
        const response = await this.getAllAssetProjectLinksRaw(requestParameters, initOverrides);
        return await response.value();
    }

    /**
     * ### Required permissions    * User account permission: `media:access`   * License component: media 
     */
    async getAllAssetRatingsRaw(requestParameters: GetAllAssetRatingsRequest, initOverrides?: RequestInit): Promise<runtime.ApiResponse<Array<AssetRating>>> {
        const queryParameters: any = {};

        if (requestParameters.user !== undefined) {
            queryParameters['user'] = requestParameters.user;
        }

        if (requestParameters.asset !== undefined) {
            queryParameters['asset'] = requestParameters.asset;
        }

        if (requestParameters.ordering !== undefined) {
            queryParameters['ordering'] = requestParameters.ordering;
        }

        if (requestParameters.limit !== undefined) {
            queryParameters['limit'] = requestParameters.limit;
        }

        if (requestParameters.offset !== undefined) {
            queryParameters['offset'] = requestParameters.offset;
        }

        const headerParameters: runtime.HTTPHeaders = {};

        if (this.configuration && this.configuration.apiKey) {
            headerParameters["Authorization"] = this.configuration.apiKey("Authorization"); // Bearer authentication
        }

        const response = await this.request({
            path: `/api/2/media/ratings`,
            method: 'GET',
            headers: headerParameters,
            query: queryParameters,
        }, initOverrides);

        return new runtime.JSONApiResponse(response, (jsonValue) => jsonValue.map(AssetRatingFromJSON));
    }

    /**
     * ### Required permissions    * User account permission: `media:access`   * License component: media 
     */
    async getAllAssetRatings(requestParameters: GetAllAssetRatingsRequest, initOverrides?: RequestInit): Promise<Array<AssetRating>> {
        const response = await this.getAllAssetRatingsRaw(requestParameters, initOverrides);
        return await response.value();
    }

    /**
     * ### Required permissions    * User account permission: `media:access`   * License component: media 
     */
    async getAllAssetSubtitleLinksRaw(requestParameters: GetAllAssetSubtitleLinksRequest, initOverrides?: RequestInit): Promise<runtime.ApiResponse<Array<AssetSubtitleLink>>> {
        const queryParameters: any = {};

        if (requestParameters.asset !== undefined) {
            queryParameters['asset'] = requestParameters.asset;
        }

        if (requestParameters.subtitle !== undefined) {
            queryParameters['subtitle'] = requestParameters.subtitle;
        }

        if (requestParameters.ordering !== undefined) {
            queryParameters['ordering'] = requestParameters.ordering;
        }

        if (requestParameters.limit !== undefined) {
            queryParameters['limit'] = requestParameters.limit;
        }

        if (requestParameters.offset !== undefined) {
            queryParameters['offset'] = requestParameters.offset;
        }

        const headerParameters: runtime.HTTPHeaders = {};

        if (this.configuration && this.configuration.apiKey) {
            headerParameters["Authorization"] = this.configuration.apiKey("Authorization"); // Bearer authentication
        }

        const response = await this.request({
            path: `/api/2/media/assets/subtitle-links`,
            method: 'GET',
            headers: headerParameters,
            query: queryParameters,
        }, initOverrides);

        return new runtime.JSONApiResponse(response, (jsonValue) => jsonValue.map(AssetSubtitleLinkFromJSON));
    }

    /**
     * ### Required permissions    * User account permission: `media:access`   * License component: media 
     */
    async getAllAssetSubtitleLinks(requestParameters: GetAllAssetSubtitleLinksRequest, initOverrides?: RequestInit): Promise<Array<AssetSubtitleLink>> {
        const response = await this.getAllAssetSubtitleLinksRaw(requestParameters, initOverrides);
        return await response.value();
    }

    /**
     * ### Required permissions    * User account permission: `media:access`   * License component: media 
     */
    async getAllAssetTapeBackupsRaw(requestParameters: GetAllAssetTapeBackupsRequest, initOverrides?: RequestInit): Promise<runtime.ApiResponse<Array<AssetBackup>>> {
        const queryParameters: any = {};

        if (requestParameters.asset !== undefined) {
            queryParameters['asset'] = requestParameters.asset;
        }

        if (requestParameters.ordering !== undefined) {
            queryParameters['ordering'] = requestParameters.ordering;
        }

        if (requestParameters.limit !== undefined) {
            queryParameters['limit'] = requestParameters.limit;
        }

        if (requestParameters.offset !== undefined) {
            queryParameters['offset'] = requestParameters.offset;
        }

        if (requestParameters.includeAsset !== undefined) {
            queryParameters['include_asset'] = requestParameters.includeAsset;
        }

        if (requestParameters.advancedSearch !== undefined) {
            queryParameters['advanced_search'] = requestParameters.advancedSearch;
        }

        const headerParameters: runtime.HTTPHeaders = {};

        if (this.configuration && this.configuration.apiKey) {
            headerParameters["Authorization"] = this.configuration.apiKey("Authorization"); // Bearer authentication
        }

        const response = await this.request({
            path: `/api/2/media/backups`,
            method: 'GET',
            headers: headerParameters,
            query: queryParameters,
        }, initOverrides);

        return new runtime.JSONApiResponse(response, (jsonValue) => jsonValue.map(AssetBackupFromJSON));
    }

    /**
     * ### Required permissions    * User account permission: `media:access`   * License component: media 
     */
    async getAllAssetTapeBackups(requestParameters: GetAllAssetTapeBackupsRequest, initOverrides?: RequestInit): Promise<Array<AssetBackup>> {
        const response = await this.getAllAssetTapeBackupsRaw(requestParameters, initOverrides);
        return await response.value();
    }

    /**
     * ### Required permissions    * User account permission: `media:access`   * License component: media 
     */
    async getAllAssetsRaw(requestParameters: GetAllAssetsRequest, initOverrides?: RequestInit): Promise<runtime.ApiResponse<Array<Asset>>> {
        const queryParameters: any = {};

        if (requestParameters.syncId !== undefined) {
            queryParameters['sync_id'] = requestParameters.syncId;
        }

        if (requestParameters.displayName !== undefined) {
            queryParameters['display_name'] = requestParameters.displayName;
        }

        if (requestParameters.set !== undefined) {
            queryParameters['set'] = requestParameters.set;
        }

        if (requestParameters.ordering !== undefined) {
            queryParameters['ordering'] = requestParameters.ordering;
        }

        if (requestParameters.limit !== undefined) {
            queryParameters['limit'] = requestParameters.limit;
        }

        if (requestParameters.offset !== undefined) {
            queryParameters['offset'] = requestParameters.offset;
        }

        if (requestParameters.includeProxies !== undefined) {
            queryParameters['include_proxies'] = requestParameters.includeProxies;
        }

        if (requestParameters.includeModifiedBy !== undefined) {
            queryParameters['include_modified_by'] = requestParameters.includeModifiedBy;
        }

        if (requestParameters.resolveAssetPermission !== undefined) {
            queryParameters['resolve_asset_permission'] = requestParameters.resolveAssetPermission;
        }

        if (requestParameters.forRoot !== undefined) {
            queryParameters['for_root'] = requestParameters.forRoot;
        }

        const headerParameters: runtime.HTTPHeaders = {};

        if (this.configuration && this.configuration.apiKey) {
            headerParameters["Authorization"] = this.configuration.apiKey("Authorization"); // Bearer authentication
        }

        const response = await this.request({
            path: `/api/2/media/assets`,
            method: 'GET',
            headers: headerParameters,
            query: queryParameters,
        }, initOverrides);

        return new runtime.JSONApiResponse(response, (jsonValue) => jsonValue.map(AssetFromJSON));
    }

    /**
     * ### Required permissions    * User account permission: `media:access`   * License component: media 
     */
    async getAllAssets(requestParameters: GetAllAssetsRequest, initOverrides?: RequestInit): Promise<Array<Asset>> {
        const response = await this.getAllAssetsRaw(requestParameters, initOverrides);
        return await response.value();
    }

    /**
     * ### Required permissions    * <class \'rest_framework.permissions.AllowAny\'> 
     */
    async getAllBundlesForMediaRootRaw(requestParameters: GetAllBundlesForMediaRootRequest, initOverrides?: RequestInit): Promise<runtime.ApiResponse<Array<MediaFileBundle>>> {
        if (requestParameters.root === null || requestParameters.root === undefined) {
            throw new runtime.RequiredError('root','Required parameter requestParameters.root was null or undefined when calling getAllBundlesForMediaRoot.');
        }

        const queryParameters: any = {};

        if (requestParameters.asset !== undefined) {
            queryParameters['asset'] = requestParameters.asset;
        }

        if (requestParameters.location !== undefined) {
            queryParameters['location'] = requestParameters.location;
        }

        if (requestParameters.sharedViaTokens !== undefined) {
            queryParameters['shared_via_tokens'] = requestParameters.sharedViaTokens;
        }

        if (requestParameters.sharedViaTokensToken !== undefined) {
            queryParameters['shared_via_tokens__token'] = requestParameters.sharedViaTokensToken;
        }

        if (requestParameters.name !== undefined) {
            queryParameters['name'] = requestParameters.name;
        }

        if (requestParameters.ordering !== undefined) {
            queryParameters['ordering'] = requestParameters.ordering;
        }

        if (requestParameters.limit !== undefined) {
            queryParameters['limit'] = requestParameters.limit;
        }

        if (requestParameters.offset !== undefined) {
            queryParameters['offset'] = requestParameters.offset;
        }

        const headerParameters: runtime.HTTPHeaders = {};

        if (this.configuration && this.configuration.apiKey) {
            headerParameters["Authorization"] = this.configuration.apiKey("Authorization"); // Bearer authentication
        }

        const response = await this.request({
            path: `/api/2/media/bundles/flat/{root}`.replace(`{${"root"}}`, encodeURIComponent(String(requestParameters.root))),
            method: 'GET',
            headers: headerParameters,
            query: queryParameters,
        }, initOverrides);

        return new runtime.JSONApiResponse(response, (jsonValue) => jsonValue.map(MediaFileBundleFromJSON));
    }

    /**
     * ### Required permissions    * <class \'rest_framework.permissions.AllowAny\'> 
     */
    async getAllBundlesForMediaRoot(requestParameters: GetAllBundlesForMediaRootRequest, initOverrides?: RequestInit): Promise<Array<MediaFileBundle>> {
        const response = await this.getAllBundlesForMediaRootRaw(requestParameters, initOverrides);
        return await response.value();
    }

    /**
     * ### Required permissions    * <class \'rest_framework.permissions.AllowAny\'> 
     */
    async getAllBundlesInSubtreeRaw(requestParameters: GetAllBundlesInSubtreeRequest, initOverrides?: RequestInit): Promise<runtime.ApiResponse<Array<MediaFileBundle>>> {
        if (requestParameters.file === null || requestParameters.file === undefined) {
            throw new runtime.RequiredError('file','Required parameter requestParameters.file was null or undefined when calling getAllBundlesInSubtree.');
        }

        const queryParameters: any = {};

        if (requestParameters.asset !== undefined) {
            queryParameters['asset'] = requestParameters.asset;
        }

        if (requestParameters.location !== undefined) {
            queryParameters['location'] = requestParameters.location;
        }

        if (requestParameters.sharedViaTokens !== undefined) {
            queryParameters['shared_via_tokens'] = requestParameters.sharedViaTokens;
        }

        if (requestParameters.sharedViaTokensToken !== undefined) {
            queryParameters['shared_via_tokens__token'] = requestParameters.sharedViaTokensToken;
        }

        if (requestParameters.name !== undefined) {
            queryParameters['name'] = requestParameters.name;
        }

        if (requestParameters.ordering !== undefined) {
            queryParameters['ordering'] = requestParameters.ordering;
        }

        if (requestParameters.limit !== undefined) {
            queryParameters['limit'] = requestParameters.limit;
        }

        if (requestParameters.offset !== undefined) {
            queryParameters['offset'] = requestParameters.offset;
        }

        const headerParameters: runtime.HTTPHeaders = {};

        if (this.configuration && this.configuration.apiKey) {
            headerParameters["Authorization"] = this.configuration.apiKey("Authorization"); // Bearer authentication
        }

        const response = await this.request({
            path: `/api/2/media/bundles/flat/subtree/{file}`.replace(`{${"file"}}`, encodeURIComponent(String(requestParameters.file))),
            method: 'GET',
            headers: headerParameters,
            query: queryParameters,
        }, initOverrides);

        return new runtime.JSONApiResponse(response, (jsonValue) => jsonValue.map(MediaFileBundleFromJSON));
    }

    /**
     * ### Required permissions    * <class \'rest_framework.permissions.AllowAny\'> 
     */
    async getAllBundlesInSubtree(requestParameters: GetAllBundlesInSubtreeRequest, initOverrides?: RequestInit): Promise<Array<MediaFileBundle>> {
        const response = await this.getAllBundlesInSubtreeRaw(requestParameters, initOverrides);
        return await response.value();
    }

    /**
     * ### Required permissions    * User account permission: `media:access`   * License component: media 
     */
    async getAllClickLinksRaw(requestParameters: GetAllClickLinksRequest, initOverrides?: RequestInit): Promise<runtime.ApiResponse<Array<AssetCloudLink>>> {
        const queryParameters: any = {};

        if (requestParameters.asset !== undefined) {
            queryParameters['asset'] = requestParameters.asset;
        }

        if (requestParameters.connection !== undefined) {
            queryParameters['connection'] = requestParameters.connection;
        }

        if (requestParameters.ordering !== undefined) {
            queryParameters['ordering'] = requestParameters.ordering;
        }

        if (requestParameters.limit !== undefined) {
            queryParameters['limit'] = requestParameters.limit;
        }

        if (requestParameters.offset !== undefined) {
            queryParameters['offset'] = requestParameters.offset;
        }

        const headerParameters: runtime.HTTPHeaders = {};

        if (this.configuration && this.configuration.apiKey) {
            headerParameters["Authorization"] = this.configuration.apiKey("Authorization"); // Bearer authentication
        }

        const response = await this.request({
            path: `/api/2/media/assets/click-links`,
            method: 'GET',
            headers: headerParameters,
            query: queryParameters,
        }, initOverrides);

        return new runtime.JSONApiResponse(response, (jsonValue) => jsonValue.map(AssetCloudLinkFromJSON));
    }

    /**
     * ### Required permissions    * User account permission: `media:access`   * License component: media 
     */
    async getAllClickLinks(requestParameters: GetAllClickLinksRequest, initOverrides?: RequestInit): Promise<Array<AssetCloudLink>> {
        const response = await this.getAllClickLinksRaw(requestParameters, initOverrides);
        return await response.value();
    }

    /**
     * ### Required permissions    * User account permission: `media:access`   * License component: media 
     */
    async getAllCommentsRaw(requestParameters: GetAllCommentsRequest, initOverrides?: RequestInit): Promise<runtime.ApiResponse<Array<Comment>>> {
        const queryParameters: any = {};

        if (requestParameters.asset !== undefined) {
            queryParameters['asset'] = requestParameters.asset;
        }

        if (requestParameters.root !== undefined) {
            queryParameters['root'] = requestParameters.root;
        }

        if (requestParameters.user !== undefined) {
            queryParameters['user'] = requestParameters.user;
        }

        if (requestParameters.ordering !== undefined) {
            queryParameters['ordering'] = requestParameters.ordering;
        }

        if (requestParameters.limit !== undefined) {
            queryParameters['limit'] = requestParameters.limit;
        }

        if (requestParameters.offset !== undefined) {
            queryParameters['offset'] = requestParameters.offset;
        }

        if (requestParameters.forRoot !== undefined) {
            queryParameters['for_root'] = requestParameters.forRoot;
        }

        if (requestParameters.tasksForUser !== undefined) {
            queryParameters['tasks_for_user'] = requestParameters.tasksForUser;
        }

        if (requestParameters.includeFullAsset !== undefined) {
            queryParameters['include_full_asset'] = requestParameters.includeFullAsset;
        }

        if (requestParameters.advancedSearch !== undefined) {
            queryParameters['advanced_search'] = requestParameters.advancedSearch;
        }

        const headerParameters: runtime.HTTPHeaders = {};

        if (this.configuration && this.configuration.apiKey) {
            headerParameters["Authorization"] = this.configuration.apiKey("Authorization"); // Bearer authentication
        }

        const response = await this.request({
            path: `/api/2/media/comments`,
            method: 'GET',
            headers: headerParameters,
            query: queryParameters,
        }, initOverrides);

        return new runtime.JSONApiResponse(response, (jsonValue) => jsonValue.map(CommentFromJSON));
    }

    /**
     * ### Required permissions    * User account permission: `media:access`   * License component: media 
     */
    async getAllComments(requestParameters: GetAllCommentsRequest, initOverrides?: RequestInit): Promise<Array<Comment>> {
        const response = await this.getAllCommentsRaw(requestParameters, initOverrides);
        return await response.value();
    }

    /**
     * ### Required permissions    * User account permission: `media:access` (read) / `media:roots:manage` (write)   * License component: media 
     */
    async getAllCustomFieldsRaw(requestParameters: GetAllCustomFieldsRequest, initOverrides?: RequestInit): Promise<runtime.ApiResponse<Array<CustomField>>> {
        const queryParameters: any = {};

        if (requestParameters.ordering !== undefined) {
            queryParameters['ordering'] = requestParameters.ordering;
        }

        if (requestParameters.limit !== undefined) {
            queryParameters['limit'] = requestParameters.limit;
        }

        if (requestParameters.offset !== undefined) {
            queryParameters['offset'] = requestParameters.offset;
        }

        const headerParameters: runtime.HTTPHeaders = {};

        if (this.configuration && this.configuration.apiKey) {
            headerParameters["Authorization"] = this.configuration.apiKey("Authorization"); // Bearer authentication
        }

        const response = await this.request({
            path: `/api/2/media/custom-fields`,
            method: 'GET',
            headers: headerParameters,
            query: queryParameters,
        }, initOverrides);

        return new runtime.JSONApiResponse(response, (jsonValue) => jsonValue.map(CustomFieldFromJSON));
    }

    /**
     * ### Required permissions    * User account permission: `media:access` (read) / `media:roots:manage` (write)   * License component: media 
     */
    async getAllCustomFields(requestParameters: GetAllCustomFieldsRequest, initOverrides?: RequestInit): Promise<Array<CustomField>> {
        const response = await this.getAllCustomFieldsRaw(requestParameters, initOverrides);
        return await response.value();
    }

    /**
     * ### Required permissions    * User account permission: `media:access` (read) / `system:admin-access` (write) 
     */
    async getAllExternalTranscodersRaw(requestParameters: GetAllExternalTranscodersRequest, initOverrides?: RequestInit): Promise<runtime.ApiResponse<Array<ExternalTranscoder>>> {
        const queryParameters: any = {};

        if (requestParameters.name !== undefined) {
            queryParameters['name'] = requestParameters.name;
        }

        if (requestParameters.id !== undefined) {
            queryParameters['id'] = requestParameters.id;
        }

        if (requestParameters.ordering !== undefined) {
            queryParameters['ordering'] = requestParameters.ordering;
        }

        if (requestParameters.limit !== undefined) {
            queryParameters['limit'] = requestParameters.limit;
        }

        if (requestParameters.offset !== undefined) {
            queryParameters['offset'] = requestParameters.offset;
        }

        const headerParameters: runtime.HTTPHeaders = {};

        if (this.configuration && this.configuration.apiKey) {
            headerParameters["Authorization"] = this.configuration.apiKey("Authorization"); // Bearer authentication
        }

        const response = await this.request({
            path: `/api/2/media/external-transcoders`,
            method: 'GET',
            headers: headerParameters,
            query: queryParameters,
        }, initOverrides);

        return new runtime.JSONApiResponse(response, (jsonValue) => jsonValue.map(ExternalTranscoderFromJSON));
    }

    /**
     * ### Required permissions    * User account permission: `media:access` (read) / `system:admin-access` (write) 
     */
    async getAllExternalTranscoders(requestParameters: GetAllExternalTranscodersRequest, initOverrides?: RequestInit): Promise<Array<ExternalTranscoder>> {
        const response = await this.getAllExternalTranscodersRaw(requestParameters, initOverrides);
        return await response.value();
    }

    /**
     * ### Required permissions    * User account permission: `media:access`   * License component: media 
     */
    async getAllMarkersRaw(requestParameters: GetAllMarkersRequest, initOverrides?: RequestInit): Promise<runtime.ApiResponse<Array<Marker>>> {
        const queryParameters: any = {};

        if (requestParameters.asset !== undefined) {
            queryParameters['asset'] = requestParameters.asset;
        }

        if (requestParameters.user !== undefined) {
            queryParameters['user'] = requestParameters.user;
        }

        if (requestParameters.ordering !== undefined) {
            queryParameters['ordering'] = requestParameters.ordering;
        }

        if (requestParameters.limit !== undefined) {
            queryParameters['limit'] = requestParameters.limit;
        }

        if (requestParameters.offset !== undefined) {
            queryParameters['offset'] = requestParameters.offset;
        }

        const headerParameters: runtime.HTTPHeaders = {};

        if (this.configuration && this.configuration.apiKey) {
            headerParameters["Authorization"] = this.configuration.apiKey("Authorization"); // Bearer authentication
        }

        const response = await this.request({
            path: `/api/2/media/markers`,
            method: 'GET',
            headers: headerParameters,
            query: queryParameters,
        }, initOverrides);

        return new runtime.JSONApiResponse(response, (jsonValue) => jsonValue.map(MarkerFromJSON));
    }

    /**
     * ### Required permissions    * User account permission: `media:access`   * License component: media 
     */
    async getAllMarkers(requestParameters: GetAllMarkersRequest, initOverrides?: RequestInit): Promise<Array<Marker>> {
        const response = await this.getAllMarkersRaw(requestParameters, initOverrides);
        return await response.value();
    }

    /**
     * ### Required permissions    * <class \'rest_framework.permissions.AllowAny\'> 
     */
    async getAllMediaFileBundlesRaw(requestParameters: GetAllMediaFileBundlesRequest, initOverrides?: RequestInit): Promise<runtime.ApiResponse<Array<MediaFileBundle>>> {
        const queryParameters: any = {};

        if (requestParameters.asset !== undefined) {
            queryParameters['asset'] = requestParameters.asset;
        }

        if (requestParameters.location !== undefined) {
            queryParameters['location'] = requestParameters.location;
        }

        if (requestParameters.sharedViaTokens !== undefined) {
            queryParameters['shared_via_tokens'] = requestParameters.sharedViaTokens;
        }

        if (requestParameters.sharedViaTokensToken !== undefined) {
            queryParameters['shared_via_tokens__token'] = requestParameters.sharedViaTokensToken;
        }

        if (requestParameters.name !== undefined) {
            queryParameters['name'] = requestParameters.name;
        }

        if (requestParameters.ordering !== undefined) {
            queryParameters['ordering'] = requestParameters.ordering;
        }

        if (requestParameters.limit !== undefined) {
            queryParameters['limit'] = requestParameters.limit;
        }

        if (requestParameters.offset !== undefined) {
            queryParameters['offset'] = requestParameters.offset;
        }

        if (requestParameters.excludeDeleted !== undefined) {
            queryParameters['exclude_deleted'] = requestParameters.excludeDeleted;
        }

        if (requestParameters.excludeUnrecognized !== undefined) {
            queryParameters['exclude_unrecognized'] = requestParameters.excludeUnrecognized;
        }

        if (requestParameters.includeProxies !== undefined) {
            queryParameters['include_proxies'] = requestParameters.includeProxies;
        }

        if (requestParameters.includeParents !== undefined) {
            queryParameters['include_parents'] = requestParameters.includeParents;
        }

        if (requestParameters.advancedSearch !== undefined) {
            queryParameters['advanced_search'] = requestParameters.advancedSearch;
        }

        const headerParameters: runtime.HTTPHeaders = {};

        if (this.configuration && this.configuration.apiKey) {
            headerParameters["Authorization"] = this.configuration.apiKey("Authorization"); // Bearer authentication
        }

        const response = await this.request({
            path: `/api/2/media/bundles`,
            method: 'GET',
            headers: headerParameters,
            query: queryParameters,
        }, initOverrides);

        return new runtime.JSONApiResponse(response, (jsonValue) => jsonValue.map(MediaFileBundleFromJSON));
    }

    /**
     * ### Required permissions    * <class \'rest_framework.permissions.AllowAny\'> 
     */
    async getAllMediaFileBundles(requestParameters: GetAllMediaFileBundlesRequest, initOverrides?: RequestInit): Promise<Array<MediaFileBundle>> {
        const response = await this.getAllMediaFileBundlesRaw(requestParameters, initOverrides);
        return await response.value();
    }

    /**
     * ### Required permissions    * User account permission: `media:access`   * License component: media 
     */
    async getAllMediaFileTemplatesRaw(requestParameters: GetAllMediaFileTemplatesRequest, initOverrides?: RequestInit): Promise<runtime.ApiResponse<Array<MediaFileTemplate>>> {
        const queryParameters: any = {};

        if (requestParameters.ordering !== undefined) {
            queryParameters['ordering'] = requestParameters.ordering;
        }

        if (requestParameters.limit !== undefined) {
            queryParameters['limit'] = requestParameters.limit;
        }

        if (requestParameters.offset !== undefined) {
            queryParameters['offset'] = requestParameters.offset;
        }

        const headerParameters: runtime.HTTPHeaders = {};

        if (this.configuration && this.configuration.apiKey) {
            headerParameters["Authorization"] = this.configuration.apiKey("Authorization"); // Bearer authentication
        }

        const response = await this.request({
            path: `/api/2/media/files/templates`,
            method: 'GET',
            headers: headerParameters,
            query: queryParameters,
        }, initOverrides);

        return new runtime.JSONApiResponse(response, (jsonValue) => jsonValue.map(MediaFileTemplateFromJSON));
    }

    /**
     * ### Required permissions    * User account permission: `media:access`   * License component: media 
     */
    async getAllMediaFileTemplates(requestParameters: GetAllMediaFileTemplatesRequest, initOverrides?: RequestInit): Promise<Array<MediaFileTemplate>> {
        const response = await this.getAllMediaFileTemplatesRaw(requestParameters, initOverrides);
        return await response.value();
    }

    /**
     * ### Required permissions    * User account permission: `media:access`   * License component: media 
     */
    async getAllMediaFilesRaw(requestParameters: GetAllMediaFilesRequest, initOverrides?: RequestInit): Promise<runtime.ApiResponse<Array<MediaFile>>> {
        const queryParameters: any = {};

        if (requestParameters.bundle !== undefined) {
            queryParameters['bundle'] = requestParameters.bundle;
        }

        if (requestParameters.bundleIn !== undefined) {
            queryParameters['bundle__in'] = requestParameters.bundleIn;
        }

        if (requestParameters.parent !== undefined) {
            queryParameters['parent'] = requestParameters.parent;
        }

        if (requestParameters.path !== undefined) {
            queryParameters['path'] = requestParameters.path;
        }

        if (requestParameters.name !== undefined) {
            queryParameters['name'] = requestParameters.name;
        }

        if (requestParameters.isDir !== undefined) {
            queryParameters['is_dir'] = requestParameters.isDir;
        }

        if (requestParameters.isShowroom !== undefined) {
            queryParameters['is_showroom'] = requestParameters.isShowroom;
        }

        if (requestParameters.present !== undefined) {
            queryParameters['present'] = requestParameters.present;
        }

        if (requestParameters.volume !== undefined) {
            queryParameters['volume'] = requestParameters.volume;
        }

        if (requestParameters.sharedViaTokens !== undefined) {
            queryParameters['shared_via_tokens'] = requestParameters.sharedViaTokens;
        }

        if (requestParameters.sharedViaTokensToken !== undefined) {
            queryParameters['shared_via_tokens__token'] = requestParameters.sharedViaTokensToken;
        }

        if (requestParameters.ordering !== undefined) {
            queryParameters['ordering'] = requestParameters.ordering;
        }

        if (requestParameters.limit !== undefined) {
            queryParameters['limit'] = requestParameters.limit;
        }

        if (requestParameters.offset !== undefined) {
            queryParameters['offset'] = requestParameters.offset;
        }

        if (requestParameters.resolveFilePermission !== undefined) {
            queryParameters['resolve_file_permission'] = requestParameters.resolveFilePermission;
        }

        if (requestParameters.includeModifiedBy !== undefined) {
            queryParameters['include_modified_by'] = requestParameters.includeModifiedBy;
        }

        if (requestParameters.includeEffectiveCustomFields !== undefined) {
            queryParameters['include_effective_custom_fields'] = requestParameters.includeEffectiveCustomFields;
        }

        if (requestParameters.includeRoot !== undefined) {
            queryParameters['include_root'] = requestParameters.includeRoot;
        }

        if (requestParameters.includeParents !== undefined) {
            queryParameters['include_parents'] = requestParameters.includeParents;
        }

        if (requestParameters.advancedSearch !== undefined) {
            queryParameters['advanced_search'] = requestParameters.advancedSearch;
        }

        const headerParameters: runtime.HTTPHeaders = {};

        if (this.configuration && this.configuration.apiKey) {
            headerParameters["Authorization"] = this.configuration.apiKey("Authorization"); // Bearer authentication
        }

        const response = await this.request({
            path: `/api/2/media/files`,
            method: 'GET',
            headers: headerParameters,
            query: queryParameters,
        }, initOverrides);

        return new runtime.JSONApiResponse(response, (jsonValue) => jsonValue.map(MediaFileFromJSON));
    }

    /**
     * ### Required permissions    * User account permission: `media:access`   * License component: media 
     */
    async getAllMediaFiles(requestParameters: GetAllMediaFilesRequest, initOverrides?: RequestInit): Promise<Array<MediaFile>> {
        const response = await this.getAllMediaFilesRaw(requestParameters, initOverrides);
        return await response.value();
    }

    /**
     * ### Required permissions    * User account permission: `media:access`   * License component: media 
     */
    async getAllMediaFilesForBundlesRaw(requestParameters: GetAllMediaFilesForBundlesRequest, initOverrides?: RequestInit): Promise<runtime.ApiResponse<Array<MediaFile>>> {
        if (requestParameters.allMediaFilesForBundlesRequest === null || requestParameters.allMediaFilesForBundlesRequest === undefined) {
            throw new runtime.RequiredError('allMediaFilesForBundlesRequest','Required parameter requestParameters.allMediaFilesForBundlesRequest was null or undefined when calling getAllMediaFilesForBundles.');
        }

        const queryParameters: any = {};

        const headerParameters: runtime.HTTPHeaders = {};

        headerParameters['Content-Type'] = 'application/json';

        if (this.configuration && this.configuration.apiKey) {
            headerParameters["Authorization"] = this.configuration.apiKey("Authorization"); // Bearer authentication
        }

        const response = await this.request({
            path: `/api/2/media/files/for-bundles`,
            method: 'POST',
            headers: headerParameters,
            query: queryParameters,
            body: AllMediaFilesForBundlesRequestToJSON(requestParameters.allMediaFilesForBundlesRequest),
        }, initOverrides);

        return new runtime.JSONApiResponse(response, (jsonValue) => jsonValue.map(MediaFileFromJSON));
    }

    /**
     * ### Required permissions    * User account permission: `media:access`   * License component: media 
     */
    async getAllMediaFilesForBundles(requestParameters: GetAllMediaFilesForBundlesRequest, initOverrides?: RequestInit): Promise<Array<MediaFile>> {
        const response = await this.getAllMediaFilesForBundlesRaw(requestParameters, initOverrides);
        return await response.value();
    }

    /**
     * ### Required permissions    * User account permission: `media:access`   * License component: media 
     */
    async getAllMediaFilesForMediaRootRaw(requestParameters: GetAllMediaFilesForMediaRootRequest, initOverrides?: RequestInit): Promise<runtime.ApiResponse<Array<MediaFile>>> {
        if (requestParameters.root === null || requestParameters.root === undefined) {
            throw new runtime.RequiredError('root','Required parameter requestParameters.root was null or undefined when calling getAllMediaFilesForMediaRoot.');
        }

        const queryParameters: any = {};

        if (requestParameters.bundle !== undefined) {
            queryParameters['bundle'] = requestParameters.bundle;
        }

        if (requestParameters.bundleIn !== undefined) {
            queryParameters['bundle__in'] = requestParameters.bundleIn;
        }

        if (requestParameters.parent !== undefined) {
            queryParameters['parent'] = requestParameters.parent;
        }

        if (requestParameters.path !== undefined) {
            queryParameters['path'] = requestParameters.path;
        }

        if (requestParameters.name !== undefined) {
            queryParameters['name'] = requestParameters.name;
        }

        if (requestParameters.isDir !== undefined) {
            queryParameters['is_dir'] = requestParameters.isDir;
        }

        if (requestParameters.isShowroom !== undefined) {
            queryParameters['is_showroom'] = requestParameters.isShowroom;
        }

        if (requestParameters.present !== undefined) {
            queryParameters['present'] = requestParameters.present;
        }

        if (requestParameters.volume !== undefined) {
            queryParameters['volume'] = requestParameters.volume;
        }

        if (requestParameters.sharedViaTokens !== undefined) {
            queryParameters['shared_via_tokens'] = requestParameters.sharedViaTokens;
        }

        if (requestParameters.sharedViaTokensToken !== undefined) {
            queryParameters['shared_via_tokens__token'] = requestParameters.sharedViaTokensToken;
        }

        if (requestParameters.ordering !== undefined) {
            queryParameters['ordering'] = requestParameters.ordering;
        }

        if (requestParameters.limit !== undefined) {
            queryParameters['limit'] = requestParameters.limit;
        }

        if (requestParameters.offset !== undefined) {
            queryParameters['offset'] = requestParameters.offset;
        }

        const headerParameters: runtime.HTTPHeaders = {};

        if (this.configuration && this.configuration.apiKey) {
            headerParameters["Authorization"] = this.configuration.apiKey("Authorization"); // Bearer authentication
        }

        const response = await this.request({
            path: `/api/2/media/files/flat/{root}`.replace(`{${"root"}}`, encodeURIComponent(String(requestParameters.root))),
            method: 'GET',
            headers: headerParameters,
            query: queryParameters,
        }, initOverrides);

        return new runtime.JSONApiResponse(response, (jsonValue) => jsonValue.map(MediaFileFromJSON));
    }

    /**
     * ### Required permissions    * User account permission: `media:access`   * License component: media 
     */
    async getAllMediaFilesForMediaRoot(requestParameters: GetAllMediaFilesForMediaRootRequest, initOverrides?: RequestInit): Promise<Array<MediaFile>> {
        const response = await this.getAllMediaFilesForMediaRootRaw(requestParameters, initOverrides);
        return await response.value();
    }

    /**
     * ### Required permissions    * User account permission: `media:access`   * License component: media 
     */
    async getAllMediaFilesInSubtreeRaw(requestParameters: GetAllMediaFilesInSubtreeRequest, initOverrides?: RequestInit): Promise<runtime.ApiResponse<Array<MediaFile>>> {
        if (requestParameters.file === null || requestParameters.file === undefined) {
            throw new runtime.RequiredError('file','Required parameter requestParameters.file was null or undefined when calling getAllMediaFilesInSubtree.');
        }

        const queryParameters: any = {};

        if (requestParameters.bundle !== undefined) {
            queryParameters['bundle'] = requestParameters.bundle;
        }

        if (requestParameters.bundleIn !== undefined) {
            queryParameters['bundle__in'] = requestParameters.bundleIn;
        }

        if (requestParameters.parent !== undefined) {
            queryParameters['parent'] = requestParameters.parent;
        }

        if (requestParameters.path !== undefined) {
            queryParameters['path'] = requestParameters.path;
        }

        if (requestParameters.name !== undefined) {
            queryParameters['name'] = requestParameters.name;
        }

        if (requestParameters.isDir !== undefined) {
            queryParameters['is_dir'] = requestParameters.isDir;
        }

        if (requestParameters.isShowroom !== undefined) {
            queryParameters['is_showroom'] = requestParameters.isShowroom;
        }

        if (requestParameters.present !== undefined) {
            queryParameters['present'] = requestParameters.present;
        }

        if (requestParameters.volume !== undefined) {
            queryParameters['volume'] = requestParameters.volume;
        }

        if (requestParameters.sharedViaTokens !== undefined) {
            queryParameters['shared_via_tokens'] = requestParameters.sharedViaTokens;
        }

        if (requestParameters.sharedViaTokensToken !== undefined) {
            queryParameters['shared_via_tokens__token'] = requestParameters.sharedViaTokensToken;
        }

        if (requestParameters.ordering !== undefined) {
            queryParameters['ordering'] = requestParameters.ordering;
        }

        if (requestParameters.limit !== undefined) {
            queryParameters['limit'] = requestParameters.limit;
        }

        if (requestParameters.offset !== undefined) {
            queryParameters['offset'] = requestParameters.offset;
        }

        const headerParameters: runtime.HTTPHeaders = {};

        if (this.configuration && this.configuration.apiKey) {
            headerParameters["Authorization"] = this.configuration.apiKey("Authorization"); // Bearer authentication
        }

        const response = await this.request({
            path: `/api/2/media/files/flat/subtree/{file}`.replace(`{${"file"}}`, encodeURIComponent(String(requestParameters.file))),
            method: 'GET',
            headers: headerParameters,
            query: queryParameters,
        }, initOverrides);

        return new runtime.JSONApiResponse(response, (jsonValue) => jsonValue.map(MediaFileFromJSON));
    }

    /**
     * ### Required permissions    * User account permission: `media:access`   * License component: media 
     */
    async getAllMediaFilesInSubtree(requestParameters: GetAllMediaFilesInSubtreeRequest, initOverrides?: RequestInit): Promise<Array<MediaFile>> {
        const response = await this.getAllMediaFilesInSubtreeRaw(requestParameters, initOverrides);
        return await response.value();
    }

    /**
     * ### Required permissions    * User account permission: `media:access` (read) / `media:roots:manage` (write)   * License component: media 
     */
    async getAllMediaRootPermissionsRaw(requestParameters: GetAllMediaRootPermissionsRequest, initOverrides?: RequestInit): Promise<runtime.ApiResponse<Array<MediaRootPermission>>> {
        const queryParameters: any = {};

        if (requestParameters.root !== undefined) {
            queryParameters['root'] = requestParameters.root;
        }

        if (requestParameters.id !== undefined) {
            queryParameters['id'] = requestParameters.id;
        }

        if (requestParameters.ordering !== undefined) {
            queryParameters['ordering'] = requestParameters.ordering;
        }

        if (requestParameters.limit !== undefined) {
            queryParameters['limit'] = requestParameters.limit;
        }

        if (requestParameters.offset !== undefined) {
            queryParameters['offset'] = requestParameters.offset;
        }

        const headerParameters: runtime.HTTPHeaders = {};

        if (this.configuration && this.configuration.apiKey) {
            headerParameters["Authorization"] = this.configuration.apiKey("Authorization"); // Bearer authentication
        }

        const response = await this.request({
            path: `/api/2/media/root-permissions`,
            method: 'GET',
            headers: headerParameters,
            query: queryParameters,
        }, initOverrides);

        return new runtime.JSONApiResponse(response, (jsonValue) => jsonValue.map(MediaRootPermissionFromJSON));
    }

    /**
     * ### Required permissions    * User account permission: `media:access` (read) / `media:roots:manage` (write)   * License component: media 
     */
    async getAllMediaRootPermissions(requestParameters: GetAllMediaRootPermissionsRequest, initOverrides?: RequestInit): Promise<Array<MediaRootPermission>> {
        const response = await this.getAllMediaRootPermissionsRaw(requestParameters, initOverrides);
        return await response.value();
    }

    /**
     * ### Required permissions    * User account permission: `media:access` (read) / `media:roots:manage` (write)   * License component: media 
     */
    async getAllMediaRootsRaw(requestParameters: GetAllMediaRootsRequest, initOverrides?: RequestInit): Promise<runtime.ApiResponse<Array<MediaRoot>>> {
        const queryParameters: any = {};

        if (requestParameters.path !== undefined) {
            queryParameters['path'] = requestParameters.path;
        }

        if (requestParameters.volume !== undefined) {
            queryParameters['volume'] = requestParameters.volume;
        }

        if (requestParameters.name !== undefined) {
            queryParameters['name'] = requestParameters.name;
        }

        if (requestParameters.ordering !== undefined) {
            queryParameters['ordering'] = requestParameters.ordering;
        }

        if (requestParameters.limit !== undefined) {
            queryParameters['limit'] = requestParameters.limit;
        }

        if (requestParameters.offset !== undefined) {
            queryParameters['offset'] = requestParameters.offset;
        }

        if (requestParameters.resolvePermissions !== undefined) {
            queryParameters['resolve_permissions'] = requestParameters.resolvePermissions;
        }

        const headerParameters: runtime.HTTPHeaders = {};

        if (this.configuration && this.configuration.apiKey) {
            headerParameters["Authorization"] = this.configuration.apiKey("Authorization"); // Bearer authentication
        }

        const response = await this.request({
            path: `/api/2/media/roots`,
            method: 'GET',
            headers: headerParameters,
            query: queryParameters,
        }, initOverrides);

        return new runtime.JSONApiResponse(response, (jsonValue) => jsonValue.map(MediaRootFromJSON));
    }

    /**
     * ### Required permissions    * User account permission: `media:access` (read) / `media:roots:manage` (write)   * License component: media 
     */
    async getAllMediaRoots(requestParameters: GetAllMediaRootsRequest, initOverrides?: RequestInit): Promise<Array<MediaRoot>> {
        const response = await this.getAllMediaRootsRaw(requestParameters, initOverrides);
        return await response.value();
    }

    /**
     * ### Required permissions    * User account permission: `media:access`   * License component: media 
     */
    async getAllMediaTagsRaw(requestParameters: GetAllMediaTagsRequest, initOverrides?: RequestInit): Promise<runtime.ApiResponse<Array<UnfilteredTag>>> {
        const queryParameters: any = {};

        if (requestParameters.name !== undefined) {
            queryParameters['name'] = requestParameters.name;
        }

        if (requestParameters.nameIcontains !== undefined) {
            queryParameters['name__icontains'] = requestParameters.nameIcontains;
        }

        if (requestParameters.roots !== undefined) {
            queryParameters['roots'] = requestParameters.roots;
        }

        if (requestParameters.rootsIsnull !== undefined) {
            queryParameters['roots__isnull'] = requestParameters.rootsIsnull;
        }

        if (requestParameters.shared !== undefined) {
            queryParameters['shared'] = requestParameters.shared;
        }

        if (requestParameters.ordering !== undefined) {
            queryParameters['ordering'] = requestParameters.ordering;
        }

        if (requestParameters.limit !== undefined) {
            queryParameters['limit'] = requestParameters.limit;
        }

        if (requestParameters.offset !== undefined) {
            queryParameters['offset'] = requestParameters.offset;
        }

        if (requestParameters.forRoot !== undefined) {
            queryParameters['for_root'] = requestParameters.forRoot;
        }

        const headerParameters: runtime.HTTPHeaders = {};

        if (this.configuration && this.configuration.apiKey) {
            headerParameters["Authorization"] = this.configuration.apiKey("Authorization"); // Bearer authentication
        }

        const response = await this.request({
            path: `/api/2/media/tags`,
            method: 'GET',
            headers: headerParameters,
            query: queryParameters,
        }, initOverrides);

        return new runtime.JSONApiResponse(response, (jsonValue) => jsonValue.map(UnfilteredTagFromJSON));
    }

    /**
     * ### Required permissions    * User account permission: `media:access`   * License component: media 
     */
    async getAllMediaTags(requestParameters: GetAllMediaTagsRequest, initOverrides?: RequestInit): Promise<Array<UnfilteredTag>> {
        const response = await this.getAllMediaTagsRaw(requestParameters, initOverrides);
        return await response.value();
    }

    /**
     * ### Required permissions    * User account permission: `media:access` (read) / `media:updates:manage` (write)   * License component: media 
     */
    async getAllMediaUpdatesRaw(requestParameters: GetAllMediaUpdatesRequest, initOverrides?: RequestInit): Promise<runtime.ApiResponse<Array<MediaUpdate>>> {
        const queryParameters: any = {};

        if (requestParameters.asset !== undefined) {
            queryParameters['asset'] = requestParameters.asset;
        }

        if (requestParameters.user !== undefined) {
            queryParameters['user'] = requestParameters.user;
        }

        if (requestParameters.root !== undefined) {
            queryParameters['root'] = requestParameters.root;
        }

        if (requestParameters.ordering !== undefined) {
            queryParameters['ordering'] = requestParameters.ordering;
        }

        if (requestParameters.limit !== undefined) {
            queryParameters['limit'] = requestParameters.limit;
        }

        if (requestParameters.offset !== undefined) {
            queryParameters['offset'] = requestParameters.offset;
        }

        const headerParameters: runtime.HTTPHeaders = {};

        if (this.configuration && this.configuration.apiKey) {
            headerParameters["Authorization"] = this.configuration.apiKey("Authorization"); // Bearer authentication
        }

        const response = await this.request({
            path: `/api/2/media/updates`,
            method: 'GET',
            headers: headerParameters,
            query: queryParameters,
        }, initOverrides);

        return new runtime.JSONApiResponse(response, (jsonValue) => jsonValue.map(MediaUpdateFromJSON));
    }

    /**
     * ### Required permissions    * User account permission: `media:access` (read) / `media:updates:manage` (write)   * License component: media 
     */
    async getAllMediaUpdates(requestParameters: GetAllMediaUpdatesRequest, initOverrides?: RequestInit): Promise<Array<MediaUpdate>> {
        const response = await this.getAllMediaUpdatesRaw(requestParameters, initOverrides);
        return await response.value();
    }

    /**
     * ### Required permissions    * User account permission: `media:access` 
     */
    async getAllProxyGeneratorsRaw(requestParameters: GetAllProxyGeneratorsRequest, initOverrides?: RequestInit): Promise<runtime.ApiResponse<Array<ProxyGenerator>>> {
        const queryParameters: any = {};

        if (requestParameters.ordering !== undefined) {
            queryParameters['ordering'] = requestParameters.ordering;
        }

        if (requestParameters.limit !== undefined) {
            queryParameters['limit'] = requestParameters.limit;
        }

        if (requestParameters.offset !== undefined) {
            queryParameters['offset'] = requestParameters.offset;
        }

        const headerParameters: runtime.HTTPHeaders = {};

        if (this.configuration && this.configuration.apiKey) {
            headerParameters["Authorization"] = this.configuration.apiKey("Authorization"); // Bearer authentication
        }

        const response = await this.request({
            path: `/api/2/media/proxy-generators`,
            method: 'GET',
            headers: headerParameters,
            query: queryParameters,
        }, initOverrides);

        return new runtime.JSONApiResponse(response, (jsonValue) => jsonValue.map(ProxyGeneratorFromJSON));
    }

    /**
     * ### Required permissions    * User account permission: `media:access` 
     */
    async getAllProxyGenerators(requestParameters: GetAllProxyGeneratorsRequest, initOverrides?: RequestInit): Promise<Array<ProxyGenerator>> {
        const response = await this.getAllProxyGeneratorsRaw(requestParameters, initOverrides);
        return await response.value();
    }

    /**
     * ### Required permissions    * User account permission: `media:access` (read) / `media:roots:manage` (write)   * License component: media 
     */
    async getAllProxyProfilesRaw(requestParameters: GetAllProxyProfilesRequest, initOverrides?: RequestInit): Promise<runtime.ApiResponse<Array<ProxyProfile>>> {
        const queryParameters: any = {};

        if (requestParameters.name !== undefined) {
            queryParameters['name'] = requestParameters.name;
        }

        if (requestParameters.ordering !== undefined) {
            queryParameters['ordering'] = requestParameters.ordering;
        }

        if (requestParameters.limit !== undefined) {
            queryParameters['limit'] = requestParameters.limit;
        }

        if (requestParameters.offset !== undefined) {
            queryParameters['offset'] = requestParameters.offset;
        }

        if (requestParameters.forRoot !== undefined) {
            queryParameters['for_root'] = requestParameters.forRoot;
        }

        const headerParameters: runtime.HTTPHeaders = {};

        if (this.configuration && this.configuration.apiKey) {
            headerParameters["Authorization"] = this.configuration.apiKey("Authorization"); // Bearer authentication
        }

        const response = await this.request({
            path: `/api/2/media/proxy-profiles`,
            method: 'GET',
            headers: headerParameters,
            query: queryParameters,
        }, initOverrides);

        return new runtime.JSONApiResponse(response, (jsonValue) => jsonValue.map(ProxyProfileFromJSON));
    }

    /**
     * ### Required permissions    * User account permission: `media:access` (read) / `media:roots:manage` (write)   * License component: media 
     */
    async getAllProxyProfiles(requestParameters: GetAllProxyProfilesRequest, initOverrides?: RequestInit): Promise<Array<ProxyProfile>> {
        const response = await this.getAllProxyProfilesRaw(requestParameters, initOverrides);
        return await response.value();
    }

    /**
     * ### Required permissions    * User account permission: `media:access`   * License component: media 
     */
    async getAllSavedSearchesRaw(requestParameters: GetAllSavedSearchesRequest, initOverrides?: RequestInit): Promise<runtime.ApiResponse<Array<SavedSearch>>> {
        const queryParameters: any = {};

        if (requestParameters.shared !== undefined) {
            queryParameters['shared'] = requestParameters.shared;
        }

        if (requestParameters.name !== undefined) {
            queryParameters['name'] = requestParameters.name;
        }

        if (requestParameters.root !== undefined) {
            queryParameters['root'] = requestParameters.root;
        }

        if (requestParameters.user !== undefined) {
            queryParameters['user'] = requestParameters.user;
        }

        if (requestParameters.ordering !== undefined) {
            queryParameters['ordering'] = requestParameters.ordering;
        }

        if (requestParameters.limit !== undefined) {
            queryParameters['limit'] = requestParameters.limit;
        }

        if (requestParameters.offset !== undefined) {
            queryParameters['offset'] = requestParameters.offset;
        }

        const headerParameters: runtime.HTTPHeaders = {};

        if (this.configuration && this.configuration.apiKey) {
            headerParameters["Authorization"] = this.configuration.apiKey("Authorization"); // Bearer authentication
        }

        const response = await this.request({
            path: `/api/2/media/saved-searches`,
            method: 'GET',
            headers: headerParameters,
            query: queryParameters,
        }, initOverrides);

        return new runtime.JSONApiResponse(response, (jsonValue) => jsonValue.map(SavedSearchFromJSON));
    }

    /**
     * ### Required permissions    * User account permission: `media:access`   * License component: media 
     */
    async getAllSavedSearches(requestParameters: GetAllSavedSearchesRequest, initOverrides?: RequestInit): Promise<Array<SavedSearch>> {
        const response = await this.getAllSavedSearchesRaw(requestParameters, initOverrides);
        return await response.value();
    }

    /**
     * ### Required permissions    * User account permission: `media:access`   * License component: media 
     */
    async getAllSubclipClipboardEntriesRaw(requestParameters: GetAllSubclipClipboardEntriesRequest, initOverrides?: RequestInit): Promise<runtime.ApiResponse<Array<SubclipClipboardEntry>>> {
        const queryParameters: any = {};

        if (requestParameters.cut !== undefined) {
            queryParameters['cut'] = requestParameters.cut;
        }

        if (requestParameters.ordering !== undefined) {
            queryParameters['ordering'] = requestParameters.ordering;
        }

        if (requestParameters.limit !== undefined) {
            queryParameters['limit'] = requestParameters.limit;
        }

        if (requestParameters.offset !== undefined) {
            queryParameters['offset'] = requestParameters.offset;
        }

        const headerParameters: runtime.HTTPHeaders = {};

        if (this.configuration && this.configuration.apiKey) {
            headerParameters["Authorization"] = this.configuration.apiKey("Authorization"); // Bearer authentication
        }

        const response = await this.request({
            path: `/api/2/media/subclips/clipboard`,
            method: 'GET',
            headers: headerParameters,
            query: queryParameters,
        }, initOverrides);

        return new runtime.JSONApiResponse(response, (jsonValue) => jsonValue.map(SubclipClipboardEntryFromJSON));
    }

    /**
     * ### Required permissions    * User account permission: `media:access`   * License component: media 
     */
    async getAllSubclipClipboardEntries(requestParameters: GetAllSubclipClipboardEntriesRequest, initOverrides?: RequestInit): Promise<Array<SubclipClipboardEntry>> {
        const response = await this.getAllSubclipClipboardEntriesRaw(requestParameters, initOverrides);
        return await response.value();
    }

    /**
     * ### Required permissions    * User account permission: `media:access`   * License component: media 
     */
    async getAllSubclipsRaw(requestParameters: GetAllSubclipsRequest, initOverrides?: RequestInit): Promise<runtime.ApiResponse<Array<Subclip>>> {
        const queryParameters: any = {};

        if (requestParameters.asset !== undefined) {
            queryParameters['asset'] = requestParameters.asset;
        }

        if (requestParameters.assetIn !== undefined) {
            queryParameters['asset__in'] = requestParameters.assetIn;
        }

        if (requestParameters.root !== undefined) {
            queryParameters['root'] = requestParameters.root;
        }

        if (requestParameters.name !== undefined) {
            queryParameters['name'] = requestParameters.name;
        }

        if (requestParameters.ordering !== undefined) {
            queryParameters['ordering'] = requestParameters.ordering;
        }

        if (requestParameters.limit !== undefined) {
            queryParameters['limit'] = requestParameters.limit;
        }

        if (requestParameters.offset !== undefined) {
            queryParameters['offset'] = requestParameters.offset;
        }

        const headerParameters: runtime.HTTPHeaders = {};

        if (this.configuration && this.configuration.apiKey) {
            headerParameters["Authorization"] = this.configuration.apiKey("Authorization"); // Bearer authentication
        }

        const response = await this.request({
            path: `/api/2/media/subclips`,
            method: 'GET',
            headers: headerParameters,
            query: queryParameters,
        }, initOverrides);

        return new runtime.JSONApiResponse(response, (jsonValue) => jsonValue.map(SubclipFromJSON));
    }

    /**
     * ### Required permissions    * User account permission: `media:access`   * License component: media 
     */
    async getAllSubclips(requestParameters: GetAllSubclipsRequest, initOverrides?: RequestInit): Promise<Array<Subclip>> {
        const response = await this.getAllSubclipsRaw(requestParameters, initOverrides);
        return await response.value();
    }

    /**
     * ### Required permissions    * User account permission: `media:access`   * License component: media 
     */
    async getAllSubtitleClipboardEntriesRaw(requestParameters: GetAllSubtitleClipboardEntriesRequest, initOverrides?: RequestInit): Promise<runtime.ApiResponse<Array<SubtitleClipboardEntry>>> {
        const queryParameters: any = {};

        if (requestParameters.subtitle !== undefined) {
            queryParameters['subtitle'] = requestParameters.subtitle;
        }

        if (requestParameters.ordering !== undefined) {
            queryParameters['ordering'] = requestParameters.ordering;
        }

        if (requestParameters.limit !== undefined) {
            queryParameters['limit'] = requestParameters.limit;
        }

        if (requestParameters.offset !== undefined) {
            queryParameters['offset'] = requestParameters.offset;
        }

        const headerParameters: runtime.HTTPHeaders = {};

        if (this.configuration && this.configuration.apiKey) {
            headerParameters["Authorization"] = this.configuration.apiKey("Authorization"); // Bearer authentication
        }

        const response = await this.request({
            path: `/api/2/media/subtitles/clipboard`,
            method: 'GET',
            headers: headerParameters,
            query: queryParameters,
        }, initOverrides);

        return new runtime.JSONApiResponse(response, (jsonValue) => jsonValue.map(SubtitleClipboardEntryFromJSON));
    }

    /**
     * ### Required permissions    * User account permission: `media:access`   * License component: media 
     */
    async getAllSubtitleClipboardEntries(requestParameters: GetAllSubtitleClipboardEntriesRequest, initOverrides?: RequestInit): Promise<Array<SubtitleClipboardEntry>> {
        const response = await this.getAllSubtitleClipboardEntriesRaw(requestParameters, initOverrides);
        return await response.value();
    }

    /**
     * ### Required permissions    * User account permission: `tasks:view` 
     */
    async getAllTranscoderProfilesRaw(requestParameters: GetAllTranscoderProfilesRequest, initOverrides?: RequestInit): Promise<runtime.ApiResponse<Array<TranscoderProfile>>> {
        const queryParameters: any = {};

        if (requestParameters.ordering !== undefined) {
            queryParameters['ordering'] = requestParameters.ordering;
        }

        if (requestParameters.limit !== undefined) {
            queryParameters['limit'] = requestParameters.limit;
        }

        if (requestParameters.offset !== undefined) {
            queryParameters['offset'] = requestParameters.offset;
        }

        const headerParameters: runtime.HTTPHeaders = {};

        if (this.configuration && this.configuration.apiKey) {
            headerParameters["Authorization"] = this.configuration.apiKey("Authorization"); // Bearer authentication
        }

        const response = await this.request({
            path: `/api/2/transcoder-profiles`,
            method: 'GET',
            headers: headerParameters,
            query: queryParameters,
        }, initOverrides);

        return new runtime.JSONApiResponse(response, (jsonValue) => jsonValue.map(TranscoderProfileFromJSON));
    }

    /**
     * ### Required permissions    * User account permission: `tasks:view` 
     */
    async getAllTranscoderProfiles(requestParameters: GetAllTranscoderProfilesRequest, initOverrides?: RequestInit): Promise<Array<TranscoderProfile>> {
        const response = await this.getAllTranscoderProfilesRaw(requestParameters, initOverrides);
        return await response.value();
    }

    /**
     * ### Required permissions    * User account permission: `media:access`   * License component: media 
     */
    async getAssetRaw(requestParameters: GetAssetRequest, initOverrides?: RequestInit): Promise<runtime.ApiResponse<Asset>> {
        if (requestParameters.id === null || requestParameters.id === undefined) {
            throw new runtime.RequiredError('id','Required parameter requestParameters.id was null or undefined when calling getAsset.');
        }

        const queryParameters: any = {};

        if (requestParameters.includeProxies !== undefined) {
            queryParameters['include_proxies'] = requestParameters.includeProxies;
        }

        if (requestParameters.includeModifiedBy !== undefined) {
            queryParameters['include_modified_by'] = requestParameters.includeModifiedBy;
        }

        if (requestParameters.resolveAssetPermission !== undefined) {
            queryParameters['resolve_asset_permission'] = requestParameters.resolveAssetPermission;
        }

        if (requestParameters.forRoot !== undefined) {
            queryParameters['for_root'] = requestParameters.forRoot;
        }

        const headerParameters: runtime.HTTPHeaders = {};

        if (this.configuration && this.configuration.apiKey) {
            headerParameters["Authorization"] = this.configuration.apiKey("Authorization"); // Bearer authentication
        }

        const response = await this.request({
            path: `/api/2/media/assets/{id}`.replace(`{${"id"}}`, encodeURIComponent(String(requestParameters.id))),
            method: 'GET',
            headers: headerParameters,
            query: queryParameters,
        }, initOverrides);

        return new runtime.JSONApiResponse(response, (jsonValue) => AssetFromJSON(jsonValue));
    }

    /**
     * ### Required permissions    * User account permission: `media:access`   * License component: media 
     */
    async getAsset(requestParameters: GetAssetRequest, initOverrides?: RequestInit): Promise<Asset> {
        const response = await this.getAssetRaw(requestParameters, initOverrides);
        return await response.value();
    }

    /**
     * ### Required permissions    * User account permission: `media:access`   * License component: media 
     */
    async getAssetRatingRaw(requestParameters: GetAssetRatingRequest, initOverrides?: RequestInit): Promise<runtime.ApiResponse<AssetRating>> {
        if (requestParameters.id === null || requestParameters.id === undefined) {
            throw new runtime.RequiredError('id','Required parameter requestParameters.id was null or undefined when calling getAssetRating.');
        }

        const queryParameters: any = {};

        const headerParameters: runtime.HTTPHeaders = {};

        if (this.configuration && this.configuration.apiKey) {
            headerParameters["Authorization"] = this.configuration.apiKey("Authorization"); // Bearer authentication
        }

        const response = await this.request({
            path: `/api/2/media/ratings/{id}`.replace(`{${"id"}}`, encodeURIComponent(String(requestParameters.id))),
            method: 'GET',
            headers: headerParameters,
            query: queryParameters,
        }, initOverrides);

        return new runtime.JSONApiResponse(response, (jsonValue) => AssetRatingFromJSON(jsonValue));
    }

    /**
     * ### Required permissions    * User account permission: `media:access`   * License component: media 
     */
    async getAssetRating(requestParameters: GetAssetRatingRequest, initOverrides?: RequestInit): Promise<AssetRating> {
        const response = await this.getAssetRatingRaw(requestParameters, initOverrides);
        return await response.value();
    }

    /**
     * ### Required permissions    * User account permission: `media:access`   * License component: media 
     */
    async getAssetSubtitleLinkRaw(requestParameters: GetAssetSubtitleLinkRequest, initOverrides?: RequestInit): Promise<runtime.ApiResponse<AssetSubtitleLink>> {
        if (requestParameters.id === null || requestParameters.id === undefined) {
            throw new runtime.RequiredError('id','Required parameter requestParameters.id was null or undefined when calling getAssetSubtitleLink.');
        }

        const queryParameters: any = {};

        const headerParameters: runtime.HTTPHeaders = {};

        if (this.configuration && this.configuration.apiKey) {
            headerParameters["Authorization"] = this.configuration.apiKey("Authorization"); // Bearer authentication
        }

        const response = await this.request({
            path: `/api/2/media/assets/subtitle-links/{id}`.replace(`{${"id"}}`, encodeURIComponent(String(requestParameters.id))),
            method: 'GET',
            headers: headerParameters,
            query: queryParameters,
        }, initOverrides);

        return new runtime.JSONApiResponse(response, (jsonValue) => AssetSubtitleLinkFromJSON(jsonValue));
    }

    /**
     * ### Required permissions    * User account permission: `media:access`   * License component: media 
     */
    async getAssetSubtitleLink(requestParameters: GetAssetSubtitleLinkRequest, initOverrides?: RequestInit): Promise<AssetSubtitleLink> {
        const response = await this.getAssetSubtitleLinkRaw(requestParameters, initOverrides);
        return await response.value();
    }

    /**
     * ### Required permissions    * User account permission: `media:access`   * License component: media 
     */
    async getBookmarkedMediaFilesDirectoriesRaw(requestParameters: GetBookmarkedMediaFilesDirectoriesRequest, initOverrides?: RequestInit): Promise<runtime.ApiResponse<Array<MediaFile>>> {
        const queryParameters: any = {};

        if (requestParameters.bundle !== undefined) {
            queryParameters['bundle'] = requestParameters.bundle;
        }

        if (requestParameters.bundleIn !== undefined) {
            queryParameters['bundle__in'] = requestParameters.bundleIn;
        }

        if (requestParameters.parent !== undefined) {
            queryParameters['parent'] = requestParameters.parent;
        }

        if (requestParameters.path !== undefined) {
            queryParameters['path'] = requestParameters.path;
        }

        if (requestParameters.name !== undefined) {
            queryParameters['name'] = requestParameters.name;
        }

        if (requestParameters.isDir !== undefined) {
            queryParameters['is_dir'] = requestParameters.isDir;
        }

        if (requestParameters.isShowroom !== undefined) {
            queryParameters['is_showroom'] = requestParameters.isShowroom;
        }

        if (requestParameters.present !== undefined) {
            queryParameters['present'] = requestParameters.present;
        }

        if (requestParameters.volume !== undefined) {
            queryParameters['volume'] = requestParameters.volume;
        }

        if (requestParameters.sharedViaTokens !== undefined) {
            queryParameters['shared_via_tokens'] = requestParameters.sharedViaTokens;
        }

        if (requestParameters.sharedViaTokensToken !== undefined) {
            queryParameters['shared_via_tokens__token'] = requestParameters.sharedViaTokensToken;
        }

        if (requestParameters.ordering !== undefined) {
            queryParameters['ordering'] = requestParameters.ordering;
        }

        if (requestParameters.limit !== undefined) {
            queryParameters['limit'] = requestParameters.limit;
        }

        if (requestParameters.offset !== undefined) {
            queryParameters['offset'] = requestParameters.offset;
        }

        const headerParameters: runtime.HTTPHeaders = {};

        if (this.configuration && this.configuration.apiKey) {
            headerParameters["Authorization"] = this.configuration.apiKey("Authorization"); // Bearer authentication
        }

        const response = await this.request({
            path: `/api/2/media/files/bookmarks`,
            method: 'GET',
            headers: headerParameters,
            query: queryParameters,
        }, initOverrides);

        return new runtime.JSONApiResponse(response, (jsonValue) => jsonValue.map(MediaFileFromJSON));
    }

    /**
     * ### Required permissions    * User account permission: `media:access`   * License component: media 
     */
    async getBookmarkedMediaFilesDirectories(requestParameters: GetBookmarkedMediaFilesDirectoriesRequest, initOverrides?: RequestInit): Promise<Array<MediaFile>> {
        const response = await this.getBookmarkedMediaFilesDirectoriesRaw(requestParameters, initOverrides);
        return await response.value();
    }

    /**
     * ### Required permissions    * User account permission: `media:access`   * License component: media 
     */
    async getCommentRaw(requestParameters: GetCommentRequest, initOverrides?: RequestInit): Promise<runtime.ApiResponse<Comment>> {
        if (requestParameters.id === null || requestParameters.id === undefined) {
            throw new runtime.RequiredError('id','Required parameter requestParameters.id was null or undefined when calling getComment.');
        }

        const queryParameters: any = {};

        if (requestParameters.forRoot !== undefined) {
            queryParameters['for_root'] = requestParameters.forRoot;
        }

        if (requestParameters.tasksForUser !== undefined) {
            queryParameters['tasks_for_user'] = requestParameters.tasksForUser;
        }

        if (requestParameters.includeFullAsset !== undefined) {
            queryParameters['include_full_asset'] = requestParameters.includeFullAsset;
        }

        if (requestParameters.advancedSearch !== undefined) {
            queryParameters['advanced_search'] = requestParameters.advancedSearch;
        }

        const headerParameters: runtime.HTTPHeaders = {};

        if (this.configuration && this.configuration.apiKey) {
            headerParameters["Authorization"] = this.configuration.apiKey("Authorization"); // Bearer authentication
        }

        const response = await this.request({
            path: `/api/2/media/comments/{id}`.replace(`{${"id"}}`, encodeURIComponent(String(requestParameters.id))),
            method: 'GET',
            headers: headerParameters,
            query: queryParameters,
        }, initOverrides);

        return new runtime.JSONApiResponse(response, (jsonValue) => CommentFromJSON(jsonValue));
    }

    /**
     * ### Required permissions    * User account permission: `media:access`   * License component: media 
     */
    async getComment(requestParameters: GetCommentRequest, initOverrides?: RequestInit): Promise<Comment> {
        const response = await this.getCommentRaw(requestParameters, initOverrides);
        return await response.value();
    }

    /**
     * ### Required permissions    * User account permission: `media:access` (read) / `media:roots:manage` (write)   * License component: media 
     */
    async getCustomFieldRaw(requestParameters: GetCustomFieldRequest, initOverrides?: RequestInit): Promise<runtime.ApiResponse<CustomField>> {
        if (requestParameters.id === null || requestParameters.id === undefined) {
            throw new runtime.RequiredError('id','Required parameter requestParameters.id was null or undefined when calling getCustomField.');
        }

        const queryParameters: any = {};

        const headerParameters: runtime.HTTPHeaders = {};

        if (this.configuration && this.configuration.apiKey) {
            headerParameters["Authorization"] = this.configuration.apiKey("Authorization"); // Bearer authentication
        }

        const response = await this.request({
            path: `/api/2/media/custom-fields/{id}`.replace(`{${"id"}}`, encodeURIComponent(String(requestParameters.id))),
            method: 'GET',
            headers: headerParameters,
            query: queryParameters,
        }, initOverrides);

        return new runtime.JSONApiResponse(response, (jsonValue) => CustomFieldFromJSON(jsonValue));
    }

    /**
     * ### Required permissions    * User account permission: `media:access` (read) / `media:roots:manage` (write)   * License component: media 
     */
    async getCustomField(requestParameters: GetCustomFieldRequest, initOverrides?: RequestInit): Promise<CustomField> {
        const response = await this.getCustomFieldRaw(requestParameters, initOverrides);
        return await response.value();
    }

    /**
     * ### Required permissions    * <class \'rest_framework.permissions.AllowAny\'> 
     */
    async getEasySharingTokenForBundleRaw(requestParameters: GetEasySharingTokenForBundleRequest, initOverrides?: RequestInit): Promise<runtime.ApiResponse<OneTimeAccessToken>> {
        if (requestParameters.id === null || requestParameters.id === undefined) {
            throw new runtime.RequiredError('id','Required parameter requestParameters.id was null or undefined when calling getEasySharingTokenForBundle.');
        }

        const queryParameters: any = {};

        const headerParameters: runtime.HTTPHeaders = {};

        if (this.configuration && this.configuration.apiKey) {
            headerParameters["Authorization"] = this.configuration.apiKey("Authorization"); // Bearer authentication
        }

        const response = await this.request({
            path: `/api/2/media/bundles/{id}/easy-sharing-token`.replace(`{${"id"}}`, encodeURIComponent(String(requestParameters.id))),
            method: 'GET',
            headers: headerParameters,
            query: queryParameters,
        }, initOverrides);

        return new runtime.JSONApiResponse(response, (jsonValue) => OneTimeAccessTokenFromJSON(jsonValue));
    }

    /**
     * ### Required permissions    * <class \'rest_framework.permissions.AllowAny\'> 
     */
    async getEasySharingTokenForBundle(requestParameters: GetEasySharingTokenForBundleRequest, initOverrides?: RequestInit): Promise<OneTimeAccessToken> {
        const response = await this.getEasySharingTokenForBundleRaw(requestParameters, initOverrides);
        return await response.value();
    }

    /**
     * ### Required permissions    * User account permission: `media:access`   * License component: media 
     */
    async getEasySharingTokenForDirectoryRaw(requestParameters: GetEasySharingTokenForDirectoryRequest, initOverrides?: RequestInit): Promise<runtime.ApiResponse<OneTimeAccessToken>> {
        if (requestParameters.id === null || requestParameters.id === undefined) {
            throw new runtime.RequiredError('id','Required parameter requestParameters.id was null or undefined when calling getEasySharingTokenForDirectory.');
        }

        const queryParameters: any = {};

        const headerParameters: runtime.HTTPHeaders = {};

        if (this.configuration && this.configuration.apiKey) {
            headerParameters["Authorization"] = this.configuration.apiKey("Authorization"); // Bearer authentication
        }

        const response = await this.request({
            path: `/api/2/media/files/{id}/easy-sharing-token`.replace(`{${"id"}}`, encodeURIComponent(String(requestParameters.id))),
            method: 'GET',
            headers: headerParameters,
            query: queryParameters,
        }, initOverrides);

        return new runtime.JSONApiResponse(response, (jsonValue) => OneTimeAccessTokenFromJSON(jsonValue));
    }

    /**
     * ### Required permissions    * User account permission: `media:access`   * License component: media 
     */
    async getEasySharingTokenForDirectory(requestParameters: GetEasySharingTokenForDirectoryRequest, initOverrides?: RequestInit): Promise<OneTimeAccessToken> {
        const response = await this.getEasySharingTokenForDirectoryRaw(requestParameters, initOverrides);
        return await response.value();
    }

    /**
     * ### Required permissions    * User account permission: `media:access` 
     */
    async getEditorProjectRaw(requestParameters: GetEditorProjectRequest, initOverrides?: RequestInit): Promise<runtime.ApiResponse<EditorProject>> {
        if (requestParameters.id === null || requestParameters.id === undefined) {
            throw new runtime.RequiredError('id','Required parameter requestParameters.id was null or undefined when calling getEditorProject.');
        }

        const queryParameters: any = {};

        const headerParameters: runtime.HTTPHeaders = {};

        if (this.configuration && this.configuration.apiKey) {
            headerParameters["Authorization"] = this.configuration.apiKey("Authorization"); // Bearer authentication
        }

        const response = await this.request({
            path: `/api/2/media/editor/{id}`.replace(`{${"id"}}`, encodeURIComponent(String(requestParameters.id))),
            method: 'GET',
            headers: headerParameters,
            query: queryParameters,
        }, initOverrides);

        return new runtime.JSONApiResponse(response, (jsonValue) => EditorProjectFromJSON(jsonValue));
    }

    /**
     * ### Required permissions    * User account permission: `media:access` 
     */
    async getEditorProject(requestParameters: GetEditorProjectRequest, initOverrides?: RequestInit): Promise<EditorProject> {
        const response = await this.getEditorProjectRaw(requestParameters, initOverrides);
        return await response.value();
    }

    /**
     * ### Required permissions    * User account permission: `media:access` 
     */
    async getEditorSubtitleRaw(requestParameters: GetEditorSubtitleRequest, initOverrides?: RequestInit): Promise<runtime.ApiResponse<EditorSubtitle>> {
        if (requestParameters.id === null || requestParameters.id === undefined) {
            throw new runtime.RequiredError('id','Required parameter requestParameters.id was null or undefined when calling getEditorSubtitle.');
        }

        const queryParameters: any = {};

        const headerParameters: runtime.HTTPHeaders = {};

        if (this.configuration && this.configuration.apiKey) {
            headerParameters["Authorization"] = this.configuration.apiKey("Authorization"); // Bearer authentication
        }

        const response = await this.request({
            path: `/api/2/media/subtitles/{id}`.replace(`{${"id"}}`, encodeURIComponent(String(requestParameters.id))),
            method: 'GET',
            headers: headerParameters,
            query: queryParameters,
        }, initOverrides);

        return new runtime.JSONApiResponse(response, (jsonValue) => EditorSubtitleFromJSON(jsonValue));
    }

    /**
     * ### Required permissions    * User account permission: `media:access` 
     */
    async getEditorSubtitle(requestParameters: GetEditorSubtitleRequest, initOverrides?: RequestInit): Promise<EditorSubtitle> {
        const response = await this.getEditorSubtitleRaw(requestParameters, initOverrides);
        return await response.value();
    }

    /**
     * ### Required permissions    * User account permission: `media:access` (read) / `system:admin-access` (write) 
     */
    async getExternalTranscoderRaw(requestParameters: GetExternalTranscoderRequest, initOverrides?: RequestInit): Promise<runtime.ApiResponse<ExternalTranscoder>> {
        if (requestParameters.id === null || requestParameters.id === undefined) {
            throw new runtime.RequiredError('id','Required parameter requestParameters.id was null or undefined when calling getExternalTranscoder.');
        }

        const queryParameters: any = {};

        const headerParameters: runtime.HTTPHeaders = {};

        if (this.configuration && this.configuration.apiKey) {
            headerParameters["Authorization"] = this.configuration.apiKey("Authorization"); // Bearer authentication
        }

        const response = await this.request({
            path: `/api/2/media/external-transcoders/{id}`.replace(`{${"id"}}`, encodeURIComponent(String(requestParameters.id))),
            method: 'GET',
            headers: headerParameters,
            query: queryParameters,
        }, initOverrides);

        return new runtime.JSONApiResponse(response, (jsonValue) => ExternalTranscoderFromJSON(jsonValue));
    }

    /**
     * ### Required permissions    * User account permission: `media:access` (read) / `system:admin-access` (write) 
     */
    async getExternalTranscoder(requestParameters: GetExternalTranscoderRequest, initOverrides?: RequestInit): Promise<ExternalTranscoder> {
        const response = await this.getExternalTranscoderRaw(requestParameters, initOverrides);
        return await response.value();
    }

    /**
     * ### Required permissions    * User account permission: `media:access`   * License component: media 
     */
    async getFrameRaw(requestParameters: GetFrameRequest, initOverrides?: RequestInit): Promise<runtime.ApiResponse<Blob>> {
        if (requestParameters.frame === null || requestParameters.frame === undefined) {
            throw new runtime.RequiredError('frame','Required parameter requestParameters.frame was null or undefined when calling getFrame.');
        }

        if (requestParameters.id === null || requestParameters.id === undefined) {
            throw new runtime.RequiredError('id','Required parameter requestParameters.id was null or undefined when calling getFrame.');
        }

        const queryParameters: any = {};

        const headerParameters: runtime.HTTPHeaders = {};

        if (this.configuration && this.configuration.apiKey) {
            headerParameters["Authorization"] = this.configuration.apiKey("Authorization"); // Bearer authentication
        }

        const response = await this.request({
            path: `/api/2/media/assets/{id}/frames/{frame}`.replace(`{${"frame"}}`, encodeURIComponent(String(requestParameters.frame))).replace(`{${"id"}}`, encodeURIComponent(String(requestParameters.id))),
            method: 'GET',
            headers: headerParameters,
            query: queryParameters,
        }, initOverrides);

        return new runtime.BlobApiResponse(response);
    }

    /**
     * ### Required permissions    * User account permission: `media:access`   * License component: media 
     */
    async getFrame(requestParameters: GetFrameRequest, initOverrides?: RequestInit): Promise<Blob> {
        const response = await this.getFrameRaw(requestParameters, initOverrides);
        return await response.value();
    }

    /**
     * ### Required permissions    * User account permission: `media:access` (read) / `media:updates:manage` (write)   * License component: media 
     */
    async getLatestMediaUpdateRaw(requestParameters: GetLatestMediaUpdateRequest, initOverrides?: RequestInit): Promise<runtime.ApiResponse<MediaUpdate>> {
        const queryParameters: any = {};

        if (requestParameters.asset !== undefined) {
            queryParameters['asset'] = requestParameters.asset;
        }

        if (requestParameters.user !== undefined) {
            queryParameters['user'] = requestParameters.user;
        }

        if (requestParameters.root !== undefined) {
            queryParameters['root'] = requestParameters.root;
        }

        if (requestParameters.ordering !== undefined) {
            queryParameters['ordering'] = requestParameters.ordering;
        }

        if (requestParameters.limit !== undefined) {
            queryParameters['limit'] = requestParameters.limit;
        }

        if (requestParameters.offset !== undefined) {
            queryParameters['offset'] = requestParameters.offset;
        }

        const headerParameters: runtime.HTTPHeaders = {};

        if (this.configuration && this.configuration.apiKey) {
            headerParameters["Authorization"] = this.configuration.apiKey("Authorization"); // Bearer authentication
        }

        const response = await this.request({
            path: `/api/2/media/updates/latest`,
            method: 'GET',
            headers: headerParameters,
            query: queryParameters,
        }, initOverrides);

        return new runtime.JSONApiResponse(response, (jsonValue) => MediaUpdateFromJSON(jsonValue));
    }

    /**
     * ### Required permissions    * User account permission: `media:access` (read) / `media:updates:manage` (write)   * License component: media 
     */
    async getLatestMediaUpdate(requestParameters: GetLatestMediaUpdateRequest, initOverrides?: RequestInit): Promise<MediaUpdate> {
        const response = await this.getLatestMediaUpdateRaw(requestParameters, initOverrides);
        return await response.value();
    }

    /**
     * ### Required permissions    * User account permission: `media:access`   * License component: media 
     */
    async getMarkerRaw(requestParameters: GetMarkerRequest, initOverrides?: RequestInit): Promise<runtime.ApiResponse<Marker>> {
        if (requestParameters.id === null || requestParameters.id === undefined) {
            throw new runtime.RequiredError('id','Required parameter requestParameters.id was null or undefined when calling getMarker.');
        }

        const queryParameters: any = {};

        const headerParameters: runtime.HTTPHeaders = {};

        if (this.configuration && this.configuration.apiKey) {
            headerParameters["Authorization"] = this.configuration.apiKey("Authorization"); // Bearer authentication
        }

        const response = await this.request({
            path: `/api/2/media/markers/{id}`.replace(`{${"id"}}`, encodeURIComponent(String(requestParameters.id))),
            method: 'GET',
            headers: headerParameters,
            query: queryParameters,
        }, initOverrides);

        return new runtime.JSONApiResponse(response, (jsonValue) => MarkerFromJSON(jsonValue));
    }

    /**
     * ### Required permissions    * User account permission: `media:access`   * License component: media 
     */
    async getMarker(requestParameters: GetMarkerRequest, initOverrides?: RequestInit): Promise<Marker> {
        const response = await this.getMarkerRaw(requestParameters, initOverrides);
        return await response.value();
    }

    /**
     * ### Required permissions    * User account permission: `media:access`   * License component: media 
     */
    async getMediaFileRaw(requestParameters: GetMediaFileRequest, initOverrides?: RequestInit): Promise<runtime.ApiResponse<MediaFile>> {
        if (requestParameters.id === null || requestParameters.id === undefined) {
            throw new runtime.RequiredError('id','Required parameter requestParameters.id was null or undefined when calling getMediaFile.');
        }

        const queryParameters: any = {};

        if (requestParameters.resolveFilePermission !== undefined) {
            queryParameters['resolve_file_permission'] = requestParameters.resolveFilePermission;
        }

        if (requestParameters.includeModifiedBy !== undefined) {
            queryParameters['include_modified_by'] = requestParameters.includeModifiedBy;
        }

        if (requestParameters.includeEffectiveCustomFields !== undefined) {
            queryParameters['include_effective_custom_fields'] = requestParameters.includeEffectiveCustomFields;
        }

        if (requestParameters.includeRoot !== undefined) {
            queryParameters['include_root'] = requestParameters.includeRoot;
        }

        if (requestParameters.includeParents !== undefined) {
            queryParameters['include_parents'] = requestParameters.includeParents;
        }

        if (requestParameters.advancedSearch !== undefined) {
            queryParameters['advanced_search'] = requestParameters.advancedSearch;
        }

        const headerParameters: runtime.HTTPHeaders = {};

        if (this.configuration && this.configuration.apiKey) {
            headerParameters["Authorization"] = this.configuration.apiKey("Authorization"); // Bearer authentication
        }

        const response = await this.request({
            path: `/api/2/media/files/{id}`.replace(`{${"id"}}`, encodeURIComponent(String(requestParameters.id))),
            method: 'GET',
            headers: headerParameters,
            query: queryParameters,
        }, initOverrides);

        return new runtime.JSONApiResponse(response, (jsonValue) => MediaFileFromJSON(jsonValue));
    }

    /**
     * ### Required permissions    * User account permission: `media:access`   * License component: media 
     */
    async getMediaFile(requestParameters: GetMediaFileRequest, initOverrides?: RequestInit): Promise<MediaFile> {
        const response = await this.getMediaFileRaw(requestParameters, initOverrides);
        return await response.value();
    }

    /**
     * ### Required permissions    * <class \'rest_framework.permissions.AllowAny\'> 
     */
    async getMediaFileBundleRaw(requestParameters: GetMediaFileBundleRequest, initOverrides?: RequestInit): Promise<runtime.ApiResponse<MediaFileBundle>> {
        if (requestParameters.id === null || requestParameters.id === undefined) {
            throw new runtime.RequiredError('id','Required parameter requestParameters.id was null or undefined when calling getMediaFileBundle.');
        }

        const queryParameters: any = {};

        if (requestParameters.excludeDeleted !== undefined) {
            queryParameters['exclude_deleted'] = requestParameters.excludeDeleted;
        }

        if (requestParameters.excludeUnrecognized !== undefined) {
            queryParameters['exclude_unrecognized'] = requestParameters.excludeUnrecognized;
        }

        if (requestParameters.includeProxies !== undefined) {
            queryParameters['include_proxies'] = requestParameters.includeProxies;
        }

        if (requestParameters.includeParents !== undefined) {
            queryParameters['include_parents'] = requestParameters.includeParents;
        }

        if (requestParameters.offset !== undefined) {
            queryParameters['offset'] = requestParameters.offset;
        }

        if (requestParameters.limit !== undefined) {
            queryParameters['limit'] = requestParameters.limit;
        }

        if (requestParameters.advancedSearch !== undefined) {
            queryParameters['advanced_search'] = requestParameters.advancedSearch;
        }

        const headerParameters: runtime.HTTPHeaders = {};

        if (this.configuration && this.configuration.apiKey) {
            headerParameters["Authorization"] = this.configuration.apiKey("Authorization"); // Bearer authentication
        }

        const response = await this.request({
            path: `/api/2/media/bundles/{id}`.replace(`{${"id"}}`, encodeURIComponent(String(requestParameters.id))),
            method: 'GET',
            headers: headerParameters,
            query: queryParameters,
        }, initOverrides);

        return new runtime.JSONApiResponse(response, (jsonValue) => MediaFileBundleFromJSON(jsonValue));
    }

    /**
     * ### Required permissions    * <class \'rest_framework.permissions.AllowAny\'> 
     */
    async getMediaFileBundle(requestParameters: GetMediaFileBundleRequest, initOverrides?: RequestInit): Promise<MediaFileBundle> {
        const response = await this.getMediaFileBundleRaw(requestParameters, initOverrides);
        return await response.value();
    }

    /**
     * ### Required permissions    * User account permission: `media:access`   * License component: media 
     */
    async getMediaFileContentsRaw(requestParameters: GetMediaFileContentsRequest, initOverrides?: RequestInit): Promise<runtime.ApiResponse<MediaFileContents>> {
        if (requestParameters.id === null || requestParameters.id === undefined) {
            throw new runtime.RequiredError('id','Required parameter requestParameters.id was null or undefined when calling getMediaFileContents.');
        }

        const queryParameters: any = {};

        if (requestParameters.excludeDeleted !== undefined) {
            queryParameters['exclude_deleted'] = requestParameters.excludeDeleted;
        }

        if (requestParameters.excludeUnrecognized !== undefined) {
            queryParameters['exclude_unrecognized'] = requestParameters.excludeUnrecognized;
        }

        if (requestParameters.offset !== undefined) {
            queryParameters['offset'] = requestParameters.offset;
        }

        if (requestParameters.limit !== undefined) {
            queryParameters['limit'] = requestParameters.limit;
        }

        const headerParameters: runtime.HTTPHeaders = {};

        if (this.configuration && this.configuration.apiKey) {
            headerParameters["Authorization"] = this.configuration.apiKey("Authorization"); // Bearer authentication
        }

        const response = await this.request({
            path: `/api/2/media/files/{id}/contents`.replace(`{${"id"}}`, encodeURIComponent(String(requestParameters.id))),
            method: 'GET',
            headers: headerParameters,
            query: queryParameters,
        }, initOverrides);

        return new runtime.JSONApiResponse(response, (jsonValue) => MediaFileContentsFromJSON(jsonValue));
    }

    /**
     * ### Required permissions    * User account permission: `media:access`   * License component: media 
     */
    async getMediaFileContents(requestParameters: GetMediaFileContentsRequest, initOverrides?: RequestInit): Promise<MediaFileContents> {
        const response = await this.getMediaFileContentsRaw(requestParameters, initOverrides);
        return await response.value();
    }

    /**
     * ### Required permissions    * User account permission: `media:access`   * License component: media 
     */
    async getMediaFileTemplateRaw(requestParameters: GetMediaFileTemplateRequest, initOverrides?: RequestInit): Promise<runtime.ApiResponse<MediaFileTemplate>> {
        if (requestParameters.id === null || requestParameters.id === undefined) {
            throw new runtime.RequiredError('id','Required parameter requestParameters.id was null or undefined when calling getMediaFileTemplate.');
        }

        const queryParameters: any = {};

        const headerParameters: runtime.HTTPHeaders = {};

        if (this.configuration && this.configuration.apiKey) {
            headerParameters["Authorization"] = this.configuration.apiKey("Authorization"); // Bearer authentication
        }

        const response = await this.request({
            path: `/api/2/media/files/templates/{id}`.replace(`{${"id"}}`, encodeURIComponent(String(requestParameters.id))),
            method: 'GET',
            headers: headerParameters,
            query: queryParameters,
        }, initOverrides);

        return new runtime.JSONApiResponse(response, (jsonValue) => MediaFileTemplateFromJSON(jsonValue));
    }

    /**
     * ### Required permissions    * User account permission: `media:access`   * License component: media 
     */
    async getMediaFileTemplate(requestParameters: GetMediaFileTemplateRequest, initOverrides?: RequestInit): Promise<MediaFileTemplate> {
        const response = await this.getMediaFileTemplateRaw(requestParameters, initOverrides);
        return await response.value();
    }

    /**
     * ### Required permissions    * User account permission: `media:access` (read) / `media:roots:manage` (write)   * License component: media 
     */
    async getMediaRootRaw(requestParameters: GetMediaRootRequest, initOverrides?: RequestInit): Promise<runtime.ApiResponse<MediaRootDetail>> {
        if (requestParameters.id === null || requestParameters.id === undefined) {
            throw new runtime.RequiredError('id','Required parameter requestParameters.id was null or undefined when calling getMediaRoot.');
        }

        const queryParameters: any = {};

        if (requestParameters.resolvePermissions !== undefined) {
            queryParameters['resolve_permissions'] = requestParameters.resolvePermissions;
        }

        const headerParameters: runtime.HTTPHeaders = {};

        if (this.configuration && this.configuration.apiKey) {
            headerParameters["Authorization"] = this.configuration.apiKey("Authorization"); // Bearer authentication
        }

        const response = await this.request({
            path: `/api/2/media/roots/{id}`.replace(`{${"id"}}`, encodeURIComponent(String(requestParameters.id))),
            method: 'GET',
            headers: headerParameters,
            query: queryParameters,
        }, initOverrides);

        return new runtime.JSONApiResponse(response, (jsonValue) => MediaRootDetailFromJSON(jsonValue));
    }

    /**
     * ### Required permissions    * User account permission: `media:access` (read) / `media:roots:manage` (write)   * License component: media 
     */
    async getMediaRoot(requestParameters: GetMediaRootRequest, initOverrides?: RequestInit): Promise<MediaRootDetail> {
        const response = await this.getMediaRootRaw(requestParameters, initOverrides);
        return await response.value();
    }

    /**
     * ### Required permissions    * User account permission: `media:access` (read) / `media:roots:manage` (write)   * License component: media 
     */
    async getMediaRootPermissionRaw(requestParameters: GetMediaRootPermissionRequest, initOverrides?: RequestInit): Promise<runtime.ApiResponse<MediaRootPermission>> {
        if (requestParameters.id === null || requestParameters.id === undefined) {
            throw new runtime.RequiredError('id','Required parameter requestParameters.id was null or undefined when calling getMediaRootPermission.');
        }

        const queryParameters: any = {};

        const headerParameters: runtime.HTTPHeaders = {};

        if (this.configuration && this.configuration.apiKey) {
            headerParameters["Authorization"] = this.configuration.apiKey("Authorization"); // Bearer authentication
        }

        const response = await this.request({
            path: `/api/2/media/root-permissions/{id}`.replace(`{${"id"}}`, encodeURIComponent(String(requestParameters.id))),
            method: 'GET',
            headers: headerParameters,
            query: queryParameters,
        }, initOverrides);

        return new runtime.JSONApiResponse(response, (jsonValue) => MediaRootPermissionFromJSON(jsonValue));
    }

    /**
     * ### Required permissions    * User account permission: `media:access` (read) / `media:roots:manage` (write)   * License component: media 
     */
    async getMediaRootPermission(requestParameters: GetMediaRootPermissionRequest, initOverrides?: RequestInit): Promise<MediaRootPermission> {
        const response = await this.getMediaRootPermissionRaw(requestParameters, initOverrides);
        return await response.value();
    }

    /**
     * ### Required permissions    * User account permission: `media:access`   * License component: media 
     */
    async getMediaTagRaw(requestParameters: GetMediaTagRequest, initOverrides?: RequestInit): Promise<runtime.ApiResponse<UnfilteredTag>> {
        if (requestParameters.id === null || requestParameters.id === undefined) {
            throw new runtime.RequiredError('id','Required parameter requestParameters.id was null or undefined when calling getMediaTag.');
        }

        const queryParameters: any = {};

        if (requestParameters.forRoot !== undefined) {
            queryParameters['for_root'] = requestParameters.forRoot;
        }

        const headerParameters: runtime.HTTPHeaders = {};

        if (this.configuration && this.configuration.apiKey) {
            headerParameters["Authorization"] = this.configuration.apiKey("Authorization"); // Bearer authentication
        }

        const response = await this.request({
            path: `/api/2/media/tags/{id}`.replace(`{${"id"}}`, encodeURIComponent(String(requestParameters.id))),
            method: 'GET',
            headers: headerParameters,
            query: queryParameters,
        }, initOverrides);

        return new runtime.JSONApiResponse(response, (jsonValue) => UnfilteredTagFromJSON(jsonValue));
    }

    /**
     * ### Required permissions    * User account permission: `media:access`   * License component: media 
     */
    async getMediaTag(requestParameters: GetMediaTagRequest, initOverrides?: RequestInit): Promise<UnfilteredTag> {
        const response = await this.getMediaTagRaw(requestParameters, initOverrides);
        return await response.value();
    }

    /**
     * ### Required permissions    * User account permission: `media:access`   * License component: media 
     */
    async getMultipleAssetsRaw(requestParameters: GetMultipleAssetsRequest, initOverrides?: RequestInit): Promise<runtime.ApiResponse<Array<Asset>>> {
        if (requestParameters.multipleAssetsRequest === null || requestParameters.multipleAssetsRequest === undefined) {
            throw new runtime.RequiredError('multipleAssetsRequest','Required parameter requestParameters.multipleAssetsRequest was null or undefined when calling getMultipleAssets.');
        }

        const queryParameters: any = {};

        const headerParameters: runtime.HTTPHeaders = {};

        headerParameters['Content-Type'] = 'application/json';

        if (this.configuration && this.configuration.apiKey) {
            headerParameters["Authorization"] = this.configuration.apiKey("Authorization"); // Bearer authentication
        }

        const response = await this.request({
            path: `/api/2/media/assets/multiple`,
            method: 'POST',
            headers: headerParameters,
            query: queryParameters,
            body: MultipleAssetsRequestToJSON(requestParameters.multipleAssetsRequest),
        }, initOverrides);

        return new runtime.JSONApiResponse(response, (jsonValue) => jsonValue.map(AssetFromJSON));
    }

    /**
     * ### Required permissions    * User account permission: `media:access`   * License component: media 
     */
    async getMultipleAssets(requestParameters: GetMultipleAssetsRequest, initOverrides?: RequestInit): Promise<Array<Asset>> {
        const response = await this.getMultipleAssetsRaw(requestParameters, initOverrides);
        return await response.value();
    }

    /**
     * ### Required permissions    * <class \'rest_framework.permissions.AllowAny\'> 
     */
    async getMultipleBundlesRaw(requestParameters: GetMultipleBundlesOperationRequest, initOverrides?: RequestInit): Promise<runtime.ApiResponse<Array<MediaFileBundle>>> {
        if (requestParameters.getMultipleBundlesRequest === null || requestParameters.getMultipleBundlesRequest === undefined) {
            throw new runtime.RequiredError('getMultipleBundlesRequest','Required parameter requestParameters.getMultipleBundlesRequest was null or undefined when calling getMultipleBundles.');
        }

        const queryParameters: any = {};

        const headerParameters: runtime.HTTPHeaders = {};

        headerParameters['Content-Type'] = 'application/json';

        if (this.configuration && this.configuration.apiKey) {
            headerParameters["Authorization"] = this.configuration.apiKey("Authorization"); // Bearer authentication
        }

        const response = await this.request({
            path: `/api/2/media/bundles/multiple`,
            method: 'POST',
            headers: headerParameters,
            query: queryParameters,
            body: GetMultipleBundlesRequestToJSON(requestParameters.getMultipleBundlesRequest),
        }, initOverrides);

        return new runtime.JSONApiResponse(response, (jsonValue) => jsonValue.map(MediaFileBundleFromJSON));
    }

    /**
     * ### Required permissions    * <class \'rest_framework.permissions.AllowAny\'> 
     */
    async getMultipleBundles(requestParameters: GetMultipleBundlesOperationRequest, initOverrides?: RequestInit): Promise<Array<MediaFileBundle>> {
        const response = await this.getMultipleBundlesRaw(requestParameters, initOverrides);
        return await response.value();
    }

    /**
     * ### Required permissions    * User account permission: `media:access`   * License component: media 
     */
    async getMultipleFilesRaw(requestParameters: GetMultipleFilesOperationRequest, initOverrides?: RequestInit): Promise<runtime.ApiResponse<Array<MediaFile>>> {
        if (requestParameters.getMultipleFilesRequest === null || requestParameters.getMultipleFilesRequest === undefined) {
            throw new runtime.RequiredError('getMultipleFilesRequest','Required parameter requestParameters.getMultipleFilesRequest was null or undefined when calling getMultipleFiles.');
        }

        const queryParameters: any = {};

        const headerParameters: runtime.HTTPHeaders = {};

        headerParameters['Content-Type'] = 'application/json';

        if (this.configuration && this.configuration.apiKey) {
            headerParameters["Authorization"] = this.configuration.apiKey("Authorization"); // Bearer authentication
        }

        const response = await this.request({
            path: `/api/2/media/files/multiple`,
            method: 'POST',
            headers: headerParameters,
            query: queryParameters,
            body: GetMultipleFilesRequestToJSON(requestParameters.getMultipleFilesRequest),
        }, initOverrides);

        return new runtime.JSONApiResponse(response, (jsonValue) => jsonValue.map(MediaFileFromJSON));
    }

    /**
     * ### Required permissions    * User account permission: `media:access`   * License component: media 
     */
    async getMultipleFiles(requestParameters: GetMultipleFilesOperationRequest, initOverrides?: RequestInit): Promise<Array<MediaFile>> {
        const response = await this.getMultipleFilesRaw(requestParameters, initOverrides);
        return await response.value();
    }

    /**
     * ### Required permissions    * User account permission: `media:access` (read) / `media:roots:manage` (write)   * License component: media 
     */
    async getMyMediaRootPermissionsRaw(requestParameters: GetMyMediaRootPermissionsRequest, initOverrides?: RequestInit): Promise<runtime.ApiResponse<Array<MediaRootPermission>>> {
        const queryParameters: any = {};

        if (requestParameters.root !== undefined) {
            queryParameters['root'] = requestParameters.root;
        }

        if (requestParameters.id !== undefined) {
            queryParameters['id'] = requestParameters.id;
        }

        if (requestParameters.ordering !== undefined) {
            queryParameters['ordering'] = requestParameters.ordering;
        }

        if (requestParameters.limit !== undefined) {
            queryParameters['limit'] = requestParameters.limit;
        }

        if (requestParameters.offset !== undefined) {
            queryParameters['offset'] = requestParameters.offset;
        }

        const headerParameters: runtime.HTTPHeaders = {};

        if (this.configuration && this.configuration.apiKey) {
            headerParameters["Authorization"] = this.configuration.apiKey("Authorization"); // Bearer authentication
        }

        const response = await this.request({
            path: `/api/2/media/root-permissions/mine`,
            method: 'GET',
            headers: headerParameters,
            query: queryParameters,
        }, initOverrides);

        return new runtime.JSONApiResponse(response, (jsonValue) => jsonValue.map(MediaRootPermissionFromJSON));
    }

    /**
     * ### Required permissions    * User account permission: `media:access` (read) / `media:roots:manage` (write)   * License component: media 
     */
    async getMyMediaRootPermissions(requestParameters: GetMyMediaRootPermissionsRequest, initOverrides?: RequestInit): Promise<Array<MediaRootPermission>> {
        const response = await this.getMyMediaRootPermissionsRaw(requestParameters, initOverrides);
        return await response.value();
    }

    /**
     * ### Required permissions    * User account permission: `media:access` (read) / `media:roots:manage` (write)   * License component: media 
     */
    async getMyResolvedMediaRootPermissionsRaw(requestParameters: GetMyResolvedMediaRootPermissionsRequest, initOverrides?: RequestInit): Promise<runtime.ApiResponse<Array<MediaRootPermission>>> {
        const queryParameters: any = {};

        if (requestParameters.root !== undefined) {
            queryParameters['root'] = requestParameters.root;
        }

        if (requestParameters.id !== undefined) {
            queryParameters['id'] = requestParameters.id;
        }

        if (requestParameters.ordering !== undefined) {
            queryParameters['ordering'] = requestParameters.ordering;
        }

        if (requestParameters.limit !== undefined) {
            queryParameters['limit'] = requestParameters.limit;
        }

        if (requestParameters.offset !== undefined) {
            queryParameters['offset'] = requestParameters.offset;
        }

        const headerParameters: runtime.HTTPHeaders = {};

        if (this.configuration && this.configuration.apiKey) {
            headerParameters["Authorization"] = this.configuration.apiKey("Authorization"); // Bearer authentication
        }

        const response = await this.request({
            path: `/api/2/media/root-permissions/mine/resolved`,
            method: 'GET',
            headers: headerParameters,
            query: queryParameters,
        }, initOverrides);

        return new runtime.JSONApiResponse(response, (jsonValue) => jsonValue.map(MediaRootPermissionFromJSON));
    }

    /**
     * ### Required permissions    * User account permission: `media:access` (read) / `media:roots:manage` (write)   * License component: media 
     */
    async getMyResolvedMediaRootPermissions(requestParameters: GetMyResolvedMediaRootPermissionsRequest, initOverrides?: RequestInit): Promise<Array<MediaRootPermission>> {
        const response = await this.getMyResolvedMediaRootPermissionsRaw(requestParameters, initOverrides);
        return await response.value();
    }

    /**
     * ### Required permissions    * User account permission: `media:access`   * License component: media 
     */
    async getProxyRaw(requestParameters: GetProxyRequest, initOverrides?: RequestInit): Promise<runtime.ApiResponse<Proxy>> {
        if (requestParameters.id === null || requestParameters.id === undefined) {
            throw new runtime.RequiredError('id','Required parameter requestParameters.id was null or undefined when calling getProxy.');
        }

        const queryParameters: any = {};

        const headerParameters: runtime.HTTPHeaders = {};

        if (this.configuration && this.configuration.apiKey) {
            headerParameters["Authorization"] = this.configuration.apiKey("Authorization"); // Bearer authentication
        }

        const response = await this.request({
            path: `/api/2/media/proxies/{id}`.replace(`{${"id"}}`, encodeURIComponent(String(requestParameters.id))),
            method: 'GET',
            headers: headerParameters,
            query: queryParameters,
        }, initOverrides);

        return new runtime.JSONApiResponse(response, (jsonValue) => ProxyFromJSON(jsonValue));
    }

    /**
     * ### Required permissions    * User account permission: `media:access`   * License component: media 
     */
    async getProxy(requestParameters: GetProxyRequest, initOverrides?: RequestInit): Promise<Proxy> {
        const response = await this.getProxyRaw(requestParameters, initOverrides);
        return await response.value();
    }

    /**
     * ### Required permissions    * User account permission: `media:access` 
     */
    async getProxyGeneratorRaw(requestParameters: GetProxyGeneratorRequest, initOverrides?: RequestInit): Promise<runtime.ApiResponse<ProxyGenerator>> {
        if (requestParameters.id === null || requestParameters.id === undefined) {
            throw new runtime.RequiredError('id','Required parameter requestParameters.id was null or undefined when calling getProxyGenerator.');
        }

        const queryParameters: any = {};

        const headerParameters: runtime.HTTPHeaders = {};

        if (this.configuration && this.configuration.apiKey) {
            headerParameters["Authorization"] = this.configuration.apiKey("Authorization"); // Bearer authentication
        }

        const response = await this.request({
            path: `/api/2/media/proxy-generators/{id}`.replace(`{${"id"}}`, encodeURIComponent(String(requestParameters.id))),
            method: 'GET',
            headers: headerParameters,
            query: queryParameters,
        }, initOverrides);

        return new runtime.JSONApiResponse(response, (jsonValue) => ProxyGeneratorFromJSON(jsonValue));
    }

    /**
     * ### Required permissions    * User account permission: `media:access` 
     */
    async getProxyGenerator(requestParameters: GetProxyGeneratorRequest, initOverrides?: RequestInit): Promise<ProxyGenerator> {
        const response = await this.getProxyGeneratorRaw(requestParameters, initOverrides);
        return await response.value();
    }

    /**
     * ### Required permissions    * User account permission: `media:access` (read) / `media:roots:manage` (write)   * License component: media 
     */
    async getProxyProfileRaw(requestParameters: GetProxyProfileRequest, initOverrides?: RequestInit): Promise<runtime.ApiResponse<ProxyProfile>> {
        if (requestParameters.id === null || requestParameters.id === undefined) {
            throw new runtime.RequiredError('id','Required parameter requestParameters.id was null or undefined when calling getProxyProfile.');
        }

        const queryParameters: any = {};

        if (requestParameters.forRoot !== undefined) {
            queryParameters['for_root'] = requestParameters.forRoot;
        }

        const headerParameters: runtime.HTTPHeaders = {};

        if (this.configuration && this.configuration.apiKey) {
            headerParameters["Authorization"] = this.configuration.apiKey("Authorization"); // Bearer authentication
        }

        const response = await this.request({
            path: `/api/2/media/proxy-profiles/{id}`.replace(`{${"id"}}`, encodeURIComponent(String(requestParameters.id))),
            method: 'GET',
            headers: headerParameters,
            query: queryParameters,
        }, initOverrides);

        return new runtime.JSONApiResponse(response, (jsonValue) => ProxyProfileFromJSON(jsonValue));
    }

    /**
     * ### Required permissions    * User account permission: `media:access` (read) / `media:roots:manage` (write)   * License component: media 
     */
    async getProxyProfile(requestParameters: GetProxyProfileRequest, initOverrides?: RequestInit): Promise<ProxyProfile> {
        const response = await this.getProxyProfileRaw(requestParameters, initOverrides);
        return await response.value();
    }

    /**
     * ### Required permissions    * User account permission: `media:access` (read) / `media:roots:manage` (write)   * License component: media 
     */
    async getProxyProfileProxyCountRaw(requestParameters: GetProxyProfileProxyCountRequest, initOverrides?: RequestInit): Promise<runtime.ApiResponse<ProxyCount>> {
        if (requestParameters.id === null || requestParameters.id === undefined) {
            throw new runtime.RequiredError('id','Required parameter requestParameters.id was null or undefined when calling getProxyProfileProxyCount.');
        }

        const queryParameters: any = {};

        const headerParameters: runtime.HTTPHeaders = {};

        if (this.configuration && this.configuration.apiKey) {
            headerParameters["Authorization"] = this.configuration.apiKey("Authorization"); // Bearer authentication
        }

        const response = await this.request({
            path: `/api/2/media/proxy-profiles/{id}/proxy-count`.replace(`{${"id"}}`, encodeURIComponent(String(requestParameters.id))),
            method: 'GET',
            headers: headerParameters,
            query: queryParameters,
        }, initOverrides);

        return new runtime.JSONApiResponse(response, (jsonValue) => ProxyCountFromJSON(jsonValue));
    }

    /**
     * ### Required permissions    * User account permission: `media:access` (read) / `media:roots:manage` (write)   * License component: media 
     */
    async getProxyProfileProxyCount(requestParameters: GetProxyProfileProxyCountRequest, initOverrides?: RequestInit): Promise<ProxyCount> {
        const response = await this.getProxyProfileProxyCountRaw(requestParameters, initOverrides);
        return await response.value();
    }

    /**
     * ### Required permissions    * User account permission: `media:access`   * License component: media 
     */
    async getSavedSearchRaw(requestParameters: GetSavedSearchRequest, initOverrides?: RequestInit): Promise<runtime.ApiResponse<SavedSearch>> {
        if (requestParameters.id === null || requestParameters.id === undefined) {
            throw new runtime.RequiredError('id','Required parameter requestParameters.id was null or undefined when calling getSavedSearch.');
        }

        const queryParameters: any = {};

        const headerParameters: runtime.HTTPHeaders = {};

        if (this.configuration && this.configuration.apiKey) {
            headerParameters["Authorization"] = this.configuration.apiKey("Authorization"); // Bearer authentication
        }

        const response = await this.request({
            path: `/api/2/media/saved-searches/{id}`.replace(`{${"id"}}`, encodeURIComponent(String(requestParameters.id))),
            method: 'GET',
            headers: headerParameters,
            query: queryParameters,
        }, initOverrides);

        return new runtime.JSONApiResponse(response, (jsonValue) => SavedSearchFromJSON(jsonValue));
    }

    /**
     * ### Required permissions    * User account permission: `media:access`   * License component: media 
     */
    async getSavedSearch(requestParameters: GetSavedSearchRequest, initOverrides?: RequestInit): Promise<SavedSearch> {
        const response = await this.getSavedSearchRaw(requestParameters, initOverrides);
        return await response.value();
    }

    /**
     * ### Required permissions    * User account permission: `media:access`   * License component: media 
     */
    async getSubclipRaw(requestParameters: GetSubclipRequest, initOverrides?: RequestInit): Promise<runtime.ApiResponse<Subclip>> {
        if (requestParameters.id === null || requestParameters.id === undefined) {
            throw new runtime.RequiredError('id','Required parameter requestParameters.id was null or undefined when calling getSubclip.');
        }

        const queryParameters: any = {};

        const headerParameters: runtime.HTTPHeaders = {};

        if (this.configuration && this.configuration.apiKey) {
            headerParameters["Authorization"] = this.configuration.apiKey("Authorization"); // Bearer authentication
        }

        const response = await this.request({
            path: `/api/2/media/subclips/{id}`.replace(`{${"id"}}`, encodeURIComponent(String(requestParameters.id))),
            method: 'GET',
            headers: headerParameters,
            query: queryParameters,
        }, initOverrides);

        return new runtime.JSONApiResponse(response, (jsonValue) => SubclipFromJSON(jsonValue));
    }

    /**
     * ### Required permissions    * User account permission: `media:access`   * License component: media 
     */
    async getSubclip(requestParameters: GetSubclipRequest, initOverrides?: RequestInit): Promise<Subclip> {
        const response = await this.getSubclipRaw(requestParameters, initOverrides);
        return await response.value();
    }

    /**
     * ### Required permissions    * User account permission: `media:access`   * License component: media 
     */
    async getSubtitlesRaw(requestParameters: GetSubtitlesRequest, initOverrides?: RequestInit): Promise<runtime.ApiResponse<Blob>> {
        if (requestParameters.id === null || requestParameters.id === undefined) {
            throw new runtime.RequiredError('id','Required parameter requestParameters.id was null or undefined when calling getSubtitles.');
        }

        if (requestParameters.title === null || requestParameters.title === undefined) {
            throw new runtime.RequiredError('title','Required parameter requestParameters.title was null or undefined when calling getSubtitles.');
        }

        const queryParameters: any = {};

        const headerParameters: runtime.HTTPHeaders = {};

        if (this.configuration && this.configuration.apiKey) {
            headerParameters["Authorization"] = this.configuration.apiKey("Authorization"); // Bearer authentication
        }

        const response = await this.request({
            path: `/api/2/media/assets/{id}/subtitle/{title}`.replace(`{${"id"}}`, encodeURIComponent(String(requestParameters.id))).replace(`{${"title"}}`, encodeURIComponent(String(requestParameters.title))),
            method: 'GET',
            headers: headerParameters,
            query: queryParameters,
        }, initOverrides);

        return new runtime.BlobApiResponse(response);
    }

    /**
     * ### Required permissions    * User account permission: `media:access`   * License component: media 
     */
    async getSubtitles(requestParameters: GetSubtitlesRequest, initOverrides?: RequestInit): Promise<Blob> {
        const response = await this.getSubtitlesRaw(requestParameters, initOverrides);
        return await response.value();
    }

    /**
     * ### Required permissions    * User account permission: `tasks:view` 
     */
    async getTranscoderProfileRaw(requestParameters: GetTranscoderProfileRequest, initOverrides?: RequestInit): Promise<runtime.ApiResponse<TranscoderProfile>> {
        if (requestParameters.id === null || requestParameters.id === undefined) {
            throw new runtime.RequiredError('id','Required parameter requestParameters.id was null or undefined when calling getTranscoderProfile.');
        }

        const queryParameters: any = {};

        const headerParameters: runtime.HTTPHeaders = {};

        if (this.configuration && this.configuration.apiKey) {
            headerParameters["Authorization"] = this.configuration.apiKey("Authorization"); // Bearer authentication
        }

        const response = await this.request({
            path: `/api/2/transcoder-profiles/{id}`.replace(`{${"id"}}`, encodeURIComponent(String(requestParameters.id))),
            method: 'GET',
            headers: headerParameters,
            query: queryParameters,
        }, initOverrides);

        return new runtime.JSONApiResponse(response, (jsonValue) => TranscoderProfileFromJSON(jsonValue));
    }

    /**
     * ### Required permissions    * User account permission: `tasks:view` 
     */
    async getTranscoderProfile(requestParameters: GetTranscoderProfileRequest, initOverrides?: RequestInit): Promise<TranscoderProfile> {
        const response = await this.getTranscoderProfileRaw(requestParameters, initOverrides);
        return await response.value();
    }

    /**
     * ### Required permissions    * User account permission: `media:access` (read) / `system:admin-access` (write) 
     */
    async getVantageWorkflowsRaw(requestParameters: GetVantageWorkflowsRequest, initOverrides?: RequestInit): Promise<runtime.ApiResponse<VantageWorkflows>> {
        if (requestParameters.id === null || requestParameters.id === undefined) {
            throw new runtime.RequiredError('id','Required parameter requestParameters.id was null or undefined when calling getVantageWorkflows.');
        }

        const queryParameters: any = {};

        const headerParameters: runtime.HTTPHeaders = {};

        if (this.configuration && this.configuration.apiKey) {
            headerParameters["Authorization"] = this.configuration.apiKey("Authorization"); // Bearer authentication
        }

        const response = await this.request({
            path: `/api/2/media/external-transcoders/{id}/workflows`.replace(`{${"id"}}`, encodeURIComponent(String(requestParameters.id))),
            method: 'GET',
            headers: headerParameters,
            query: queryParameters,
        }, initOverrides);

        return new runtime.JSONApiResponse(response, (jsonValue) => VantageWorkflowsFromJSON(jsonValue));
    }

    /**
     * ### Required permissions    * User account permission: `media:access` (read) / `system:admin-access` (write) 
     */
    async getVantageWorkflows(requestParameters: GetVantageWorkflowsRequest, initOverrides?: RequestInit): Promise<VantageWorkflows> {
        const response = await this.getVantageWorkflowsRaw(requestParameters, initOverrides);
        return await response.value();
    }

    /**
     * ### Required permissions    * User account permission: `media:access`   * License component: media 
     */
    async instantiateMediaFileTemplateRaw(requestParameters: InstantiateMediaFileTemplateRequest, initOverrides?: RequestInit): Promise<runtime.ApiResponse<void>> {
        if (requestParameters.id === null || requestParameters.id === undefined) {
            throw new runtime.RequiredError('id','Required parameter requestParameters.id was null or undefined when calling instantiateMediaFileTemplate.');
        }

        if (requestParameters.instantiateFileTemplateRequest === null || requestParameters.instantiateFileTemplateRequest === undefined) {
            throw new runtime.RequiredError('instantiateFileTemplateRequest','Required parameter requestParameters.instantiateFileTemplateRequest was null or undefined when calling instantiateMediaFileTemplate.');
        }

        const queryParameters: any = {};

        const headerParameters: runtime.HTTPHeaders = {};

        headerParameters['Content-Type'] = 'application/json';

        if (this.configuration && this.configuration.apiKey) {
            headerParameters["Authorization"] = this.configuration.apiKey("Authorization"); // Bearer authentication
        }

        const response = await this.request({
            path: `/api/2/media/files/templates/{id}/instantiate`.replace(`{${"id"}}`, encodeURIComponent(String(requestParameters.id))),
            method: 'POST',
            headers: headerParameters,
            query: queryParameters,
            body: InstantiateFileTemplateRequestToJSON(requestParameters.instantiateFileTemplateRequest),
        }, initOverrides);

        return new runtime.VoidApiResponse(response);
    }

    /**
     * ### Required permissions    * User account permission: `media:access`   * License component: media 
     */
    async instantiateMediaFileTemplate(requestParameters: InstantiateMediaFileTemplateRequest, initOverrides?: RequestInit): Promise<void> {
        await this.instantiateMediaFileTemplateRaw(requestParameters, initOverrides);
    }

    /**
     * ### Required permissions    * User account permission: `media:access` 
     */
    async locateEditorProjectPathsRaw(requestParameters: LocateEditorProjectPathsRequest, initOverrides?: RequestInit): Promise<runtime.ApiResponse<Array<LocateResult>>> {
        if (requestParameters.id === null || requestParameters.id === undefined) {
            throw new runtime.RequiredError('id','Required parameter requestParameters.id was null or undefined when calling locateEditorProjectPaths.');
        }

        const queryParameters: any = {};

        const headerParameters: runtime.HTTPHeaders = {};

        if (this.configuration && this.configuration.apiKey) {
            headerParameters["Authorization"] = this.configuration.apiKey("Authorization"); // Bearer authentication
        }

        const response = await this.request({
            path: `/api/2/media/editor/{id}/locate-paths`.replace(`{${"id"}}`, encodeURIComponent(String(requestParameters.id))),
            method: 'GET',
            headers: headerParameters,
            query: queryParameters,
        }, initOverrides);

        return new runtime.JSONApiResponse(response, (jsonValue) => jsonValue.map(LocateResultFromJSON));
    }

    /**
     * ### Required permissions    * User account permission: `media:access` 
     */
    async locateEditorProjectPaths(requestParameters: LocateEditorProjectPathsRequest, initOverrides?: RequestInit): Promise<Array<LocateResult>> {
        const response = await this.locateEditorProjectPathsRaw(requestParameters, initOverrides);
        return await response.value();
    }

    /**
     * ### Required permissions    * User account permission: `media:access`   * License component: media 
     */
    async lookupMediaFilesRaw(requestParameters: LookupMediaFilesRequest, initOverrides?: RequestInit): Promise<runtime.ApiResponse<Array<MediaFile>>> {
        if (requestParameters.mediaFilesLookupRequest === null || requestParameters.mediaFilesLookupRequest === undefined) {
            throw new runtime.RequiredError('mediaFilesLookupRequest','Required parameter requestParameters.mediaFilesLookupRequest was null or undefined when calling lookupMediaFiles.');
        }

        const queryParameters: any = {};

        const headerParameters: runtime.HTTPHeaders = {};

        headerParameters['Content-Type'] = 'application/json';

        if (this.configuration && this.configuration.apiKey) {
            headerParameters["Authorization"] = this.configuration.apiKey("Authorization"); // Bearer authentication
        }

        const response = await this.request({
            path: `/api/2/media/files/lookup`,
            method: 'POST',
            headers: headerParameters,
            query: queryParameters,
            body: MediaFilesLookupRequestToJSON(requestParameters.mediaFilesLookupRequest),
        }, initOverrides);

        return new runtime.JSONApiResponse(response, (jsonValue) => jsonValue.map(MediaFileFromJSON));
    }

    /**
     * ### Required permissions    * User account permission: `media:access`   * License component: media 
     */
    async lookupMediaFiles(requestParameters: LookupMediaFilesRequest, initOverrides?: RequestInit): Promise<Array<MediaFile>> {
        const response = await this.lookupMediaFilesRaw(requestParameters, initOverrides);
        return await response.value();
    }

    /**
     * ### Required permissions    * User account permission: `media:access`   * License component: media 
     */
    async markMediaDirectoryAsShowroomRaw(requestParameters: MarkMediaDirectoryAsShowroomRequest, initOverrides?: RequestInit): Promise<runtime.ApiResponse<void>> {
        if (requestParameters.id === null || requestParameters.id === undefined) {
            throw new runtime.RequiredError('id','Required parameter requestParameters.id was null or undefined when calling markMediaDirectoryAsShowroom.');
        }

        const queryParameters: any = {};

        const headerParameters: runtime.HTTPHeaders = {};

        if (this.configuration && this.configuration.apiKey) {
            headerParameters["Authorization"] = this.configuration.apiKey("Authorization"); // Bearer authentication
        }

        const response = await this.request({
            path: `/api/2/media/files/{id}/showroom`.replace(`{${"id"}}`, encodeURIComponent(String(requestParameters.id))),
            method: 'POST',
            headers: headerParameters,
            query: queryParameters,
        }, initOverrides);

        return new runtime.VoidApiResponse(response);
    }

    /**
     * ### Required permissions    * User account permission: `media:access`   * License component: media 
     */
    async markMediaDirectoryAsShowroom(requestParameters: MarkMediaDirectoryAsShowroomRequest, initOverrides?: RequestInit): Promise<void> {
        await this.markMediaDirectoryAsShowroomRaw(requestParameters, initOverrides);
    }

    /**
     * ### Required permissions    * User account permission: `media:access`   * License component: media 
     */
    async patchAssetRaw(requestParameters: PatchAssetRequest, initOverrides?: RequestInit): Promise<runtime.ApiResponse<Asset>> {
        if (requestParameters.id === null || requestParameters.id === undefined) {
            throw new runtime.RequiredError('id','Required parameter requestParameters.id was null or undefined when calling patchAsset.');
        }

        if (requestParameters.assetPartialUpdate === null || requestParameters.assetPartialUpdate === undefined) {
            throw new runtime.RequiredError('assetPartialUpdate','Required parameter requestParameters.assetPartialUpdate was null or undefined when calling patchAsset.');
        }

        const queryParameters: any = {};

        if (requestParameters.root !== undefined) {
            queryParameters['root'] = requestParameters.root;
        }

        const headerParameters: runtime.HTTPHeaders = {};

        headerParameters['Content-Type'] = 'application/json';

        if (this.configuration && this.configuration.apiKey) {
            headerParameters["Authorization"] = this.configuration.apiKey("Authorization"); // Bearer authentication
        }

        const response = await this.request({
            path: `/api/2/media/assets/{id}`.replace(`{${"id"}}`, encodeURIComponent(String(requestParameters.id))),
            method: 'PATCH',
            headers: headerParameters,
            query: queryParameters,
            body: AssetPartialUpdateToJSON(requestParameters.assetPartialUpdate),
        }, initOverrides);

        return new runtime.JSONApiResponse(response, (jsonValue) => AssetFromJSON(jsonValue));
    }

    /**
     * ### Required permissions    * User account permission: `media:access`   * License component: media 
     */
    async patchAsset(requestParameters: PatchAssetRequest, initOverrides?: RequestInit): Promise<Asset> {
        const response = await this.patchAssetRaw(requestParameters, initOverrides);
        return await response.value();
    }

    /**
     * ### Required permissions    * User account permission: `media:access`   * License component: media 
     */
    async patchAssetRatingRaw(requestParameters: PatchAssetRatingRequest, initOverrides?: RequestInit): Promise<runtime.ApiResponse<AssetRating>> {
        if (requestParameters.id === null || requestParameters.id === undefined) {
            throw new runtime.RequiredError('id','Required parameter requestParameters.id was null or undefined when calling patchAssetRating.');
        }

        if (requestParameters.assetRatingPartialUpdate === null || requestParameters.assetRatingPartialUpdate === undefined) {
            throw new runtime.RequiredError('assetRatingPartialUpdate','Required parameter requestParameters.assetRatingPartialUpdate was null or undefined when calling patchAssetRating.');
        }

        const queryParameters: any = {};

        const headerParameters: runtime.HTTPHeaders = {};

        headerParameters['Content-Type'] = 'application/json';

        if (this.configuration && this.configuration.apiKey) {
            headerParameters["Authorization"] = this.configuration.apiKey("Authorization"); // Bearer authentication
        }

        const response = await this.request({
            path: `/api/2/media/ratings/{id}`.replace(`{${"id"}}`, encodeURIComponent(String(requestParameters.id))),
            method: 'PATCH',
            headers: headerParameters,
            query: queryParameters,
            body: AssetRatingPartialUpdateToJSON(requestParameters.assetRatingPartialUpdate),
        }, initOverrides);

        return new runtime.JSONApiResponse(response, (jsonValue) => AssetRatingFromJSON(jsonValue));
    }

    /**
     * ### Required permissions    * User account permission: `media:access`   * License component: media 
     */
    async patchAssetRating(requestParameters: PatchAssetRatingRequest, initOverrides?: RequestInit): Promise<AssetRating> {
        const response = await this.patchAssetRatingRaw(requestParameters, initOverrides);
        return await response.value();
    }

    /**
     * ### Required permissions    * User account permission: `media:access`   * License component: media 
     */
    async patchAssetSubtitleLinkRaw(requestParameters: PatchAssetSubtitleLinkRequest, initOverrides?: RequestInit): Promise<runtime.ApiResponse<AssetSubtitleLink>> {
        if (requestParameters.id === null || requestParameters.id === undefined) {
            throw new runtime.RequiredError('id','Required parameter requestParameters.id was null or undefined when calling patchAssetSubtitleLink.');
        }

        if (requestParameters.assetSubtitleLinkPartialUpdate === null || requestParameters.assetSubtitleLinkPartialUpdate === undefined) {
            throw new runtime.RequiredError('assetSubtitleLinkPartialUpdate','Required parameter requestParameters.assetSubtitleLinkPartialUpdate was null or undefined when calling patchAssetSubtitleLink.');
        }

        const queryParameters: any = {};

        const headerParameters: runtime.HTTPHeaders = {};

        headerParameters['Content-Type'] = 'application/json';

        if (this.configuration && this.configuration.apiKey) {
            headerParameters["Authorization"] = this.configuration.apiKey("Authorization"); // Bearer authentication
        }

        const response = await this.request({
            path: `/api/2/media/assets/subtitle-links/{id}`.replace(`{${"id"}}`, encodeURIComponent(String(requestParameters.id))),
            method: 'PATCH',
            headers: headerParameters,
            query: queryParameters,
            body: AssetSubtitleLinkPartialUpdateToJSON(requestParameters.assetSubtitleLinkPartialUpdate),
        }, initOverrides);

        return new runtime.JSONApiResponse(response, (jsonValue) => AssetSubtitleLinkFromJSON(jsonValue));
    }

    /**
     * ### Required permissions    * User account permission: `media:access`   * License component: media 
     */
    async patchAssetSubtitleLink(requestParameters: PatchAssetSubtitleLinkRequest, initOverrides?: RequestInit): Promise<AssetSubtitleLink> {
        const response = await this.patchAssetSubtitleLinkRaw(requestParameters, initOverrides);
        return await response.value();
    }

    /**
     * ### Required permissions    * User account permission: `media:access`   * License component: media 
     */
    async patchCommentRaw(requestParameters: PatchCommentRequest, initOverrides?: RequestInit): Promise<runtime.ApiResponse<Comment>> {
        if (requestParameters.id === null || requestParameters.id === undefined) {
            throw new runtime.RequiredError('id','Required parameter requestParameters.id was null or undefined when calling patchComment.');
        }

        if (requestParameters.commentPartialUpdate === null || requestParameters.commentPartialUpdate === undefined) {
            throw new runtime.RequiredError('commentPartialUpdate','Required parameter requestParameters.commentPartialUpdate was null or undefined when calling patchComment.');
        }

        const queryParameters: any = {};

        const headerParameters: runtime.HTTPHeaders = {};

        headerParameters['Content-Type'] = 'application/json';

        if (this.configuration && this.configuration.apiKey) {
            headerParameters["Authorization"] = this.configuration.apiKey("Authorization"); // Bearer authentication
        }

        const response = await this.request({
            path: `/api/2/media/comments/{id}`.replace(`{${"id"}}`, encodeURIComponent(String(requestParameters.id))),
            method: 'PATCH',
            headers: headerParameters,
            query: queryParameters,
            body: CommentPartialUpdateToJSON(requestParameters.commentPartialUpdate),
        }, initOverrides);

        return new runtime.JSONApiResponse(response, (jsonValue) => CommentFromJSON(jsonValue));
    }

    /**
     * ### Required permissions    * User account permission: `media:access`   * License component: media 
     */
    async patchComment(requestParameters: PatchCommentRequest, initOverrides?: RequestInit): Promise<Comment> {
        const response = await this.patchCommentRaw(requestParameters, initOverrides);
        return await response.value();
    }

    /**
     * ### Required permissions    * User account permission: `media:access` (read) / `media:roots:manage` (write)   * License component: media 
     */
    async patchCustomFieldRaw(requestParameters: PatchCustomFieldRequest, initOverrides?: RequestInit): Promise<runtime.ApiResponse<CustomField>> {
        if (requestParameters.id === null || requestParameters.id === undefined) {
            throw new runtime.RequiredError('id','Required parameter requestParameters.id was null or undefined when calling patchCustomField.');
        }

        if (requestParameters.customFieldPartialUpdate === null || requestParameters.customFieldPartialUpdate === undefined) {
            throw new runtime.RequiredError('customFieldPartialUpdate','Required parameter requestParameters.customFieldPartialUpdate was null or undefined when calling patchCustomField.');
        }

        const queryParameters: any = {};

        const headerParameters: runtime.HTTPHeaders = {};

        headerParameters['Content-Type'] = 'application/json';

        if (this.configuration && this.configuration.apiKey) {
            headerParameters["Authorization"] = this.configuration.apiKey("Authorization"); // Bearer authentication
        }

        const response = await this.request({
            path: `/api/2/media/custom-fields/{id}`.replace(`{${"id"}}`, encodeURIComponent(String(requestParameters.id))),
            method: 'PATCH',
            headers: headerParameters,
            query: queryParameters,
            body: CustomFieldPartialUpdateToJSON(requestParameters.customFieldPartialUpdate),
        }, initOverrides);

        return new runtime.JSONApiResponse(response, (jsonValue) => CustomFieldFromJSON(jsonValue));
    }

    /**
     * ### Required permissions    * User account permission: `media:access` (read) / `media:roots:manage` (write)   * License component: media 
     */
    async patchCustomField(requestParameters: PatchCustomFieldRequest, initOverrides?: RequestInit): Promise<CustomField> {
        const response = await this.patchCustomFieldRaw(requestParameters, initOverrides);
        return await response.value();
    }

    /**
     * ### Required permissions    * User account permission: `media:access` 
     */
    async patchEditorProjectRaw(requestParameters: PatchEditorProjectRequest, initOverrides?: RequestInit): Promise<runtime.ApiResponse<EditorProject>> {
        if (requestParameters.id === null || requestParameters.id === undefined) {
            throw new runtime.RequiredError('id','Required parameter requestParameters.id was null or undefined when calling patchEditorProject.');
        }

        if (requestParameters.editorProjectPartialUpdate === null || requestParameters.editorProjectPartialUpdate === undefined) {
            throw new runtime.RequiredError('editorProjectPartialUpdate','Required parameter requestParameters.editorProjectPartialUpdate was null or undefined when calling patchEditorProject.');
        }

        const queryParameters: any = {};

        const headerParameters: runtime.HTTPHeaders = {};

        headerParameters['Content-Type'] = 'application/json';

        if (this.configuration && this.configuration.apiKey) {
            headerParameters["Authorization"] = this.configuration.apiKey("Authorization"); // Bearer authentication
        }

        const response = await this.request({
            path: `/api/2/media/editor/{id}`.replace(`{${"id"}}`, encodeURIComponent(String(requestParameters.id))),
            method: 'PATCH',
            headers: headerParameters,
            query: queryParameters,
            body: EditorProjectPartialUpdateToJSON(requestParameters.editorProjectPartialUpdate),
        }, initOverrides);

        return new runtime.JSONApiResponse(response, (jsonValue) => EditorProjectFromJSON(jsonValue));
    }

    /**
     * ### Required permissions    * User account permission: `media:access` 
     */
    async patchEditorProject(requestParameters: PatchEditorProjectRequest, initOverrides?: RequestInit): Promise<EditorProject> {
        const response = await this.patchEditorProjectRaw(requestParameters, initOverrides);
        return await response.value();
    }

    /**
     * ### Required permissions    * User account permission: `media:access` 
     */
    async patchEditorSubtitleRaw(requestParameters: PatchEditorSubtitleRequest, initOverrides?: RequestInit): Promise<runtime.ApiResponse<EditorSubtitle>> {
        if (requestParameters.id === null || requestParameters.id === undefined) {
            throw new runtime.RequiredError('id','Required parameter requestParameters.id was null or undefined when calling patchEditorSubtitle.');
        }

        if (requestParameters.editorSubtitlePartialUpdate === null || requestParameters.editorSubtitlePartialUpdate === undefined) {
            throw new runtime.RequiredError('editorSubtitlePartialUpdate','Required parameter requestParameters.editorSubtitlePartialUpdate was null or undefined when calling patchEditorSubtitle.');
        }

        const queryParameters: any = {};

        const headerParameters: runtime.HTTPHeaders = {};

        headerParameters['Content-Type'] = 'application/json';

        if (this.configuration && this.configuration.apiKey) {
            headerParameters["Authorization"] = this.configuration.apiKey("Authorization"); // Bearer authentication
        }

        const response = await this.request({
            path: `/api/2/media/subtitles/{id}`.replace(`{${"id"}}`, encodeURIComponent(String(requestParameters.id))),
            method: 'PATCH',
            headers: headerParameters,
            query: queryParameters,
            body: EditorSubtitlePartialUpdateToJSON(requestParameters.editorSubtitlePartialUpdate),
        }, initOverrides);

        return new runtime.JSONApiResponse(response, (jsonValue) => EditorSubtitleFromJSON(jsonValue));
    }

    /**
     * ### Required permissions    * User account permission: `media:access` 
     */
    async patchEditorSubtitle(requestParameters: PatchEditorSubtitleRequest, initOverrides?: RequestInit): Promise<EditorSubtitle> {
        const response = await this.patchEditorSubtitleRaw(requestParameters, initOverrides);
        return await response.value();
    }

    /**
     * ### Required permissions    * User account permission: `media:access` (read) / `system:admin-access` (write) 
     */
    async patchExternalTranscoderRaw(requestParameters: PatchExternalTranscoderRequest, initOverrides?: RequestInit): Promise<runtime.ApiResponse<ExternalTranscoder>> {
        if (requestParameters.id === null || requestParameters.id === undefined) {
            throw new runtime.RequiredError('id','Required parameter requestParameters.id was null or undefined when calling patchExternalTranscoder.');
        }

        if (requestParameters.externalTranscoderPartialUpdate === null || requestParameters.externalTranscoderPartialUpdate === undefined) {
            throw new runtime.RequiredError('externalTranscoderPartialUpdate','Required parameter requestParameters.externalTranscoderPartialUpdate was null or undefined when calling patchExternalTranscoder.');
        }

        const queryParameters: any = {};

        const headerParameters: runtime.HTTPHeaders = {};

        headerParameters['Content-Type'] = 'application/json';

        if (this.configuration && this.configuration.apiKey) {
            headerParameters["Authorization"] = this.configuration.apiKey("Authorization"); // Bearer authentication
        }

        const response = await this.request({
            path: `/api/2/media/external-transcoders/{id}`.replace(`{${"id"}}`, encodeURIComponent(String(requestParameters.id))),
            method: 'PATCH',
            headers: headerParameters,
            query: queryParameters,
            body: ExternalTranscoderPartialUpdateToJSON(requestParameters.externalTranscoderPartialUpdate),
        }, initOverrides);

        return new runtime.JSONApiResponse(response, (jsonValue) => ExternalTranscoderFromJSON(jsonValue));
    }

    /**
     * ### Required permissions    * User account permission: `media:access` (read) / `system:admin-access` (write) 
     */
    async patchExternalTranscoder(requestParameters: PatchExternalTranscoderRequest, initOverrides?: RequestInit): Promise<ExternalTranscoder> {
        const response = await this.patchExternalTranscoderRaw(requestParameters, initOverrides);
        return await response.value();
    }

    /**
     * ### Required permissions    * User account permission: `media:access`   * License component: media 
     */
    async patchMarkerRaw(requestParameters: PatchMarkerRequest, initOverrides?: RequestInit): Promise<runtime.ApiResponse<Marker>> {
        if (requestParameters.id === null || requestParameters.id === undefined) {
            throw new runtime.RequiredError('id','Required parameter requestParameters.id was null or undefined when calling patchMarker.');
        }

        if (requestParameters.markerPartialUpdate === null || requestParameters.markerPartialUpdate === undefined) {
            throw new runtime.RequiredError('markerPartialUpdate','Required parameter requestParameters.markerPartialUpdate was null or undefined when calling patchMarker.');
        }

        const queryParameters: any = {};

        const headerParameters: runtime.HTTPHeaders = {};

        headerParameters['Content-Type'] = 'application/json';

        if (this.configuration && this.configuration.apiKey) {
            headerParameters["Authorization"] = this.configuration.apiKey("Authorization"); // Bearer authentication
        }

        const response = await this.request({
            path: `/api/2/media/markers/{id}`.replace(`{${"id"}}`, encodeURIComponent(String(requestParameters.id))),
            method: 'PATCH',
            headers: headerParameters,
            query: queryParameters,
            body: MarkerPartialUpdateToJSON(requestParameters.markerPartialUpdate),
        }, initOverrides);

        return new runtime.JSONApiResponse(response, (jsonValue) => MarkerFromJSON(jsonValue));
    }

    /**
     * ### Required permissions    * User account permission: `media:access`   * License component: media 
     */
    async patchMarker(requestParameters: PatchMarkerRequest, initOverrides?: RequestInit): Promise<Marker> {
        const response = await this.patchMarkerRaw(requestParameters, initOverrides);
        return await response.value();
    }

    /**
     * ### Required permissions    * User account permission: `media:access`   * License component: media 
     */
    async patchMediaFileRaw(requestParameters: PatchMediaFileRequest, initOverrides?: RequestInit): Promise<runtime.ApiResponse<MediaFile>> {
        if (requestParameters.id === null || requestParameters.id === undefined) {
            throw new runtime.RequiredError('id','Required parameter requestParameters.id was null or undefined when calling patchMediaFile.');
        }

        if (requestParameters.mediaFilePartialUpdate === null || requestParameters.mediaFilePartialUpdate === undefined) {
            throw new runtime.RequiredError('mediaFilePartialUpdate','Required parameter requestParameters.mediaFilePartialUpdate was null or undefined when calling patchMediaFile.');
        }

        const queryParameters: any = {};

        if (requestParameters.root !== undefined) {
            queryParameters['root'] = requestParameters.root;
        }

        const headerParameters: runtime.HTTPHeaders = {};

        headerParameters['Content-Type'] = 'application/json';

        if (this.configuration && this.configuration.apiKey) {
            headerParameters["Authorization"] = this.configuration.apiKey("Authorization"); // Bearer authentication
        }

        const response = await this.request({
            path: `/api/2/media/files/{id}`.replace(`{${"id"}}`, encodeURIComponent(String(requestParameters.id))),
            method: 'PATCH',
            headers: headerParameters,
            query: queryParameters,
            body: MediaFilePartialUpdateToJSON(requestParameters.mediaFilePartialUpdate),
        }, initOverrides);

        return new runtime.JSONApiResponse(response, (jsonValue) => MediaFileFromJSON(jsonValue));
    }

    /**
     * ### Required permissions    * User account permission: `media:access`   * License component: media 
     */
    async patchMediaFile(requestParameters: PatchMediaFileRequest, initOverrides?: RequestInit): Promise<MediaFile> {
        const response = await this.patchMediaFileRaw(requestParameters, initOverrides);
        return await response.value();
    }

    /**
     * ### Required permissions    * User account permission: `media:access`   * License component: media 
     */
    async patchMediaFileTemplateRaw(requestParameters: PatchMediaFileTemplateRequest, initOverrides?: RequestInit): Promise<runtime.ApiResponse<MediaFileTemplate>> {
        if (requestParameters.id === null || requestParameters.id === undefined) {
            throw new runtime.RequiredError('id','Required parameter requestParameters.id was null or undefined when calling patchMediaFileTemplate.');
        }

        if (requestParameters.mediaFileTemplatePartialUpdate === null || requestParameters.mediaFileTemplatePartialUpdate === undefined) {
            throw new runtime.RequiredError('mediaFileTemplatePartialUpdate','Required parameter requestParameters.mediaFileTemplatePartialUpdate was null or undefined when calling patchMediaFileTemplate.');
        }

        const queryParameters: any = {};

        const headerParameters: runtime.HTTPHeaders = {};

        headerParameters['Content-Type'] = 'application/json';

        if (this.configuration && this.configuration.apiKey) {
            headerParameters["Authorization"] = this.configuration.apiKey("Authorization"); // Bearer authentication
        }

        const response = await this.request({
            path: `/api/2/media/files/templates/{id}`.replace(`{${"id"}}`, encodeURIComponent(String(requestParameters.id))),
            method: 'PATCH',
            headers: headerParameters,
            query: queryParameters,
            body: MediaFileTemplatePartialUpdateToJSON(requestParameters.mediaFileTemplatePartialUpdate),
        }, initOverrides);

        return new runtime.JSONApiResponse(response, (jsonValue) => MediaFileTemplateFromJSON(jsonValue));
    }

    /**
     * ### Required permissions    * User account permission: `media:access`   * License component: media 
     */
    async patchMediaFileTemplate(requestParameters: PatchMediaFileTemplateRequest, initOverrides?: RequestInit): Promise<MediaFileTemplate> {
        const response = await this.patchMediaFileTemplateRaw(requestParameters, initOverrides);
        return await response.value();
    }

    /**
     * ### Required permissions    * User account permission: `media:access` (read) / `media:roots:manage` (write)   * License component: media 
     */
    async patchMediaRootRaw(requestParameters: PatchMediaRootRequest, initOverrides?: RequestInit): Promise<runtime.ApiResponse<MediaRootDetail>> {
        if (requestParameters.id === null || requestParameters.id === undefined) {
            throw new runtime.RequiredError('id','Required parameter requestParameters.id was null or undefined when calling patchMediaRoot.');
        }

        if (requestParameters.mediaRootDetailPartialUpdate === null || requestParameters.mediaRootDetailPartialUpdate === undefined) {
            throw new runtime.RequiredError('mediaRootDetailPartialUpdate','Required parameter requestParameters.mediaRootDetailPartialUpdate was null or undefined when calling patchMediaRoot.');
        }

        const queryParameters: any = {};

        const headerParameters: runtime.HTTPHeaders = {};

        headerParameters['Content-Type'] = 'application/json';

        if (this.configuration && this.configuration.apiKey) {
            headerParameters["Authorization"] = this.configuration.apiKey("Authorization"); // Bearer authentication
        }

        const response = await this.request({
            path: `/api/2/media/roots/{id}`.replace(`{${"id"}}`, encodeURIComponent(String(requestParameters.id))),
            method: 'PATCH',
            headers: headerParameters,
            query: queryParameters,
            body: MediaRootDetailPartialUpdateToJSON(requestParameters.mediaRootDetailPartialUpdate),
        }, initOverrides);

        return new runtime.JSONApiResponse(response, (jsonValue) => MediaRootDetailFromJSON(jsonValue));
    }

    /**
     * ### Required permissions    * User account permission: `media:access` (read) / `media:roots:manage` (write)   * License component: media 
     */
    async patchMediaRoot(requestParameters: PatchMediaRootRequest, initOverrides?: RequestInit): Promise<MediaRootDetail> {
        const response = await this.patchMediaRootRaw(requestParameters, initOverrides);
        return await response.value();
    }

    /**
     * ### Required permissions    * User account permission: `media:access` (read) / `media:roots:manage` (write)   * License component: media 
     */
    async patchMediaRootPermissionRaw(requestParameters: PatchMediaRootPermissionRequest, initOverrides?: RequestInit): Promise<runtime.ApiResponse<MediaRootPermission>> {
        if (requestParameters.id === null || requestParameters.id === undefined) {
            throw new runtime.RequiredError('id','Required parameter requestParameters.id was null or undefined when calling patchMediaRootPermission.');
        }

        if (requestParameters.mediaRootPermissionPartialUpdate === null || requestParameters.mediaRootPermissionPartialUpdate === undefined) {
            throw new runtime.RequiredError('mediaRootPermissionPartialUpdate','Required parameter requestParameters.mediaRootPermissionPartialUpdate was null or undefined when calling patchMediaRootPermission.');
        }

        const queryParameters: any = {};

        const headerParameters: runtime.HTTPHeaders = {};

        headerParameters['Content-Type'] = 'application/json';

        if (this.configuration && this.configuration.apiKey) {
            headerParameters["Authorization"] = this.configuration.apiKey("Authorization"); // Bearer authentication
        }

        const response = await this.request({
            path: `/api/2/media/root-permissions/{id}`.replace(`{${"id"}}`, encodeURIComponent(String(requestParameters.id))),
            method: 'PATCH',
            headers: headerParameters,
            query: queryParameters,
            body: MediaRootPermissionPartialUpdateToJSON(requestParameters.mediaRootPermissionPartialUpdate),
        }, initOverrides);

        return new runtime.JSONApiResponse(response, (jsonValue) => MediaRootPermissionFromJSON(jsonValue));
    }

    /**
     * ### Required permissions    * User account permission: `media:access` (read) / `media:roots:manage` (write)   * License component: media 
     */
    async patchMediaRootPermission(requestParameters: PatchMediaRootPermissionRequest, initOverrides?: RequestInit): Promise<MediaRootPermission> {
        const response = await this.patchMediaRootPermissionRaw(requestParameters, initOverrides);
        return await response.value();
    }

    /**
     * ### Required permissions    * User account permission: `media:access`   * License component: media 
     */
    async patchMediaTagRaw(requestParameters: PatchMediaTagRequest, initOverrides?: RequestInit): Promise<runtime.ApiResponse<UnfilteredTag>> {
        if (requestParameters.id === null || requestParameters.id === undefined) {
            throw new runtime.RequiredError('id','Required parameter requestParameters.id was null or undefined when calling patchMediaTag.');
        }

        if (requestParameters.unfilteredTagPartialUpdate === null || requestParameters.unfilteredTagPartialUpdate === undefined) {
            throw new runtime.RequiredError('unfilteredTagPartialUpdate','Required parameter requestParameters.unfilteredTagPartialUpdate was null or undefined when calling patchMediaTag.');
        }

        const queryParameters: any = {};

        const headerParameters: runtime.HTTPHeaders = {};

        headerParameters['Content-Type'] = 'application/json';

        if (this.configuration && this.configuration.apiKey) {
            headerParameters["Authorization"] = this.configuration.apiKey("Authorization"); // Bearer authentication
        }

        const response = await this.request({
            path: `/api/2/media/tags/{id}`.replace(`{${"id"}}`, encodeURIComponent(String(requestParameters.id))),
            method: 'PATCH',
            headers: headerParameters,
            query: queryParameters,
            body: UnfilteredTagPartialUpdateToJSON(requestParameters.unfilteredTagPartialUpdate),
        }, initOverrides);

        return new runtime.JSONApiResponse(response, (jsonValue) => UnfilteredTagFromJSON(jsonValue));
    }

    /**
     * ### Required permissions    * User account permission: `media:access`   * License component: media 
     */
    async patchMediaTag(requestParameters: PatchMediaTagRequest, initOverrides?: RequestInit): Promise<UnfilteredTag> {
        const response = await this.patchMediaTagRaw(requestParameters, initOverrides);
        return await response.value();
    }

    /**
     * ### Required permissions    * User account permission: `media:access` (read) / `media:roots:manage` (write)   * License component: media 
     */
    async patchProxyProfileRaw(requestParameters: PatchProxyProfileRequest, initOverrides?: RequestInit): Promise<runtime.ApiResponse<ProxyProfile>> {
        if (requestParameters.id === null || requestParameters.id === undefined) {
            throw new runtime.RequiredError('id','Required parameter requestParameters.id was null or undefined when calling patchProxyProfile.');
        }

        if (requestParameters.proxyProfilePartialUpdate === null || requestParameters.proxyProfilePartialUpdate === undefined) {
            throw new runtime.RequiredError('proxyProfilePartialUpdate','Required parameter requestParameters.proxyProfilePartialUpdate was null or undefined when calling patchProxyProfile.');
        }

        const queryParameters: any = {};

        const headerParameters: runtime.HTTPHeaders = {};

        headerParameters['Content-Type'] = 'application/json';

        if (this.configuration && this.configuration.apiKey) {
            headerParameters["Authorization"] = this.configuration.apiKey("Authorization"); // Bearer authentication
        }

        const response = await this.request({
            path: `/api/2/media/proxy-profiles/{id}`.replace(`{${"id"}}`, encodeURIComponent(String(requestParameters.id))),
            method: 'PATCH',
            headers: headerParameters,
            query: queryParameters,
            body: ProxyProfilePartialUpdateToJSON(requestParameters.proxyProfilePartialUpdate),
        }, initOverrides);

        return new runtime.JSONApiResponse(response, (jsonValue) => ProxyProfileFromJSON(jsonValue));
    }

    /**
     * ### Required permissions    * User account permission: `media:access` (read) / `media:roots:manage` (write)   * License component: media 
     */
    async patchProxyProfile(requestParameters: PatchProxyProfileRequest, initOverrides?: RequestInit): Promise<ProxyProfile> {
        const response = await this.patchProxyProfileRaw(requestParameters, initOverrides);
        return await response.value();
    }

    /**
     * ### Required permissions    * User account permission: `media:access`   * License component: media 
     */
    async patchSavedSearchRaw(requestParameters: PatchSavedSearchRequest, initOverrides?: RequestInit): Promise<runtime.ApiResponse<SavedSearch>> {
        if (requestParameters.id === null || requestParameters.id === undefined) {
            throw new runtime.RequiredError('id','Required parameter requestParameters.id was null or undefined when calling patchSavedSearch.');
        }

        if (requestParameters.savedSearchPartialUpdate === null || requestParameters.savedSearchPartialUpdate === undefined) {
            throw new runtime.RequiredError('savedSearchPartialUpdate','Required parameter requestParameters.savedSearchPartialUpdate was null or undefined when calling patchSavedSearch.');
        }

        const queryParameters: any = {};

        const headerParameters: runtime.HTTPHeaders = {};

        headerParameters['Content-Type'] = 'application/json';

        if (this.configuration && this.configuration.apiKey) {
            headerParameters["Authorization"] = this.configuration.apiKey("Authorization"); // Bearer authentication
        }

        const response = await this.request({
            path: `/api/2/media/saved-searches/{id}`.replace(`{${"id"}}`, encodeURIComponent(String(requestParameters.id))),
            method: 'PATCH',
            headers: headerParameters,
            query: queryParameters,
            body: SavedSearchPartialUpdateToJSON(requestParameters.savedSearchPartialUpdate),
        }, initOverrides);

        return new runtime.JSONApiResponse(response, (jsonValue) => SavedSearchFromJSON(jsonValue));
    }

    /**
     * ### Required permissions    * User account permission: `media:access`   * License component: media 
     */
    async patchSavedSearch(requestParameters: PatchSavedSearchRequest, initOverrides?: RequestInit): Promise<SavedSearch> {
        const response = await this.patchSavedSearchRaw(requestParameters, initOverrides);
        return await response.value();
    }

    /**
     * ### Required permissions    * User account permission: `media:access`   * License component: media 
     */
    async patchSubclipRaw(requestParameters: PatchSubclipRequest, initOverrides?: RequestInit): Promise<runtime.ApiResponse<Subclip>> {
        if (requestParameters.id === null || requestParameters.id === undefined) {
            throw new runtime.RequiredError('id','Required parameter requestParameters.id was null or undefined when calling patchSubclip.');
        }

        if (requestParameters.subclipPartialUpdate === null || requestParameters.subclipPartialUpdate === undefined) {
            throw new runtime.RequiredError('subclipPartialUpdate','Required parameter requestParameters.subclipPartialUpdate was null or undefined when calling patchSubclip.');
        }

        const queryParameters: any = {};

        const headerParameters: runtime.HTTPHeaders = {};

        headerParameters['Content-Type'] = 'application/json';

        if (this.configuration && this.configuration.apiKey) {
            headerParameters["Authorization"] = this.configuration.apiKey("Authorization"); // Bearer authentication
        }

        const response = await this.request({
            path: `/api/2/media/subclips/{id}`.replace(`{${"id"}}`, encodeURIComponent(String(requestParameters.id))),
            method: 'PATCH',
            headers: headerParameters,
            query: queryParameters,
            body: SubclipPartialUpdateToJSON(requestParameters.subclipPartialUpdate),
        }, initOverrides);

        return new runtime.JSONApiResponse(response, (jsonValue) => SubclipFromJSON(jsonValue));
    }

    /**
     * ### Required permissions    * User account permission: `media:access`   * License component: media 
     */
    async patchSubclip(requestParameters: PatchSubclipRequest, initOverrides?: RequestInit): Promise<Subclip> {
        const response = await this.patchSubclipRaw(requestParameters, initOverrides);
        return await response.value();
    }

    /**
     * ### Required permissions    * User account permission: `media:access`   * License component: media 
     */
    async recursivelyTagMediaDirectoryRaw(requestParameters: RecursivelyTagMediaDirectoryRequest, initOverrides?: RequestInit): Promise<runtime.ApiResponse<void>> {
        if (requestParameters.id === null || requestParameters.id === undefined) {
            throw new runtime.RequiredError('id','Required parameter requestParameters.id was null or undefined when calling recursivelyTagMediaDirectory.');
        }

        if (requestParameters.tagMediaDirectoryRequest === null || requestParameters.tagMediaDirectoryRequest === undefined) {
            throw new runtime.RequiredError('tagMediaDirectoryRequest','Required parameter requestParameters.tagMediaDirectoryRequest was null or undefined when calling recursivelyTagMediaDirectory.');
        }

        const queryParameters: any = {};

        const headerParameters: runtime.HTTPHeaders = {};

        headerParameters['Content-Type'] = 'application/json';

        if (this.configuration && this.configuration.apiKey) {
            headerParameters["Authorization"] = this.configuration.apiKey("Authorization"); // Bearer authentication
        }

        const response = await this.request({
            path: `/api/2/media/files/{id}/tag`.replace(`{${"id"}}`, encodeURIComponent(String(requestParameters.id))),
            method: 'POST',
            headers: headerParameters,
            query: queryParameters,
            body: TagMediaDirectoryRequestToJSON(requestParameters.tagMediaDirectoryRequest),
        }, initOverrides);

        return new runtime.VoidApiResponse(response);
    }

    /**
     * ### Required permissions    * User account permission: `media:access`   * License component: media 
     */
    async recursivelyTagMediaDirectory(requestParameters: RecursivelyTagMediaDirectoryRequest, initOverrides?: RequestInit): Promise<void> {
        await this.recursivelyTagMediaDirectoryRaw(requestParameters, initOverrides);
    }

    /**
     * ### Required permissions    * User account permission: `media:access`   * License component: media 
     */
    async reindexMediaDirectoryRaw(requestParameters: ReindexMediaDirectoryRequest, initOverrides?: RequestInit): Promise<runtime.ApiResponse<void>> {
        if (requestParameters.id === null || requestParameters.id === undefined) {
            throw new runtime.RequiredError('id','Required parameter requestParameters.id was null or undefined when calling reindexMediaDirectory.');
        }

        const queryParameters: any = {};

        const headerParameters: runtime.HTTPHeaders = {};

        if (this.configuration && this.configuration.apiKey) {
            headerParameters["Authorization"] = this.configuration.apiKey("Authorization"); // Bearer authentication
        }

        const response = await this.request({
            path: `/api/2/media/files/{id}/search-reindex`.replace(`{${"id"}}`, encodeURIComponent(String(requestParameters.id))),
            method: 'POST',
            headers: headerParameters,
            query: queryParameters,
        }, initOverrides);

        return new runtime.VoidApiResponse(response);
    }

    /**
     * ### Required permissions    * User account permission: `media:access`   * License component: media 
     */
    async reindexMediaDirectory(requestParameters: ReindexMediaDirectoryRequest, initOverrides?: RequestInit): Promise<void> {
        await this.reindexMediaDirectoryRaw(requestParameters, initOverrides);
    }

    /**
     * ### Required permissions    * User account permission: `media:access` (read) / `media:roots:manage` (write)   * License component: media 
     */
    async renameCustomFieldRaw(requestParameters: RenameCustomFieldOperationRequest, initOverrides?: RequestInit): Promise<runtime.ApiResponse<TaskInfo>> {
        if (requestParameters.id === null || requestParameters.id === undefined) {
            throw new runtime.RequiredError('id','Required parameter requestParameters.id was null or undefined when calling renameCustomField.');
        }

        if (requestParameters.renameCustomFieldRequest === null || requestParameters.renameCustomFieldRequest === undefined) {
            throw new runtime.RequiredError('renameCustomFieldRequest','Required parameter requestParameters.renameCustomFieldRequest was null or undefined when calling renameCustomField.');
        }

        const queryParameters: any = {};

        const headerParameters: runtime.HTTPHeaders = {};

        headerParameters['Content-Type'] = 'application/json';

        if (this.configuration && this.configuration.apiKey) {
            headerParameters["Authorization"] = this.configuration.apiKey("Authorization"); // Bearer authentication
        }

        const response = await this.request({
            path: `/api/2/media/custom-fields/{id}/rename`.replace(`{${"id"}}`, encodeURIComponent(String(requestParameters.id))),
            method: 'POST',
            headers: headerParameters,
            query: queryParameters,
            body: RenameCustomFieldRequestToJSON(requestParameters.renameCustomFieldRequest),
        }, initOverrides);

        return new runtime.JSONApiResponse(response, (jsonValue) => TaskInfoFromJSON(jsonValue));
    }

    /**
     * ### Required permissions    * User account permission: `media:access` (read) / `media:roots:manage` (write)   * License component: media 
     */
    async renameCustomField(requestParameters: RenameCustomFieldOperationRequest, initOverrides?: RequestInit): Promise<TaskInfo> {
        const response = await this.renameCustomFieldRaw(requestParameters, initOverrides);
        return await response.value();
    }

    /**
     * ### Required permissions    * User account permission: `media:access` 
     */
    async renderSequenceRaw(requestParameters: RenderSequenceRequest, initOverrides?: RequestInit): Promise<runtime.ApiResponse<TaskInfo>> {
        if (requestParameters.renderEndpointRequest === null || requestParameters.renderEndpointRequest === undefined) {
            throw new runtime.RequiredError('renderEndpointRequest','Required parameter requestParameters.renderEndpointRequest was null or undefined when calling renderSequence.');
        }

        const queryParameters: any = {};

        const headerParameters: runtime.HTTPHeaders = {};

        headerParameters['Content-Type'] = 'application/json';

        if (this.configuration && this.configuration.apiKey) {
            headerParameters["Authorization"] = this.configuration.apiKey("Authorization"); // Bearer authentication
        }

        const response = await this.request({
            path: `/api/2/media/editor/render`,
            method: 'POST',
            headers: headerParameters,
            query: queryParameters,
            body: RenderEndpointRequestToJSON(requestParameters.renderEndpointRequest),
        }, initOverrides);

        return new runtime.JSONApiResponse(response, (jsonValue) => TaskInfoFromJSON(jsonValue));
    }

    /**
     * ### Required permissions    * User account permission: `media:access` 
     */
    async renderSequence(requestParameters: RenderSequenceRequest, initOverrides?: RequestInit): Promise<TaskInfo> {
        const response = await this.renderSequenceRaw(requestParameters, initOverrides);
        return await response.value();
    }

    /**
     * ### Required permissions    * User account permission: `media:access`   * License component: media 
     */
    async renderSubclipRaw(requestParameters: RenderSubclipRequest, initOverrides?: RequestInit): Promise<runtime.ApiResponse<TaskInfo>> {
        if (requestParameters.id === null || requestParameters.id === undefined) {
            throw new runtime.RequiredError('id','Required parameter requestParameters.id was null or undefined when calling renderSubclip.');
        }

        if (requestParameters.renderRequest === null || requestParameters.renderRequest === undefined) {
            throw new runtime.RequiredError('renderRequest','Required parameter requestParameters.renderRequest was null or undefined when calling renderSubclip.');
        }

        const queryParameters: any = {};

        const headerParameters: runtime.HTTPHeaders = {};

        headerParameters['Content-Type'] = 'application/json';

        if (this.configuration && this.configuration.apiKey) {
            headerParameters["Authorization"] = this.configuration.apiKey("Authorization"); // Bearer authentication
        }

        const response = await this.request({
            path: `/api/2/media/subclips/{id}/render`.replace(`{${"id"}}`, encodeURIComponent(String(requestParameters.id))),
            method: 'POST',
            headers: headerParameters,
            query: queryParameters,
            body: RenderRequestToJSON(requestParameters.renderRequest),
        }, initOverrides);

        return new runtime.JSONApiResponse(response, (jsonValue) => TaskInfoFromJSON(jsonValue));
    }

    /**
     * ### Required permissions    * User account permission: `media:access`   * License component: media 
     */
    async renderSubclip(requestParameters: RenderSubclipRequest, initOverrides?: RequestInit): Promise<TaskInfo> {
        const response = await this.renderSubclipRaw(requestParameters, initOverrides);
        return await response.value();
    }

    /**
     * ### Required permissions    * User account permission: `media:access` 
     */
    async requestMediaScanRaw(requestParameters: RequestMediaScanRequest, initOverrides?: RequestInit): Promise<runtime.ApiResponse<void>> {
        if (requestParameters.scannerScanEndpointRequest === null || requestParameters.scannerScanEndpointRequest === undefined) {
            throw new runtime.RequiredError('scannerScanEndpointRequest','Required parameter requestParameters.scannerScanEndpointRequest was null or undefined when calling requestMediaScan.');
        }

        const queryParameters: any = {};

        const headerParameters: runtime.HTTPHeaders = {};

        headerParameters['Content-Type'] = 'application/json';

        if (this.configuration && this.configuration.apiKey) {
            headerParameters["Authorization"] = this.configuration.apiKey("Authorization"); // Bearer authentication
        }

        const response = await this.request({
            path: `/api/2/scanner/scan`,
            method: 'POST',
            headers: headerParameters,
            query: queryParameters,
            body: ScannerScanEndpointRequestToJSON(requestParameters.scannerScanEndpointRequest),
        }, initOverrides);

        return new runtime.VoidApiResponse(response);
    }

    /**
     * ### Required permissions    * User account permission: `media:access` 
     */
    async requestMediaScan(requestParameters: RequestMediaScanRequest, initOverrides?: RequestInit): Promise<void> {
        await this.requestMediaScanRaw(requestParameters, initOverrides);
    }

    /**
     * ### Required permissions    * User account permission: `media:access`   * License component: media 
     */
    async resolveCommentRaw(requestParameters: ResolveCommentRequest, initOverrides?: RequestInit): Promise<runtime.ApiResponse<Comment>> {
        if (requestParameters.id === null || requestParameters.id === undefined) {
            throw new runtime.RequiredError('id','Required parameter requestParameters.id was null or undefined when calling resolveComment.');
        }

        const queryParameters: any = {};

        const headerParameters: runtime.HTTPHeaders = {};

        if (this.configuration && this.configuration.apiKey) {
            headerParameters["Authorization"] = this.configuration.apiKey("Authorization"); // Bearer authentication
        }

        const response = await this.request({
            path: `/api/2/media/comments/{id}/resolve`.replace(`{${"id"}}`, encodeURIComponent(String(requestParameters.id))),
            method: 'POST',
            headers: headerParameters,
            query: queryParameters,
        }, initOverrides);

        return new runtime.JSONApiResponse(response, (jsonValue) => CommentFromJSON(jsonValue));
    }

    /**
     * ### Required permissions    * User account permission: `media:access`   * License component: media 
     */
    async resolveComment(requestParameters: ResolveCommentRequest, initOverrides?: RequestInit): Promise<Comment> {
        const response = await this.resolveCommentRaw(requestParameters, initOverrides);
        return await response.value();
    }

    /**
     * ### Required permissions    * <class \'rest_framework.permissions.AllowAny\'> 
     */
    async shareMediaLibraryObjectsRaw(requestParameters: ShareMediaLibraryObjectsRequest, initOverrides?: RequestInit): Promise<runtime.ApiResponse<OneTimeAccessToken>> {
        if (requestParameters.mediaLibraryShareRequest === null || requestParameters.mediaLibraryShareRequest === undefined) {
            throw new runtime.RequiredError('mediaLibraryShareRequest','Required parameter requestParameters.mediaLibraryShareRequest was null or undefined when calling shareMediaLibraryObjects.');
        }

        const queryParameters: any = {};

        const headerParameters: runtime.HTTPHeaders = {};

        headerParameters['Content-Type'] = 'application/json';

        if (this.configuration && this.configuration.apiKey) {
            headerParameters["Authorization"] = this.configuration.apiKey("Authorization"); // Bearer authentication
        }

        const response = await this.request({
            path: `/api/2/media/share`,
            method: 'POST',
            headers: headerParameters,
            query: queryParameters,
            body: MediaLibraryShareRequestToJSON(requestParameters.mediaLibraryShareRequest),
        }, initOverrides);

        return new runtime.JSONApiResponse(response, (jsonValue) => OneTimeAccessTokenFromJSON(jsonValue));
    }

    /**
     * ### Required permissions    * <class \'rest_framework.permissions.AllowAny\'> 
     */
    async shareMediaLibraryObjects(requestParameters: ShareMediaLibraryObjectsRequest, initOverrides?: RequestInit): Promise<OneTimeAccessToken> {
        const response = await this.shareMediaLibraryObjectsRaw(requestParameters, initOverrides);
        return await response.value();
    }

    /**
     * ### Required permissions    * User account permission: `media:access` (read) / `system:admin-access` (write) 
     */
    async testExternalTranscoderConnectionRaw(requestParameters: TestExternalTranscoderConnectionOperationRequest, initOverrides?: RequestInit): Promise<runtime.ApiResponse<TestExternalTranscoderConnectionResponse>> {
        if (requestParameters.testExternalTranscoderConnectionRequest === null || requestParameters.testExternalTranscoderConnectionRequest === undefined) {
            throw new runtime.RequiredError('testExternalTranscoderConnectionRequest','Required parameter requestParameters.testExternalTranscoderConnectionRequest was null or undefined when calling testExternalTranscoderConnection.');
        }

        const queryParameters: any = {};

        const headerParameters: runtime.HTTPHeaders = {};

        headerParameters['Content-Type'] = 'application/json';

        if (this.configuration && this.configuration.apiKey) {
            headerParameters["Authorization"] = this.configuration.apiKey("Authorization"); // Bearer authentication
        }

        const response = await this.request({
            path: `/api/2/media/external-transcoders/test-connection`,
            method: 'POST',
            headers: headerParameters,
            query: queryParameters,
            body: TestExternalTranscoderConnectionRequestToJSON(requestParameters.testExternalTranscoderConnectionRequest),
        }, initOverrides);

        return new runtime.JSONApiResponse(response, (jsonValue) => TestExternalTranscoderConnectionResponseFromJSON(jsonValue));
    }

    /**
     * ### Required permissions    * User account permission: `media:access` (read) / `system:admin-access` (write) 
     */
    async testExternalTranscoderConnection(requestParameters: TestExternalTranscoderConnectionOperationRequest, initOverrides?: RequestInit): Promise<TestExternalTranscoderConnectionResponse> {
        const response = await this.testExternalTranscoderConnectionRaw(requestParameters, initOverrides);
        return await response.value();
    }

    /**
     * ### Required permissions    * <class \'rest_framework.permissions.AllowAny\'> 
     */
    async transitionWorkflowRaw(requestParameters: TransitionWorkflowRequest, initOverrides?: RequestInit): Promise<runtime.ApiResponse<WorkflowTransitionResponse>> {
        if (requestParameters.workflowTransitionRequest === null || requestParameters.workflowTransitionRequest === undefined) {
            throw new runtime.RequiredError('workflowTransitionRequest','Required parameter requestParameters.workflowTransitionRequest was null or undefined when calling transitionWorkflow.');
        }

        const queryParameters: any = {};

        const headerParameters: runtime.HTTPHeaders = {};

        headerParameters['Content-Type'] = 'application/json';

        if (this.configuration && this.configuration.apiKey) {
            headerParameters["Authorization"] = this.configuration.apiKey("Authorization"); // Bearer authentication
        }

        const response = await this.request({
            path: `/api/2/media/workflow/transition`,
            method: 'POST',
            headers: headerParameters,
            query: queryParameters,
            body: WorkflowTransitionRequestToJSON(requestParameters.workflowTransitionRequest),
        }, initOverrides);

        return new runtime.JSONApiResponse(response, (jsonValue) => WorkflowTransitionResponseFromJSON(jsonValue));
    }

    /**
     * ### Required permissions    * <class \'rest_framework.permissions.AllowAny\'> 
     */
    async transitionWorkflow(requestParameters: TransitionWorkflowRequest, initOverrides?: RequestInit): Promise<WorkflowTransitionResponse> {
        const response = await this.transitionWorkflowRaw(requestParameters, initOverrides);
        return await response.value();
    }

    /**
     * ### Required permissions    * User account permission: `media:access`   * License component: media 
     */
    async unbookmarkMediaDirectoryRaw(requestParameters: UnbookmarkMediaDirectoryRequest, initOverrides?: RequestInit): Promise<runtime.ApiResponse<void>> {
        if (requestParameters.id === null || requestParameters.id === undefined) {
            throw new runtime.RequiredError('id','Required parameter requestParameters.id was null or undefined when calling unbookmarkMediaDirectory.');
        }

        const queryParameters: any = {};

        const headerParameters: runtime.HTTPHeaders = {};

        if (this.configuration && this.configuration.apiKey) {
            headerParameters["Authorization"] = this.configuration.apiKey("Authorization"); // Bearer authentication
        }

        const response = await this.request({
            path: `/api/2/media/files/{id}/bookmark`.replace(`{${"id"}}`, encodeURIComponent(String(requestParameters.id))),
            method: 'DELETE',
            headers: headerParameters,
            query: queryParameters,
        }, initOverrides);

        return new runtime.VoidApiResponse(response);
    }

    /**
     * ### Required permissions    * User account permission: `media:access`   * License component: media 
     */
    async unbookmarkMediaDirectory(requestParameters: UnbookmarkMediaDirectoryRequest, initOverrides?: RequestInit): Promise<void> {
        await this.unbookmarkMediaDirectoryRaw(requestParameters, initOverrides);
    }

    /**
     * ### Required permissions    * User account permission: `media:access`   * License component: media 
     */
    async unmarkMediaDirectoryAsShowroomRaw(requestParameters: UnmarkMediaDirectoryAsShowroomRequest, initOverrides?: RequestInit): Promise<runtime.ApiResponse<void>> {
        if (requestParameters.id === null || requestParameters.id === undefined) {
            throw new runtime.RequiredError('id','Required parameter requestParameters.id was null or undefined when calling unmarkMediaDirectoryAsShowroom.');
        }

        const queryParameters: any = {};

        const headerParameters: runtime.HTTPHeaders = {};

        if (this.configuration && this.configuration.apiKey) {
            headerParameters["Authorization"] = this.configuration.apiKey("Authorization"); // Bearer authentication
        }

        const response = await this.request({
            path: `/api/2/media/files/{id}/showroom`.replace(`{${"id"}}`, encodeURIComponent(String(requestParameters.id))),
            method: 'DELETE',
            headers: headerParameters,
            query: queryParameters,
        }, initOverrides);

        return new runtime.VoidApiResponse(response);
    }

    /**
     * ### Required permissions    * User account permission: `media:access`   * License component: media 
     */
    async unmarkMediaDirectoryAsShowroom(requestParameters: UnmarkMediaDirectoryAsShowroomRequest, initOverrides?: RequestInit): Promise<void> {
        await this.unmarkMediaDirectoryAsShowroomRaw(requestParameters, initOverrides);
    }

    /**
     * ### Required permissions    * User account permission: `media:access`   * License component: media 
     */
    async unresolveCommentRaw(requestParameters: UnresolveCommentRequest, initOverrides?: RequestInit): Promise<runtime.ApiResponse<Comment>> {
        if (requestParameters.id === null || requestParameters.id === undefined) {
            throw new runtime.RequiredError('id','Required parameter requestParameters.id was null or undefined when calling unresolveComment.');
        }

        const queryParameters: any = {};

        const headerParameters: runtime.HTTPHeaders = {};

        if (this.configuration && this.configuration.apiKey) {
            headerParameters["Authorization"] = this.configuration.apiKey("Authorization"); // Bearer authentication
        }

        const response = await this.request({
            path: `/api/2/media/comments/{id}/unresolve`.replace(`{${"id"}}`, encodeURIComponent(String(requestParameters.id))),
            method: 'POST',
            headers: headerParameters,
            query: queryParameters,
        }, initOverrides);

        return new runtime.JSONApiResponse(response, (jsonValue) => CommentFromJSON(jsonValue));
    }

    /**
     * ### Required permissions    * User account permission: `media:access`   * License component: media 
     */
    async unresolveComment(requestParameters: UnresolveCommentRequest, initOverrides?: RequestInit): Promise<Comment> {
        const response = await this.unresolveCommentRaw(requestParameters, initOverrides);
        return await response.value();
    }

    /**
     * ### Required permissions    * User account permission: `media:access`   * License component: media 
     */
    async updateAssetRaw(requestParameters: UpdateAssetRequest, initOverrides?: RequestInit): Promise<runtime.ApiResponse<Asset>> {
        if (requestParameters.id === null || requestParameters.id === undefined) {
            throw new runtime.RequiredError('id','Required parameter requestParameters.id was null or undefined when calling updateAsset.');
        }

        if (requestParameters.assetUpdate === null || requestParameters.assetUpdate === undefined) {
            throw new runtime.RequiredError('assetUpdate','Required parameter requestParameters.assetUpdate was null or undefined when calling updateAsset.');
        }

        const queryParameters: any = {};

        if (requestParameters.root !== undefined) {
            queryParameters['root'] = requestParameters.root;
        }

        const headerParameters: runtime.HTTPHeaders = {};

        headerParameters['Content-Type'] = 'application/json';

        if (this.configuration && this.configuration.apiKey) {
            headerParameters["Authorization"] = this.configuration.apiKey("Authorization"); // Bearer authentication
        }

        const response = await this.request({
            path: `/api/2/media/assets/{id}`.replace(`{${"id"}}`, encodeURIComponent(String(requestParameters.id))),
            method: 'PUT',
            headers: headerParameters,
            query: queryParameters,
            body: AssetUpdateToJSON(requestParameters.assetUpdate),
        }, initOverrides);

        return new runtime.JSONApiResponse(response, (jsonValue) => AssetFromJSON(jsonValue));
    }

    /**
     * ### Required permissions    * User account permission: `media:access`   * License component: media 
     */
    async updateAsset(requestParameters: UpdateAssetRequest, initOverrides?: RequestInit): Promise<Asset> {
        const response = await this.updateAssetRaw(requestParameters, initOverrides);
        return await response.value();
    }

    /**
     * ### Required permissions    * User account permission: `media:access`   * License component: media 
     */
    async updateAssetRatingRaw(requestParameters: UpdateAssetRatingRequest, initOverrides?: RequestInit): Promise<runtime.ApiResponse<AssetRating>> {
        if (requestParameters.id === null || requestParameters.id === undefined) {
            throw new runtime.RequiredError('id','Required parameter requestParameters.id was null or undefined when calling updateAssetRating.');
        }

        if (requestParameters.assetRatingUpdate === null || requestParameters.assetRatingUpdate === undefined) {
            throw new runtime.RequiredError('assetRatingUpdate','Required parameter requestParameters.assetRatingUpdate was null or undefined when calling updateAssetRating.');
        }

        const queryParameters: any = {};

        const headerParameters: runtime.HTTPHeaders = {};

        headerParameters['Content-Type'] = 'application/json';

        if (this.configuration && this.configuration.apiKey) {
            headerParameters["Authorization"] = this.configuration.apiKey("Authorization"); // Bearer authentication
        }

        const response = await this.request({
            path: `/api/2/media/ratings/{id}`.replace(`{${"id"}}`, encodeURIComponent(String(requestParameters.id))),
            method: 'PUT',
            headers: headerParameters,
            query: queryParameters,
            body: AssetRatingUpdateToJSON(requestParameters.assetRatingUpdate),
        }, initOverrides);

        return new runtime.JSONApiResponse(response, (jsonValue) => AssetRatingFromJSON(jsonValue));
    }

    /**
     * ### Required permissions    * User account permission: `media:access`   * License component: media 
     */
    async updateAssetRating(requestParameters: UpdateAssetRatingRequest, initOverrides?: RequestInit): Promise<AssetRating> {
        const response = await this.updateAssetRatingRaw(requestParameters, initOverrides);
        return await response.value();
    }

    /**
     * ### Required permissions    * User account permission: `media:access`   * License component: media 
     */
    async updateAssetSubtitleLinkRaw(requestParameters: UpdateAssetSubtitleLinkRequest, initOverrides?: RequestInit): Promise<runtime.ApiResponse<AssetSubtitleLink>> {
        if (requestParameters.id === null || requestParameters.id === undefined) {
            throw new runtime.RequiredError('id','Required parameter requestParameters.id was null or undefined when calling updateAssetSubtitleLink.');
        }

        if (requestParameters.assetSubtitleLinkUpdate === null || requestParameters.assetSubtitleLinkUpdate === undefined) {
            throw new runtime.RequiredError('assetSubtitleLinkUpdate','Required parameter requestParameters.assetSubtitleLinkUpdate was null or undefined when calling updateAssetSubtitleLink.');
        }

        const queryParameters: any = {};

        const headerParameters: runtime.HTTPHeaders = {};

        headerParameters['Content-Type'] = 'application/json';

        if (this.configuration && this.configuration.apiKey) {
            headerParameters["Authorization"] = this.configuration.apiKey("Authorization"); // Bearer authentication
        }

        const response = await this.request({
            path: `/api/2/media/assets/subtitle-links/{id}`.replace(`{${"id"}}`, encodeURIComponent(String(requestParameters.id))),
            method: 'PUT',
            headers: headerParameters,
            query: queryParameters,
            body: AssetSubtitleLinkUpdateToJSON(requestParameters.assetSubtitleLinkUpdate),
        }, initOverrides);

        return new runtime.JSONApiResponse(response, (jsonValue) => AssetSubtitleLinkFromJSON(jsonValue));
    }

    /**
     * ### Required permissions    * User account permission: `media:access`   * License component: media 
     */
    async updateAssetSubtitleLink(requestParameters: UpdateAssetSubtitleLinkRequest, initOverrides?: RequestInit): Promise<AssetSubtitleLink> {
        const response = await this.updateAssetSubtitleLinkRaw(requestParameters, initOverrides);
        return await response.value();
    }

    /**
     * ### Required permissions    * User account permission: `media:access`   * License component: media 
     */
    async updateCommentRaw(requestParameters: UpdateCommentRequest, initOverrides?: RequestInit): Promise<runtime.ApiResponse<Comment>> {
        if (requestParameters.id === null || requestParameters.id === undefined) {
            throw new runtime.RequiredError('id','Required parameter requestParameters.id was null or undefined when calling updateComment.');
        }

        if (requestParameters.commentUpdate === null || requestParameters.commentUpdate === undefined) {
            throw new runtime.RequiredError('commentUpdate','Required parameter requestParameters.commentUpdate was null or undefined when calling updateComment.');
        }

        const queryParameters: any = {};

        const headerParameters: runtime.HTTPHeaders = {};

        headerParameters['Content-Type'] = 'application/json';

        if (this.configuration && this.configuration.apiKey) {
            headerParameters["Authorization"] = this.configuration.apiKey("Authorization"); // Bearer authentication
        }

        const response = await this.request({
            path: `/api/2/media/comments/{id}`.replace(`{${"id"}}`, encodeURIComponent(String(requestParameters.id))),
            method: 'PUT',
            headers: headerParameters,
            query: queryParameters,
            body: CommentUpdateToJSON(requestParameters.commentUpdate),
        }, initOverrides);

        return new runtime.JSONApiResponse(response, (jsonValue) => CommentFromJSON(jsonValue));
    }

    /**
     * ### Required permissions    * User account permission: `media:access`   * License component: media 
     */
    async updateComment(requestParameters: UpdateCommentRequest, initOverrides?: RequestInit): Promise<Comment> {
        const response = await this.updateCommentRaw(requestParameters, initOverrides);
        return await response.value();
    }

    /**
     * ### Required permissions    * User account permission: `media:access` (read) / `media:roots:manage` (write)   * License component: media 
     */
    async updateCustomFieldRaw(requestParameters: UpdateCustomFieldRequest, initOverrides?: RequestInit): Promise<runtime.ApiResponse<CustomField>> {
        if (requestParameters.id === null || requestParameters.id === undefined) {
            throw new runtime.RequiredError('id','Required parameter requestParameters.id was null or undefined when calling updateCustomField.');
        }

        if (requestParameters.customFieldUpdate === null || requestParameters.customFieldUpdate === undefined) {
            throw new runtime.RequiredError('customFieldUpdate','Required parameter requestParameters.customFieldUpdate was null or undefined when calling updateCustomField.');
        }

        const queryParameters: any = {};

        const headerParameters: runtime.HTTPHeaders = {};

        headerParameters['Content-Type'] = 'application/json';

        if (this.configuration && this.configuration.apiKey) {
            headerParameters["Authorization"] = this.configuration.apiKey("Authorization"); // Bearer authentication
        }

        const response = await this.request({
            path: `/api/2/media/custom-fields/{id}`.replace(`{${"id"}}`, encodeURIComponent(String(requestParameters.id))),
            method: 'PUT',
            headers: headerParameters,
            query: queryParameters,
            body: CustomFieldUpdateToJSON(requestParameters.customFieldUpdate),
        }, initOverrides);

        return new runtime.JSONApiResponse(response, (jsonValue) => CustomFieldFromJSON(jsonValue));
    }

    /**
     * ### Required permissions    * User account permission: `media:access` (read) / `media:roots:manage` (write)   * License component: media 
     */
    async updateCustomField(requestParameters: UpdateCustomFieldRequest, initOverrides?: RequestInit): Promise<CustomField> {
        const response = await this.updateCustomFieldRaw(requestParameters, initOverrides);
        return await response.value();
    }

    /**
     * ### Required permissions    * User account permission: `media:access` 
     */
    async updateEditorProjectRaw(requestParameters: UpdateEditorProjectRequest, initOverrides?: RequestInit): Promise<runtime.ApiResponse<EditorProject>> {
        if (requestParameters.id === null || requestParameters.id === undefined) {
            throw new runtime.RequiredError('id','Required parameter requestParameters.id was null or undefined when calling updateEditorProject.');
        }

        if (requestParameters.editorProjectUpdate === null || requestParameters.editorProjectUpdate === undefined) {
            throw new runtime.RequiredError('editorProjectUpdate','Required parameter requestParameters.editorProjectUpdate was null or undefined when calling updateEditorProject.');
        }

        const queryParameters: any = {};

        const headerParameters: runtime.HTTPHeaders = {};

        headerParameters['Content-Type'] = 'application/json';

        if (this.configuration && this.configuration.apiKey) {
            headerParameters["Authorization"] = this.configuration.apiKey("Authorization"); // Bearer authentication
        }

        const response = await this.request({
            path: `/api/2/media/editor/{id}`.replace(`{${"id"}}`, encodeURIComponent(String(requestParameters.id))),
            method: 'PUT',
            headers: headerParameters,
            query: queryParameters,
            body: EditorProjectUpdateToJSON(requestParameters.editorProjectUpdate),
        }, initOverrides);

        return new runtime.JSONApiResponse(response, (jsonValue) => EditorProjectFromJSON(jsonValue));
    }

    /**
     * ### Required permissions    * User account permission: `media:access` 
     */
    async updateEditorProject(requestParameters: UpdateEditorProjectRequest, initOverrides?: RequestInit): Promise<EditorProject> {
        const response = await this.updateEditorProjectRaw(requestParameters, initOverrides);
        return await response.value();
    }

    /**
     * ### Required permissions    * User account permission: `media:access` 
     */
    async updateEditorSubtitleRaw(requestParameters: UpdateEditorSubtitleRequest, initOverrides?: RequestInit): Promise<runtime.ApiResponse<EditorSubtitle>> {
        if (requestParameters.id === null || requestParameters.id === undefined) {
            throw new runtime.RequiredError('id','Required parameter requestParameters.id was null or undefined when calling updateEditorSubtitle.');
        }

        if (requestParameters.editorSubtitleUpdate === null || requestParameters.editorSubtitleUpdate === undefined) {
            throw new runtime.RequiredError('editorSubtitleUpdate','Required parameter requestParameters.editorSubtitleUpdate was null or undefined when calling updateEditorSubtitle.');
        }

        const queryParameters: any = {};

        const headerParameters: runtime.HTTPHeaders = {};

        headerParameters['Content-Type'] = 'application/json';

        if (this.configuration && this.configuration.apiKey) {
            headerParameters["Authorization"] = this.configuration.apiKey("Authorization"); // Bearer authentication
        }

        const response = await this.request({
            path: `/api/2/media/subtitles/{id}`.replace(`{${"id"}}`, encodeURIComponent(String(requestParameters.id))),
            method: 'PUT',
            headers: headerParameters,
            query: queryParameters,
            body: EditorSubtitleUpdateToJSON(requestParameters.editorSubtitleUpdate),
        }, initOverrides);

        return new runtime.JSONApiResponse(response, (jsonValue) => EditorSubtitleFromJSON(jsonValue));
    }

    /**
     * ### Required permissions    * User account permission: `media:access` 
     */
    async updateEditorSubtitle(requestParameters: UpdateEditorSubtitleRequest, initOverrides?: RequestInit): Promise<EditorSubtitle> {
        const response = await this.updateEditorSubtitleRaw(requestParameters, initOverrides);
        return await response.value();
    }

    /**
     * ### Required permissions    * User account permission: `media:access` (read) / `system:admin-access` (write) 
     */
    async updateExternalTranscoderRaw(requestParameters: UpdateExternalTranscoderRequest, initOverrides?: RequestInit): Promise<runtime.ApiResponse<ExternalTranscoder>> {
        if (requestParameters.id === null || requestParameters.id === undefined) {
            throw new runtime.RequiredError('id','Required parameter requestParameters.id was null or undefined when calling updateExternalTranscoder.');
        }

        if (requestParameters.externalTranscoderUpdate === null || requestParameters.externalTranscoderUpdate === undefined) {
            throw new runtime.RequiredError('externalTranscoderUpdate','Required parameter requestParameters.externalTranscoderUpdate was null or undefined when calling updateExternalTranscoder.');
        }

        const queryParameters: any = {};

        const headerParameters: runtime.HTTPHeaders = {};

        headerParameters['Content-Type'] = 'application/json';

        if (this.configuration && this.configuration.apiKey) {
            headerParameters["Authorization"] = this.configuration.apiKey("Authorization"); // Bearer authentication
        }

        const response = await this.request({
            path: `/api/2/media/external-transcoders/{id}`.replace(`{${"id"}}`, encodeURIComponent(String(requestParameters.id))),
            method: 'PUT',
            headers: headerParameters,
            query: queryParameters,
            body: ExternalTranscoderUpdateToJSON(requestParameters.externalTranscoderUpdate),
        }, initOverrides);

        return new runtime.JSONApiResponse(response, (jsonValue) => ExternalTranscoderFromJSON(jsonValue));
    }

    /**
     * ### Required permissions    * User account permission: `media:access` (read) / `system:admin-access` (write) 
     */
    async updateExternalTranscoder(requestParameters: UpdateExternalTranscoderRequest, initOverrides?: RequestInit): Promise<ExternalTranscoder> {
        const response = await this.updateExternalTranscoderRaw(requestParameters, initOverrides);
        return await response.value();
    }

    /**
     * ### Required permissions    * User account permission: `media:access`   * License component: media 
     */
    async updateMarkerRaw(requestParameters: UpdateMarkerRequest, initOverrides?: RequestInit): Promise<runtime.ApiResponse<Marker>> {
        if (requestParameters.id === null || requestParameters.id === undefined) {
            throw new runtime.RequiredError('id','Required parameter requestParameters.id was null or undefined when calling updateMarker.');
        }

        if (requestParameters.markerUpdate === null || requestParameters.markerUpdate === undefined) {
            throw new runtime.RequiredError('markerUpdate','Required parameter requestParameters.markerUpdate was null or undefined when calling updateMarker.');
        }

        const queryParameters: any = {};

        const headerParameters: runtime.HTTPHeaders = {};

        headerParameters['Content-Type'] = 'application/json';

        if (this.configuration && this.configuration.apiKey) {
            headerParameters["Authorization"] = this.configuration.apiKey("Authorization"); // Bearer authentication
        }

        const response = await this.request({
            path: `/api/2/media/markers/{id}`.replace(`{${"id"}}`, encodeURIComponent(String(requestParameters.id))),
            method: 'PUT',
            headers: headerParameters,
            query: queryParameters,
            body: MarkerUpdateToJSON(requestParameters.markerUpdate),
        }, initOverrides);

        return new runtime.JSONApiResponse(response, (jsonValue) => MarkerFromJSON(jsonValue));
    }

    /**
     * ### Required permissions    * User account permission: `media:access`   * License component: media 
     */
    async updateMarker(requestParameters: UpdateMarkerRequest, initOverrides?: RequestInit): Promise<Marker> {
        const response = await this.updateMarkerRaw(requestParameters, initOverrides);
        return await response.value();
    }

    /**
     * ### Required permissions    * User account permission: `media:access`   * License component: media 
     */
    async updateMediaFileRaw(requestParameters: UpdateMediaFileRequest, initOverrides?: RequestInit): Promise<runtime.ApiResponse<MediaFile>> {
        if (requestParameters.id === null || requestParameters.id === undefined) {
            throw new runtime.RequiredError('id','Required parameter requestParameters.id was null or undefined when calling updateMediaFile.');
        }

        if (requestParameters.mediaFileUpdate === null || requestParameters.mediaFileUpdate === undefined) {
            throw new runtime.RequiredError('mediaFileUpdate','Required parameter requestParameters.mediaFileUpdate was null or undefined when calling updateMediaFile.');
        }

        const queryParameters: any = {};

        if (requestParameters.root !== undefined) {
            queryParameters['root'] = requestParameters.root;
        }

        const headerParameters: runtime.HTTPHeaders = {};

        headerParameters['Content-Type'] = 'application/json';

        if (this.configuration && this.configuration.apiKey) {
            headerParameters["Authorization"] = this.configuration.apiKey("Authorization"); // Bearer authentication
        }

        const response = await this.request({
            path: `/api/2/media/files/{id}`.replace(`{${"id"}}`, encodeURIComponent(String(requestParameters.id))),
            method: 'PUT',
            headers: headerParameters,
            query: queryParameters,
            body: MediaFileUpdateToJSON(requestParameters.mediaFileUpdate),
        }, initOverrides);

        return new runtime.JSONApiResponse(response, (jsonValue) => MediaFileFromJSON(jsonValue));
    }

    /**
     * ### Required permissions    * User account permission: `media:access`   * License component: media 
     */
    async updateMediaFile(requestParameters: UpdateMediaFileRequest, initOverrides?: RequestInit): Promise<MediaFile> {
        const response = await this.updateMediaFileRaw(requestParameters, initOverrides);
        return await response.value();
    }

    /**
     * ### Required permissions    * User account permission: `media:access`   * License component: media 
     */
    async updateMediaFileTemplateRaw(requestParameters: UpdateMediaFileTemplateRequest, initOverrides?: RequestInit): Promise<runtime.ApiResponse<MediaFileTemplate>> {
        if (requestParameters.id === null || requestParameters.id === undefined) {
            throw new runtime.RequiredError('id','Required parameter requestParameters.id was null or undefined when calling updateMediaFileTemplate.');
        }

        if (requestParameters.mediaFileTemplateUpdate === null || requestParameters.mediaFileTemplateUpdate === undefined) {
            throw new runtime.RequiredError('mediaFileTemplateUpdate','Required parameter requestParameters.mediaFileTemplateUpdate was null or undefined when calling updateMediaFileTemplate.');
        }

        const queryParameters: any = {};

        const headerParameters: runtime.HTTPHeaders = {};

        headerParameters['Content-Type'] = 'application/json';

        if (this.configuration && this.configuration.apiKey) {
            headerParameters["Authorization"] = this.configuration.apiKey("Authorization"); // Bearer authentication
        }

        const response = await this.request({
            path: `/api/2/media/files/templates/{id}`.replace(`{${"id"}}`, encodeURIComponent(String(requestParameters.id))),
            method: 'PUT',
            headers: headerParameters,
            query: queryParameters,
            body: MediaFileTemplateUpdateToJSON(requestParameters.mediaFileTemplateUpdate),
        }, initOverrides);

        return new runtime.JSONApiResponse(response, (jsonValue) => MediaFileTemplateFromJSON(jsonValue));
    }

    /**
     * ### Required permissions    * User account permission: `media:access`   * License component: media 
     */
    async updateMediaFileTemplate(requestParameters: UpdateMediaFileTemplateRequest, initOverrides?: RequestInit): Promise<MediaFileTemplate> {
        const response = await this.updateMediaFileTemplateRaw(requestParameters, initOverrides);
        return await response.value();
    }

    /**
     * ### Required permissions    * User account permission: `media:access` (read) / `media:roots:manage` (write)   * License component: media 
     */
    async updateMediaRootRaw(requestParameters: UpdateMediaRootRequest, initOverrides?: RequestInit): Promise<runtime.ApiResponse<MediaRootDetail>> {
        if (requestParameters.id === null || requestParameters.id === undefined) {
            throw new runtime.RequiredError('id','Required parameter requestParameters.id was null or undefined when calling updateMediaRoot.');
        }

        if (requestParameters.mediaRootDetailUpdate === null || requestParameters.mediaRootDetailUpdate === undefined) {
            throw new runtime.RequiredError('mediaRootDetailUpdate','Required parameter requestParameters.mediaRootDetailUpdate was null or undefined when calling updateMediaRoot.');
        }

        const queryParameters: any = {};

        const headerParameters: runtime.HTTPHeaders = {};

        headerParameters['Content-Type'] = 'application/json';

        if (this.configuration && this.configuration.apiKey) {
            headerParameters["Authorization"] = this.configuration.apiKey("Authorization"); // Bearer authentication
        }

        const response = await this.request({
            path: `/api/2/media/roots/{id}`.replace(`{${"id"}}`, encodeURIComponent(String(requestParameters.id))),
            method: 'PUT',
            headers: headerParameters,
            query: queryParameters,
            body: MediaRootDetailUpdateToJSON(requestParameters.mediaRootDetailUpdate),
        }, initOverrides);

        return new runtime.JSONApiResponse(response, (jsonValue) => MediaRootDetailFromJSON(jsonValue));
    }

    /**
     * ### Required permissions    * User account permission: `media:access` (read) / `media:roots:manage` (write)   * License component: media 
     */
    async updateMediaRoot(requestParameters: UpdateMediaRootRequest, initOverrides?: RequestInit): Promise<MediaRootDetail> {
        const response = await this.updateMediaRootRaw(requestParameters, initOverrides);
        return await response.value();
    }

    /**
     * ### Required permissions    * User account permission: `media:access` (read) / `media:roots:manage` (write)   * License component: media 
     */
    async updateMediaRootPermissionRaw(requestParameters: UpdateMediaRootPermissionRequest, initOverrides?: RequestInit): Promise<runtime.ApiResponse<MediaRootPermission>> {
        if (requestParameters.id === null || requestParameters.id === undefined) {
            throw new runtime.RequiredError('id','Required parameter requestParameters.id was null or undefined when calling updateMediaRootPermission.');
        }

        if (requestParameters.mediaRootPermissionUpdate === null || requestParameters.mediaRootPermissionUpdate === undefined) {
            throw new runtime.RequiredError('mediaRootPermissionUpdate','Required parameter requestParameters.mediaRootPermissionUpdate was null or undefined when calling updateMediaRootPermission.');
        }

        const queryParameters: any = {};

        const headerParameters: runtime.HTTPHeaders = {};

        headerParameters['Content-Type'] = 'application/json';

        if (this.configuration && this.configuration.apiKey) {
            headerParameters["Authorization"] = this.configuration.apiKey("Authorization"); // Bearer authentication
        }

        const response = await this.request({
            path: `/api/2/media/root-permissions/{id}`.replace(`{${"id"}}`, encodeURIComponent(String(requestParameters.id))),
            method: 'PUT',
            headers: headerParameters,
            query: queryParameters,
            body: MediaRootPermissionUpdateToJSON(requestParameters.mediaRootPermissionUpdate),
        }, initOverrides);

        return new runtime.JSONApiResponse(response, (jsonValue) => MediaRootPermissionFromJSON(jsonValue));
    }

    /**
     * ### Required permissions    * User account permission: `media:access` (read) / `media:roots:manage` (write)   * License component: media 
     */
    async updateMediaRootPermission(requestParameters: UpdateMediaRootPermissionRequest, initOverrides?: RequestInit): Promise<MediaRootPermission> {
        const response = await this.updateMediaRootPermissionRaw(requestParameters, initOverrides);
        return await response.value();
    }

    /**
     * ### Required permissions    * User account permission: `media:access`   * License component: media 
     */
    async updateMediaTagRaw(requestParameters: UpdateMediaTagRequest, initOverrides?: RequestInit): Promise<runtime.ApiResponse<UnfilteredTag>> {
        if (requestParameters.id === null || requestParameters.id === undefined) {
            throw new runtime.RequiredError('id','Required parameter requestParameters.id was null or undefined when calling updateMediaTag.');
        }

        if (requestParameters.unfilteredTagUpdate === null || requestParameters.unfilteredTagUpdate === undefined) {
            throw new runtime.RequiredError('unfilteredTagUpdate','Required parameter requestParameters.unfilteredTagUpdate was null or undefined when calling updateMediaTag.');
        }

        const queryParameters: any = {};

        const headerParameters: runtime.HTTPHeaders = {};

        headerParameters['Content-Type'] = 'application/json';

        if (this.configuration && this.configuration.apiKey) {
            headerParameters["Authorization"] = this.configuration.apiKey("Authorization"); // Bearer authentication
        }

        const response = await this.request({
            path: `/api/2/media/tags/{id}`.replace(`{${"id"}}`, encodeURIComponent(String(requestParameters.id))),
            method: 'PUT',
            headers: headerParameters,
            query: queryParameters,
            body: UnfilteredTagUpdateToJSON(requestParameters.unfilteredTagUpdate),
        }, initOverrides);

        return new runtime.JSONApiResponse(response, (jsonValue) => UnfilteredTagFromJSON(jsonValue));
    }

    /**
     * ### Required permissions    * User account permission: `media:access`   * License component: media 
     */
    async updateMediaTag(requestParameters: UpdateMediaTagRequest, initOverrides?: RequestInit): Promise<UnfilteredTag> {
        const response = await this.updateMediaTagRaw(requestParameters, initOverrides);
        return await response.value();
    }

    /**
     * ### Required permissions    * User account permission: `media:access` (read) / `media:roots:manage` (write)   * License component: media 
     */
    async updateProxyProfileRaw(requestParameters: UpdateProxyProfileRequest, initOverrides?: RequestInit): Promise<runtime.ApiResponse<ProxyProfile>> {
        if (requestParameters.id === null || requestParameters.id === undefined) {
            throw new runtime.RequiredError('id','Required parameter requestParameters.id was null or undefined when calling updateProxyProfile.');
        }

        if (requestParameters.proxyProfileUpdate === null || requestParameters.proxyProfileUpdate === undefined) {
            throw new runtime.RequiredError('proxyProfileUpdate','Required parameter requestParameters.proxyProfileUpdate was null or undefined when calling updateProxyProfile.');
        }

        const queryParameters: any = {};

        const headerParameters: runtime.HTTPHeaders = {};

        headerParameters['Content-Type'] = 'application/json';

        if (this.configuration && this.configuration.apiKey) {
            headerParameters["Authorization"] = this.configuration.apiKey("Authorization"); // Bearer authentication
        }

        const response = await this.request({
            path: `/api/2/media/proxy-profiles/{id}`.replace(`{${"id"}}`, encodeURIComponent(String(requestParameters.id))),
            method: 'PUT',
            headers: headerParameters,
            query: queryParameters,
            body: ProxyProfileUpdateToJSON(requestParameters.proxyProfileUpdate),
        }, initOverrides);

        return new runtime.JSONApiResponse(response, (jsonValue) => ProxyProfileFromJSON(jsonValue));
    }

    /**
     * ### Required permissions    * User account permission: `media:access` (read) / `media:roots:manage` (write)   * License component: media 
     */
    async updateProxyProfile(requestParameters: UpdateProxyProfileRequest, initOverrides?: RequestInit): Promise<ProxyProfile> {
        const response = await this.updateProxyProfileRaw(requestParameters, initOverrides);
        return await response.value();
    }

    /**
     * ### Required permissions    * User account permission: `media:access`   * License component: media 
     */
    async updateSavedSearchRaw(requestParameters: UpdateSavedSearchRequest, initOverrides?: RequestInit): Promise<runtime.ApiResponse<SavedSearch>> {
        if (requestParameters.id === null || requestParameters.id === undefined) {
            throw new runtime.RequiredError('id','Required parameter requestParameters.id was null or undefined when calling updateSavedSearch.');
        }

        if (requestParameters.savedSearchUpdate === null || requestParameters.savedSearchUpdate === undefined) {
            throw new runtime.RequiredError('savedSearchUpdate','Required parameter requestParameters.savedSearchUpdate was null or undefined when calling updateSavedSearch.');
        }

        const queryParameters: any = {};

        const headerParameters: runtime.HTTPHeaders = {};

        headerParameters['Content-Type'] = 'application/json';

        if (this.configuration && this.configuration.apiKey) {
            headerParameters["Authorization"] = this.configuration.apiKey("Authorization"); // Bearer authentication
        }

        const response = await this.request({
            path: `/api/2/media/saved-searches/{id}`.replace(`{${"id"}}`, encodeURIComponent(String(requestParameters.id))),
            method: 'PUT',
            headers: headerParameters,
            query: queryParameters,
            body: SavedSearchUpdateToJSON(requestParameters.savedSearchUpdate),
        }, initOverrides);

        return new runtime.JSONApiResponse(response, (jsonValue) => SavedSearchFromJSON(jsonValue));
    }

    /**
     * ### Required permissions    * User account permission: `media:access`   * License component: media 
     */
    async updateSavedSearch(requestParameters: UpdateSavedSearchRequest, initOverrides?: RequestInit): Promise<SavedSearch> {
        const response = await this.updateSavedSearchRaw(requestParameters, initOverrides);
        return await response.value();
    }

    /**
     * ### Required permissions    * User account permission: `media:access`   * License component: media 
     */
    async updateSubclipRaw(requestParameters: UpdateSubclipRequest, initOverrides?: RequestInit): Promise<runtime.ApiResponse<Subclip>> {
        if (requestParameters.id === null || requestParameters.id === undefined) {
            throw new runtime.RequiredError('id','Required parameter requestParameters.id was null or undefined when calling updateSubclip.');
        }

        if (requestParameters.subclipUpdate === null || requestParameters.subclipUpdate === undefined) {
            throw new runtime.RequiredError('subclipUpdate','Required parameter requestParameters.subclipUpdate was null or undefined when calling updateSubclip.');
        }

        const queryParameters: any = {};

        const headerParameters: runtime.HTTPHeaders = {};

        headerParameters['Content-Type'] = 'application/json';

        if (this.configuration && this.configuration.apiKey) {
            headerParameters["Authorization"] = this.configuration.apiKey("Authorization"); // Bearer authentication
        }

        const response = await this.request({
            path: `/api/2/media/subclips/{id}`.replace(`{${"id"}}`, encodeURIComponent(String(requestParameters.id))),
            method: 'PUT',
            headers: headerParameters,
            query: queryParameters,
            body: SubclipUpdateToJSON(requestParameters.subclipUpdate),
        }, initOverrides);

        return new runtime.JSONApiResponse(response, (jsonValue) => SubclipFromJSON(jsonValue));
    }

    /**
     * ### Required permissions    * User account permission: `media:access`   * License component: media 
     */
    async updateSubclip(requestParameters: UpdateSubclipRequest, initOverrides?: RequestInit): Promise<Subclip> {
        const response = await this.updateSubclipRaw(requestParameters, initOverrides);
        return await response.value();
    }

}