@freqhole/api-client 0.1.30

package/src/automerge/index.ts

@@ -0,0 +1,14 @@
+// automerge transport layer - iroh QUIC network adapter for automerge-repo.
+//
+// re-exports everything needed by consuming packages.
+export {
+  IrohNetworkAdapter,
+  SYNC_ALPN,
+} from "./IrohNetworkAdapter.js";
+
+export type {
+  BiStreamLike,
+  MiddenStreamNode,
+  ConnectionSummary,
+  IrohNetworkAdapterOptions,
+} from "./IrohNetworkAdapter.js";

package/src/codegen/admin_commands.ts

@@ -0,0 +1,61 @@
+// generated freqhole-admin/1 ALPN command map
+//
+// do not edit by hand: regenerate with `cd client-codegen && make all`.
+import * as s from './schema';
+import { z } from 'zod';
+
+export type AdminAuthType = 'admin';
+
+export type AdminAuth = { type: AdminAuthType };
+
+export const adminCommands = {
+  invites_generate: { req: s.AdminInvitesGenerateRequestSchema, resp: s.AdminInvitesGenerateResponseSchema, auth: { type: 'admin' } as const },
+  invites_list: { req: s.AdminInvitesListRequestSchema, resp: s.AdminInviteInfoSchema.array(), auth: { type: 'admin' } as const },
+  invites_revoke: { req: s.AdminInvitesRevokeRequestSchema, resp: z.unknown().optional(), auth: { type: 'admin' } as const },
+  invites_revoke_all: { req: z.void().optional(), resp: s.AdminInvitesRevokeAllResponseSchema, auth: { type: 'admin' } as const },
+  invites_update_role: { req: s.AdminInvitesUpdateRoleRequestSchema, resp: z.unknown().optional(), auth: { type: 'admin' } as const },
+  knocks_accept: { req: s.KnocksAcceptRequestSchema, resp: s.KnockRequestSchema, auth: { type: 'admin' } as const },
+  knocks_delete: { req: s.KnocksDeleteRequestSchema, resp: z.unknown().optional(), auth: { type: 'admin' } as const },
+  knocks_list: { req: z.void().optional(), resp: s.KnockRequestSchema.array(), auth: { type: 'admin' } as const },
+  knocks_list_all: { req: z.void().optional(), resp: s.KnockRequestSchema.array(), auth: { type: 'admin' } as const },
+  knocks_reject: { req: s.KnocksRejectRequestSchema, resp: s.KnockRequestSchema, auth: { type: 'admin' } as const },
+  knocks_reject_all: { req: z.void().optional(), resp: s.KnocksRejectAllResponseSchema, auth: { type: 'admin' } as const },
+  peers_allow: { req: s.AdminPeersAllowRequestSchema, resp: s.AdminPeersAllowResponseSchema, auth: { type: 'admin' } as const },
+  peers_hard_delete: { req: s.AdminPeersHardDeleteRequestSchema, resp: s.AdminPeersHardDeleteResponseSchema, auth: { type: 'admin' } as const },
+  peers_list_all: { req: s.AdminPeersListAllRequestSchema, resp: s.AdminPeerSummarySchema.array(), auth: { type: 'admin' } as const },
+  peers_list_for_user: { req: s.AdminPeersListForUserRequestSchema, resp: s.AdminPeerNodeSummarySchema.array(), auth: { type: 'admin' } as const },
+  peers_reassign_user: { req: s.AdminPeersReassignUserRequestSchema, resp: z.unknown().optional(), auth: { type: 'admin' } as const },
+  peers_remove: { req: s.AdminPeersRemoveRequestSchema, resp: z.unknown().optional(), auth: { type: 'admin' } as const },
+  peers_restore: { req: s.AdminPeersRestoreRequestSchema, resp: z.unknown().optional(), auth: { type: 'admin' } as const },
+  radio_bumpers_add: { req: s.RadioBumpersAddRequestSchema, resp: s.RadioBumperSchema, auth: { type: 'admin' } as const },
+  radio_bumpers_list: { req: s.RadioBumpersListRequestSchema, resp: s.RadioBumperSchema.array(), auth: { type: 'admin' } as const },
+  radio_bumpers_remove: { req: s.RadioBumpersRemoveRequestSchema, resp: z.unknown().optional(), auth: { type: 'admin' } as const },
+  radio_bumpers_set_frequency: { req: s.RadioBumpersSetFrequencyRequestSchema, resp: z.unknown().optional(), auth: { type: 'admin' } as const },
+  radio_config_get: { req: z.void().optional(), resp: s.RadioConfigPayloadSchema, auth: { type: 'admin' } as const },
+  radio_config_set: { req: s.RadioConfigPayloadSchema, resp: s.RadioConfigPayloadSchema, auth: { type: 'admin' } as const },
+  radio_filters_add: { req: s.RadioFiltersAddRequestSchema, resp: s.StationFilterSchema, auth: { type: 'admin' } as const },
+  radio_filters_list: { req: s.RadioStationByStationIdRequestSchema, resp: s.StationFilterSchema.array(), auth: { type: 'admin' } as const },
+  radio_filters_remove: { req: s.RadioFiltersRemoveRequestSchema, resp: z.unknown().optional(), auth: { type: 'admin' } as const },
+  radio_seed_suggest: { req: s.RadioSeedSuggestRequestSchema, resp: s.RadioSeedSuggestionSchema.array(), auth: { type: 'admin' } as const },
+  radio_stations_create: { req: s.CreateStationRequestSchema, resp: s.RadioStationSchema, auth: { type: 'admin' } as const },
+  radio_stations_delete: { req: s.RadioStationsByIdRequestSchema, resp: z.unknown().optional(), auth: { type: 'admin' } as const },
+  radio_stations_get: { req: s.RadioStationsByIdRequestSchema, resp: s.RadioStationSchema, auth: { type: 'admin' } as const },
+  radio_stations_list: { req: z.void().optional(), resp: s.RadioStationSchema.array(), auth: { type: 'admin' } as const },
+  radio_stations_update: { req: s.UpdateStationRequestSchema, resp: s.RadioStationSchema, auth: { type: 'admin' } as const },
+  radio_supervisor_restart: { req: s.RadioSupervisorStationRequestSchema, resp: s.RadioSupervisorStatusResponseSchema, auth: { type: 'admin' } as const },
+  radio_supervisor_skip_track: { req: s.RadioSupervisorStationRequestSchema, resp: s.RadioSupervisorStatusResponseSchema, auth: { type: 'admin' } as const },
+  radio_supervisor_start: { req: s.RadioSupervisorStationRequestSchema, resp: s.RadioSupervisorStatusResponseSchema, auth: { type: 'admin' } as const },
+  radio_supervisor_status: { req: z.void().optional(), resp: s.RadioSupervisorStatusResponseSchema, auth: { type: 'admin' } as const },
+  radio_supervisor_stop: { req: s.RadioSupervisorStationRequestSchema, resp: s.RadioSupervisorStatusResponseSchema, auth: { type: 'admin' } as const },
+  users_add_peer_node: { req: s.AdminUsersAddPeerNodeRequestSchema, resp: s.AdminPeerNodeSummarySchema, auth: { type: 'admin' } as const },
+  users_delete: { req: s.AdminUsersDeleteRequestSchema, resp: z.unknown().optional(), auth: { type: 'admin' } as const },
+  users_generate_account_link: { req: s.AdminUsersGenerateAccountLinkRequestSchema, resp: s.AdminAccountLinkResponseSchema, auth: { type: 'admin' } as const },
+  users_get: { req: s.AdminUsersGetRequestSchema, resp: s.AdminUserSummarySchema, auth: { type: 'admin' } as const },
+  users_hard_delete: { req: s.AdminUsersHardDeleteRequestSchema, resp: z.unknown().optional(), auth: { type: 'admin' } as const },
+  users_list: { req: s.AdminUsersListRequestSchema, resp: s.AdminUserSummarySchema.array(), auth: { type: 'admin' } as const },
+  users_remove_peer_node: { req: s.AdminUsersRemovePeerNodeRequestSchema, resp: z.unknown().optional(), auth: { type: 'admin' } as const },
+  users_restore: { req: s.AdminUsersRestoreRequestSchema, resp: s.AdminUserSummarySchema, auth: { type: 'admin' } as const },
+  users_update_role: { req: s.AdminUsersUpdateRoleRequestSchema, resp: z.unknown().optional(), auth: { type: 'admin' } as const },
+} as const;
+
+export type AdminCommandName = keyof typeof adminCommands;

