@magritte/api 0.0.0-stage → 0.1.0

package/dist/index.d.ts

@@ -0,0 +1,4899 @@
+import * as z from 'zod';
+
+/**
+ * AlbumRead
+ */
+export declare type AlbumRead = {
+    /**
+     * Id
+     */
+    id: number;
+    /**
+     * Title
+     */
+    title: string;
+    /**
+     * Artist Id
+     */
+    artist_id: number | null;
+    /**
+     * Artworks
+     *
+     * The artworks of this album
+     */
+    artworks?: Array<ArtworkRead>;
+};
+
+/**
+ * AlbumRead
+ */
+export declare const AlbumReadSchema: z.ZodObject<{
+    id: z.ZodInt;
+    title: z.ZodString;
+    artist_id: z.ZodNullable<z.ZodInt>;
+    artworks: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        id: z.ZodInt;
+        kind: z.ZodEnum<{
+            front_cover: "front_cover";
+        }>;
+        image_url: z.ZodString;
+        background_color: z.ZodNullable<z.ZodString>;
+        primary_color: z.ZodNullable<z.ZodString>;
+        secondary_color: z.ZodNullable<z.ZodString>;
+        tertiary_color: z.ZodNullable<z.ZodString>;
+    }, z.core.$strip>>>;
+}, z.core.$strip>;
+
+/**
+ * AlbumUpdate
+ */
+export declare type AlbumUpdate = {
+    /**
+     * Title
+     */
+    title?: string | null;
+    /**
+     * Artist Id
+     */
+    artist_id?: number | null;
+};
+
+/**
+ * AlbumUpdate
+ */
+export declare const AlbumUpdateSchema: z.ZodObject<{
+    title: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    artist_id: z.ZodOptional<z.ZodNullable<z.ZodInt>>;
+}, z.core.$strip>;
+
+export declare interface API {
+    readonly client: APIClient;
+    readonly fileAccess: FileAccess;
+    readonly userEventsManager: UserEventsManager;
+    readonly userSessionManager: UserSessionManager;
+}
+
+export declare class APIClient {
+    private readonly options;
+    private readonly subscribers;
+    constructor({ baseUrl, userSessionManager }: APIClientOptions);
+    subscribe(subscriber: (event: APIClientEvent) => void): () => void;
+    /** Access the instance status of the API, fetching it if it's not already loaded */
+    instanceStatus(): Promise<InstanceStatusRead>;
+    signUp(body: SignUp): Promise<UserProfileMeRead>;
+    signIn(body: BodySignInSignInPost): Promise<Token>;
+    verifyEmail(token: string): Promise<OperationResult>;
+    resetPassword(body: ResetPassword): Promise<OperationResult>;
+    resetPasswordComplete(body: CompleteResetPassword): Promise<OperationResult>;
+    readMe(): Promise<UserProfileMeRead>;
+    updateMe(body: UserProfileMeUpdate): Promise<UserProfileMeRead>;
+    readNotifications(query?: ReadNotificationsUsersNotificationsGetData["query"]): Promise<NotificationsRead>;
+    readNotification(notification_id: number): Promise<NotificationRead>;
+    updateNotification(notification_id: number, body: NotificationUpdate): Promise<NotificationRead>;
+    deleteNotification(notification_id: number): Promise<OperationResult>;
+    markAllNotificationsRead(): Promise<OperationResult>;
+    streamUserEventsPreflight(): Promise<UserEventPreflight>;
+    readUser(id_or_username: number | string): Promise<UserProfileRead>;
+    readAllUsers(query?: ReadUsersUsersAllGetData["query"]): Promise<UserProfilesRead>;
+    readUserAdmin(id_or_username: number | string): Promise<UserAdminRead>;
+    readAllUsersAdmin(query?: ReadUsersAdminUsersAdminAllGetData["query"]): Promise<UserAdminsRead>;
+    updateUserAdmin(user_id: number, body: UserAdminUpdate): Promise<UserAdminRead>;
+    deleteUserAdmin(user_id: number): Promise<OperationResult>;
+    readFilesPreflight(): Promise<UserFileAccessPreflight>;
+    readLibraries(): Promise<readonly LibraryRead[]>;
+    readLibraryHomeSubpaths(query: ReadLibraryHomeSubpathsLibrariesHomeSubpathsGetData["query"]): Promise<LibraryHomePathRead>;
+    createLibrary(body: LibraryCreate): Promise<LibraryRead>;
+    updateLibrary(library_id: number, body: LibraryUpdate): Promise<LibraryRead>;
+    readLibrary(library_id: number): Promise<LibraryRead>;
+    readLibraryPermissions(library_id: number): Promise<readonly LibraryPermissionRead[]>;
+    createLibraryPermission(library_id: number, body: LibraryPermissionCreate): Promise<LibraryPermissionRead>;
+    updateLibraryPermission(library_id: number, user_id: number, body: LibraryPermissionUpdate): Promise<LibraryPermissionRead>;
+    deleteLibraryPermission(library_id: number, user_id: number): Promise<OperationResult>;
+    readLibraryIgnoredResources(library_id: number, query?: ReadLibraryIgnoredResourcesLibrariesLibraryIdIgnoredGetData["query"]): Promise<LibraryMediaReadLibraryIgnoredResourceRead>;
+    deleteLibraryIgnoredResource(library_id: number, ignored_resource_id: number): Promise<OperationResult>;
+    updateLibraryAlbum(library_id: number, album_id: number, body: AlbumUpdate): Promise<AlbumRead>;
+    deleteLibraryAlbum(library_id: number, album_id: number): Promise<void>;
+    readLibraryAlbum(library_id: number, album_id: number): Promise<AlbumRead>;
+    readLibraryAlbums(library_id: number, query?: ReadLibraryAlbumsLibrariesLibraryIdAlbumsGetData["query"]): Promise<LibraryMediaReadAlbumRead>;
+    updateLibraryArtist(library_id: number, artist_id: number, body: ArtistUpdate): Promise<ArtistRead>;
+    deleteLibraryArtist(library_id: number, artist_id: number): Promise<void>;
+    readLibraryArtist(library_id: number, artist_id: number): Promise<ArtistRead>;
+    readLibraryArtists(library_id: number, query?: ReadLibraryArtistsLibrariesLibraryIdArtistsGetData["query"]): Promise<LibraryMediaReadArtistRead>;
+    updateLibrarySong(library_id: number, song_id: number, body: SongUpdate): Promise<SongRead>;
+    deleteLibrarySong(library_id: number, song_id: number, query?: DeleteLibrarySongLibrariesLibraryIdSongsSongIdDeleteData["query"]): Promise<void>;
+    readLibrarySong(library_id: number, song_id: number): Promise<SongRead>;
+    readLibrarySongs(library_id: number, query?: ReadLibrarySongsLibrariesLibraryIdSongsGetData["query"]): Promise<LibraryMediaReadSongRead>;
+    createArtwork(body: ArtworkCreate): Promise<ArtworkRead>;
+    updateArtwork(artwork_id: number, body: ArtworkUpdate): Promise<ArtworkRead>;
+    deleteArtwork(artwork_id: number): Promise<void>;
+    readAllSources(query?: ReadAllSourcesSourcesAllGetData["query"]): Promise<LibraryMediaReadSourceRead>;
+    createSource(body: SourceCreate): Promise<SourceRead>;
+    updateSource(source_id: number, body: SourceUpdate): Promise<SourceRead>;
+    deleteSource(source_id: number): Promise<void>;
+    readSourceChanges(query: ReadSourceChangesSourcesChangesGetData["query"]): Promise<SourceChangesRead>;
+    ingestPlaybackEvents(body: IngestPlaybackEvent[]): Promise<PlaybackEventIngestResult>;
+    ingestFiles(library_id: number, files: Array<Blob | File>): Promise<OperationResult>;
+    ingestSongs(library_id: number, body: BulkIngestSongs): Promise<readonly SongRead[]>;
+    requestSyncLibrary(library_id: number): Promise<OperationResult>;
+    importExtension(body: ExtensionImportAdmin): Promise<OperationResult>;
+    updateExtension(extension_id: number): Promise<OperationResult>;
+    deleteExtension(extension_id: number): Promise<OperationResult>;
+    readAvailableExtensions(query?: ReadAvailableExtensionsExtensionsAvailableGetData["query"]): Promise<LibraryMediaReadExtensionRead>;
+    installExtension(extension_id: number): Promise<OperationResult>;
+    uninstallExtension(extension_id: number): Promise<OperationResult>;
+    readInstalledExtensions(query?: ReadInstalledExtensionsExtensionsInstalledGetData["query"]): Promise<LibraryMediaReadExtensionRead>;
+}
+
+export declare type APIClientEvent = {
+    type: "unauthorized";
+};
+
+export declare interface APIClientOptions {
+    readonly baseUrl: string;
+    readonly userSessionManager: UserSessionManager;
+}
+
+export declare interface APIOptions {
+    readonly baseUrl: string;
+    readonly userSessionManager?: UserSessionManager;
+}
+
+/**
+ * ArtistRead
+ */
+export declare type ArtistRead = {
+    /**
+     * Id
+     */
+    id: number;
+    /**
+     * Name
+     */
+    name: string;
+    /**
+     * Artworks
+     *
+     * The artworks of this artist
+     */
+    artworks?: Array<ArtworkRead>;
+};
+
+/**
+ * ArtistRead
+ */
+export declare const ArtistReadSchema: z.ZodObject<{
+    id: z.ZodInt;
+    name: z.ZodString;
+    artworks: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        id: z.ZodInt;
+        kind: z.ZodEnum<{
+            front_cover: "front_cover";
+        }>;
+        image_url: z.ZodString;
+        background_color: z.ZodNullable<z.ZodString>;
+        primary_color: z.ZodNullable<z.ZodString>;
+        secondary_color: z.ZodNullable<z.ZodString>;
+        tertiary_color: z.ZodNullable<z.ZodString>;
+    }, z.core.$strip>>>;
+}, z.core.$strip>;
+
+/**
+ * ArtistUpdate
+ */
+export declare type ArtistUpdate = {
+    /**
+     * Name
+     */
+    name?: string | null;
+};
+
+/**
+ * ArtistUpdate
+ */
+export declare const ArtistUpdateSchema: z.ZodObject<{
+    name: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+}, z.core.$strip>;
+
+/**
+ * ArtworkCreate
+ */
+export declare type ArtworkCreate = {
+    kind: ArtworkKind;
+    /**
+     * Image Url
+     */
+    image_url: string;
+    /**
+     * Background Color
+     */
+    background_color: string | null;
+    /**
+     * Primary Color
+     */
+    primary_color: string | null;
+    /**
+     * Secondary Color
+     */
+    secondary_color: string | null;
+    /**
+     * Tertiary Color
+     */
+    tertiary_color: string | null;
+};
+
+/**
+ * ArtworkCreate
+ */
+export declare const ArtworkCreateSchema: z.ZodObject<{
+    kind: z.ZodEnum<{
+        front_cover: "front_cover";
+    }>;
+    image_url: z.ZodString;
+    background_color: z.ZodNullable<z.ZodString>;
+    primary_color: z.ZodNullable<z.ZodString>;
+    secondary_color: z.ZodNullable<z.ZodString>;
+    tertiary_color: z.ZodNullable<z.ZodString>;
+}, z.core.$strip>;
+
+/**
+ * ArtworkKind
+ */
+export declare type ArtworkKind = "front_cover";
+
+/**
+ * ArtworkKind
+ */
+export declare const ArtworkKindSchema: z.ZodEnum<{
+    front_cover: "front_cover";
+}>;
+
+/**
+ * ArtworkRead
+ */
+export declare type ArtworkRead = {
+    /**
+     * Id
+     */
+    id: number;
+    kind: ArtworkKind;
+    /**
+     * Image Url
+     */
+    image_url: string;
+    /**
+     * Background Color
+     */
+    background_color: string | null;
+    /**
+     * Primary Color
+     */
+    primary_color: string | null;
+    /**
+     * Secondary Color
+     */
+    secondary_color: string | null;
+    /**
+     * Tertiary Color
+     */
+    tertiary_color: string | null;
+};
+
+/**
+ * ArtworkRead
+ */
+export declare const ArtworkReadSchema: z.ZodObject<{
+    id: z.ZodInt;
+    kind: z.ZodEnum<{
+        front_cover: "front_cover";
+    }>;
+    image_url: z.ZodString;
+    background_color: z.ZodNullable<z.ZodString>;
+    primary_color: z.ZodNullable<z.ZodString>;
+    secondary_color: z.ZodNullable<z.ZodString>;
+    tertiary_color: z.ZodNullable<z.ZodString>;
+}, z.core.$strip>;
+
+/**
+ * ArtworkUpdate
+ */
+export declare type ArtworkUpdate = {
+    kind?: ArtworkKind | null;
+    /**
+     * Image Url
+     */
+    image_url?: string | null;
+    /**
+     * Background Color
+     */
+    background_color?: string | null;
+    /**
+     * Primary Color
+     */
+    primary_color?: string | null;
+    /**
+     * Secondary Color
+     */
+    secondary_color?: string | null;
+    /**
+     * Tertiary Color
+     */
+    tertiary_color?: string | null;
+};
+
+/**
+ * ArtworkUpdate
+ */
+export declare const ArtworkUpdateSchema: z.ZodObject<{
+    kind: z.ZodOptional<z.ZodNullable<z.ZodEnum<{
+        front_cover: "front_cover";
+    }>>>;
+    image_url: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    background_color: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    primary_color: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    secondary_color: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    tertiary_color: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+}, z.core.$strip>;
+
+/**
+ * Body_ingest_files_libraries__library_id__ingest_files_post
+ */
+export declare type BodyIngestFilesLibrariesLibraryIdIngestFilesPost = {
+    /**
+     * Files
+     */
+    files: Array<Blob | File>;
+};
+
+/**
+ * Body_ingest_files_libraries__library_id__ingest_files_post
+ */
+export declare const BodyIngestFilesLibrariesLibraryIdIngestFilesPostSchema: z.ZodObject<{
+    files: z.ZodArray<z.ZodString>;
+}, z.core.$strip>;
+
+/**
+ * Body_sign_in_sign_in_post
+ */
+export declare type BodySignInSignInPost = {
+    /**
+     * Grant Type
+     */
+    grant_type?: string | null;
+    /**
+     * Username
+     */
+    username: string;
+    /**
+     * Password
+     */
+    password: string;
+    /**
+     * Scope
+     */
+    scope?: string;
+    /**
+     * Client Id
+     */
+    client_id?: string | null;
+    /**
+     * Client Secret
+     */
+    client_secret?: string | null;
+};
+
+/**
+ * Body_sign_in_sign_in_post
+ */
+export declare const BodySignInSignInPostSchema: z.ZodObject<{
+    grant_type: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    username: z.ZodString;
+    password: z.ZodString;
+    scope: z.ZodOptional<z.ZodString>;
+    client_id: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    client_secret: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+}, z.core.$strip>;
+
+/**
+ * BulkIngestSongs
+ */
+export declare type BulkIngestSongs = {
+    /**
+     * Songs
+     */
+    songs: Array<IngestSong>;
+};
+
+/**
+ * BulkIngestSongs
+ */
+export declare const BulkIngestSongsSchema: z.ZodObject<{
+    songs: z.ZodArray<z.ZodObject<{
+        artist_name: z.ZodNullable<z.ZodString>;
+        album_title: z.ZodNullable<z.ZodString>;
+        artworks: z.ZodArray<z.ZodObject<{
+            kind: z.ZodEnum<{
+                front_cover: "front_cover";
+            }>;
+            image_url: z.ZodString;
+            background_color: z.ZodNullable<z.ZodString>;
+            primary_color: z.ZodNullable<z.ZodString>;
+            secondary_color: z.ZodNullable<z.ZodString>;
+            tertiary_color: z.ZodNullable<z.ZodString>;
+        }, z.core.$strip>>;
+        sources: z.ZodArray<z.ZodObject<{
+            url: z.ZodString;
+            mime_type: z.ZodNullable<z.ZodString>;
+            extension_manifest_id: z.ZodNullable<z.ZodString>;
+            extension_tag: z.ZodNullable<z.ZodString>;
+        }, z.core.$strip>>;
+        start_time: z.ZodNumber;
+        end_time: z.ZodNumber;
+        title: z.ZodNullable<z.ZodString>;
+        album_artist: z.ZodNullable<z.ZodString>;
+        composer: z.ZodNullable<z.ZodString>;
+        genre: z.ZodNullable<z.ZodString>;
+        release_date: z.ZodNullable<z.ZodString>;
+        track_number: z.ZodNullable<z.ZodInt>;
+        track_total: z.ZodNullable<z.ZodInt>;
+        disc_number: z.ZodNullable<z.ZodInt>;
+        disc_total: z.ZodNullable<z.ZodInt>;
+        lyrics: z.ZodNullable<z.ZodString>;
+        rating: z.ZodNullable<z.ZodNumber>;
+        bpm: z.ZodNullable<z.ZodInt>;
+        comment: z.ZodNullable<z.ZodString>;
+        grouping: z.ZodNullable<z.ZodString>;
+        mcn: z.ZodNullable<z.ZodString>;
+        isrc: z.ZodNullable<z.ZodString>;
+        music_brainz_release_id: z.ZodNullable<z.ZodString>;
+        music_brainz_recording_id: z.ZodNullable<z.ZodString>;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+
+export declare type ClientOptions = {
+    baseUrl: `${string}://${string}` | (string & {});
+};
+
+/**
+ * CompleteResetPassword
+ */
+export declare type CompleteResetPassword = {
+    /**
+     * Email
+     */
+    email: string;
+    /**
+     * Token
+     */
+    token: string;
+    /**
+     * New Password
+     */
+    new_password: string;
+};
+
+/**
+ * CompleteResetPassword
+ */
+export declare const CompleteResetPasswordSchema: z.ZodObject<{
+    email: z.ZodEmail;
+    token: z.ZodString;
+    new_password: z.ZodString;
+}, z.core.$strip>;
+
+export declare function createAPI({ baseUrl, userSessionManager, }: APIOptions): API;
+
+export declare type CreateArtworkArtworksCreatePostData = {
+    body: ArtworkCreate;
+    path?: never;
+    query?: never;
+    url: "/artworks/create";
+};
+
+export declare type CreateArtworkArtworksCreatePostError = CreateArtworkArtworksCreatePostErrors[keyof CreateArtworkArtworksCreatePostErrors];
+
+export declare type CreateArtworkArtworksCreatePostErrors = {
+    /**
+     * Validation Error
+     */
+    422: HttpValidationError;
+};
+
+export declare type CreateArtworkArtworksCreatePostResponse = CreateArtworkArtworksCreatePostResponses[keyof CreateArtworkArtworksCreatePostResponses];
+
+export declare type CreateArtworkArtworksCreatePostResponses = {
+    /**
+     * Successful Response
+     */
+    200: ArtworkRead;
+};
+
+export declare type CreateLibraryLibrariesCreatePostData = {
+    body: LibraryCreate;
+    path?: never;
+    query?: never;
+    url: "/libraries/create";
+};
+
+export declare type CreateLibraryLibrariesCreatePostError = CreateLibraryLibrariesCreatePostErrors[keyof CreateLibraryLibrariesCreatePostErrors];
+
+export declare type CreateLibraryLibrariesCreatePostErrors = {
+    /**
+     * Validation Error
+     */
+    422: HttpValidationError;
+};
+
+export declare type CreateLibraryLibrariesCreatePostResponse = CreateLibraryLibrariesCreatePostResponses[keyof CreateLibraryLibrariesCreatePostResponses];
+
+export declare type CreateLibraryLibrariesCreatePostResponses = {
+    /**
+     * Successful Response
+     */
+    200: LibraryRead;
+};
+
+export declare type CreateLibraryPermissionLibrariesLibraryIdPermissionCreatePostData = {
+    body: LibraryPermissionCreate;
+    path: {
+        /**
+         * Library Id
+         */
+        library_id: number;
+    };
+    query?: never;
+    url: "/libraries/{library_id}/permission/create";
+};
+
+export declare type CreateLibraryPermissionLibrariesLibraryIdPermissionCreatePostError = CreateLibraryPermissionLibrariesLibraryIdPermissionCreatePostErrors[keyof CreateLibraryPermissionLibrariesLibraryIdPermissionCreatePostErrors];
+
+export declare type CreateLibraryPermissionLibrariesLibraryIdPermissionCreatePostErrors = {
+    /**
+     * Validation Error
+     */
+    422: HttpValidationError;
+};
+
+export declare type CreateLibraryPermissionLibrariesLibraryIdPermissionCreatePostResponse = CreateLibraryPermissionLibrariesLibraryIdPermissionCreatePostResponses[keyof CreateLibraryPermissionLibrariesLibraryIdPermissionCreatePostResponses];
+
+export declare type CreateLibraryPermissionLibrariesLibraryIdPermissionCreatePostResponses = {
+    /**
+     * Successful Response
+     */
+    200: LibraryPermissionRead;
+};
+
+export declare type CreateSourceSourcesCreatePostData = {
+    body: SourceCreate;
+    path?: never;
+    query?: never;
+    url: "/sources/create";
+};
+
+export declare type CreateSourceSourcesCreatePostError = CreateSourceSourcesCreatePostErrors[keyof CreateSourceSourcesCreatePostErrors];
+
+export declare type CreateSourceSourcesCreatePostErrors = {
+    /**
+     * Validation Error
+     */
+    422: HttpValidationError;
+};
+
+export declare type CreateSourceSourcesCreatePostResponse = CreateSourceSourcesCreatePostResponses[keyof CreateSourceSourcesCreatePostResponses];
+
+export declare type CreateSourceSourcesCreatePostResponses = {
+    /**
+     * Successful Response
+     */
+    200: SourceRead;
+};
+
+export declare type DeleteArtworkArtworksArtworkIdDeleteData = {
+    body?: never;
+    path: {
+        /**
+         * Artwork Id
+         */
+        artwork_id: number;
+    };
+    query?: never;
+    url: "/artworks/{artwork_id}";
+};
+
+export declare type DeleteArtworkArtworksArtworkIdDeleteError = DeleteArtworkArtworksArtworkIdDeleteErrors[keyof DeleteArtworkArtworksArtworkIdDeleteErrors];
+
+export declare type DeleteArtworkArtworksArtworkIdDeleteErrors = {
+    /**
+     * Validation Error
+     */
+    422: HttpValidationError;
+};
+
+export declare type DeleteArtworkArtworksArtworkIdDeleteResponses = {
+    /**
+     * Successful Response
+     */
+    200: unknown;
+};
+
+export declare type DeleteExtensionExtensionsAvailableExtensionIdDeleteData = {
+    body?: never;
+    path: {
+        /**
+         * Extension Id
+         */
+        extension_id: number;
+    };
+    query?: never;
+    url: "/extensions/available/{extension_id}";
+};
+
+export declare type DeleteExtensionExtensionsAvailableExtensionIdDeleteError = DeleteExtensionExtensionsAvailableExtensionIdDeleteErrors[keyof DeleteExtensionExtensionsAvailableExtensionIdDeleteErrors];
+
+export declare type DeleteExtensionExtensionsAvailableExtensionIdDeleteErrors = {
+    /**
+     * Validation Error
+     */
+    422: HttpValidationError;
+};
+
+export declare type DeleteExtensionExtensionsAvailableExtensionIdDeleteResponse = DeleteExtensionExtensionsAvailableExtensionIdDeleteResponses[keyof DeleteExtensionExtensionsAvailableExtensionIdDeleteResponses];
+
+export declare type DeleteExtensionExtensionsAvailableExtensionIdDeleteResponses = {
+    /**
+     * Successful Response
+     */
+    200: OperationResult;
+};
+
+export declare type DeleteLibraryAlbumLibrariesLibraryIdAlbumsAlbumIdDeleteData = {
+    body?: never;
+    path: {
+        /**
+         * Library Id
+         */
+        library_id: number;
+        /**
+         * Album Id
+         */
+        album_id: number;
+    };
+    query?: never;
+    url: "/libraries/{library_id}/albums/{album_id}";
+};
+
+export declare type DeleteLibraryAlbumLibrariesLibraryIdAlbumsAlbumIdDeleteError = DeleteLibraryAlbumLibrariesLibraryIdAlbumsAlbumIdDeleteErrors[keyof DeleteLibraryAlbumLibrariesLibraryIdAlbumsAlbumIdDeleteErrors];
+
+export declare type DeleteLibraryAlbumLibrariesLibraryIdAlbumsAlbumIdDeleteErrors = {
+    /**
+     * Validation Error
+     */
+    422: HttpValidationError;
+};
+
+export declare type DeleteLibraryAlbumLibrariesLibraryIdAlbumsAlbumIdDeleteResponses = {
+    /**
+     * Successful Response
+     */
+    200: unknown;
+};
+
+export declare type DeleteLibraryArtistLibrariesLibraryIdArtistsArtistIdDeleteData = {
+    body?: never;
+    path: {
+        /**
+         * Library Id
+         */
+        library_id: number;
+        /**
+         * Artist Id
+         */
+        artist_id: number;
+    };
+    query?: never;
+    url: "/libraries/{library_id}/artists/{artist_id}";
+};
+
+export declare type DeleteLibraryArtistLibrariesLibraryIdArtistsArtistIdDeleteError = DeleteLibraryArtistLibrariesLibraryIdArtistsArtistIdDeleteErrors[keyof DeleteLibraryArtistLibrariesLibraryIdArtistsArtistIdDeleteErrors];
+
+export declare type DeleteLibraryArtistLibrariesLibraryIdArtistsArtistIdDeleteErrors = {
+    /**
+     * Validation Error
+     */
+    422: HttpValidationError;
+};
+
+export declare type DeleteLibraryArtistLibrariesLibraryIdArtistsArtistIdDeleteResponses = {
+    /**
+     * Successful Response
+     */
+    200: unknown;
+};
+
+export declare type DeleteLibraryIgnoredResourceLibrariesLibraryIdIgnoredIgnoredResourceIdDeleteData = {
+    body?: never;
+    path: {
+        /**
+         * Library Id
+         */
+        library_id: number;
+        /**
+         * Ignored Resource Id
+         */
+        ignored_resource_id: number;
+    };
+    query?: never;
+    url: "/libraries/{library_id}/ignored/{ignored_resource_id}";
+};
+
+export declare type DeleteLibraryIgnoredResourceLibrariesLibraryIdIgnoredIgnoredResourceIdDeleteError = DeleteLibraryIgnoredResourceLibrariesLibraryIdIgnoredIgnoredResourceIdDeleteErrors[keyof DeleteLibraryIgnoredResourceLibrariesLibraryIdIgnoredIgnoredResourceIdDeleteErrors];
+
+export declare type DeleteLibraryIgnoredResourceLibrariesLibraryIdIgnoredIgnoredResourceIdDeleteErrors = {
+    /**
+     * Validation Error
+     */
+    422: HttpValidationError;
+};
+
+export declare type DeleteLibraryIgnoredResourceLibrariesLibraryIdIgnoredIgnoredResourceIdDeleteResponse = DeleteLibraryIgnoredResourceLibrariesLibraryIdIgnoredIgnoredResourceIdDeleteResponses[keyof DeleteLibraryIgnoredResourceLibrariesLibraryIdIgnoredIgnoredResourceIdDeleteResponses];
+
+export declare type DeleteLibraryIgnoredResourceLibrariesLibraryIdIgnoredIgnoredResourceIdDeleteResponses = {
+    /**
+     * Successful Response
+     */
+    200: OperationResult;
+};
+
+export declare type DeleteLibraryPermissionLibrariesLibraryIdPermissionUserIdDeleteData = {
+    body?: never;
+    path: {
+        /**
+         * Library Id
+         */
+        library_id: number;
+        /**
+         * User Id
+         */
+        user_id: number;
+    };
+    query?: never;
+    url: "/libraries/{library_id}/permission/{user_id}";
+};
+
+export declare type DeleteLibraryPermissionLibrariesLibraryIdPermissionUserIdDeleteError = DeleteLibraryPermissionLibrariesLibraryIdPermissionUserIdDeleteErrors[keyof DeleteLibraryPermissionLibrariesLibraryIdPermissionUserIdDeleteErrors];
+
+export declare type DeleteLibraryPermissionLibrariesLibraryIdPermissionUserIdDeleteErrors = {
+    /**
+     * Validation Error
+     */
+    422: HttpValidationError;
+};
+
+export declare type DeleteLibraryPermissionLibrariesLibraryIdPermissionUserIdDeleteResponse = DeleteLibraryPermissionLibrariesLibraryIdPermissionUserIdDeleteResponses[keyof DeleteLibraryPermissionLibrariesLibraryIdPermissionUserIdDeleteResponses];
+
+export declare type DeleteLibraryPermissionLibrariesLibraryIdPermissionUserIdDeleteResponses = {
+    /**
+     * Successful Response
+     */
+    200: OperationResult;
+};
+
+export declare type DeleteLibrarySongLibrariesLibraryIdSongsSongIdDeleteData = {
+    body?: never;
+    path: {
+        /**
+         * Library Id
+         */
+        library_id: number;
+        /**
+         * Song Id
+         */
+        song_id: number;
+    };
+    query?: {
+        /**
+         * Suppress Source File
+         */
+        suppress_source_file?: boolean;
+    };
+    url: "/libraries/{library_id}/songs/{song_id}";
+};
+
+export declare type DeleteLibrarySongLibrariesLibraryIdSongsSongIdDeleteError = DeleteLibrarySongLibrariesLibraryIdSongsSongIdDeleteErrors[keyof DeleteLibrarySongLibrariesLibraryIdSongsSongIdDeleteErrors];
+
+export declare type DeleteLibrarySongLibrariesLibraryIdSongsSongIdDeleteErrors = {
+    /**
+     * Validation Error
+     */
+    422: HttpValidationError;
+};
+
+export declare type DeleteLibrarySongLibrariesLibraryIdSongsSongIdDeleteResponses = {
+    /**
+     * Successful Response
+     */
+    200: unknown;
+};
+
+export declare type DeleteNotificationUsersNotificationsNotificationIdDeleteData = {
+    body?: never;
+    path: {
+        /**
+         * Notification Id
+         */
+        notification_id: number;
+    };
+    query?: never;
+    url: "/users/notifications/{notification_id}";
+};
+
+export declare type DeleteNotificationUsersNotificationsNotificationIdDeleteError = DeleteNotificationUsersNotificationsNotificationIdDeleteErrors[keyof DeleteNotificationUsersNotificationsNotificationIdDeleteErrors];
+
+export declare type DeleteNotificationUsersNotificationsNotificationIdDeleteErrors = {
+    /**
+     * Validation Error
+     */
+    422: HttpValidationError;
+};
+
+export declare type DeleteNotificationUsersNotificationsNotificationIdDeleteResponse = DeleteNotificationUsersNotificationsNotificationIdDeleteResponses[keyof DeleteNotificationUsersNotificationsNotificationIdDeleteResponses];
+
+export declare type DeleteNotificationUsersNotificationsNotificationIdDeleteResponses = {
+    /**
+     * Successful Response
+     */
+    200: OperationResult;
+};
+
+export declare type DeleteSourceSourcesSourceIdDeleteData = {
+    body?: never;
+    path: {
+        /**
+         * Source Id
+         */
+        source_id: number;
+    };
+    query?: never;
+    url: "/sources/{source_id}";
+};
+
+export declare type DeleteSourceSourcesSourceIdDeleteError = DeleteSourceSourcesSourceIdDeleteErrors[keyof DeleteSourceSourcesSourceIdDeleteErrors];
+
+export declare type DeleteSourceSourcesSourceIdDeleteErrors = {
+    /**
+     * Validation Error
+     */
+    422: HttpValidationError;
+};
+
+export declare type DeleteSourceSourcesSourceIdDeleteResponses = {
+    /**
+     * Successful Response
+     */
+    200: unknown;
+};
+
+export declare type DeleteUserAdminUsersAdminAllUserIdDeleteData = {
+    body?: never;
+    path: {
+        /**
+         * User Id
+         */
+        user_id: number;
+    };
+    query?: never;
+    url: "/users/admin/all/{user_id}";
+};
+
+export declare type DeleteUserAdminUsersAdminAllUserIdDeleteError = DeleteUserAdminUsersAdminAllUserIdDeleteErrors[keyof DeleteUserAdminUsersAdminAllUserIdDeleteErrors];
+
+export declare type DeleteUserAdminUsersAdminAllUserIdDeleteErrors = {
+    /**
+     * Validation Error
+     */
+    422: HttpValidationError;
+};
+
+export declare type DeleteUserAdminUsersAdminAllUserIdDeleteResponse = DeleteUserAdminUsersAdminAllUserIdDeleteResponses[keyof DeleteUserAdminUsersAdminAllUserIdDeleteResponses];
+
+export declare type DeleteUserAdminUsersAdminAllUserIdDeleteResponses = {
+    /**
+     * Successful Response
+     */
+    200: OperationResult;
+};
+
+/** The maximum length of embedded text such as the lyrics of a song. */
+export declare const EMBEDDED_TEXT_MAX_LENGTH = 5000;
+
+/**
+ * ExtensionCommand
+ */
+export declare type ExtensionCommand = {
+    /**
+     * Id
+     *
+     * Unique identifier for the command
+     */
+    id: string;
+    /**
+     * Searchterms
+     *
+     * The static search terms for the command
+     */
+    searchTerms: string;
+    /**
+     * Requiredinputkinds
+     *
+     * The kinds of the inputs this command requires to execute
+     */
+    requiredInputKinds: Array<string>;
+    /**
+     * Highlightavailability
+     *
+     * Whether the command should be highlighted when it becomes available
+     */
+    highlightAvailability?: boolean;
+    [key: string]: unknown;
+};
+
+/**
+ * ExtensionCommand
+ */
+export declare const ExtensionCommandSchema: z.ZodObject<{
+    id: z.ZodString;
+    searchTerms: z.ZodString;
+    requiredInputKinds: z.ZodArray<z.ZodString>;
+    highlightAvailability: z.ZodOptional<z.ZodBoolean>;
+}, z.core.$strip>;
+
+/**
+ * ExtensionImportAdmin
+ */
+export declare type ExtensionImportAdmin = {
+    /**
+     * Manifest Url
+     */
+    manifest_url: string;
+};
+
+/**
+ * ExtensionImportAdmin
+ */
+export declare const ExtensionImportAdminSchema: z.ZodObject<{
+    manifest_url: z.ZodURL;
+}, z.core.$strip>;
+
+/**
+ * ExtensionManifest
+ */
+export declare type ExtensionManifest = {
+    /**
+     * Name
+     *
+     * A friendly name for the extension
+     */
+    name: string;
+    /**
+     * Id
+     *
+     * A unique identifier for the extension
+     */
+    id: string;
+    /**
+     * Version
+     *
+     * The version of the extension
+     */
+    version: string;
+    /**
+     * Description
+     *
+     * An optional description of the extension
+     */
+    description?: string | null;
+    /**
+     * Url
+     *
+     * The possibly relative URL of the extension
+     */
+    url: string;
+    /**
+     * Icon Url
+     *
+     * The possibly relative URL of the extension's icon, if any
+     */
+    icon_url?: string | null;
+    /**
+     * Preferredwidth
+     *
+     * The preferred width of the extension as a CSS dimension
+     */
+    preferredWidth?: string | null;
+    /**
+     * Preferredheight
+     *
+     * The preferred height of the extension as a CSS dimension
+     */
+    preferredHeight?: string | null;
+    /**
+     * Permissions
+     *
+     * An optional array of permissions required by the extension
+     */
+    permissions?: Array<ExtensionPermissions | string> | null;
+    /**
+     * Sourceschemes
+     *
+     * An optional array of source schemes supported by the extension
+     */
+    sourceSchemes?: Array<string> | null;
+    /**
+     * Commands
+     *
+     * An optional array of commands supported by the extension
+     */
+    commands?: Array<ExtensionCommand> | null;
+    /**
+     * An optional search command supported by the extension
+     */
+    searchCommand?: ExtensionSearchCommand | null;
+    [key: string]: unknown;
+};
+
+/**
+ * ExtensionManifest
+ */
+export declare const ExtensionManifestSchema: z.ZodObject<{
+    name: z.ZodString;
+    id: z.ZodString;
+    version: z.ZodString;
+    description: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    url: z.ZodString;
+    icon_url: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    preferredWidth: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    preferredHeight: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    permissions: z.ZodOptional<z.ZodNullable<z.ZodArray<z.ZodUnion<readonly [z.ZodEnum<{
+        "run:background": "run:background";
+        "run:eager": "run:eager";
+        "commands:input:read": "commands:input:read";
+        "commands:input:add": "commands:input:add";
+        "commands:query": "commands:query";
+        "commands:run": "commands:run";
+        "libraries:read": "libraries:read";
+        "libraries:write": "libraries:write";
+        "playback:read": "playback:read";
+        "playback:control": "playback:control";
+    }>, z.ZodString]>>>>;
+    sourceSchemes: z.ZodOptional<z.ZodNullable<z.ZodArray<z.ZodString>>>;
+    commands: z.ZodOptional<z.ZodNullable<z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        searchTerms: z.ZodString;
+        requiredInputKinds: z.ZodArray<z.ZodString>;
+        highlightAvailability: z.ZodOptional<z.ZodBoolean>;
+    }, z.core.$strip>>>>;
+    searchCommand: z.ZodOptional<z.ZodNullable<z.ZodObject<{
+        requiredInputKinds: z.ZodArray<z.ZodString>;
+    }, z.core.$strip>>>;
+}, z.core.$strip>;
+
+/**
+ * ExtensionPermissions
+ */
+export declare type ExtensionPermissions = "run:background" | "run:eager" | "commands:input:read" | "commands:input:add" | "commands:query" | "commands:run" | "libraries:read" | "libraries:write" | "playback:read" | "playback:control";
+
+/**
+ * ExtensionPermissions
+ */
+export declare const ExtensionPermissionsSchema: z.ZodEnum<{
+    "run:background": "run:background";
+    "run:eager": "run:eager";
+    "commands:input:read": "commands:input:read";
+    "commands:input:add": "commands:input:add";
+    "commands:query": "commands:query";
+    "commands:run": "commands:run";
+    "libraries:read": "libraries:read";
+    "libraries:write": "libraries:write";
+    "playback:read": "playback:read";
+    "playback:control": "playback:control";
+}>;
+
+/**
+ * ExtensionRead
+ */
+export declare type ExtensionRead = {
+    /**
+     * Id
+     */
+    id: number;
+    manifest: ExtensionManifest;
+};
+
+/**
+ * ExtensionRead
+ */
+export declare const ExtensionReadSchema: z.ZodObject<{
+    id: z.ZodInt;
+    manifest: z.ZodObject<{
+        name: z.ZodString;
+        id: z.ZodString;
+        version: z.ZodString;
+        description: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+        url: z.ZodString;
+        icon_url: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+        preferredWidth: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+        preferredHeight: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+        permissions: z.ZodOptional<z.ZodNullable<z.ZodArray<z.ZodUnion<readonly [z.ZodEnum<{
+            "run:background": "run:background";
+            "run:eager": "run:eager";
+            "commands:input:read": "commands:input:read";
+            "commands:input:add": "commands:input:add";
+            "commands:query": "commands:query";
+            "commands:run": "commands:run";
+            "libraries:read": "libraries:read";
+            "libraries:write": "libraries:write";
+            "playback:read": "playback:read";
+            "playback:control": "playback:control";
+        }>, z.ZodString]>>>>;
+        sourceSchemes: z.ZodOptional<z.ZodNullable<z.ZodArray<z.ZodString>>>;
+        commands: z.ZodOptional<z.ZodNullable<z.ZodArray<z.ZodObject<{
+            id: z.ZodString;
+            searchTerms: z.ZodString;
+            requiredInputKinds: z.ZodArray<z.ZodString>;
+            highlightAvailability: z.ZodOptional<z.ZodBoolean>;
+        }, z.core.$strip>>>>;
+        searchCommand: z.ZodOptional<z.ZodNullable<z.ZodObject<{
+            requiredInputKinds: z.ZodArray<z.ZodString>;
+        }, z.core.$strip>>>;
+    }, z.core.$strip>;
+}, z.core.$strip>;
+
+/**
+ * ExtensionSearchCommand
+ */
+export declare type ExtensionSearchCommand = {
+    /**
+     * Requiredinputkinds
+     *
+     * The kinds of the inputs the search command requires to execute
+     */
+    requiredInputKinds: Array<string>;
+    [key: string]: unknown;
+};
+
+/**
+ * ExtensionSearchCommand
+ */
+export declare const ExtensionSearchCommandSchema: z.ZodObject<{
+    requiredInputKinds: z.ZodArray<z.ZodString>;
+}, z.core.$strip>;
+
+/**
+ * Helper object which manages a file access token.
+ */
+export declare class FileAccess {
+    private readonly client;
+    private _token;
+    private _expiresAt;
+    private _pending;
+    /**
+     * Construct a file access helper.
+     *
+     * @param client The API client files will be accessed through.
+     */
+    constructor(client: APIClient);
+    /**
+     * Indicates whether the file access helper has a valid token.
+     */
+    get hasValidToken(): boolean;
+    /**
+     * Returns a file access token, fetching one if required.
+     *
+     * @param options Customizes how the token is handled.
+     * @returns A file access token.
+     */
+    token(options?: FileAccessTokenOptions): Promise<string>;
+}
+
+export declare interface FileAccessTokenOptions {
+    /**
+     * Whether to refresh the token even if the current one is valid.
+     */
+    readonly refresh?: boolean;
+}
+
+/**
+ * HTTPValidationError
+ */
+export declare type HttpValidationError = {
+    /**
+     * Detail
+     */
+    detail?: Array<ValidationError>;
+};
+
+/**
+ * HTTPValidationError
+ */
+export declare const HttpValidationErrorSchema: z.ZodObject<{
+    detail: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        loc: z.ZodArray<z.ZodUnion<readonly [z.ZodString, z.ZodInt]>>;
+        msg: z.ZodString;
+        type: z.ZodString;
+        input: z.ZodOptional<z.ZodUnknown>;
+        ctx: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    }, z.core.$strip>>>;
+}, z.core.$strip>;
+
+export declare type ImportExtensionExtensionsAvailableImportPostData = {
+    body: ExtensionImportAdmin;
+    path?: never;
+    query?: never;
+    url: "/extensions/available/import";
+};
+
+export declare type ImportExtensionExtensionsAvailableImportPostError = ImportExtensionExtensionsAvailableImportPostErrors[keyof ImportExtensionExtensionsAvailableImportPostErrors];
+
+export declare type ImportExtensionExtensionsAvailableImportPostErrors = {
+    /**
+     * Validation Error
+     */
+    422: HttpValidationError;
+};
+
+export declare type ImportExtensionExtensionsAvailableImportPostResponse = ImportExtensionExtensionsAvailableImportPostResponses[keyof ImportExtensionExtensionsAvailableImportPostResponses];
+
+export declare type ImportExtensionExtensionsAvailableImportPostResponses = {
+    /**
+     * Successful Response
+     */
+    200: OperationResult;
+};
+
+/** The maximum number of items that can be ingested in a single batch. */
+export declare const INGEST_BATCH_MAX_SIZE = 50;
+
+/**
+ * IngestArtwork
+ */
+export declare type IngestArtwork = {
+    kind: ArtworkKind;
+    /**
+     * Image Url
+     */
+    image_url: string;
+    /**
+     * Background Color
+     */
+    background_color: string | null;
+    /**
+     * Primary Color
+     */
+    primary_color: string | null;
+    /**
+     * Secondary Color
+     */
+    secondary_color: string | null;
+    /**
+     * Tertiary Color
+     */
+    tertiary_color: string | null;
+};
+
+/**
+ * IngestArtwork
+ */
+export declare const IngestArtworkSchema: z.ZodObject<{
+    kind: z.ZodEnum<{
+        front_cover: "front_cover";
+    }>;
+    image_url: z.ZodString;
+    background_color: z.ZodNullable<z.ZodString>;
+    primary_color: z.ZodNullable<z.ZodString>;
+    secondary_color: z.ZodNullable<z.ZodString>;
+    tertiary_color: z.ZodNullable<z.ZodString>;
+}, z.core.$strip>;
+
+export declare type IngestFilesLibrariesLibraryIdIngestFilesPostData = {
+    body: BodyIngestFilesLibrariesLibraryIdIngestFilesPost;
+    path: {
+        /**
+         * Library Id
+         */
+        library_id: number;
+    };
+    query?: never;
+    url: "/libraries/{library_id}/ingest/files";
+};
+
+export declare type IngestFilesLibrariesLibraryIdIngestFilesPostError = IngestFilesLibrariesLibraryIdIngestFilesPostErrors[keyof IngestFilesLibrariesLibraryIdIngestFilesPostErrors];
+
+export declare type IngestFilesLibrariesLibraryIdIngestFilesPostErrors = {
+    /**
+     * Validation Error
+     */
+    422: HttpValidationError;
+};
+
+export declare type IngestFilesLibrariesLibraryIdIngestFilesPostResponse = IngestFilesLibrariesLibraryIdIngestFilesPostResponses[keyof IngestFilesLibrariesLibraryIdIngestFilesPostResponses];
+
+export declare type IngestFilesLibrariesLibraryIdIngestFilesPostResponses = {
+    /**
+     * Successful Response
+     */
+    200: OperationResult;
+};
+
+/**
+ * IngestPlaybackEvent
+ */
+export declare type IngestPlaybackEvent = {
+    /**
+     * Recorded At
+     *
+     * When the event was recorded
+     */
+    recorded_at: string;
+    /**
+     * The kind of event which happened
+     */
+    kind: PlaybackEventKind;
+    /**
+     * Song Id
+     *
+     * ID of the song involved in this playback event
+     */
+    song_id: number;
+    /**
+     * Start Time
+     *
+     * The current time in the song when the event started
+     */
+    start_time: number;
+    /**
+     * End Time
+     *
+     * The current time in the song when the event ended
+     */
+    end_time: number;
+};
+
+/**
+ * IngestPlaybackEvent
+ */
+export declare const IngestPlaybackEventSchema: z.ZodObject<{
+    recorded_at: z.ZodISODateTime;
+    kind: z.ZodEnum<{
+        play: "play";
+        pause: "pause";
+        stop: "stop";
+        fast_forward: "fast_forward";
+        rewind: "rewind";
+    }>;
+    song_id: z.ZodInt;
+    start_time: z.ZodInt;
+    end_time: z.ZodInt;
+}, z.core.$strip>;
+
+export declare type IngestPlaybackEventsPlaybackEventsIngestPostData = {
+    /**
+     * Ingestable Events
+     *
+     * Playback events to ingest, max 100
+     */
+    body: Array<IngestPlaybackEvent>;
+    path?: never;
+    query?: never;
+    url: "/playback-events/ingest";
+};
+
+export declare type IngestPlaybackEventsPlaybackEventsIngestPostError = IngestPlaybackEventsPlaybackEventsIngestPostErrors[keyof IngestPlaybackEventsPlaybackEventsIngestPostErrors];
+
+export declare type IngestPlaybackEventsPlaybackEventsIngestPostErrors = {
+    /**
+     * Validation Error
+     */
+    422: HttpValidationError;
+};
+
+export declare type IngestPlaybackEventsPlaybackEventsIngestPostResponse = IngestPlaybackEventsPlaybackEventsIngestPostResponses[keyof IngestPlaybackEventsPlaybackEventsIngestPostResponses];
+
+export declare type IngestPlaybackEventsPlaybackEventsIngestPostResponses = {
+    /**
+     * Successful Response
+     */
+    200: PlaybackEventIngestResult;
+};
+
+/**
+ * IngestSong
+ */
+export declare type IngestSong = {
+    /**
+     * Artist Name
+     */
+    artist_name: string | null;
+    /**
+     * Album Title
+     */
+    album_title: string | null;
+    /**
+     * Artworks
+     */
+    artworks: Array<IngestArtwork>;
+    /**
+     * Sources
+     */
+    sources: Array<IngestSource>;
+    /**
+     * Start Time
+     */
+    start_time: number;
+    /**
+     * End Time
+     */
+    end_time: number;
+    /**
+     * Title
+     */
+    title: string | null;
+    /**
+     * Album Artist
+     */
+    album_artist: string | null;
+    /**
+     * Composer
+     */
+    composer: string | null;
+    /**
+     * Genre
+     */
+    genre: string | null;
+    /**
+     * Release Date
+     */
+    release_date: string | null;
+    /**
+     * Track Number
+     */
+    track_number: number | null;
+    /**
+     * Track Total
+     */
+    track_total: number | null;
+    /**
+     * Disc Number
+     */
+    disc_number: number | null;
+    /**
+     * Disc Total
+     */
+    disc_total: number | null;
+    /**
+     * Lyrics
+     */
+    lyrics: string | null;
+    /**
+     * Rating
+     */
+    rating: number | null;
+    /**
+     * Bpm
+     */
+    bpm: number | null;
+    /**
+     * Comment
+     */
+    comment: string | null;
+    /**
+     * Grouping
+     */
+    grouping: string | null;
+    /**
+     * Mcn
+     */
+    mcn: string | null;
+    /**
+     * Isrc
+     */
+    isrc: string | null;
+    /**
+     * Music Brainz Release Id
+     */
+    music_brainz_release_id: string | null;
+    /**
+     * Music Brainz Recording Id
+     */
+    music_brainz_recording_id: string | null;
+};
+
+/**
+ * IngestSong
+ */
+export declare const IngestSongSchema: z.ZodObject<{
+    artist_name: z.ZodNullable<z.ZodString>;
+    album_title: z.ZodNullable<z.ZodString>;
+    artworks: z.ZodArray<z.ZodObject<{
+        kind: z.ZodEnum<{
+            front_cover: "front_cover";
+        }>;
+        image_url: z.ZodString;
+        background_color: z.ZodNullable<z.ZodString>;
+        primary_color: z.ZodNullable<z.ZodString>;
+        secondary_color: z.ZodNullable<z.ZodString>;
+        tertiary_color: z.ZodNullable<z.ZodString>;
+    }, z.core.$strip>>;
+    sources: z.ZodArray<z.ZodObject<{
+        url: z.ZodString;
+        mime_type: z.ZodNullable<z.ZodString>;
+        extension_manifest_id: z.ZodNullable<z.ZodString>;
+        extension_tag: z.ZodNullable<z.ZodString>;
+    }, z.core.$strip>>;
+    start_time: z.ZodNumber;
+    end_time: z.ZodNumber;
+    title: z.ZodNullable<z.ZodString>;
+    album_artist: z.ZodNullable<z.ZodString>;
+    composer: z.ZodNullable<z.ZodString>;
+    genre: z.ZodNullable<z.ZodString>;
+    release_date: z.ZodNullable<z.ZodString>;
+    track_number: z.ZodNullable<z.ZodInt>;
+    track_total: z.ZodNullable<z.ZodInt>;
+    disc_number: z.ZodNullable<z.ZodInt>;
+    disc_total: z.ZodNullable<z.ZodInt>;
+    lyrics: z.ZodNullable<z.ZodString>;
+    rating: z.ZodNullable<z.ZodNumber>;
+    bpm: z.ZodNullable<z.ZodInt>;
+    comment: z.ZodNullable<z.ZodString>;
+    grouping: z.ZodNullable<z.ZodString>;
+    mcn: z.ZodNullable<z.ZodString>;
+    isrc: z.ZodNullable<z.ZodString>;
+    music_brainz_release_id: z.ZodNullable<z.ZodString>;
+    music_brainz_recording_id: z.ZodNullable<z.ZodString>;
+}, z.core.$strip>;
+
+export declare type IngestSongsLibrariesLibraryIdIngestSongsPostData = {
+    body: BulkIngestSongs;
+    path: {
+        /**
+         * Library Id
+         */
+        library_id: number;
+    };
+    query?: never;
+    url: "/libraries/{library_id}/ingest/songs";
+};
+
+export declare type IngestSongsLibrariesLibraryIdIngestSongsPostError = IngestSongsLibrariesLibraryIdIngestSongsPostErrors[keyof IngestSongsLibrariesLibraryIdIngestSongsPostErrors];
+
+export declare type IngestSongsLibrariesLibraryIdIngestSongsPostErrors = {
+    /**
+     * Validation Error
+     */
+    422: HttpValidationError;
+};
+
+export declare type IngestSongsLibrariesLibraryIdIngestSongsPostResponse = IngestSongsLibrariesLibraryIdIngestSongsPostResponses[keyof IngestSongsLibrariesLibraryIdIngestSongsPostResponses];
+
+export declare type IngestSongsLibrariesLibraryIdIngestSongsPostResponses = {
+    /**
+     * Response Ingest Songs Libraries  Library Id  Ingest Songs Post
+     *
+     * Successful Response
+     */
+    200: Array<SongRead>;
+};
+
+/**
+ * IngestSource
+ */
+export declare type IngestSource = {
+    /**
+     * Url
+     */
+    url: string;
+    /**
+     * Mime Type
+     */
+    mime_type: string | null;
+    /**
+     * Extension Manifest Id
+     */
+    extension_manifest_id: string | null;
+    /**
+     * Extension Tag
+     */
+    extension_tag: string | null;
+};
+
+/**
+ * IngestSource
+ */
+export declare const IngestSourceSchema: z.ZodObject<{
+    url: z.ZodString;
+    mime_type: z.ZodNullable<z.ZodString>;
+    extension_manifest_id: z.ZodNullable<z.ZodString>;
+    extension_tag: z.ZodNullable<z.ZodString>;
+}, z.core.$strip>;
+
+export declare type InstallExtensionExtensionsAvailableExtensionIdInstallPostData = {
+    body?: never;
+    path: {
+        /**
+         * Extension Id
+         */
+        extension_id: number;
+    };
+    query?: never;
+    url: "/extensions/available/{extension_id}/install";
+};
+
+export declare type InstallExtensionExtensionsAvailableExtensionIdInstallPostError = InstallExtensionExtensionsAvailableExtensionIdInstallPostErrors[keyof InstallExtensionExtensionsAvailableExtensionIdInstallPostErrors];
+
+export declare type InstallExtensionExtensionsAvailableExtensionIdInstallPostErrors = {
+    /**
+     * Validation Error
+     */
+    422: HttpValidationError;
+};
+
+export declare type InstallExtensionExtensionsAvailableExtensionIdInstallPostResponse = InstallExtensionExtensionsAvailableExtensionIdInstallPostResponses[keyof InstallExtensionExtensionsAvailableExtensionIdInstallPostResponses];
+
+export declare type InstallExtensionExtensionsAvailableExtensionIdInstallPostResponses = {
+    /**
+     * Successful Response
+     */
+    200: OperationResult;
+};
+
+/**
+ * InstanceStatusRead
+ */
+export declare type InstanceStatusRead = {
+    /**
+     * Env
+     */
+    env: "dev" | "ci" | "prod";
+    /**
+     * Version
+     */
+    version: string;
+    /**
+     * Uploads Enabled
+     */
+    uploads_enabled: boolean;
+    /**
+     * Email Enabled
+     */
+    email_enabled: boolean;
+    /**
+     * First Setup Complete
+     */
+    first_setup_complete: boolean;
+};
+
+/**
+ * InstanceStatusRead
+ */
+export declare const InstanceStatusReadSchema: z.ZodObject<{
+    env: z.ZodEnum<{
+        dev: "dev";
+        ci: "ci";
+        prod: "prod";
+    }>;
+    version: z.ZodString;
+    uploads_enabled: z.ZodBoolean;
+    email_enabled: z.ZodBoolean;
+    first_setup_complete: z.ZodBoolean;
+}, z.core.$strip>;
+
+/**
+ * LibraryCreate
+ */
+export declare type LibraryCreate = {
+    /**
+     * Name
+     */
+    name: string;
+    /**
+     * Home Path
+     */
+    home_path: string | null;
+    /**
+     * Uploads Enabled
+     */
+    uploads_enabled: boolean;
+    cover_artwork: ArtworkRead | null;
+};
+
+/**
+ * LibraryCreate
+ */
+export declare const LibraryCreateSchema: z.ZodObject<{
+    name: z.ZodString;
+    home_path: z.ZodNullable<z.ZodString>;
+    uploads_enabled: z.ZodBoolean;
+    cover_artwork: z.ZodNullable<z.ZodObject<{
+        id: z.ZodInt;
+        kind: z.ZodEnum<{
+            front_cover: "front_cover";
+        }>;
+        image_url: z.ZodString;
+        background_color: z.ZodNullable<z.ZodString>;
+        primary_color: z.ZodNullable<z.ZodString>;
+        secondary_color: z.ZodNullable<z.ZodString>;
+        tertiary_color: z.ZodNullable<z.ZodString>;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+
+/**
+ * LibraryHomePathRead
+ */
+export declare type LibraryHomePathRead = {
+    /**
+     * Relative To
+     */
+    relative_to: string;
+    /**
+     * Subpaths
+     */
+    subpaths: Array<string>;
+};
+
+/**
+ * LibraryHomePathRead
+ */
+export declare const LibraryHomePathReadSchema: z.ZodObject<{
+    relative_to: z.ZodString;
+    subpaths: z.ZodArray<z.ZodString>;
+}, z.core.$strip>;
+
+/**
+ * LibraryIgnoredResourceRead
+ */
+export declare type LibraryIgnoredResourceRead = {
+    /**
+     * Id
+     */
+    id: number;
+    /**
+     * Url
+     */
+    url: string;
+};
+
+/**
+ * LibraryIgnoredResourceRead
+ */
+export declare const LibraryIgnoredResourceReadSchema: z.ZodObject<{
+    id: z.ZodInt;
+    url: z.ZodString;
+}, z.core.$strip>;
+
+/**
+ * LibraryMediaRead[AlbumRead]
+ */
+export declare type LibraryMediaReadAlbumRead = {
+    /**
+     * Items
+     */
+    items: Array<AlbumRead>;
+    /**
+     * Offset
+     */
+    offset: number;
+    /**
+     * Limit
+     */
+    limit: number;
+    /**
+     * Total
+     */
+    total: number;
+};
+
+/**
+ * LibraryMediaRead[AlbumRead]
+ */
+export declare const LibraryMediaReadAlbumReadSchema: z.ZodObject<{
+    items: z.ZodArray<z.ZodObject<{
+        id: z.ZodInt;
+        title: z.ZodString;
+        artist_id: z.ZodNullable<z.ZodInt>;
+        artworks: z.ZodOptional<z.ZodArray<z.ZodObject<{
+            id: z.ZodInt;
+            kind: z.ZodEnum<{
+                front_cover: "front_cover";
+            }>;
+            image_url: z.ZodString;
+            background_color: z.ZodNullable<z.ZodString>;
+            primary_color: z.ZodNullable<z.ZodString>;
+            secondary_color: z.ZodNullable<z.ZodString>;
+            tertiary_color: z.ZodNullable<z.ZodString>;
+        }, z.core.$strip>>>;
+    }, z.core.$strip>>;
+    offset: z.ZodInt;
+    limit: z.ZodInt;
+    total: z.ZodInt;
+}, z.core.$strip>;
+
+/**
+ * LibraryMediaRead[ArtistRead]
+ */
+export declare type LibraryMediaReadArtistRead = {
+    /**
+     * Items
+     */
+    items: Array<ArtistRead>;
+    /**
+     * Offset
+     */
+    offset: number;
+    /**
+     * Limit
+     */
+    limit: number;
+    /**
+     * Total
+     */
+    total: number;
+};
+
+/**
+ * LibraryMediaRead[ArtistRead]
+ */
+export declare const LibraryMediaReadArtistReadSchema: z.ZodObject<{
+    items: z.ZodArray<z.ZodObject<{
+        id: z.ZodInt;
+        name: z.ZodString;
+        artworks: z.ZodOptional<z.ZodArray<z.ZodObject<{
+            id: z.ZodInt;
+            kind: z.ZodEnum<{
+                front_cover: "front_cover";
+            }>;
+            image_url: z.ZodString;
+            background_color: z.ZodNullable<z.ZodString>;
+            primary_color: z.ZodNullable<z.ZodString>;
+            secondary_color: z.ZodNullable<z.ZodString>;
+            tertiary_color: z.ZodNullable<z.ZodString>;
+        }, z.core.$strip>>>;
+    }, z.core.$strip>>;
+    offset: z.ZodInt;
+    limit: z.ZodInt;
+    total: z.ZodInt;
+}, z.core.$strip>;
+
+/**
+ * LibraryMediaRead[ExtensionRead]
+ */
+export declare type LibraryMediaReadExtensionRead = {
+    /**
+     * Items
+     */
+    items: Array<ExtensionRead>;
+    /**
+     * Offset
+     */
+    offset: number;
+    /**
+     * Limit
+     */
+    limit: number;
+    /**
+     * Total
+     */
+    total: number;
+};
+
+/**
+ * LibraryMediaRead[ExtensionRead]
+ */
+export declare const LibraryMediaReadExtensionReadSchema: z.ZodObject<{
+    items: z.ZodArray<z.ZodObject<{
+        id: z.ZodInt;
+        manifest: z.ZodObject<{
+            name: z.ZodString;
+            id: z.ZodString;
+            version: z.ZodString;
+            description: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+            url: z.ZodString;
+            icon_url: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+            preferredWidth: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+            preferredHeight: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+            permissions: z.ZodOptional<z.ZodNullable<z.ZodArray<z.ZodUnion<readonly [z.ZodEnum<{
+                "run:background": "run:background";
+                "run:eager": "run:eager";
+                "commands:input:read": "commands:input:read";
+                "commands:input:add": "commands:input:add";
+                "commands:query": "commands:query";
+                "commands:run": "commands:run";
+                "libraries:read": "libraries:read";
+                "libraries:write": "libraries:write";
+                "playback:read": "playback:read";
+                "playback:control": "playback:control";
+            }>, z.ZodString]>>>>;
+            sourceSchemes: z.ZodOptional<z.ZodNullable<z.ZodArray<z.ZodString>>>;
+            commands: z.ZodOptional<z.ZodNullable<z.ZodArray<z.ZodObject<{
+                id: z.ZodString;
+                searchTerms: z.ZodString;
+                requiredInputKinds: z.ZodArray<z.ZodString>;
+                highlightAvailability: z.ZodOptional<z.ZodBoolean>;
+            }, z.core.$strip>>>>;
+            searchCommand: z.ZodOptional<z.ZodNullable<z.ZodObject<{
+                requiredInputKinds: z.ZodArray<z.ZodString>;
+            }, z.core.$strip>>>;
+        }, z.core.$strip>;
+    }, z.core.$strip>>;
+    offset: z.ZodInt;
+    limit: z.ZodInt;
+    total: z.ZodInt;
+}, z.core.$strip>;
+
+/**
+ * LibraryMediaRead[LibraryIgnoredResourceRead]
+ */
+export declare type LibraryMediaReadLibraryIgnoredResourceRead = {
+    /**
+     * Items
+     */
+    items: Array<LibraryIgnoredResourceRead>;
+    /**
+     * Offset
+     */
+    offset: number;
+    /**
+     * Limit
+     */
+    limit: number;
+    /**
+     * Total
+     */
+    total: number;
+};
+
+/**
+ * LibraryMediaRead[LibraryIgnoredResourceRead]
+ */
+export declare const LibraryMediaReadLibraryIgnoredResourceReadSchema: z.ZodObject<{
+    items: z.ZodArray<z.ZodObject<{
+        id: z.ZodInt;
+        url: z.ZodString;
+    }, z.core.$strip>>;
+    offset: z.ZodInt;
+    limit: z.ZodInt;
+    total: z.ZodInt;
+}, z.core.$strip>;
+
+/**
+ * LibraryMediaRead[SongRead]
+ */
+export declare type LibraryMediaReadSongRead = {
+    /**
+     * Items
+     */
+    items: Array<SongRead>;
+    /**
+     * Offset
+     */
+    offset: number;
+    /**
+     * Limit
+     */
+    limit: number;
+    /**
+     * Total
+     */
+    total: number;
+};
+
+/**
+ * LibraryMediaRead[SongRead]
+ */
+export declare const LibraryMediaReadSongReadSchema: z.ZodObject<{
+    items: z.ZodArray<z.ZodObject<{
+        id: z.ZodInt;
+        artist_id: z.ZodOptional<z.ZodNullable<z.ZodInt>>;
+        artist_name: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+        album_id: z.ZodOptional<z.ZodNullable<z.ZodInt>>;
+        album_title: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+        artworks: z.ZodOptional<z.ZodArray<z.ZodObject<{
+            id: z.ZodInt;
+            kind: z.ZodEnum<{
+                front_cover: "front_cover";
+            }>;
+            image_url: z.ZodString;
+            background_color: z.ZodNullable<z.ZodString>;
+            primary_color: z.ZodNullable<z.ZodString>;
+            secondary_color: z.ZodNullable<z.ZodString>;
+            tertiary_color: z.ZodNullable<z.ZodString>;
+        }, z.core.$strip>>>;
+        sources: z.ZodOptional<z.ZodArray<z.ZodObject<{
+            id: z.ZodInt;
+            url: z.ZodString;
+            mime_type: z.ZodNullable<z.ZodString>;
+            is_invalid: z.ZodBoolean;
+            extension_manifest_id: z.ZodNullable<z.ZodString>;
+            extension_tag: z.ZodNullable<z.ZodString>;
+        }, z.core.$strip>>>;
+        start_time: z.ZodOptional<z.ZodNumber>;
+        end_time: z.ZodNumber;
+        title: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+        album_artist: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+        composer: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+        genre: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+        release_date: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+        track_number: z.ZodOptional<z.ZodNullable<z.ZodInt>>;
+        track_total: z.ZodOptional<z.ZodNullable<z.ZodInt>>;
+        disc_number: z.ZodOptional<z.ZodNullable<z.ZodInt>>;
+        disc_total: z.ZodOptional<z.ZodNullable<z.ZodInt>>;
+        lyrics: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+        rating: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
+        bpm: z.ZodOptional<z.ZodNullable<z.ZodInt>>;
+        comment: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+        grouping: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+        mcn: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+        isrc: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+        music_brainz_release_id: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+        music_brainz_recording_id: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    }, z.core.$strip>>;
+    offset: z.ZodInt;
+    limit: z.ZodInt;
+    total: z.ZodInt;
+}, z.core.$strip>;
+
+/**
+ * LibraryMediaRead[SourceRead]
+ */
+export declare type LibraryMediaReadSourceRead = {
+    /**
+     * Items
+     */
+    items: Array<SourceRead>;
+    /**
+     * Offset
+     */
+    offset: number;
+    /**
+     * Limit
+     */
+    limit: number;
+    /**
+     * Total
+     */
+    total: number;
+};
+
+/**
+ * LibraryMediaRead[SourceRead]
+ */
+export declare const LibraryMediaReadSourceReadSchema: z.ZodObject<{
+    items: z.ZodArray<z.ZodObject<{
+        id: z.ZodInt;
+        url: z.ZodString;
+        mime_type: z.ZodNullable<z.ZodString>;
+        is_invalid: z.ZodBoolean;
+        extension_manifest_id: z.ZodNullable<z.ZodString>;
+        extension_tag: z.ZodNullable<z.ZodString>;
+    }, z.core.$strip>>;
+    offset: z.ZodInt;
+    limit: z.ZodInt;
+    total: z.ZodInt;
+}, z.core.$strip>;
+
+/**
+ * LibraryPermissionCreate
+ */
+export declare type LibraryPermissionCreate = {
+    /**
+     * User Id
+     */
+    user_id: number;
+    /**
+     * Can Add
+     */
+    can_add: boolean;
+    /**
+     * Can Edit
+     */
+    can_edit: boolean;
+    /**
+     * Can Remove
+     */
+    can_remove: boolean;
+};
+
+/**
+ * LibraryPermissionCreate
+ */
+export declare const LibraryPermissionCreateSchema: z.ZodObject<{
+    user_id: z.ZodInt;
+    can_add: z.ZodBoolean;
+    can_edit: z.ZodBoolean;
+    can_remove: z.ZodBoolean;
+}, z.core.$strip>;
+
+/**
+ * LibraryPermissionRead
+ */
+export declare type LibraryPermissionRead = {
+    /**
+     * User Id
+     */
+    user_id: number;
+    /**
+     * Username
+     */
+    username: string;
+    /**
+     * Can Add
+     */
+    can_add: boolean;
+    /**
+     * Can Edit
+     */
+    can_edit: boolean;
+    /**
+     * Can Remove
+     */
+    can_remove: boolean;
+};
+
+/**
+ * LibraryPermissionRead
+ */
+export declare const LibraryPermissionReadSchema: z.ZodObject<{
+    user_id: z.ZodInt;
+    username: z.ZodString;
+    can_add: z.ZodBoolean;
+    can_edit: z.ZodBoolean;
+    can_remove: z.ZodBoolean;
+}, z.core.$strip>;
+
+/**
+ * LibraryPermissionUpdate
+ */
+export declare type LibraryPermissionUpdate = {
+    /**
+     * Can Add
+     */
+    can_add?: boolean | null;
+    /**
+     * Can Edit
+     */
+    can_edit?: boolean | null;
+    /**
+     * Can Remove
+     */
+    can_remove?: boolean | null;
+};
+
+/**
+ * LibraryPermissionUpdate
+ */
+export declare const LibraryPermissionUpdateSchema: z.ZodObject<{
+    can_add: z.ZodOptional<z.ZodNullable<z.ZodBoolean>>;
+    can_edit: z.ZodOptional<z.ZodNullable<z.ZodBoolean>>;
+    can_remove: z.ZodOptional<z.ZodNullable<z.ZodBoolean>>;
+}, z.core.$strip>;
+
+/**
+ * LibraryRead
+ */
+export declare type LibraryRead = {
+    /**
+     * Id
+     */
+    id: number;
+    /**
+     * Name
+     */
+    name: string;
+    /**
+     * Home Path
+     */
+    home_path: string | null;
+    /**
+     * Uploads Enabled
+     */
+    uploads_enabled: boolean;
+    cover_artwork: ArtworkRead | null;
+};
+
+/**
+ * LibraryRead
+ */
+export declare const LibraryReadSchema: z.ZodObject<{
+    id: z.ZodInt;
+    name: z.ZodString;
+    home_path: z.ZodNullable<z.ZodString>;
+    uploads_enabled: z.ZodBoolean;
+    cover_artwork: z.ZodNullable<z.ZodObject<{
+        id: z.ZodInt;
+        kind: z.ZodEnum<{
+            front_cover: "front_cover";
+        }>;
+        image_url: z.ZodString;
+        background_color: z.ZodNullable<z.ZodString>;
+        primary_color: z.ZodNullable<z.ZodString>;
+        secondary_color: z.ZodNullable<z.ZodString>;
+        tertiary_color: z.ZodNullable<z.ZodString>;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+
+/**
+ * LibraryUpdate
+ */
+export declare type LibraryUpdate = {
+    /**
+     * Name
+     */
+    name?: string | null;
+    /**
+     * Uploads Enabled
+     */
+    uploads_enabled?: boolean | null;
+    cover_artwork?: ArtworkRead | null;
+};
+
+/**
+ * LibraryUpdate
+ */
+export declare const LibraryUpdateSchema: z.ZodObject<{
+    name: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    uploads_enabled: z.ZodOptional<z.ZodNullable<z.ZodBoolean>>;
+    cover_artwork: z.ZodOptional<z.ZodNullable<z.ZodObject<{
+        id: z.ZodInt;
+        kind: z.ZodEnum<{
+            front_cover: "front_cover";
+        }>;
+        image_url: z.ZodString;
+        background_color: z.ZodNullable<z.ZodString>;
+        primary_color: z.ZodNullable<z.ZodString>;
+        secondary_color: z.ZodNullable<z.ZodString>;
+        tertiary_color: z.ZodNullable<z.ZodString>;
+    }, z.core.$strip>>>;
+}, z.core.$strip>;
+
+/** The maximum number of items to read per page. */
+export declare const LIMIT_MAX = 250;
+
+export declare type MarkAllNotificationsReadUsersNotificationsMarkAllReadPostData = {
+    body?: never;
+    path?: never;
+    query?: never;
+    url: "/users/notifications/mark-all-read";
+};
+
+export declare type MarkAllNotificationsReadUsersNotificationsMarkAllReadPostResponse = MarkAllNotificationsReadUsersNotificationsMarkAllReadPostResponses[keyof MarkAllNotificationsReadUsersNotificationsMarkAllReadPostResponses];
+
+export declare type MarkAllNotificationsReadUsersNotificationsMarkAllReadPostResponses = {
+    /**
+     * Successful Response
+     */
+    200: OperationResult;
+};
+
+/**
+ * NotificationRead
+ */
+export declare type NotificationRead = {
+    /**
+     * Id
+     */
+    id: number;
+    /**
+     * Title
+     */
+    title: string;
+    /**
+     * Description
+     */
+    description: string | null;
+    /**
+     * Progress
+     */
+    progress: number | null;
+    /**
+     * Is Read
+     */
+    is_read: boolean;
+};
+
+/**
+ * NotificationRead
+ */
+export declare const NotificationReadSchema: z.ZodObject<{
+    id: z.ZodInt;
+    title: z.ZodString;
+    description: z.ZodNullable<z.ZodString>;
+    progress: z.ZodNullable<z.ZodNumber>;
+    is_read: z.ZodBoolean;
+}, z.core.$strip>;
+
+/**
+ * NotificationsRead
+ */
+export declare type NotificationsRead = {
+    /**
+     * Items
+     */
+    items: Array<NotificationRead>;
+    /**
+     * Offset
+     */
+    offset: number;
+    /**
+     * Limit
+     */
+    limit: number;
+    /**
+     * Total
+     */
+    total: number;
+};
+
+/**
+ * NotificationsRead
+ */
+export declare const NotificationsReadSchema: z.ZodObject<{
+    items: z.ZodArray<z.ZodObject<{
+        id: z.ZodInt;
+        title: z.ZodString;
+        description: z.ZodNullable<z.ZodString>;
+        progress: z.ZodNullable<z.ZodNumber>;
+        is_read: z.ZodBoolean;
+    }, z.core.$strip>>;
+    offset: z.ZodInt;
+    limit: z.ZodInt;
+    total: z.ZodInt;
+}, z.core.$strip>;
+
+/**
+ * NotificationUpdate
+ */
+export declare type NotificationUpdate = {
+    /**
+     * Is Read
+     */
+    is_read?: boolean | null;
+};
+
+/**
+ * NotificationUpdate
+ */
+export declare const NotificationUpdateSchema: z.ZodObject<{
+    is_read: z.ZodOptional<z.ZodNullable<z.ZodBoolean>>;
+}, z.core.$strip>;
+
+/**
+ * OAuth2Scope
+ */
+export declare type OAuth2Scope = "profile" | "library:read" | "library:write" | "admin";
+
+/**
+ * OAuth2Scope
+ */
+export declare const OAuth2ScopeSchema: z.ZodEnum<{
+    profile: "profile";
+    "library:read": "library:read";
+    "library:write": "library:write";
+    admin: "admin";
+}>;
+
+/**
+ * OperationResult
+ */
+export declare type OperationResult = {
+    /**
+     * Message
+     */
+    message: string;
+    /**
+     * Row Count
+     */
+    row_count?: number | null;
+};
+
+/**
+ * OperationResult
+ */
+export declare const OperationResultSchema: z.ZodObject<{
+    message: z.ZodString;
+    row_count: z.ZodOptional<z.ZodNullable<z.ZodInt>>;
+}, z.core.$strip>;
+
+/** The maximum length of a file path. */
+export declare const PATH_MAX_LENGTH = 2000;
+
+/**
+ * PlaybackEventIngestResult
+ */
+export declare type PlaybackEventIngestResult = {
+    /**
+     * Accepted Count
+     */
+    accepted_count: number;
+    /**
+     * Rejected Events
+     */
+    rejected_events: Array<IngestPlaybackEvent>;
+};
+
+/**
+ * PlaybackEventIngestResult
+ */
+export declare const PlaybackEventIngestResultSchema: z.ZodObject<{
+    accepted_count: z.ZodInt;
+    rejected_events: z.ZodArray<z.ZodObject<{
+        recorded_at: z.ZodISODateTime;
+        kind: z.ZodEnum<{
+            play: "play";
+            pause: "pause";
+            stop: "stop";
+            fast_forward: "fast_forward";
+            rewind: "rewind";
+        }>;
+        song_id: z.ZodInt;
+        start_time: z.ZodInt;
+        end_time: z.ZodInt;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+
+/**
+ * PlaybackEventKind
+ */
+export declare type PlaybackEventKind = "play" | "pause" | "stop" | "fast_forward" | "rewind";
+
+/**
+ * PlaybackEventKind
+ */
+export declare const PlaybackEventKindSchema: z.ZodEnum<{
+    play: "play";
+    pause: "pause";
+    stop: "stop";
+    fast_forward: "fast_forward";
+    rewind: "rewind";
+}>;
+
+export declare type ReadAllSourcesSourcesAllGetData = {
+    body?: never;
+    path?: never;
+    query?: {
+        /**
+         * Offset
+         *
+         * The page offset to read from
+         */
+        offset?: number;
+        /**
+         * Limit
+         *
+         * How many items to read per page
+         */
+        limit?: number;
+        /**
+         * Library Id
+         */
+        library_id?: number | null;
+        /**
+         * Extension Manifest Id
+         */
+        extension_manifest_id?: string | null;
+        /**
+         * Extension Tags
+         */
+        extension_tags?: Array<string> | null;
+    };
+    url: "/sources/all";
+};
+
+export declare type ReadAllSourcesSourcesAllGetError = ReadAllSourcesSourcesAllGetErrors[keyof ReadAllSourcesSourcesAllGetErrors];
+
+export declare type ReadAllSourcesSourcesAllGetErrors = {
+    /**
+     * Validation Error
+     */
+    422: HttpValidationError;
+};
+
+export declare type ReadAllSourcesSourcesAllGetResponse = ReadAllSourcesSourcesAllGetResponses[keyof ReadAllSourcesSourcesAllGetResponses];
+
+export declare type ReadAllSourcesSourcesAllGetResponses = {
+    /**
+     * Successful Response
+     */
+    200: LibraryMediaReadSourceRead;
+};
+
+export declare type ReadArtworkImageArtworksArtworkIdImageGetData = {
+    body?: never;
+    path: {
+        /**
+         * Artwork Id
+         */
+        artwork_id: number;
+    };
+    query: {
+        /**
+         * Token
+         *
+         * A feature token
+         */
+        token: string;
+    };
+    url: "/artworks/{artwork_id}/image";
+};
+
+export declare type ReadArtworkImageArtworksArtworkIdImageGetError = ReadArtworkImageArtworksArtworkIdImageGetErrors[keyof ReadArtworkImageArtworksArtworkIdImageGetErrors];
+
+export declare type ReadArtworkImageArtworksArtworkIdImageGetErrors = {
+    /**
+     * Validation Error
+     */
+    422: HttpValidationError;
+};
+
+export declare type ReadArtworkImageArtworksArtworkIdImageGetResponses = {
+    /**
+     * Successful Response
+     */
+    200: unknown;
+};
+
+export declare type ReadAvailableExtensionsExtensionsAvailableGetData = {
+    body?: never;
+    path?: never;
+    query?: {
+        /**
+         * Offset
+         *
+         * The page offset to read from
+         */
+        offset?: number;
+        /**
+         * Limit
+         *
+         * How many items to read per page
+         */
+        limit?: number;
+    };
+    url: "/extensions/available";
+};
+
+export declare type ReadAvailableExtensionsExtensionsAvailableGetError = ReadAvailableExtensionsExtensionsAvailableGetErrors[keyof ReadAvailableExtensionsExtensionsAvailableGetErrors];
+
+export declare type ReadAvailableExtensionsExtensionsAvailableGetErrors = {
+    /**
+     * Validation Error
+     */
+    422: HttpValidationError;
+};
+
+export declare type ReadAvailableExtensionsExtensionsAvailableGetResponse = ReadAvailableExtensionsExtensionsAvailableGetResponses[keyof ReadAvailableExtensionsExtensionsAvailableGetResponses];
+
+export declare type ReadAvailableExtensionsExtensionsAvailableGetResponses = {
+    /**
+     * Successful Response
+     */
+    200: LibraryMediaReadExtensionRead;
+};
+
+export declare type ReadFilesPreflightUsersFilesPreflightPostData = {
+    body?: never;
+    path?: never;
+    query?: never;
+    url: "/users/files/preflight";
+};
+
+export declare type ReadFilesPreflightUsersFilesPreflightPostResponse = ReadFilesPreflightUsersFilesPreflightPostResponses[keyof ReadFilesPreflightUsersFilesPreflightPostResponses];
+
+export declare type ReadFilesPreflightUsersFilesPreflightPostResponses = {
+    /**
+     * Successful Response
+     */
+    200: UserFileAccessPreflight;
+};
+
+export declare type ReadInstalledExtensionsExtensionsInstalledGetData = {
+    body?: never;
+    path?: never;
+    query?: {
+        /**
+         * Offset
+         *
+         * The page offset to read from
+         */
+        offset?: number;
+        /**
+         * Limit
+         *
+         * How many items to read per page
+         */
+        limit?: number;
+    };
+    url: "/extensions/installed";
+};
+
+export declare type ReadInstalledExtensionsExtensionsInstalledGetError = ReadInstalledExtensionsExtensionsInstalledGetErrors[keyof ReadInstalledExtensionsExtensionsInstalledGetErrors];
+
+export declare type ReadInstalledExtensionsExtensionsInstalledGetErrors = {
+    /**
+     * Validation Error
+     */
+    422: HttpValidationError;
+};
+
+export declare type ReadInstalledExtensionsExtensionsInstalledGetResponse = ReadInstalledExtensionsExtensionsInstalledGetResponses[keyof ReadInstalledExtensionsExtensionsInstalledGetResponses];
+
+export declare type ReadInstalledExtensionsExtensionsInstalledGetResponses = {
+    /**
+     * Successful Response
+     */
+    200: LibraryMediaReadExtensionRead;
+};
+
+export declare type ReadInstanceStatusStatusGetData = {
+    body?: never;
+    path?: never;
+    query?: never;
+    url: "/status";
+};
+
+export declare type ReadInstanceStatusStatusGetResponse = ReadInstanceStatusStatusGetResponses[keyof ReadInstanceStatusStatusGetResponses];
+
+export declare type ReadInstanceStatusStatusGetResponses = {
+    /**
+     * Successful Response
+     */
+    200: InstanceStatusRead;
+};
+
+export declare type ReadLibrariesLibrariesGetData = {
+    body?: never;
+    path?: never;
+    query?: never;
+    url: "/libraries/";
+};
+
+export declare type ReadLibrariesLibrariesGetResponse = ReadLibrariesLibrariesGetResponses[keyof ReadLibrariesLibrariesGetResponses];
+
+export declare type ReadLibrariesLibrariesGetResponses = {
+    /**
+     * Response Read Libraries Libraries  Get
+     *
+     * Successful Response
+     */
+    200: Array<LibraryRead>;
+};
+
+export declare type ReadLibraryAlbumLibrariesLibraryIdAlbumsAlbumIdGetData = {
+    body?: never;
+    path: {
+        /**
+         * Library Id
+         */
+        library_id: number;
+        /**
+         * Album Id
+         */
+        album_id: number;
+    };
+    query?: never;
+    url: "/libraries/{library_id}/albums/{album_id}";
+};
+
+export declare type ReadLibraryAlbumLibrariesLibraryIdAlbumsAlbumIdGetError = ReadLibraryAlbumLibrariesLibraryIdAlbumsAlbumIdGetErrors[keyof ReadLibraryAlbumLibrariesLibraryIdAlbumsAlbumIdGetErrors];
+
+export declare type ReadLibraryAlbumLibrariesLibraryIdAlbumsAlbumIdGetErrors = {
+    /**
+     * Validation Error
+     */
+    422: HttpValidationError;
+};
+
+export declare type ReadLibraryAlbumLibrariesLibraryIdAlbumsAlbumIdGetResponse = ReadLibraryAlbumLibrariesLibraryIdAlbumsAlbumIdGetResponses[keyof ReadLibraryAlbumLibrariesLibraryIdAlbumsAlbumIdGetResponses];
+
+export declare type ReadLibraryAlbumLibrariesLibraryIdAlbumsAlbumIdGetResponses = {
+    /**
+     * Successful Response
+     */
+    200: AlbumRead;
+};
+
+export declare type ReadLibraryAlbumsLibrariesLibraryIdAlbumsGetData = {
+    body?: never;
+    path: {
+        /**
+         * Library Id
+         */
+        library_id: number;
+    };
+    query?: {
+        /**
+         * Offset
+         *
+         * The page offset to read from
+         */
+        offset?: number;
+        /**
+         * Limit
+         *
+         * How many items to read per page
+         */
+        limit?: number;
+        /**
+         * Query
+         *
+         * Query string to filter the albums by
+         */
+        query?: string | null;
+        /**
+         * Artist Id
+         *
+         * ID of the artist to filter the songs by
+         */
+        artist_id?: number | null;
+    };
+    url: "/libraries/{library_id}/albums";
+};
+
+export declare type ReadLibraryAlbumsLibrariesLibraryIdAlbumsGetError = ReadLibraryAlbumsLibrariesLibraryIdAlbumsGetErrors[keyof ReadLibraryAlbumsLibrariesLibraryIdAlbumsGetErrors];
+
+export declare type ReadLibraryAlbumsLibrariesLibraryIdAlbumsGetErrors = {
+    /**
+     * Validation Error
+     */
+    422: HttpValidationError;
+};
+
+export declare type ReadLibraryAlbumsLibrariesLibraryIdAlbumsGetResponse = ReadLibraryAlbumsLibrariesLibraryIdAlbumsGetResponses[keyof ReadLibraryAlbumsLibrariesLibraryIdAlbumsGetResponses];
+
+export declare type ReadLibraryAlbumsLibrariesLibraryIdAlbumsGetResponses = {
+    /**
+     * Successful Response
+     */
+    200: LibraryMediaReadAlbumRead;
+};
+
+export declare type ReadLibraryArtistLibrariesLibraryIdArtistsArtistIdGetData = {
+    body?: never;
+    path: {
+        /**
+         * Library Id
+         */
+        library_id: number;
+        /**
+         * Artist Id
+         */
+        artist_id: number;
+    };
+    query?: never;
+    url: "/libraries/{library_id}/artists/{artist_id}";
+};
+
+export declare type ReadLibraryArtistLibrariesLibraryIdArtistsArtistIdGetError = ReadLibraryArtistLibrariesLibraryIdArtistsArtistIdGetErrors[keyof ReadLibraryArtistLibrariesLibraryIdArtistsArtistIdGetErrors];
+
+export declare type ReadLibraryArtistLibrariesLibraryIdArtistsArtistIdGetErrors = {
+    /**
+     * Validation Error
+     */
+    422: HttpValidationError;
+};
+
+export declare type ReadLibraryArtistLibrariesLibraryIdArtistsArtistIdGetResponse = ReadLibraryArtistLibrariesLibraryIdArtistsArtistIdGetResponses[keyof ReadLibraryArtistLibrariesLibraryIdArtistsArtistIdGetResponses];
+
+export declare type ReadLibraryArtistLibrariesLibraryIdArtistsArtistIdGetResponses = {
+    /**
+     * Successful Response
+     */
+    200: ArtistRead;
+};
+
+export declare type ReadLibraryArtistsLibrariesLibraryIdArtistsGetData = {
+    body?: never;
+    path: {
+        /**
+         * Library Id
+         */
+        library_id: number;
+    };
+    query?: {
+        /**
+         * Offset
+         *
+         * The page offset to read from
+         */
+        offset?: number;
+        /**
+         * Limit
+         *
+         * How many items to read per page
+         */
+        limit?: number;
+        /**
+         * Query
+         *
+         * Query string to filter the artists by
+         */
+        query?: string | null;
+    };
+    url: "/libraries/{library_id}/artists";
+};
+
+export declare type ReadLibraryArtistsLibrariesLibraryIdArtistsGetError = ReadLibraryArtistsLibrariesLibraryIdArtistsGetErrors[keyof ReadLibraryArtistsLibrariesLibraryIdArtistsGetErrors];
+
+export declare type ReadLibraryArtistsLibrariesLibraryIdArtistsGetErrors = {
+    /**
+     * Validation Error
+     */
+    422: HttpValidationError;
+};
+
+export declare type ReadLibraryArtistsLibrariesLibraryIdArtistsGetResponse = ReadLibraryArtistsLibrariesLibraryIdArtistsGetResponses[keyof ReadLibraryArtistsLibrariesLibraryIdArtistsGetResponses];
+
+export declare type ReadLibraryArtistsLibrariesLibraryIdArtistsGetResponses = {
+    /**
+     * Successful Response
+     */
+    200: LibraryMediaReadArtistRead;
+};
+
+export declare type ReadLibraryHomeSubpathsLibrariesHomeSubpathsGetData = {
+    body?: never;
+    path?: never;
+    query: {
+        /**
+         * Relative To
+         */
+        relative_to: string;
+    };
+    url: "/libraries/home-subpaths";
+};
+
+export declare type ReadLibraryHomeSubpathsLibrariesHomeSubpathsGetError = ReadLibraryHomeSubpathsLibrariesHomeSubpathsGetErrors[keyof ReadLibraryHomeSubpathsLibrariesHomeSubpathsGetErrors];
+
+export declare type ReadLibraryHomeSubpathsLibrariesHomeSubpathsGetErrors = {
+    /**
+     * Validation Error
+     */
+    422: HttpValidationError;
+};
+
+export declare type ReadLibraryHomeSubpathsLibrariesHomeSubpathsGetResponse = ReadLibraryHomeSubpathsLibrariesHomeSubpathsGetResponses[keyof ReadLibraryHomeSubpathsLibrariesHomeSubpathsGetResponses];
+
+export declare type ReadLibraryHomeSubpathsLibrariesHomeSubpathsGetResponses = {
+    /**
+     * Successful Response
+     */
+    200: LibraryHomePathRead;
+};
+
+export declare type ReadLibraryIgnoredResourcesLibrariesLibraryIdIgnoredGetData = {
+    body?: never;
+    path: {
+        /**
+         * Library Id
+         */
+        library_id: number;
+    };
+    query?: {
+        /**
+         * Offset
+         */
+        offset?: number;
+        /**
+         * Limit
+         */
+        limit?: number;
+    };
+    url: "/libraries/{library_id}/ignored";
+};
+
+export declare type ReadLibraryIgnoredResourcesLibrariesLibraryIdIgnoredGetError = ReadLibraryIgnoredResourcesLibrariesLibraryIdIgnoredGetErrors[keyof ReadLibraryIgnoredResourcesLibrariesLibraryIdIgnoredGetErrors];
+
+export declare type ReadLibraryIgnoredResourcesLibrariesLibraryIdIgnoredGetErrors = {
+    /**
+     * Validation Error
+     */
+    422: HttpValidationError;
+};
+
+export declare type ReadLibraryIgnoredResourcesLibrariesLibraryIdIgnoredGetResponse = ReadLibraryIgnoredResourcesLibrariesLibraryIdIgnoredGetResponses[keyof ReadLibraryIgnoredResourcesLibrariesLibraryIdIgnoredGetResponses];
+
+export declare type ReadLibraryIgnoredResourcesLibrariesLibraryIdIgnoredGetResponses = {
+    /**
+     * Successful Response
+     */
+    200: LibraryMediaReadLibraryIgnoredResourceRead;
+};
+
+export declare type ReadLibraryLibrariesLibraryIdGetData = {
+    body?: never;
+    path: {
+        /**
+         * Library Id
+         */
+        library_id: number;
+    };
+    query?: never;
+    url: "/libraries/{library_id}";
+};
+
+export declare type ReadLibraryLibrariesLibraryIdGetError = ReadLibraryLibrariesLibraryIdGetErrors[keyof ReadLibraryLibrariesLibraryIdGetErrors];
+
+export declare type ReadLibraryLibrariesLibraryIdGetErrors = {
+    /**
+     * Validation Error
+     */
+    422: HttpValidationError;
+};
+
+export declare type ReadLibraryLibrariesLibraryIdGetResponse = ReadLibraryLibrariesLibraryIdGetResponses[keyof ReadLibraryLibrariesLibraryIdGetResponses];
+
+export declare type ReadLibraryLibrariesLibraryIdGetResponses = {
+    /**
+     * Successful Response
+     */
+    200: LibraryRead;
+};
+
+export declare type ReadLibraryPermissionsLibrariesLibraryIdPermissionsGetData = {
+    body?: never;
+    path: {
+        /**
+         * Library Id
+         */
+        library_id: number;
+    };
+    query?: never;
+    url: "/libraries/{library_id}/permissions";
+};
+
+export declare type ReadLibraryPermissionsLibrariesLibraryIdPermissionsGetError = ReadLibraryPermissionsLibrariesLibraryIdPermissionsGetErrors[keyof ReadLibraryPermissionsLibrariesLibraryIdPermissionsGetErrors];
+
+export declare type ReadLibraryPermissionsLibrariesLibraryIdPermissionsGetErrors = {
+    /**
+     * Validation Error
+     */
+    422: HttpValidationError;
+};
+
+export declare type ReadLibraryPermissionsLibrariesLibraryIdPermissionsGetResponse = ReadLibraryPermissionsLibrariesLibraryIdPermissionsGetResponses[keyof ReadLibraryPermissionsLibrariesLibraryIdPermissionsGetResponses];
+
+export declare type ReadLibraryPermissionsLibrariesLibraryIdPermissionsGetResponses = {
+    /**
+     * Response Read Library Permissions Libraries  Library Id  Permissions Get
+     *
+     * Successful Response
+     */
+    200: Array<LibraryPermissionRead>;
+};
+
+export declare type ReadLibrarySongLibrariesLibraryIdSongsSongIdGetData = {
+    body?: never;
+    path: {
+        /**
+         * Library Id
+         */
+        library_id: number;
+        /**
+         * Song Id
+         */
+        song_id: number;
+    };
+    query?: never;
+    url: "/libraries/{library_id}/songs/{song_id}";
+};
+
+export declare type ReadLibrarySongLibrariesLibraryIdSongsSongIdGetError = ReadLibrarySongLibrariesLibraryIdSongsSongIdGetErrors[keyof ReadLibrarySongLibrariesLibraryIdSongsSongIdGetErrors];
+
+export declare type ReadLibrarySongLibrariesLibraryIdSongsSongIdGetErrors = {
+    /**
+     * Validation Error
+     */
+    422: HttpValidationError;
+};
+
+export declare type ReadLibrarySongLibrariesLibraryIdSongsSongIdGetResponse = ReadLibrarySongLibrariesLibraryIdSongsSongIdGetResponses[keyof ReadLibrarySongLibrariesLibraryIdSongsSongIdGetResponses];
+
+export declare type ReadLibrarySongLibrariesLibraryIdSongsSongIdGetResponses = {
+    /**
+     * Successful Response
+     */
+    200: SongRead;
+};
+
+export declare type ReadLibrarySongsLibrariesLibraryIdSongsGetData = {
+    body?: never;
+    path: {
+        /**
+         * Library Id
+         */
+        library_id: number;
+    };
+    query?: {
+        /**
+         * Offset
+         *
+         * The page offset to read from
+         */
+        offset?: number;
+        /**
+         * Limit
+         *
+         * How many items to read per page
+         */
+        limit?: number;
+        /**
+         * Query
+         *
+         * Query string to filter the songs by
+         */
+        query?: string | null;
+        /**
+         * Album Id
+         *
+         * ID of the album to filter the songs by
+         */
+        album_id?: number | null;
+        /**
+         * Artist Id
+         *
+         * ID of the artist to filter the songs by
+         */
+        artist_id?: number | null;
+        /**
+         * Sort By
+         *
+         * How to sort the items
+         */
+        sort_by?: Array<"+artist_name" | "-artist_name" | "+album_title" | "-album_title" | "+title" | "-title" | "+album_artist" | "-album_artist" | "+composer" | "-composer" | "+genre" | "-genre" | "+release_date" | "-release_date" | "+track_number" | "-track_number" | "+track_total" | "-track_total" | "+disc_number" | "-disc_number" | "+disc_total" | "-disc_total" | "+rating" | "-rating" | "+bpm" | "-bpm" | "+grouping" | "-grouping">;
+    };
+    url: "/libraries/{library_id}/songs";
+};
+
+export declare type ReadLibrarySongsLibrariesLibraryIdSongsGetError = ReadLibrarySongsLibrariesLibraryIdSongsGetErrors[keyof ReadLibrarySongsLibrariesLibraryIdSongsGetErrors];
+
+export declare type ReadLibrarySongsLibrariesLibraryIdSongsGetErrors = {
+    /**
+     * Validation Error
+     */
+    422: HttpValidationError;
+};
+
+export declare type ReadLibrarySongsLibrariesLibraryIdSongsGetResponse = ReadLibrarySongsLibrariesLibraryIdSongsGetResponses[keyof ReadLibrarySongsLibrariesLibraryIdSongsGetResponses];
+
+export declare type ReadLibrarySongsLibrariesLibraryIdSongsGetResponses = {
+    /**
+     * Successful Response
+     */
+    200: LibraryMediaReadSongRead;
+};
+
+export declare type ReadLibrarySongsSortBy = NonNullable<ReadLibrarySongsLibrariesLibraryIdSongsGetData["query"]>["sort_by"];
+
+export declare type ReadMeUsersMeGetData = {
+    body?: never;
+    path?: never;
+    query?: never;
+    url: "/users/me";
+};
+
+export declare type ReadMeUsersMeGetResponse = ReadMeUsersMeGetResponses[keyof ReadMeUsersMeGetResponses];
+
+export declare type ReadMeUsersMeGetResponses = {
+    /**
+     * Successful Response
+     */
+    200: UserProfileMeRead;
+};
+
+export declare type ReadNotificationsUsersNotificationsGetData = {
+    body?: never;
+    path?: never;
+    query?: {
+        /**
+         * Offset
+         *
+         * The page offset to read from
+         */
+        offset?: number;
+        /**
+         * Limit
+         *
+         * How many items to read per page
+         */
+        limit?: number;
+    };
+    url: "/users/notifications";
+};
+
+export declare type ReadNotificationsUsersNotificationsGetError = ReadNotificationsUsersNotificationsGetErrors[keyof ReadNotificationsUsersNotificationsGetErrors];
+
+export declare type ReadNotificationsUsersNotificationsGetErrors = {
+    /**
+     * Validation Error
+     */
+    422: HttpValidationError;
+};
+
+export declare type ReadNotificationsUsersNotificationsGetResponse = ReadNotificationsUsersNotificationsGetResponses[keyof ReadNotificationsUsersNotificationsGetResponses];
+
+export declare type ReadNotificationsUsersNotificationsGetResponses = {
+    /**
+     * Successful Response
+     */
+    200: NotificationsRead;
+};
+
+export declare type ReadNotificationUsersNotificationsNotificationIdGetData = {
+    body?: never;
+    path: {
+        /**
+         * Notification Id
+         */
+        notification_id: number;
+    };
+    query?: never;
+    url: "/users/notifications/{notification_id}";
+};
+
+export declare type ReadNotificationUsersNotificationsNotificationIdGetError = ReadNotificationUsersNotificationsNotificationIdGetErrors[keyof ReadNotificationUsersNotificationsNotificationIdGetErrors];
+
+export declare type ReadNotificationUsersNotificationsNotificationIdGetErrors = {
+    /**
+     * Validation Error
+     */
+    422: HttpValidationError;
+};
+
+export declare type ReadNotificationUsersNotificationsNotificationIdGetResponse = ReadNotificationUsersNotificationsNotificationIdGetResponses[keyof ReadNotificationUsersNotificationsNotificationIdGetResponses];
+
+export declare type ReadNotificationUsersNotificationsNotificationIdGetResponses = {
+    /**
+     * Successful Response
+     */
+    200: NotificationRead;
+};
+
+export declare type ReadSourceChangesSourcesChangesGetData = {
+    body?: never;
+    path?: never;
+    query: {
+        /**
+         * Since
+         */
+        since: string;
+        /**
+         * Ids
+         */
+        ids?: Array<number> | null;
+    };
+    url: "/sources/changes";
+};
+
+export declare type ReadSourceChangesSourcesChangesGetError = ReadSourceChangesSourcesChangesGetErrors[keyof ReadSourceChangesSourcesChangesGetErrors];
+
+export declare type ReadSourceChangesSourcesChangesGetErrors = {
+    /**
+     * Validation Error
+     */
+    422: HttpValidationError;
+};
+
+export declare type ReadSourceChangesSourcesChangesGetResponse = ReadSourceChangesSourcesChangesGetResponses[keyof ReadSourceChangesSourcesChangesGetResponses];
+
+export declare type ReadSourceChangesSourcesChangesGetResponses = {
+    /**
+     * Successful Response
+     */
+    200: SourceChangesRead;
+};
+
+export declare type ReadSourceSourcesSourceIdGetData = {
+    body?: never;
+    path: {
+        /**
+         * Source Id
+         */
+        source_id: number;
+    };
+    query?: never;
+    url: "/sources/{source_id}";
+};
+
+export declare type ReadSourceSourcesSourceIdGetError = ReadSourceSourcesSourceIdGetErrors[keyof ReadSourceSourcesSourceIdGetErrors];
+
+export declare type ReadSourceSourcesSourceIdGetErrors = {
+    /**
+     * Validation Error
+     */
+    422: HttpValidationError;
+};
+
+export declare type ReadSourceSourcesSourceIdGetResponse = ReadSourceSourcesSourceIdGetResponses[keyof ReadSourceSourcesSourceIdGetResponses];
+
+export declare type ReadSourceSourcesSourceIdGetResponses = {
+    /**
+     * Successful Response
+     */
+    200: SourceRead;
+};
+
+export declare type ReadUserAdminUsersAdminAllIdOrUsernameGetData = {
+    body?: never;
+    path: {
+        /**
+         * Id Or Username
+         */
+        id_or_username: string;
+    };
+    query?: never;
+    url: "/users/admin/all/{id_or_username}";
+};
+
+export declare type ReadUserAdminUsersAdminAllIdOrUsernameGetError = ReadUserAdminUsersAdminAllIdOrUsernameGetErrors[keyof ReadUserAdminUsersAdminAllIdOrUsernameGetErrors];
+
+export declare type ReadUserAdminUsersAdminAllIdOrUsernameGetErrors = {
+    /**
+     * Validation Error
+     */
+    422: HttpValidationError;
+};
+
+export declare type ReadUserAdminUsersAdminAllIdOrUsernameGetResponse = ReadUserAdminUsersAdminAllIdOrUsernameGetResponses[keyof ReadUserAdminUsersAdminAllIdOrUsernameGetResponses];
+
+export declare type ReadUserAdminUsersAdminAllIdOrUsernameGetResponses = {
+    /**
+     * Successful Response
+     */
+    200: UserAdminRead;
+};
+
+export declare type ReadUsersAdminUsersAdminAllGetData = {
+    body?: never;
+    path?: never;
+    query?: {
+        /**
+         * Offset
+         *
+         * The page offset to read from
+         */
+        offset?: number;
+        /**
+         * Limit
+         *
+         * How many items to read per page
+         */
+        limit?: number;
+        /**
+         * Query
+         *
+         * Query string to filter the users by
+         */
+        query?: string | null;
+    };
+    url: "/users/admin/all";
+};
+
+export declare type ReadUsersAdminUsersAdminAllGetError = ReadUsersAdminUsersAdminAllGetErrors[keyof ReadUsersAdminUsersAdminAllGetErrors];
+
+export declare type ReadUsersAdminUsersAdminAllGetErrors = {
+    /**
+     * Validation Error
+     */
+    422: HttpValidationError;
+};
+
+export declare type ReadUsersAdminUsersAdminAllGetResponse = ReadUsersAdminUsersAdminAllGetResponses[keyof ReadUsersAdminUsersAdminAllGetResponses];
+
+export declare type ReadUsersAdminUsersAdminAllGetResponses = {
+    /**
+     * Successful Response
+     */
+    200: UserAdminsRead;
+};
+
+export declare type ReadUsersUsersAllGetData = {
+    body?: never;
+    path?: never;
+    query?: {
+        /**
+         * Offset
+         *
+         * The page offset to read from
+         */
+        offset?: number;
+        /**
+         * Limit
+         *
+         * How many items to read per page
+         */
+        limit?: number;
+        /**
+         * Query
+         *
+         * Query string to filter the users by
+         */
+        query?: string | null;
+    };
+    url: "/users/all";
+};
+
+export declare type ReadUsersUsersAllGetError = ReadUsersUsersAllGetErrors[keyof ReadUsersUsersAllGetErrors];
+
+export declare type ReadUsersUsersAllGetErrors = {
+    /**
+     * Validation Error
+     */
+    422: HttpValidationError;
+};
+
+export declare type ReadUsersUsersAllGetResponse = ReadUsersUsersAllGetResponses[keyof ReadUsersUsersAllGetResponses];
+
+export declare type ReadUsersUsersAllGetResponses = {
+    /**
+     * Successful Response
+     */
+    200: UserProfilesRead;
+};
+
+export declare type ReadUserUsersAllIdOrUsernameGetData = {
+    body?: never;
+    path: {
+        /**
+         * Id Or Username
+         */
+        id_or_username: string;
+    };
+    query?: never;
+    url: "/users/all/{id_or_username}";
+};
+
+export declare type ReadUserUsersAllIdOrUsernameGetError = ReadUserUsersAllIdOrUsernameGetErrors[keyof ReadUserUsersAllIdOrUsernameGetErrors];
+
+export declare type ReadUserUsersAllIdOrUsernameGetErrors = {
+    /**
+     * Validation Error
+     */
+    422: HttpValidationError;
+};
+
+export declare type ReadUserUsersAllIdOrUsernameGetResponse = ReadUserUsersAllIdOrUsernameGetResponses[keyof ReadUserUsersAllIdOrUsernameGetResponses];
+
+export declare type ReadUserUsersAllIdOrUsernameGetResponses = {
+    /**
+     * Successful Response
+     */
+    200: UserProfileRead;
+};
+
+export declare type RequestSyncLibraryLibrariesLibraryIdSyncPostData = {
+    body?: never;
+    path: {
+        /**
+         * Library Id
+         */
+        library_id: number;
+    };
+    query?: never;
+    url: "/libraries/{library_id}/sync";
+};
+
+export declare type RequestSyncLibraryLibrariesLibraryIdSyncPostError = RequestSyncLibraryLibrariesLibraryIdSyncPostErrors[keyof RequestSyncLibraryLibrariesLibraryIdSyncPostErrors];
+
+export declare type RequestSyncLibraryLibrariesLibraryIdSyncPostErrors = {
+    /**
+     * Validation Error
+     */
+    422: HttpValidationError;
+};
+
+export declare type RequestSyncLibraryLibrariesLibraryIdSyncPostResponse = RequestSyncLibraryLibrariesLibraryIdSyncPostResponses[keyof RequestSyncLibraryLibrariesLibraryIdSyncPostResponses];
+
+export declare type RequestSyncLibraryLibrariesLibraryIdSyncPostResponses = {
+    /**
+     * Successful Response
+     */
+    200: OperationResult;
+};
+
+/**
+ * ResetPassword
+ */
+export declare type ResetPassword = {
+    /**
+     * Email
+     */
+    email: string;
+};
+
+export declare type ResetPasswordCompleteResetPasswordCompletePostData = {
+    body: CompleteResetPassword;
+    path?: never;
+    query?: never;
+    url: "/reset-password/complete";
+};
+
+export declare type ResetPasswordCompleteResetPasswordCompletePostError = ResetPasswordCompleteResetPasswordCompletePostErrors[keyof ResetPasswordCompleteResetPasswordCompletePostErrors];
+
+export declare type ResetPasswordCompleteResetPasswordCompletePostErrors = {
+    /**
+     * Validation Error
+     */
+    422: HttpValidationError;
+};
+
+export declare type ResetPasswordCompleteResetPasswordCompletePostResponse = ResetPasswordCompleteResetPasswordCompletePostResponses[keyof ResetPasswordCompleteResetPasswordCompletePostResponses];
+
+export declare type ResetPasswordCompleteResetPasswordCompletePostResponses = {
+    /**
+     * Successful Response
+     */
+    200: OperationResult;
+};
+
+export declare type ResetPasswordResetPasswordPostData = {
+    body: ResetPassword;
+    path?: never;
+    query?: never;
+    url: "/reset-password";
+};
+
+export declare type ResetPasswordResetPasswordPostError = ResetPasswordResetPasswordPostErrors[keyof ResetPasswordResetPasswordPostErrors];
+
+export declare type ResetPasswordResetPasswordPostErrors = {
+    /**
+     * Validation Error
+     */
+    422: HttpValidationError;
+};
+
+export declare type ResetPasswordResetPasswordPostResponse = ResetPasswordResetPasswordPostResponses[keyof ResetPasswordResetPasswordPostResponses];
+
+export declare type ResetPasswordResetPasswordPostResponses = {
+    /**
+     * Successful Response
+     */
+    200: OperationResult;
+};
+
+/**
+ * ResetPassword
+ */
+export declare const ResetPasswordSchema: z.ZodObject<{
+    email: z.ZodEmail;
+}, z.core.$strip>;
+
+export declare type SignInSignInPostData = {
+    body: BodySignInSignInPost;
+    path?: never;
+    query?: never;
+    url: "/sign-in";
+};
+
+export declare type SignInSignInPostError = SignInSignInPostErrors[keyof SignInSignInPostErrors];
+
+export declare type SignInSignInPostErrors = {
+    /**
+     * Validation Error
+     */
+    422: HttpValidationError;
+};
+
+export declare type SignInSignInPostResponse = SignInSignInPostResponses[keyof SignInSignInPostResponses];
+
+export declare type SignInSignInPostResponses = {
+    /**
+     * Successful Response
+     */
+    200: Token;
+};
+
+/**
+ * SignUp
+ */
+export declare type SignUp = {
+    /**
+     * Email
+     */
+    email?: string | null;
+    /**
+     * Username
+     */
+    username: string;
+    /**
+     * Password
+     */
+    password: string;
+};
+
+/**
+ * SignUp
+ */
+export declare const SignUpSchema: z.ZodObject<{
+    email: z.ZodOptional<z.ZodNullable<z.ZodEmail>>;
+    username: z.ZodString;
+    password: z.ZodString;
+}, z.core.$strip>;
+
+export declare type SignUpSignUpPostData = {
+    body: SignUp;
+    path?: never;
+    query?: never;
+    url: "/sign-up";
+};
+
+export declare type SignUpSignUpPostError = SignUpSignUpPostErrors[keyof SignUpSignUpPostErrors];
+
+export declare type SignUpSignUpPostErrors = {
+    /**
+     * Validation Error
+     */
+    422: HttpValidationError;
+};
+
+export declare type SignUpSignUpPostResponse = SignUpSignUpPostResponses[keyof SignUpSignUpPostResponses];
+
+export declare type SignUpSignUpPostResponses = {
+    /**
+     * Successful Response
+     */
+    200: UserProfileMeRead;
+};
+
+/**
+ * SongRead
+ */
+export declare type SongRead = {
+    /**
+     * Id
+     */
+    id: number;
+    /**
+     * Artist Id
+     *
+     * ID of this song's artist, if any
+     */
+    artist_id?: number | null;
+    /**
+     * Artist Name
+     *
+     * Name of this song's song, if any
+     */
+    artist_name?: string | null;
+    /**
+     * Album Id
+     *
+     * ID of this song's album, if any
+     */
+    album_id?: number | null;
+    /**
+     * Album Title
+     *
+     * Title of this song's album, if any
+     */
+    album_title?: string | null;
+    /**
+     * Artworks
+     *
+     * The artworks of this song
+     */
+    artworks?: Array<ArtworkRead>;
+    /**
+     * Sources
+     *
+     * The sources of this song
+     */
+    sources?: Array<SourceRead>;
+    /**
+     * Start Time
+     *
+     * Where in the song to start playback
+     */
+    start_time?: number;
+    /**
+     * End Time
+     *
+     * Where in the song to end playback
+     */
+    end_time: number;
+    /**
+     * Title
+     *
+     * The title of the song
+     */
+    title?: string | null;
+    /**
+     * Album Artist
+     *
+     * The song's album artist
+     */
+    album_artist?: string | null;
+    /**
+     * Composer
+     *
+     * The composer of the song
+     */
+    composer?: string | null;
+    /**
+     * Genre
+     *
+     * The genre of the song
+     */
+    genre?: string | null;
+    /**
+     * Release Date
+     *
+     * The release date of the song
+     */
+    release_date?: string | null;
+    /**
+     * Track Number
+     *
+     * The track number of the song
+     */
+    track_number?: number | null;
+    /**
+     * Track Total
+     *
+     * The total number of tracks on the album
+     */
+    track_total?: number | null;
+    /**
+     * Disc Number
+     *
+     * The disc number in the album
+     */
+    disc_number?: number | null;
+    /**
+     * Disc Total
+     *
+     * The total number of discs in the album
+     */
+    disc_total?: number | null;
+    /**
+     * Lyrics
+     *
+     * The lyrics of the song
+     */
+    lyrics?: string | null;
+    /**
+     * Rating
+     *
+     * The rating of the song
+     */
+    rating?: number | null;
+    /**
+     * Bpm
+     *
+     * The beats per minute of the song
+     */
+    bpm?: number | null;
+    /**
+     * Comment
+     *
+     * A user defined comment
+     */
+    comment?: string | null;
+    /**
+     * Grouping
+     *
+     * The grouping of the song
+     */
+    grouping?: string | null;
+    /**
+     * Mcn
+     */
+    mcn?: string | null;
+    /**
+     * Isrc
+     */
+    isrc?: string | null;
+    /**
+     * Music Brainz Release Id
+     */
+    music_brainz_release_id?: string | null;
+    /**
+     * Music Brainz Recording Id
+     */
+    music_brainz_recording_id?: string | null;
+};
+
+/**
+ * SongRead
+ */
+export declare const SongReadSchema: z.ZodObject<{
+    id: z.ZodInt;
+    artist_id: z.ZodOptional<z.ZodNullable<z.ZodInt>>;
+    artist_name: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    album_id: z.ZodOptional<z.ZodNullable<z.ZodInt>>;
+    album_title: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    artworks: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        id: z.ZodInt;
+        kind: z.ZodEnum<{
+            front_cover: "front_cover";
+        }>;
+        image_url: z.ZodString;
+        background_color: z.ZodNullable<z.ZodString>;
+        primary_color: z.ZodNullable<z.ZodString>;
+        secondary_color: z.ZodNullable<z.ZodString>;
+        tertiary_color: z.ZodNullable<z.ZodString>;
+    }, z.core.$strip>>>;
+    sources: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        id: z.ZodInt;
+        url: z.ZodString;
+        mime_type: z.ZodNullable<z.ZodString>;
+        is_invalid: z.ZodBoolean;
+        extension_manifest_id: z.ZodNullable<z.ZodString>;
+        extension_tag: z.ZodNullable<z.ZodString>;
+    }, z.core.$strip>>>;
+    start_time: z.ZodOptional<z.ZodNumber>;
+    end_time: z.ZodNumber;
+    title: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    album_artist: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    composer: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    genre: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    release_date: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    track_number: z.ZodOptional<z.ZodNullable<z.ZodInt>>;
+    track_total: z.ZodOptional<z.ZodNullable<z.ZodInt>>;
+    disc_number: z.ZodOptional<z.ZodNullable<z.ZodInt>>;
+    disc_total: z.ZodOptional<z.ZodNullable<z.ZodInt>>;
+    lyrics: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    rating: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
+    bpm: z.ZodOptional<z.ZodNullable<z.ZodInt>>;
+    comment: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    grouping: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    mcn: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    isrc: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    music_brainz_release_id: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    music_brainz_recording_id: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+}, z.core.$strip>;
+
+/**
+ * SongUpdate
+ */
+export declare type SongUpdate = {
+    /**
+     * Artist Id
+     */
+    artist_id?: number | null;
+    /**
+     * Album Id
+     */
+    album_id?: number | null;
+    /**
+     * Artwork Ids
+     */
+    artwork_ids?: Array<number> | null;
+    /**
+     * Source Ids
+     */
+    source_ids?: Array<number> | null;
+    /**
+     * Start Time
+     */
+    start_time?: number | null;
+    /**
+     * End Time
+     */
+    end_time?: number | null;
+    /**
+     * Title
+     */
+    title?: string | null;
+    /**
+     * Album Artist
+     */
+    album_artist?: string | null;
+    /**
+     * Composer
+     */
+    composer?: string | null;
+    /**
+     * Genre
+     */
+    genre?: string | null;
+    /**
+     * Release Date
+     */
+    release_date?: string | null;
+    /**
+     * Track Number
+     */
+    track_number?: number | null;
+    /**
+     * Track Total
+     */
+    track_total?: number | null;
+    /**
+     * Disc Number
+     */
+    disc_number?: number | null;
+    /**
+     * Disc Total
+     */
+    disc_total?: number | null;
+    /**
+     * Lyrics
+     */
+    lyrics?: string | null;
+    /**
+     * Rating
+     */
+    rating?: number | null;
+    /**
+     * Bpm
+     */
+    bpm?: number | null;
+    /**
+     * Comment
+     */
+    comment?: string | null;
+    /**
+     * Grouping
+     */
+    grouping?: string | null;
+    /**
+     * Mcn
+     */
+    mcn?: string | null;
+    /**
+     * Isrc
+     */
+    isrc?: string | null;
+    /**
+     * Music Brainz Release Id
+     */
+    music_brainz_release_id?: string | null;
+    /**
+     * Music Brainz Recording Id
+     */
+    music_brainz_recording_id?: string | null;
+};
+
+/**
+ * SongUpdate
+ */
+export declare const SongUpdateSchema: z.ZodObject<{
+    artist_id: z.ZodOptional<z.ZodNullable<z.ZodInt>>;
+    album_id: z.ZodOptional<z.ZodNullable<z.ZodInt>>;
+    artwork_ids: z.ZodOptional<z.ZodNullable<z.ZodArray<z.ZodInt>>>;
+    source_ids: z.ZodOptional<z.ZodNullable<z.ZodArray<z.ZodInt>>>;
+    start_time: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
+    end_time: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
+    title: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    album_artist: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    composer: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    genre: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    release_date: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    track_number: z.ZodOptional<z.ZodNullable<z.ZodInt>>;
+    track_total: z.ZodOptional<z.ZodNullable<z.ZodInt>>;
+    disc_number: z.ZodOptional<z.ZodNullable<z.ZodInt>>;
+    disc_total: z.ZodOptional<z.ZodNullable<z.ZodInt>>;
+    lyrics: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    rating: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
+    bpm: z.ZodOptional<z.ZodNullable<z.ZodInt>>;
+    comment: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    grouping: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    mcn: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    isrc: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    music_brainz_release_id: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    music_brainz_recording_id: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+}, z.core.$strip>;
+
+/**
+ * SourceChangesRead
+ */
+export declare type SourceChangesRead = {
+    /**
+     * Since
+     */
+    since: string;
+    /**
+     * Ids
+     */
+    ids: Array<number>;
+};
+
+/**
+ * SourceChangesRead
+ */
+export declare const SourceChangesReadSchema: z.ZodObject<{
+    since: z.ZodISODateTime;
+    ids: z.ZodArray<z.ZodInt>;
+}, z.core.$strip>;
+
+/**
+ * SourceCreate
+ */
+export declare type SourceCreate = {
+    /**
+     * Url
+     */
+    url: string;
+    /**
+     * Mime Type
+     */
+    mime_type: string | null;
+    /**
+     * Extension Manifest Id
+     */
+    extension_manifest_id: string | null;
+    /**
+     * Extension Tag
+     */
+    extension_tag: string | null;
+};
+
+/**
+ * SourceCreate
+ */
+export declare const SourceCreateSchema: z.ZodObject<{
+    url: z.ZodString;
+    mime_type: z.ZodNullable<z.ZodString>;
+    extension_manifest_id: z.ZodNullable<z.ZodString>;
+    extension_tag: z.ZodNullable<z.ZodString>;
+}, z.core.$strip>;
+
+/**
+ * SourceRead
+ */
+export declare type SourceRead = {
+    /**
+     * Id
+     */
+    id: number;
+    /**
+     * Url
+     */
+    url: string;
+    /**
+     * Mime Type
+     */
+    mime_type: string | null;
+    /**
+     * Is Invalid
+     */
+    is_invalid: boolean;
+    /**
+     * Extension Manifest Id
+     */
+    extension_manifest_id: string | null;
+    /**
+     * Extension Tag
+     */
+    extension_tag: string | null;
+};
+
+/**
+ * SourceRead
+ */
+export declare const SourceReadSchema: z.ZodObject<{
+    id: z.ZodInt;
+    url: z.ZodString;
+    mime_type: z.ZodNullable<z.ZodString>;
+    is_invalid: z.ZodBoolean;
+    extension_manifest_id: z.ZodNullable<z.ZodString>;
+    extension_tag: z.ZodNullable<z.ZodString>;
+}, z.core.$strip>;
+
+/**
+ * SourceUpdate
+ */
+export declare type SourceUpdate = {
+    /**
+     * Url
+     */
+    url?: string | null;
+    /**
+     * Mime Type
+     */
+    mime_type?: string | null;
+    /**
+     * Is Invalid
+     */
+    is_invalid?: boolean | null;
+    /**
+     * Extension Manifest Id
+     */
+    extension_manifest_id?: string | null;
+    /**
+     * Extension Tag
+     */
+    extension_tag?: string | null;
+};
+
+/**
+ * SourceUpdate
+ */
+export declare const SourceUpdateSchema: z.ZodObject<{
+    url: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    mime_type: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    is_invalid: z.ZodOptional<z.ZodNullable<z.ZodBoolean>>;
+    extension_manifest_id: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    extension_tag: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+}, z.core.$strip>;
+
+export declare class StorageUserSessionManager implements UserSessionManager {
+    private static _local;
+    static get local(): StorageUserSessionManager;
+    constructor(storage: Storage);
+    private readonly storage;
+    private readonly subscribers;
+    private _current;
+    get session(): UserSession | null;
+    get isSignedIn(): boolean;
+    replaceSession(newSession: UserSession | null): void;
+    hasScope(scope: OAuth2Scope): boolean;
+    subscribe(subscriber: (event: UserSessionManagerEvent) => void): () => void;
+}
+
+export declare type StreamSourceFileSourcesSourceIdFileGetData = {
+    body?: never;
+    path: {
+        /**
+         * Source Id
+         */
+        source_id: number;
+    };
+    query: {
+        /**
+         * Token
+         *
+         * A feature token
+         */
+        token: string;
+    };
+    url: "/sources/{source_id}/file";
+};
+
+export declare type StreamSourceFileSourcesSourceIdFileGetError = StreamSourceFileSourcesSourceIdFileGetErrors[keyof StreamSourceFileSourcesSourceIdFileGetErrors];
+
+export declare type StreamSourceFileSourcesSourceIdFileGetErrors = {
+    /**
+     * Validation Error
+     */
+    422: HttpValidationError;
+};
+
+export declare type StreamSourceFileSourcesSourceIdFileGetResponses = {
+    /**
+     * Successful Response
+     */
+    200: unknown;
+};
+
+export declare type StreamUserEventsPreflightUsersEventsPreflightPostData = {
+    body?: never;
+    path?: never;
+    query?: never;
+    url: "/users/events/preflight";
+};
+
+export declare type StreamUserEventsPreflightUsersEventsPreflightPostResponse = StreamUserEventsPreflightUsersEventsPreflightPostResponses[keyof StreamUserEventsPreflightUsersEventsPreflightPostResponses];
+
+export declare type StreamUserEventsPreflightUsersEventsPreflightPostResponses = {
+    /**
+     * Successful Response
+     */
+    200: UserEventPreflight;
+};
+
+/** The maximum length of a common tag such as the name of a song. */
+export declare const TAG_MAX_LENGTH = 1000;
+
+/**
+ * Token
+ */
+export declare type Token = {
+    /**
+     * Scopes
+     */
+    scopes: Array<OAuth2Scope>;
+    /**
+     * Access Token
+     */
+    access_token: string;
+    /**
+     * Token Type
+     */
+    token_type: "bearer";
+};
+
+/**
+ * Token
+ */
+export declare const TokenSchema: z.ZodObject<{
+    scopes: z.ZodArray<z.ZodEnum<{
+        profile: "profile";
+        "library:read": "library:read";
+        "library:write": "library:write";
+        admin: "admin";
+    }>>;
+    access_token: z.ZodString;
+    token_type: z.ZodLiteral<"bearer">;
+}, z.core.$strip>;
+
+export declare type UninstallExtensionExtensionsInstalledExtensionIdDeleteData = {
+    body?: never;
+    path: {
+        /**
+         * Extension Id
+         */
+        extension_id: number;
+    };
+    query?: never;
+    url: "/extensions/installed/{extension_id}";
+};
+
+export declare type UninstallExtensionExtensionsInstalledExtensionIdDeleteError = UninstallExtensionExtensionsInstalledExtensionIdDeleteErrors[keyof UninstallExtensionExtensionsInstalledExtensionIdDeleteErrors];
+
+export declare type UninstallExtensionExtensionsInstalledExtensionIdDeleteErrors = {
+    /**
+     * Validation Error
+     */
+    422: HttpValidationError;
+};
+
+export declare type UninstallExtensionExtensionsInstalledExtensionIdDeleteResponse = UninstallExtensionExtensionsInstalledExtensionIdDeleteResponses[keyof UninstallExtensionExtensionsInstalledExtensionIdDeleteResponses];
+
+export declare type UninstallExtensionExtensionsInstalledExtensionIdDeleteResponses = {
+    /**
+     * Successful Response
+     */
+    200: OperationResult;
+};
+
+export declare type UpdateArtworkArtworksArtworkIdPatchData = {
+    body: ArtworkUpdate;
+    path: {
+        /**
+         * Artwork Id
+         */
+        artwork_id: number;
+    };
+    query?: never;
+    url: "/artworks/{artwork_id}";
+};
+
+export declare type UpdateArtworkArtworksArtworkIdPatchError = UpdateArtworkArtworksArtworkIdPatchErrors[keyof UpdateArtworkArtworksArtworkIdPatchErrors];
+
+export declare type UpdateArtworkArtworksArtworkIdPatchErrors = {
+    /**
+     * Validation Error
+     */
+    422: HttpValidationError;
+};
+
+export declare type UpdateArtworkArtworksArtworkIdPatchResponse = UpdateArtworkArtworksArtworkIdPatchResponses[keyof UpdateArtworkArtworksArtworkIdPatchResponses];
+
+export declare type UpdateArtworkArtworksArtworkIdPatchResponses = {
+    /**
+     * Successful Response
+     */
+    200: ArtworkRead;
+};
+
+export declare type UpdateExtensionExtensionsAvailableExtensionIdUpdatePostData = {
+    body?: never;
+    path: {
+        /**
+         * Extension Id
+         */
+        extension_id: number;
+    };
+    query?: never;
+    url: "/extensions/available/{extension_id}/update";
+};
+
+export declare type UpdateExtensionExtensionsAvailableExtensionIdUpdatePostError = UpdateExtensionExtensionsAvailableExtensionIdUpdatePostErrors[keyof UpdateExtensionExtensionsAvailableExtensionIdUpdatePostErrors];
+
+export declare type UpdateExtensionExtensionsAvailableExtensionIdUpdatePostErrors = {
+    /**
+     * Validation Error
+     */
+    422: HttpValidationError;
+};
+
+export declare type UpdateExtensionExtensionsAvailableExtensionIdUpdatePostResponse = UpdateExtensionExtensionsAvailableExtensionIdUpdatePostResponses[keyof UpdateExtensionExtensionsAvailableExtensionIdUpdatePostResponses];
+
+export declare type UpdateExtensionExtensionsAvailableExtensionIdUpdatePostResponses = {
+    /**
+     * Successful Response
+     */
+    200: OperationResult;
+};
+
+export declare type UpdateLibraryAlbumLibrariesLibraryIdAlbumsAlbumIdPatchData = {
+    body: AlbumUpdate;
+    path: {
+        /**
+         * Library Id
+         */
+        library_id: number;
+        /**
+         * Album Id
+         */
+        album_id: number;
+    };
+    query?: never;
+    url: "/libraries/{library_id}/albums/{album_id}";
+};
+
+export declare type UpdateLibraryAlbumLibrariesLibraryIdAlbumsAlbumIdPatchError = UpdateLibraryAlbumLibrariesLibraryIdAlbumsAlbumIdPatchErrors[keyof UpdateLibraryAlbumLibrariesLibraryIdAlbumsAlbumIdPatchErrors];
+
+export declare type UpdateLibraryAlbumLibrariesLibraryIdAlbumsAlbumIdPatchErrors = {
+    /**
+     * Validation Error
+     */
+    422: HttpValidationError;
+};
+
+export declare type UpdateLibraryAlbumLibrariesLibraryIdAlbumsAlbumIdPatchResponse = UpdateLibraryAlbumLibrariesLibraryIdAlbumsAlbumIdPatchResponses[keyof UpdateLibraryAlbumLibrariesLibraryIdAlbumsAlbumIdPatchResponses];
+
+export declare type UpdateLibraryAlbumLibrariesLibraryIdAlbumsAlbumIdPatchResponses = {
+    /**
+     * Successful Response
+     */
+    200: AlbumRead;
+};
+
+export declare type UpdateLibraryArtistLibrariesLibraryIdArtistsArtistIdPatchData = {
+    body: ArtistUpdate;
+    path: {
+        /**
+         * Library Id
+         */
+        library_id: number;
+        /**
+         * Artist Id
+         */
+        artist_id: number;
+    };
+    query?: never;
+    url: "/libraries/{library_id}/artists/{artist_id}";
+};
+
+export declare type UpdateLibraryArtistLibrariesLibraryIdArtistsArtistIdPatchError = UpdateLibraryArtistLibrariesLibraryIdArtistsArtistIdPatchErrors[keyof UpdateLibraryArtistLibrariesLibraryIdArtistsArtistIdPatchErrors];
+
+export declare type UpdateLibraryArtistLibrariesLibraryIdArtistsArtistIdPatchErrors = {
+    /**
+     * Validation Error
+     */
+    422: HttpValidationError;
+};
+
+export declare type UpdateLibraryArtistLibrariesLibraryIdArtistsArtistIdPatchResponse = UpdateLibraryArtistLibrariesLibraryIdArtistsArtistIdPatchResponses[keyof UpdateLibraryArtistLibrariesLibraryIdArtistsArtistIdPatchResponses];
+
+export declare type UpdateLibraryArtistLibrariesLibraryIdArtistsArtistIdPatchResponses = {
+    /**
+     * Successful Response
+     */
+    200: ArtistRead;
+};
+
+export declare type UpdateLibraryLibrariesLibraryIdPatchData = {
+    body: LibraryUpdate;
+    path: {
+        /**
+         * Library Id
+         */
+        library_id: number;
+    };
+    query?: never;
+    url: "/libraries/{library_id}";
+};
+
+export declare type UpdateLibraryLibrariesLibraryIdPatchError = UpdateLibraryLibrariesLibraryIdPatchErrors[keyof UpdateLibraryLibrariesLibraryIdPatchErrors];
+
+export declare type UpdateLibraryLibrariesLibraryIdPatchErrors = {
+    /**
+     * Validation Error
+     */
+    422: HttpValidationError;
+};
+
+export declare type UpdateLibraryLibrariesLibraryIdPatchResponse = UpdateLibraryLibrariesLibraryIdPatchResponses[keyof UpdateLibraryLibrariesLibraryIdPatchResponses];
+
+export declare type UpdateLibraryLibrariesLibraryIdPatchResponses = {
+    /**
+     * Successful Response
+     */
+    200: LibraryRead;
+};
+
+export declare type UpdateLibraryPermissionLibrariesLibraryIdPermissionUserIdPatchData = {
+    body: LibraryPermissionUpdate;
+    path: {
+        /**
+         * Library Id
+         */
+        library_id: number;
+        /**
+         * User Id
+         */
+        user_id: number;
+    };
+    query?: never;
+    url: "/libraries/{library_id}/permission/{user_id}";
+};
+
+export declare type UpdateLibraryPermissionLibrariesLibraryIdPermissionUserIdPatchError = UpdateLibraryPermissionLibrariesLibraryIdPermissionUserIdPatchErrors[keyof UpdateLibraryPermissionLibrariesLibraryIdPermissionUserIdPatchErrors];
+
+export declare type UpdateLibraryPermissionLibrariesLibraryIdPermissionUserIdPatchErrors = {
+    /**
+     * Validation Error
+     */
+    422: HttpValidationError;
+};
+
+export declare type UpdateLibraryPermissionLibrariesLibraryIdPermissionUserIdPatchResponse = UpdateLibraryPermissionLibrariesLibraryIdPermissionUserIdPatchResponses[keyof UpdateLibraryPermissionLibrariesLibraryIdPermissionUserIdPatchResponses];
+
+export declare type UpdateLibraryPermissionLibrariesLibraryIdPermissionUserIdPatchResponses = {
+    /**
+     * Successful Response
+     */
+    200: LibraryPermissionRead;
+};
+
+export declare type UpdateLibrarySongLibrariesLibraryIdSongsSongIdPatchData = {
+    body: SongUpdate;
+    path: {
+        /**
+         * Library Id
+         */
+        library_id: number;
+        /**
+         * Song Id
+         */
+        song_id: number;
+    };
+    query?: never;
+    url: "/libraries/{library_id}/songs/{song_id}";
+};
+
+export declare type UpdateLibrarySongLibrariesLibraryIdSongsSongIdPatchError = UpdateLibrarySongLibrariesLibraryIdSongsSongIdPatchErrors[keyof UpdateLibrarySongLibrariesLibraryIdSongsSongIdPatchErrors];
+
+export declare type UpdateLibrarySongLibrariesLibraryIdSongsSongIdPatchErrors = {
+    /**
+     * Validation Error
+     */
+    422: HttpValidationError;
+};
+
+export declare type UpdateLibrarySongLibrariesLibraryIdSongsSongIdPatchResponse = UpdateLibrarySongLibrariesLibraryIdSongsSongIdPatchResponses[keyof UpdateLibrarySongLibrariesLibraryIdSongsSongIdPatchResponses];
+
+export declare type UpdateLibrarySongLibrariesLibraryIdSongsSongIdPatchResponses = {
+    /**
+     * Successful Response
+     */
+    200: SongRead;
+};
+
+export declare type UpdateMeUsersMePostData = {
+    body: UserProfileMeUpdate;
+    path?: never;
+    query?: never;
+    url: "/users/me";
+};
+
+export declare type UpdateMeUsersMePostError = UpdateMeUsersMePostErrors[keyof UpdateMeUsersMePostErrors];
+
+export declare type UpdateMeUsersMePostErrors = {
+    /**
+     * Validation Error
+     */
+    422: HttpValidationError;
+};
+
+export declare type UpdateMeUsersMePostResponse = UpdateMeUsersMePostResponses[keyof UpdateMeUsersMePostResponses];
+
+export declare type UpdateMeUsersMePostResponses = {
+    /**
+     * Successful Response
+     */
+    200: UserProfileMeRead;
+};
+
+export declare type UpdateNotificationUsersNotificationsNotificationIdPatchData = {
+    body: NotificationUpdate;
+    path: {
+        /**
+         * Notification Id
+         */
+        notification_id: number;
+    };
+    query?: never;
+    url: "/users/notifications/{notification_id}";
+};
+
+export declare type UpdateNotificationUsersNotificationsNotificationIdPatchError = UpdateNotificationUsersNotificationsNotificationIdPatchErrors[keyof UpdateNotificationUsersNotificationsNotificationIdPatchErrors];
+
+export declare type UpdateNotificationUsersNotificationsNotificationIdPatchErrors = {
+    /**
+     * Validation Error
+     */
+    422: HttpValidationError;
+};
+
+export declare type UpdateNotificationUsersNotificationsNotificationIdPatchResponse = UpdateNotificationUsersNotificationsNotificationIdPatchResponses[keyof UpdateNotificationUsersNotificationsNotificationIdPatchResponses];
+
+export declare type UpdateNotificationUsersNotificationsNotificationIdPatchResponses = {
+    /**
+     * Successful Response
+     */
+    200: NotificationRead;
+};
+
+export declare type UpdateSourceSourcesSourceIdPatchData = {
+    body: SourceUpdate;
+    path: {
+        /**
+         * Source Id
+         */
+        source_id: number;
+    };
+    query?: never;
+    url: "/sources/{source_id}";
+};
+
+export declare type UpdateSourceSourcesSourceIdPatchError = UpdateSourceSourcesSourceIdPatchErrors[keyof UpdateSourceSourcesSourceIdPatchErrors];
+
+export declare type UpdateSourceSourcesSourceIdPatchErrors = {
+    /**
+     * Validation Error
+     */
+    422: HttpValidationError;
+};
+
+export declare type UpdateSourceSourcesSourceIdPatchResponse = UpdateSourceSourcesSourceIdPatchResponses[keyof UpdateSourceSourcesSourceIdPatchResponses];
+
+export declare type UpdateSourceSourcesSourceIdPatchResponses = {
+    /**
+     * Successful Response
+     */
+    200: SourceRead;
+};
+
+export declare type UpdateUserAdminUsersAdminAllUserIdPatchData = {
+    body: UserAdminUpdate;
+    path: {
+        /**
+         * User Id
+         */
+        user_id: number;
+    };
+    query?: never;
+    url: "/users/admin/all/{user_id}";
+};
+
+export declare type UpdateUserAdminUsersAdminAllUserIdPatchError = UpdateUserAdminUsersAdminAllUserIdPatchErrors[keyof UpdateUserAdminUsersAdminAllUserIdPatchErrors];
+
+export declare type UpdateUserAdminUsersAdminAllUserIdPatchErrors = {
+    /**
+     * Validation Error
+     */
+    422: HttpValidationError;
+};
+
+export declare type UpdateUserAdminUsersAdminAllUserIdPatchResponse = UpdateUserAdminUsersAdminAllUserIdPatchResponses[keyof UpdateUserAdminUsersAdminAllUserIdPatchResponses];
+
+export declare type UpdateUserAdminUsersAdminAllUserIdPatchResponses = {
+    /**
+     * Successful Response
+     */
+    200: UserAdminRead;
+};
+
+/** The maximum length of a URL. */
+export declare const URL_MAX_LENGTH = 8000;
+
+/**
+ * UserAdminRead
+ */
+export declare type UserAdminRead = {
+    /**
+     * Id
+     */
+    id: number;
+    /**
+     * Username
+     */
+    username: string;
+    /**
+     * Preferred Name
+     */
+    preferred_name: string | null;
+    /**
+     * Scopes
+     */
+    scopes: Array<OAuth2Scope>;
+};
+
+/**
+ * UserAdminRead
+ */
+export declare const UserAdminReadSchema: z.ZodObject<{
+    id: z.ZodInt;
+    username: z.ZodString;
+    preferred_name: z.ZodNullable<z.ZodString>;
+    scopes: z.ZodArray<z.ZodEnum<{
+        profile: "profile";
+        "library:read": "library:read";
+        "library:write": "library:write";
+        admin: "admin";
+    }>>;
+}, z.core.$strip>;
+
+/**
+ * UserAdminsRead
+ */
+export declare type UserAdminsRead = {
+    /**
+     * Users
+     */
+    users: Array<UserAdminRead>;
+    /**
+     * Offset
+     */
+    offset: number;
+    /**
+     * Limit
+     */
+    limit: number;
+    /**
+     * Total
+     */
+    total: number;
+};
+
+/**
+ * UserAdminsRead
+ */
+export declare const UserAdminsReadSchema: z.ZodObject<{
+    users: z.ZodArray<z.ZodObject<{
+        id: z.ZodInt;
+        username: z.ZodString;
+        preferred_name: z.ZodNullable<z.ZodString>;
+        scopes: z.ZodArray<z.ZodEnum<{
+            profile: "profile";
+            "library:read": "library:read";
+            "library:write": "library:write";
+            admin: "admin";
+        }>>;
+    }, z.core.$strip>>;
+    offset: z.ZodInt;
+    limit: z.ZodInt;
+    total: z.ZodInt;
+}, z.core.$strip>;
+
+/**
+ * UserAdminUpdate
+ */
+export declare type UserAdminUpdate = {
+    /**
+     * Preferred Name
+     */
+    preferred_name?: string | null;
+    /**
+     * Scopes
+     *
+     * The complete set of scopes to grant the user
+     */
+    scopes?: Array<OAuth2Scope> | null;
+};
+
+/**
+ * UserAdminUpdate
+ */
+export declare const UserAdminUpdateSchema: z.ZodObject<{
+    preferred_name: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    scopes: z.ZodOptional<z.ZodNullable<z.ZodArray<z.ZodEnum<{
+        profile: "profile";
+        "library:read": "library:read";
+        "library:write": "library:write";
+        admin: "admin";
+    }>>>>;
+}, z.core.$strip>;
+
+export declare type UserEvent = {
+    event_type: "notifications_changed" | "libraries_changed" | "extensions_changed";
+    ids: readonly number[];
+};
+
+/**
+ * UserEventPreflight
+ */
+export declare type UserEventPreflight = {
+    /**
+     * Token
+     */
+    token: string;
+};
+
+/**
+ * UserEventPreflight
+ */
+export declare const UserEventPreflightSchema: z.ZodObject<{
+    token: z.ZodString;
+}, z.core.$strip>;
+
+export declare class UserEventsManager {
+    private readonly baseUrl;
+    private readonly client;
+    private readonly userSessionManager;
+    private readonly subscribers;
+    private state;
+    constructor(baseUrl: string, client: APIClient, userSessionManager: UserSessionManager);
+    _syncWithUserSession(): Promise<void>;
+    _connect(): Promise<void>;
+    _disconnect(): void;
+    private _onOpen;
+    private _onError;
+    private _onMessage;
+    private _onClose;
+    subscribe(subscriber: (userEvent: UserEvent) => void): () => void;
+}
+
+/**
+ * UserFileAccessPreflight
+ */
+export declare type UserFileAccessPreflight = {
+    /**
+     * Token
+     */
+    token: string;
+    /**
+     * Expires At
+     */
+    expires_at: string;
+};
+
+/**
+ * UserFileAccessPreflight
+ */
+export declare const UserFileAccessPreflightSchema: z.ZodObject<{
+    token: z.ZodString;
+    expires_at: z.ZodISODateTime;
+}, z.core.$strip>;
+
+/**
+ * UserProfileMeRead
+ */
+export declare type UserProfileMeRead = {
+    /**
+     * Id
+     */
+    id: number;
+    /**
+     * Username
+     */
+    username: string;
+    /**
+     * Preferred Name
+     */
+    preferred_name: string | null;
+    /**
+     * Email
+     */
+    email: string | null;
+    /**
+     * Is Email Verified
+     */
+    is_email_verified: boolean;
+    /**
+     * Enable Playback Events
+     */
+    enable_playback_events: boolean;
+};
+
+/**
+ * UserProfileMeRead
+ */
+export declare const UserProfileMeReadSchema: z.ZodObject<{
+    id: z.ZodInt;
+    username: z.ZodString;
+    preferred_name: z.ZodNullable<z.ZodString>;
+    email: z.ZodNullable<z.ZodString>;
+    is_email_verified: z.ZodBoolean;
+    enable_playback_events: z.ZodBoolean;
+}, z.core.$strip>;
+
+/**
+ * UserProfileMeUpdate
+ */
+export declare type UserProfileMeUpdate = {
+    /**
+     * Email
+     */
+    email: string | null;
+    /**
+     * Preferred Name
+     */
+    preferred_name: string | null;
+    /**
+     * Enable Playback Events
+     */
+    enable_playback_events: boolean;
+};
+
+/**
+ * UserProfileMeUpdate
+ */
+export declare const UserProfileMeUpdateSchema: z.ZodObject<{
+    email: z.ZodNullable<z.ZodEmail>;
+    preferred_name: z.ZodNullable<z.ZodString>;
+    enable_playback_events: z.ZodBoolean;
+}, z.core.$strip>;
+
+/**
+ * UserProfileRead
+ */
+export declare type UserProfileRead = {
+    /**
+     * Id
+     */
+    id: number;
+    /**
+     * Username
+     */
+    username: string;
+    /**
+     * Preferred Name
+     */
+    preferred_name: string | null;
+};
+
+/**
+ * UserProfileRead
+ */
+export declare const UserProfileReadSchema: z.ZodObject<{
+    id: z.ZodInt;
+    username: z.ZodString;
+    preferred_name: z.ZodNullable<z.ZodString>;
+}, z.core.$strip>;
+
+/**
+ * UserProfilesRead
+ */
+export declare type UserProfilesRead = {
+    /**
+     * Users
+     */
+    users: Array<UserProfileRead>;
+    /**
+     * Offset
+     */
+    offset: number;
+    /**
+     * Limit
+     */
+    limit: number;
+    /**
+     * Total
+     */
+    total: number;
+};
+
+/**
+ * UserProfilesRead
+ */
+export declare const UserProfilesReadSchema: z.ZodObject<{
+    users: z.ZodArray<z.ZodObject<{
+        id: z.ZodInt;
+        username: z.ZodString;
+        preferred_name: z.ZodNullable<z.ZodString>;
+    }, z.core.$strip>>;
+    offset: z.ZodInt;
+    limit: z.ZodInt;
+    total: z.ZodInt;
+}, z.core.$strip>;
+
+export declare interface UserSession {
+    readonly accessToken: string;
+    readonly scopes: readonly OAuth2Scope[];
+}
+
+export declare interface UserSessionManager {
+    readonly session: UserSession | null;
+    readonly isSignedIn: boolean;
+    replaceSession(newSession: UserSession | null): void;
+    hasScope(scope: OAuth2Scope): boolean;
+    subscribe(subscriber: (event: UserSessionManagerEvent) => void): () => void;
+}
+
+export declare type UserSessionManagerEvent = {
+    type: "currentChanged";
+};
+
+/**
+ * ValidationError
+ */
+export declare type ValidationError = {
+    /**
+     * Location
+     */
+    loc: Array<string | number>;
+    /**
+     * Message
+     */
+    msg: string;
+    /**
+     * Error Type
+     */
+    type: string;
+    /**
+     * Input
+     */
+    input?: unknown;
+    /**
+     * Context
+     */
+    ctx?: {
+        [key: string]: unknown;
+    };
+};
+
+/**
+ * ValidationError
+ */
+export declare const ValidationErrorSchema: z.ZodObject<{
+    loc: z.ZodArray<z.ZodUnion<readonly [z.ZodString, z.ZodInt]>>;
+    msg: z.ZodString;
+    type: z.ZodString;
+    input: z.ZodOptional<z.ZodUnknown>;
+    ctx: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+}, z.core.$strip>;
+
+export declare type VerifyEmailVerifyEmailPostData = {
+    body?: never;
+    path?: never;
+    query: {
+        /**
+         * Token
+         *
+         * A feature token
+         */
+        token: string;
+    };
+    url: "/verify-email";
+};
+
+export declare type VerifyEmailVerifyEmailPostError = VerifyEmailVerifyEmailPostErrors[keyof VerifyEmailVerifyEmailPostErrors];
+
+export declare type VerifyEmailVerifyEmailPostErrors = {
+    /**
+     * Validation Error
+     */
+    422: HttpValidationError;
+};
+
+export declare type VerifyEmailVerifyEmailPostResponse = VerifyEmailVerifyEmailPostResponses[keyof VerifyEmailVerifyEmailPostResponses];
+
+export declare type VerifyEmailVerifyEmailPostResponses = {
+    /**
+     * Successful Response
+     */
+    200: OperationResult;
+};
+
+export { }