package/src/codegen/routes.ts

@@ -0,0 +1,213 @@
+// generated route config
+import * as s from './schema';
+import { z } from 'zod';
+
+// role hierarchy - lower number = higher privilege
+export const roleHierarchy = {
+  root: 0,
+  admin: 10,
+  member: 20,
+  viewer: 30,
+} as const;
+
+export type UserRoleName = keyof typeof roleHierarchy;
+export type RouteAuthType = 'public' | 'authenticated' | 'role' | 'owner' | 'owner_or';
+export type RouteAuth =
+  | { type: 'public' }
+  | { type: 'authenticated' }
+  | { type: 'role'; role: UserRoleName }
+  | { type: 'owner' }
+  | { type: 'owner_or'; role: UserRoleName };
+
+export const routes = {
+  admin: {
+    accept_knock: { method: 'POST', path: '/api/admin/knocks/accept', req: s.AcceptKnockRequestSchema, resp: s.KnockRequestSchema, auth: { type: 'role', role: 'admin' } as const },
+    create_knock_public: { method: 'POST', path: '/api/knock', req: s.CreateKnockRequestSchema, resp: s.KnockRequestSchema, auth: { type: 'public' } as const },
+    delete_knock: { method: 'POST', path: '/api/admin/knocks/delete', req: s.DeleteKnockRequestSchema, resp: s.EmptyResponseSchema, auth: { type: 'role', role: 'admin' } as const },
+    device_linked_callback: { method: 'POST', path: '/api/internal/device-linked', req: s.DeviceLinkedCallbackRequestSchema, resp: s.EmptyResponseSchema, auth: { type: 'public' } as const },
+    get_knock: { method: 'POST', path: '/api/admin/knocks/get', req: s.GetKnockRequestSchema, resp: s.KnockRequestSchema, auth: { type: 'role', role: 'admin' } as const },
+    get_knock_status_public: { method: 'GET', path: '/api/knock/status', req: null, resp: s.KnockStatusResponseSchema, auth: { type: 'public' } as const },
+    knock_accepted_callback: { method: 'POST', path: '/api/internal/knock-accepted', req: s.KnockAcceptedCallbackRequestSchema, resp: s.EmptyResponseSchema, auth: { type: 'public' } as const },
+    list_all_knocks: { method: 'GET', path: '/api/admin/knocks/all', req: null, resp: s.KnockRequestSchema.array(), auth: { type: 'role', role: 'admin' } as const },
+    list_knocks: { method: 'GET', path: '/api/admin/knocks', req: null, resp: s.KnockRequestSchema.array(), auth: { type: 'role', role: 'admin' } as const },
+    reject_knock: { method: 'POST', path: '/api/admin/knocks/reject', req: s.RejectKnockRequestSchema, resp: s.KnockRequestSchema, auth: { type: 'role', role: 'admin' } as const },
+  },
+  app: {
+    health_check: { method: 'GET', path: '/health', req: null, resp: s.HealthResponseSchema, auth: { type: 'public' } as const },
+    radio_info: { method: 'GET', path: '/api/radio/info', req: null, resp: s.RadioInfoResponseSchema, auth: { type: 'public' } as const },
+    radio_public_blob: { method: 'GET', path: '/api/radio/stations/{station_id}/blobs/{blob_id}', req: null, resp: null, auth: { type: 'public' } as const },
+    radio_public_blob_data: { method: 'GET', path: '/api/radio/stations/{station_id}/blobs/{blob_id}/data', req: null, resp: null, auth: { type: 'public' } as const },
+    radio_public_blob_thumbnail: { method: 'GET', path: '/api/radio/stations/{station_id}/blobs/{blob_id}/thumb/{size}', req: null, resp: null, auth: { type: 'public' } as const },
+    radio_public_timeline: { method: 'GET', path: '/api/radio/stations/{station_id}/timeline', req: null, resp: s.PublicTimelineManifestSchema, auth: { type: 'public' } as const },
+    radio_stations: { method: 'GET', path: '/api/radio/stations', req: null, resp: s.RadioStationsResponseSchema, auth: { type: 'public' } as const },
+    server_info: { method: 'GET', path: '/api/hello', req: null, resp: s.ServerInfoResponseSchema, auth: { type: 'public' } as const },
+  },
+  auth: {
+    api_key_status: { method: 'GET', path: '/api/auth/api-key/status', req: null, resp: s.ApiKeyStatusResponseSchema, auth: { type: 'authenticated' } as const },
+    delete_passkey: { method: 'POST', path: '/api/auth/webauthn/passkeys/delete', req: s.DeletePasskeyRequestSchema, resp: z.any(), auth: { type: 'owner' } as const },
+    generate_self_account_link: { method: 'POST', path: '/api/auth/profile/generate-invite', req: null, resp: s.SelfAccountLinkResponseSchema, auth: { type: 'authenticated' } as const },
+    link_node: { method: 'POST', path: '/api/auth/webauthn/link-node', req: s.LinkNodeRequestSchema, resp: z.any(), auth: { type: 'owner' } as const },
+    list_own_invites: { method: 'GET', path: '/api/auth/profile/invites', req: null, resp: s.SelfAccountLinkResponseSchema.array(), auth: { type: 'authenticated' } as const },
+    list_passkeys: { method: 'GET', path: '/api/auth/webauthn/passkeys', req: null, resp: s.PasskeyCredentialSummarySchema.array(), auth: { type: 'owner' } as const },
+    login_finish: { method: 'POST', path: '/api/auth/webauthn/login/finish', req: z.any(), resp: z.any(), auth: { type: 'public' } as const },
+    login_start: { method: 'POST', path: '/api/auth/webauthn/login/start', req: s.StartLoginRequestSchema, resp: z.any(), auth: { type: 'public' } as const },
+    logout: { method: 'POST', path: '/api/auth/logout', req: null, resp: z.any(), auth: { type: 'authenticated' } as const },
+    redeem_invite: { method: 'POST', path: '/api/auth/invite', req: s.RedeemInviteRequestSchema, resp: z.any(), auth: { type: 'public' } as const },
+    regenerate_api_key: { method: 'POST', path: '/api/auth/api-key/regenerate', req: null, resp: s.ApiKeyRegenerateResponseSchema, auth: { type: 'authenticated' } as const },
+    register_finish: { method: 'POST', path: '/api/auth/webauthn/register/finish', req: z.any(), resp: z.any(), auth: { type: 'public' } as const },
+    register_start: { method: 'POST', path: '/api/auth/webauthn/register/start', req: s.RegisterStartRequestSchema, resp: z.any(), auth: { type: 'public' } as const },
+    revoke_own_invite: { method: 'POST', path: '/api/auth/profile/invites/revoke', req: s.RevokeOwnInviteRequestSchema, resp: z.any(), auth: { type: 'authenticated' } as const },
+    update_passkey_name: { method: 'POST', path: '/api/auth/profile/passkey-name', req: s.UpdatePasskeyNameRequestSchema, resp: z.any(), auth: { type: 'authenticated' } as const },
+    update_username: { method: 'POST', path: '/api/auth/profile/update-username', req: s.UpdateUsernameRequestSchema, resp: s.WhoAmIResponseSchema, auth: { type: 'authenticated' } as const },
+    whoami: { method: 'GET', path: '/api/auth/whoami', req: null, resp: s.WhoAmIResponseSchema, auth: { type: 'authenticated' } as const },
+  },
+  music: {
+    activity_feed: { method: 'POST', path: '/api/analytics/feed', req: s.FeedRequestSchema, resp: s.FeedResponseSchema, auth: { type: 'authenticated' } as const },
+    add_album_taxon: { method: 'POST', path: '/api/taxonomy/album-links/add', req: s.AddAlbumTaxonRequestSchema, resp: s.EmptyResponseSchema, auth: { type: 'role', role: 'admin' } as const },
+    add_albums_tags: { method: 'POST', path: '/api/tags/albums/add', req: s.AddAlbumsTagsRequestSchema, resp: s.EmptyResponseSchema, auth: { type: 'role', role: 'admin' } as const },
+    add_songs_to_playlist: { method: 'POST', path: '/api/playlists/add-songs', req: s.AddSongsToPlaylistRequestSchema, resp: s.EmptyResponseSchema, auth: { type: 'owner_or', role: 'admin' } as const },
+    add_taxon_parent: { method: 'POST', path: '/api/taxonomy/parents/add', req: s.AddTaxonParentRequestSchema, resp: s.EmptyResponseSchema, auth: { type: 'role', role: 'admin' } as const },
+    album_pending: { method: 'POST', path: '/api/music/import/album-pending', req: s.AlbumPendingRequestSchema, resp: s.AlbumPendingResponseSchema, auth: { type: 'authenticated' } as const },
+    albums_by_value: { method: 'POST', path: '/api/music/relations/albums-by-value', req: s.AlbumsByValueRequestSchema, resp: s.AlbumsByValueResponseSchema, auth: { type: 'authenticated' } as const },
+    apply_artist_bio: { method: 'POST', path: '/api/artists/apply-bio', req: s.ApplyArtistBioRequestSchema, resp: s.ApplyArtistBioResultSchema, auth: { type: 'role', role: 'admin' } as const },
+    apply_external_urls: { method: 'POST', path: '/api/albums/apply-external-urls', req: s.ApplyExternalUrlsRequestSchema, resp: s.ApplyExternalUrlsResultSchema, auth: { type: 'role', role: 'admin' } as const },
+    apply_related_artists: { method: 'POST', path: '/api/artists/apply-related', req: s.ApplyRelatedArtistsRequestSchema, resp: s.ApplyRelatedArtistsResultSchema, auth: { type: 'role', role: 'admin' } as const },
+    apply_taxon_proposals: { method: 'POST', path: '/api/albums/apply-taxon-proposals', req: s.ApplyTaxonProposalsRequestSchema, resp: s.ApplyTaxonProposalsResultSchema, auth: { type: 'role', role: 'admin' } as const },
+    auto_confirm_mb_matches: { method: 'POST', path: '/api/albums/mb-auto-confirm', req: s.AutoConfirmMbMatchesRequestSchema, resp: s.AutoConfirmMbMatchesResultSchema, auth: { type: 'role', role: 'admin' } as const },
+    blob_metadata: { method: 'POST', path: '/api/blob_metadata', req: s.GetBlobMetadataRequestSchema, resp: s.BlobMetadataResponseSchema, auth: { type: 'authenticated' } as const },
+    blob_metadata_by_blake3: { method: 'POST', path: '/api/blob_metadata_by_blake3', req: s.GetBlobMetadataByBlake3RequestSchema, resp: s.BlobMetadataResponseSchema, auth: { type: 'authenticated' } as const },
+    build_atlas: { method: 'POST', path: '/api/blobs/atlas', req: s.BuildAtlasRequestSchema, resp: s.AtlasManifestSchema, auth: { type: 'authenticated' } as const },
+    bulk_clear_song_artwork: { method: 'POST', path: '/api/songs/bulk-clear-artwork', req: s.BulkClearSongArtworkRequestSchema, resp: s.BulkClearSongArtworkResponseSchema, auth: { type: 'role', role: 'admin' } as const },
+    bulk_delete_songs: { method: 'POST', path: '/api/songs/bulk-delete', req: s.BulkDeleteSongsRequestSchema, resp: s.BulkDeleteSongsResponseSchema, auth: { type: 'role', role: 'admin' } as const },
+    cancel_bulk_enrichment: { method: 'POST', path: '/api/music/albums/enrichment/cancel', req: s.CancelBulkEnrichmentRequestSchema, resp: s.CancelBulkEnrichmentResponseSchema, auth: { type: 'role', role: 'admin' } as const },
+    cancel_job: { method: 'POST', path: '/api/jobs/cancel', req: s.CancelJobRequestSchema, resp: s.EmptyResponseSchema, auth: { type: 'authenticated' } as const },
+    confirm_mb_match: { method: 'POST', path: '/api/albums/mb-confirm', req: s.ConfirmMbMatchRequestSchema, resp: s.MbMatchActionResponseSchema, auth: { type: 'role', role: 'admin' } as const },
+    create_artist: { method: 'POST', path: '/api/music/artists', req: s.CreateArtistRequestSchema, resp: s.ArtistSchema, auth: { type: 'role', role: 'admin' } as const },
+    create_fetch_job: { method: 'POST', path: '/api/music/fetch', req: s.FetchMediaParamsSchema, resp: s.JobResponseSchema, auth: { type: 'role', role: 'member' } as const },
+    create_listen_session: { method: 'POST', path: '/api/analytics/sessions', req: s.CreateListenSessionRequestSchema, resp: s.ListenSessionSchema, auth: { type: 'role', role: 'member' } as const },
+    create_playlist: { method: 'POST', path: '/api/music/playlists', req: s.CreatePlaylistRequestSchema, resp: s.PlaylistSchema, auth: { type: 'role', role: 'member' } as const },
+    create_precheck_fetch_job: { method: 'POST', path: '/api/music/fetch/precheck', req: s.PreCheckFetchParamsSchema, resp: s.JobResponseSchema, auth: { type: 'role', role: 'member' } as const },
+    create_taxon: { method: 'POST', path: '/api/taxonomy/taxons/create', req: s.CreateTaxonRequestSchema, resp: s.TaxonSchema, auth: { type: 'role', role: 'admin' } as const },
+    create_taxon_kind: { method: 'POST', path: '/api/taxonomy/kinds/create', req: s.CreateTaxonKindRequestSchema, resp: s.TaxonKindSchema, auth: { type: 'role', role: 'admin' } as const },
+    delete_album: { method: 'POST', path: '/api/albums/delete', req: s.DeleteAlbumRequestSchema, resp: s.DeleteAlbumResponseSchema, auth: { type: 'role', role: 'admin' } as const },
+    delete_artist: { method: 'POST', path: '/api/artists/delete', req: s.DeleteArtistRequestSchema, resp: s.DeleteArtistResponseSchema, auth: { type: 'role', role: 'admin' } as const },
+    delete_feed_event: { method: 'POST', path: '/api/analytics/feed/delete', req: s.DeleteFeedEventRequestSchema, resp: s.EmptyResponseSchema, auth: { type: 'authenticated' } as const },
+    delete_image: { method: 'POST', path: '/api/music/images/delete', req: s.DeleteImageRequestSchema, resp: s.EmptyResponseSchema, auth: { type: 'role', role: 'admin' } as const },
+    delete_listen_session: { method: 'POST', path: '/api/analytics/sessions/delete', req: s.DeleteListenSessionRequestSchema, resp: s.EmptyResponseSchema, auth: { type: 'owner_or', role: 'admin' } as const },
+    delete_playlist: { method: 'POST', path: '/api/playlists/delete', req: s.DeletePlaylistRequestSchema, resp: s.EmptyResponseSchema, auth: { type: 'owner_or', role: 'admin' } as const },
+    delete_song: { method: 'POST', path: '/api/songs/delete', req: s.DeleteSongRequestSchema, resp: s.DeleteSongResponseSchema, auth: { type: 'role', role: 'admin' } as const },
+    delete_tag: { method: 'POST', path: '/api/tags/delete', req: s.DeleteTagRequestSchema, resp: s.EmptyResponseSchema, auth: { type: 'role', role: 'admin' } as const },
+    delete_taxon: { method: 'POST', path: '/api/taxonomy/taxons/delete', req: s.DeleteTaxonRequestSchema, resp: s.EmptyResponseSchema, auth: { type: 'role', role: 'admin' } as const },
+    enqueue_audiodb_album_detail: { method: 'POST', path: '/api/music/albums/audiodb/enqueue', req: s.EnqueueAudioDbAlbumDetailRequestSchema, resp: s.EnqueueAudioDbAlbumDetailResponseSchema, auth: { type: 'role', role: 'admin' } as const },
+    enqueue_bulk_enrichment: { method: 'POST', path: '/api/music/albums/enrichment/bulk', req: s.BulkEnrichmentRequestSchema, resp: s.BulkEnrichmentResponseSchema, auth: { type: 'role', role: 'admin' } as const },
+    enqueue_lastfm_album_detail: { method: 'POST', path: '/api/music/albums/lastfm/enqueue', req: s.EnqueueLastFmAlbumDetailRequestSchema, resp: s.EnqueueLastFmAlbumDetailResponseSchema, auth: { type: 'role', role: 'admin' } as const },
+    enqueue_mb_album_search: { method: 'POST', path: '/api/music/albums/mb-search/enqueue', req: s.EnqueueMbAlbumSearchRequestSchema, resp: s.EnqueueMbAlbumSearchResponseSchema, auth: { type: 'role', role: 'admin' } as const },
+    entity_taxons_batch: { method: 'POST', path: '/api/music/entities/taxons', req: s.EntityTaxonsBatchRequestSchema, resp: s.EntityTaxonsBatchResponseSchema, auth: { type: 'authenticated' } as const },
+    era_albums: { method: 'POST', path: '/api/music/relations/era-albums', req: s.EraAlbumsRequestSchema, resp: s.EraAlbumsResponseSchema, auth: { type: 'authenticated' } as const },
+    era_bins: { method: 'POST', path: '/api/music/relations/era-bins', req: s.EraBinsRequestSchema, resp: s.EraBinsResponseSchema, auth: { type: 'authenticated' } as const },
+    events_snapshot: { method: 'POST', path: '/api/jobs/events/snapshot', req: s.EventFilterSchema, resp: s.JobStateSnapshotSchema.array(), auth: { type: 'authenticated' } as const },
+    events_subscribe: { method: 'POST', path: '/api/jobs/events/subscribe', req: s.EventFilterSchema, resp: s.JobEventSchema, auth: { type: 'authenticated' } as const },
+    find_by_merged_key: { method: 'POST', path: '/api/music/relations/by-merged-key', req: s.FindByMergedKeyRequestSchema, resp: s.FindByMergedKeyResponseSchema, auth: { type: 'authenticated' } as const },
+    get_album: { method: 'POST', path: '/api/albums/get', req: s.GetAlbumRequestSchema, resp: s.AlbumSchema, auth: { type: 'authenticated' } as const },
+    get_album_images: { method: 'POST', path: '/api/albums/images', req: s.GetAlbumRequestSchema, resp: z.string().array(), auth: { type: 'authenticated' } as const },
+    get_album_taxon_links: { method: 'POST', path: '/api/taxonomy/album-links/get', req: s.GetAlbumTaxonLinksRequestSchema, resp: s.AlbumTaxonLinkSchema.array(), auth: { type: 'authenticated' } as const },
+    get_albums_tags: { method: 'POST', path: '/api/tags/albums/get', req: s.GetAlbumsTagsRequestSchema, resp: s.TagSchema.array(), auth: { type: 'authenticated' } as const },
+    get_artist: { method: 'POST', path: '/api/artists/get', req: s.GetArtistRequestSchema, resp: s.ArtistSchema, auth: { type: 'authenticated' } as const },
+    get_artist_images: { method: 'POST', path: '/api/artists/images', req: s.GetArtistRequestSchema, resp: z.string().array(), auth: { type: 'authenticated' } as const },
+    get_blob_thumbnail: { method: 'GET', path: '/api/blobs/{id}/thumb/{size}', req: null, resp: null, auth: { type: 'authenticated' } as const },
+    get_enrichment_progress: { method: 'POST', path: '/api/music/albums/enrichment/progress', req: s.GetEnrichmentProgressRequestSchema, resp: s.GetEnrichmentProgressResponseSchema, auth: { type: 'role', role: 'admin' } as const },
+    get_fetch_job: { method: 'POST', path: '/api/music/fetch/status', req: s.GetJobRequestSchema, resp: s.JobResponseSchema, auth: { type: 'authenticated' } as const },
+    get_job_status: { method: 'POST', path: '/api/jobs/status', req: s.GetJobsStatusRequestSchema, resp: s.GetJobsStatusResponseSchema, auth: { type: 'authenticated' } as const },
+    get_listen_session: { method: 'POST', path: '/api/analytics/sessions/get', req: s.GetListenSessionRequestSchema, resp: s.ListenSessionSchema, auth: { type: 'authenticated' } as const },
+    get_musicbrainz_release: { method: 'POST', path: '/api/musicbrainz/release', req: s.GetReleaseRequestSchema, resp: s.MbReleaseDetailSchema, auth: { type: 'role', role: 'admin' } as const },
+    get_playlist_by_id: { method: 'POST', path: '/api/music/playlists/get', req: s.GetPlaylistRequestSchema, resp: s.PlaylistSchema, auth: { type: 'authenticated' } as const },
+    get_playlist_etag: { method: 'POST', path: '/api/music/playlists/etag', req: s.GetPlaylistRequestSchema, resp: s.EmptyResponseSchema, auth: { type: 'authenticated' } as const },
+    get_playlist_images: { method: 'POST', path: '/api/playlists/images', req: s.GetPlaylistRequestSchema, resp: z.string().array(), auth: { type: 'authenticated' } as const },
+    get_rating_stats: { method: 'POST', path: '/api/ratings/stats', req: s.GetRatingStatsRequestSchema, resp: s.RatingStatsSchema, auth: { type: 'authenticated' } as const },
+    get_tag: { method: 'POST', path: '/api/tags/get', req: s.GetTagRequestSchema, resp: s.TagSchema, auth: { type: 'authenticated' } as const },
+    get_taxon: { method: 'POST', path: '/api/taxonomy/taxons/get', req: s.GetTaxonRequestSchema, resp: s.TaxonSchema, auth: { type: 'authenticated' } as const },
+    get_taxon_ancestors: { method: 'POST', path: '/api/taxonomy/taxons/ancestors', req: s.GetTaxonRequestSchema, resp: s.TaxonRefSchema.array(), auth: { type: 'authenticated' } as const },
+    get_taxon_descendants: { method: 'POST', path: '/api/taxonomy/taxons/descendants', req: s.GetTaxonRequestSchema, resp: s.TaxonRefSchema.array(), auth: { type: 'authenticated' } as const },
+    has_blobs: { method: 'POST', path: '/api/blobz/has', req: s.HasBlobsRequestSchema, resp: s.HasBlobsResponseSchema, auth: { type: 'authenticated' } as const },
+    image_candidates_for_album: { method: 'POST', path: '/api/music/albums/image-candidates', req: s.AlbumImageCandidatesRequestSchema, resp: s.AlbumImageCandidatesResponseSchema, auth: { type: 'role', role: 'admin' } as const },
+    image_candidates_for_artist: { method: 'POST', path: '/api/artists/image-candidates', req: s.ArtistImageCandidatesRequestSchema, resp: s.ArtistImageCandidatesResponseSchema, auth: { type: 'role', role: 'admin' } as const },
+    ingest_remote_image: { method: 'POST', path: '/api/music/images/ingest', req: s.IngestRemoteImageRequestSchema, resp: s.IngestRemoteImageResponseSchema, auth: { type: 'role', role: 'admin' } as const },
+    list_beloved: { method: 'POST', path: '/api/favorites/beloved', req: s.ListBelovedRequestSchema, resp: s.ListBelovedResponseSchema, auth: { type: 'authenticated' } as const },
+    list_favorites: { method: 'POST', path: '/api/favorites/list', req: s.ListFavoritesRequestSchema, resp: s.ListFavoritesResponseSchema, auth: { type: 'role', role: 'member' } as const },
+    list_jobs: { method: 'POST', path: '/api/jobs/list', req: s.ListJobsRequestSchema, resp: s.JobResponseSchema.array(), auth: { type: 'authenticated' } as const },
+    list_listen_sessions: { method: 'POST', path: '/api/analytics/sessions/list', req: s.ListListenSessionsRequestSchema, resp: s.ListListenSessionsResponseSchema, auth: { type: 'authenticated' } as const },
+    list_pending_import_review: { method: 'POST', path: '/api/music/import/pending', req: s.ListPendingReviewRequestSchema, resp: s.PendingReviewSessionSchema.array(), auth: { type: 'authenticated' } as const },
+    list_playlists: { method: 'POST', path: '/api/music/playlists/list', req: s.QueryParamsSchema, resp: s.PlaylistsQueryResultSchema, auth: { type: 'authenticated' } as const },
+    list_related_artists: { method: 'POST', path: '/api/related-artists/list', req: s.ListRelatedArtistsRequestSchema, resp: s.ListRelatedArtistsResponseSchema, auth: { type: 'authenticated' } as const },
+    list_related_artists_batch: { method: 'POST', path: '/api/related-artists/list-batch', req: s.ListRelatedArtistsBatchRequestSchema, resp: s.ListRelatedArtistsBatchResponseSchema, auth: { type: 'authenticated' } as const },
+    list_tags: { method: 'GET', path: '/api/tags/list', req: null, resp: s.TagSchema.array(), auth: { type: 'authenticated' } as const },
+    list_taxon_kinds: { method: 'POST', path: '/api/taxonomy/kinds/list', req: null, resp: s.TaxonKindSchema.array(), auth: { type: 'authenticated' } as const },
+    list_taxon_parents_for_kind: { method: 'POST', path: '/api/taxonomy/parents/list-by-kind', req: s.ListTaxonParentsForKindRequestSchema, resp: s.TaxonParentEdgeSchema.array(), auth: { type: 'authenticated' } as const },
+    list_taxons_by_kind: { method: 'POST', path: '/api/taxonomy/taxons/list-by-kind', req: s.ListTaxonsByKindRequestSchema, resp: s.TaxonSchema.array(), auth: { type: 'authenticated' } as const },
+    listening_history: { method: 'POST', path: '/api/analytics/listening-history', req: s.ListeningHistoryRequestSchema, resp: s.ListeningHistoryResponseSchema, auth: { type: 'authenticated' } as const },
+    mark_album_reviewed: { method: 'POST', path: '/api/music/import/mark-reviewed', req: s.MarkAlbumReviewedRequestSchema, resp: s.ImportReviewOkSchema, auth: { type: 'authenticated' } as const },
+    merge_albums_review: { method: 'POST', path: '/api/music/import/merge-albums', req: s.MergeAlbumsReviewRequestSchema, resp: s.ImportReviewOkSchema, auth: { type: 'authenticated' } as const },
+    move_song_review: { method: 'POST', path: '/api/music/import/move-song', req: s.MoveSongReviewRequestSchema, resp: s.ImportReviewOkSchema, auth: { type: 'authenticated' } as const },
+    patch_album_review: { method: 'POST', path: '/api/music/import/patch-album', req: s.PatchAlbumReviewRequestSchema, resp: s.ImportReviewOkSchema, auth: { type: 'authenticated' } as const },
+    propose_artist_bios: { method: 'POST', path: '/api/artists/propose-bios', req: s.ProposeArtistBiosRequestSchema, resp: s.ProposeArtistBiosResponseSchema, auth: { type: 'role', role: 'admin' } as const },
+    propose_external_urls: { method: 'POST', path: '/api/albums/propose-external-urls', req: s.ProposeExternalUrlsRequestSchema, resp: s.ProposeExternalUrlsResponseSchema, auth: { type: 'role', role: 'admin' } as const },
+    propose_related_artists: { method: 'POST', path: '/api/artists/propose-related', req: s.ProposeRelatedArtistsRequestSchema, resp: s.ProposeRelatedArtistsResponseSchema, auth: { type: 'role', role: 'admin' } as const },
+    propose_taxons: { method: 'POST', path: '/api/albums/propose-taxons', req: s.ProposeTaxonsRequestSchema, resp: s.TaxonProposalSchema.array(), auth: { type: 'role', role: 'admin' } as const },
+    query_album_status_counts: { method: 'POST', path: '/api/albums/status-counts', req: s.QueryParamsSchema, resp: s.AlbumStatusCountsSchema, auth: { type: 'authenticated' } as const },
+    query_albums: { method: 'POST', path: '/api/albums/query', req: s.QueryParamsSchema, resp: s.AlbumsQueryResultSchema, auth: { type: 'authenticated' } as const },
+    query_albums_by_scalar_range: { method: 'POST', path: '/api/taxonomy/scalars/query-range', req: s.QueryScalarRangeRequestSchema, resp: z.string().array(), auth: { type: 'authenticated' } as const },
+    query_artists: { method: 'POST', path: '/api/artists/query', req: s.QueryParamsSchema, resp: s.ArtistsQueryResultSchema, auth: { type: 'authenticated' } as const },
+    query_playlist_songs: { method: 'POST', path: '/api/playlists/songs', req: s.QueryPlaylistSongsRequestSchema, resp: s.PlaylistSongsQueryResultSchema, auth: { type: 'authenticated' } as const },
+    query_songs: { method: 'POST', path: '/api/songs/query', req: s.QueryParamsSchema, resp: s.SongsQueryResultSchema, auth: { type: 'authenticated' } as const },
+    query_tags: { method: 'POST', path: '/api/tags/query', req: s.QueryTagsRequestSchema, resp: s.TagSchema.array(), auth: { type: 'authenticated' } as const },
+    query_taxons: { method: 'POST', path: '/api/taxonomy/taxons/query', req: s.QueryTaxonsRequestSchema, resp: s.TaxonsQueryResultSchema, auth: { type: 'authenticated' } as const },
+    recent_songs: { method: 'POST', path: '/api/songs/recent', req: s.RecentSongsRequestSchema, resp: s.SongSchema.array(), auth: { type: 'authenticated' } as const },
+    recently_added_albums: { method: 'POST', path: '/api/music/relations/recently-added-albums', req: s.RecentlyAddedAlbumsRequestSchema, resp: s.RecentlyAddedAlbumsResponseSchema, auth: { type: 'authenticated' } as const },
+    record_play: { method: 'POST', path: '/api/analytics/play', req: s.RecordPlayRequestSchema, resp: s.EmptyResponseSchema, auth: { type: 'role', role: 'member' } as const },
+    record_playlist_play: { method: 'POST', path: '/api/playlists/record-play', req: s.GetPlaylistRequestSchema, resp: s.EmptyResponseSchema, auth: { type: 'authenticated' } as const },
+    reject_mb_match: { method: 'POST', path: '/api/albums/mb-reject', req: s.RejectMbMatchRequestSchema, resp: s.MbMatchActionResponseSchema, auth: { type: 'role', role: 'admin' } as const },
+    remove_album_taxon: { method: 'POST', path: '/api/taxonomy/album-links/remove', req: s.RemoveAlbumTaxonRequestSchema, resp: s.EmptyResponseSchema, auth: { type: 'role', role: 'admin' } as const },
+    remove_albums_tags: { method: 'POST', path: '/api/tags/albums/remove', req: s.RemoveAlbumsTagsRequestSchema, resp: s.EmptyResponseSchema, auth: { type: 'role', role: 'admin' } as const },
+    remove_rating: { method: 'POST', path: '/api/ratings/remove', req: s.RemoveRatingRequestSchema, resp: s.RemoveRatingResponseSchema, auth: { type: 'role', role: 'member' } as const },
+    remove_songs_from_playlist: { method: 'POST', path: '/api/playlists/remove-songs', req: s.RemoveSongsFromPlaylistRequestSchema, resp: s.EmptyResponseSchema, auth: { type: 'owner_or', role: 'admin' } as const },
+    remove_taxon_parent: { method: 'POST', path: '/api/taxonomy/parents/remove', req: s.RemoveTaxonParentRequestSchema, resp: s.EmptyResponseSchema, auth: { type: 'role', role: 'admin' } as const },
+    reorder_playlist_songs: { method: 'POST', path: '/api/playlists/reorder', req: s.ReorderPlaylistSongsRequestSchema, resp: s.EmptyResponseSchema, auth: { type: 'owner_or', role: 'admin' } as const },
+    replace_albums_tags: { method: 'POST', path: '/api/tags/albums/replace', req: s.ReplaceAlbumsTagsRequestSchema, resp: s.EmptyResponseSchema, auth: { type: 'role', role: 'admin' } as const },
+    requery_enrichment: { method: 'POST', path: '/api/music/albums/enrichment/requery', req: s.RequeryEnrichmentRequestSchema, resp: s.RequeryEnrichmentResponseSchema, auth: { type: 'role', role: 'admin' } as const },
+    search: { method: 'POST', path: '/api/music/search', req: s.SearchRequestSchema, resp: s.SearchResponseSchema, auth: { type: 'authenticated' } as const },
+    search_musicbrainz_releases: { method: 'POST', path: '/api/musicbrainz/search/releases', req: s.SearchReleasesRequestSchema, resp: s.MbSearchReleasesResponseSchema, auth: { type: 'role', role: 'admin' } as const },
+    set_album_taxons: { method: 'POST', path: '/api/taxonomy/album-links/set', req: s.SetAlbumTaxonsRequestSchema, resp: s.AlbumTaxonLinkSchema.array(), auth: { type: 'role', role: 'admin' } as const },
+    set_favorite: { method: 'POST', path: '/api/favorites/set', req: s.SetFavoriteRequestSchema, resp: s.SetFavoriteResponseSchema, auth: { type: 'role', role: 'member' } as const },
+    set_mb_lookup_status: { method: 'POST', path: '/api/albums/set-mb-lookup-status', req: s.SetMbLookupStatusRequestSchema, resp: s.EmptyResponseSchema, auth: { type: 'role', role: 'admin' } as const },
+    set_primary_image: { method: 'POST', path: '/api/music/images/set-primary', req: s.SetPrimaryImageRequestSchema, resp: s.EmptyResponseSchema, auth: { type: 'role', role: 'admin' } as const },
+    set_rating: { method: 'POST', path: '/api/ratings/set', req: s.SetRatingRequestSchema, resp: s.SetRatingResponseSchema, auth: { type: 'role', role: 'member' } as const },
+    set_related_artist_bandcamp: { method: 'POST', path: '/api/related-artists/set-bandcamp', req: s.SetRelatedArtistBandcampRequestSchema, resp: s.RelatedArtistApiSchema, auth: { type: 'role', role: 'admin' } as const },
+    set_scalar_attribute: { method: 'POST', path: '/api/taxonomy/scalars/set', req: s.SetScalarAttributeRequestSchema, resp: s.ScalarAttributeSchema, auth: { type: 'role', role: 'admin' } as const },
+    set_taxon_color: { method: 'POST', path: '/api/taxonomy/taxons/set-color', req: s.SetTaxonColorRequestSchema, resp: s.TaxonSchema, auth: { type: 'role', role: 'admin' } as const },
+    set_taxon_kind_color: { method: 'POST', path: '/api/taxonomy/kinds/set-color', req: s.SetTaxonKindColorRequestSchema, resp: s.TaxonKindSchema, auth: { type: 'role', role: 'admin' } as const },
+    set_taxon_kind_label: { method: 'POST', path: '/api/taxonomy/kinds/set-label', req: s.SetTaxonKindLabelRequestSchema, resp: s.TaxonKindSchema, auth: { type: 'role', role: 'admin' } as const },
+    set_taxon_label: { method: 'POST', path: '/api/taxonomy/taxons/set-label', req: s.SetTaxonLabelRequestSchema, resp: s.TaxonSchema, auth: { type: 'role', role: 'admin' } as const },
+    song_analytics: { method: 'POST', path: '/api/analytics/song-stats', req: s.SongAnalyticsRequestSchema, resp: s.PlayAnalyticsSchema, auth: { type: 'authenticated' } as const },
+    stream_blob: { method: 'GET', path: '/api/blobs/{id}', req: null, resp: null, auth: { type: 'authenticated' } as const },
+    suggestions: { method: 'POST', path: '/api/music/suggestions', req: s.SuggestionsRequestSchema, resp: s.SuggestionsResponseSchema, auth: { type: 'authenticated' } as const },
+    sync_album: { method: 'POST', path: '/api/sync/album', req: s.SyncAlbumRequestSchema, resp: s.SyncAlbumResponseSchema, auth: { type: 'role', role: 'member' } as const },
+    sync_playlist: { method: 'POST', path: '/api/sync/playlist', req: s.SyncPlaylistRequestSchema, resp: s.SyncPlaylistResponseSchema, auth: { type: 'role', role: 'member' } as const },
+    sync_song_by_blake3: { method: 'POST', path: '/api/sync/song-by-blake3', req: s.SyncSongByBlake3RequestSchema, resp: s.SyncSongByBlake3ResponseSchema, auth: { type: 'role', role: 'member' } as const },
+    synced_sha256s: { method: 'GET', path: '/api/sync/sha256s', req: null, resp: z.string().array(), auth: { type: 'role', role: 'member' } as const },
+    top_albums: { method: 'POST', path: '/api/analytics/top-albums', req: s.TopAlbumsRequestSchema, resp: s.TopAlbumSchema.array(), auth: { type: 'authenticated' } as const },
+    top_artists: { method: 'POST', path: '/api/analytics/top-artists', req: s.TopArtistsRequestSchema, resp: s.TopArtistSchema.array(), auth: { type: 'authenticated' } as const },
+    top_songs: { method: 'POST', path: '/api/analytics/top-songs', req: s.TopSongsRequestSchema, resp: s.TopSongSchema.array(), auth: { type: 'authenticated' } as const },
+    unassigned_albums: { method: 'POST', path: '/api/music/relations/unassigned-albums', req: s.UnassignedAlbumsRequestSchema, resp: s.UnassignedAlbumsResponseSchema, auth: { type: 'authenticated' } as const },
+    update_album: { method: 'POST', path: '/api/albums/update', req: s.UpdateAlbumRequestSchema, resp: s.AlbumSchema, auth: { type: 'role', role: 'admin' } as const },
+    update_artist: { method: 'POST', path: '/api/artists/update', req: s.UpdateArtistRequestSchema, resp: s.ArtistSchema, auth: { type: 'role', role: 'admin' } as const },
+    update_artist_metadata: { method: 'POST', path: '/api/artists/update-metadata', req: s.UpdateArtistMetadataRequestSchema, resp: s.UpdateArtistMetadataResponseSchema, auth: { type: 'role', role: 'admin' } as const },
+    update_listen_session_progress: { method: 'POST', path: '/api/analytics/sessions/progress', req: s.UpdateListenSessionProgressRequestSchema, resp: s.EmptyResponseSchema, auth: { type: 'owner' } as const },
+    update_listen_session_songs: { method: 'POST', path: '/api/analytics/sessions/songs', req: s.UpdateListenSessionSongsRequestSchema, resp: s.EmptyResponseSchema, auth: { type: 'owner' } as const },
+    update_listen_session_status: { method: 'POST', path: '/api/analytics/sessions/status', req: s.UpdateListenSessionStatusRequestSchema, resp: s.EmptyResponseSchema, auth: { type: 'owner' } as const },
+    update_playlist: { method: 'POST', path: '/api/playlists/update', req: s.UpdatePlaylistRequestSchema, resp: s.PlaylistSchema, auth: { type: 'owner_or', role: 'admin' } as const },
+    update_songs: { method: 'POST', path: '/api/songs/update', req: s.UpdateSongsRequestSchema, resp: s.UpdateSongsResultSchema, auth: { type: 'role', role: 'admin' } as const },
+    upload_image: { method: 'POST', path: '/api/upload/image', req: null, resp: s.ImageUploadResponseSchema, auth: { type: 'role', role: 'member' } as const },
+    upload_music: { method: 'POST', path: '/api/upload/music', req: null, resp: s.MusicUploadResponseSchema, auth: { type: 'role', role: 'member' } as const },
+    upload_music_by_blake3: { method: 'POST', path: '/api/upload/music-by-blake3', req: s.UploadMusicByBlake3RequestSchema, resp: s.MusicUploadResponseSchema, auth: { type: 'role', role: 'member' } as const },
+  },
+} as const;