@syra.fm/sdk 0.3.0 → 0.5.0

package/src/live/types.ts

@@ -0,0 +1,119 @@
+import type { RoomParticipant } from './validation';
+
+export type {
+  Room,
+  RoomParticipant,
+  Recording,
+  House,
+  HouseMember,
+  Series,
+  SeriesEpisode,
+  Recurrence,
+  RoomTemplate,
+  RoomAttachment,
+} from './validation';
+
+/**
+ * The "now playing" stream surfaced in the live room. Derived from the
+ * `room:stream:started` socket payload (and the room's persisted stream fields);
+ * it is NOT parsed through zod, so it stays a plain structural type rather than
+ * `z.infer<typeof ZStreamInfo>`. `startedAt` / `durationSec` are present for
+ * length-known streams (e.g. a podcast episode) and drive the progress bar;
+ * manual URL/RTMP streams omit them and render no progress UI.
+ */
+export interface StreamInfo {
+  title?: string;
+  image?: string;
+  description?: string;
+  /** ISO timestamp when the current stream began. */
+  startedAt?: string;
+  /** Total length of the current stream in seconds, when known. */
+  durationSec?: number;
+}
+
+export interface ParticipantsUpdateData {
+  roomId: string;
+  participants: RoomParticipant[];
+  count: number;
+  timestamp: string;
+}
+
+export interface MuteUpdateData {
+  userId: string;
+  isMuted: boolean;
+  timestamp: string;
+}
+
+export interface SpeakerRequestData {
+  roomId: string;
+  userId: string;
+  timestamp: string;
+}
+
+export interface RecordingStateData {
+  roomId: string;
+  recordingId: string;
+  reason?: 'manual' | 'max_duration' | 'room_ended' | 'room_stopped';
+  timestamp: string;
+}
+
+export interface RoomAttachmentData {
+  roomId: string;
+  title: string;
+  status?: 'scheduled' | 'live' | 'ended';
+  type?: 'talk' | 'stage' | 'broadcast';
+  topic?: string;
+  host?: string;
+}
+
+export interface UserEntity {
+  id: string;
+  username?: string;
+  name?: { displayName?: string; full?: string; first?: string; last?: string } | string;
+  handle?: string;
+  // Adapts the Oxy SDK `User.avatar` (`string | null`): the API projects avatar
+  // from a nullable column, so `null` is a legitimate value at this boundary.
+  avatar?: string | null;
+  verified?: boolean;
+  bio?: string;
+  displayName?: string;
+  createdAt?: string;
+  [key: string]: unknown;
+}
+
+export interface LiveTheme {
+  isDark?: boolean;
+  colors: {
+    text: string;
+    textSecondary: string;
+    background: string;
+    backgroundSecondary: string;
+    card: string;
+    border: string;
+    primary: string;
+    [key: string]: string;
+  };
+}
+
+export interface HttpRequestConfig {
+  params?: Record<string, string | number | boolean | undefined>;
+  [key: string]: unknown;
+}
+
+/**
+ * The HTTP client the engine consumes. Deliberately shaped to match an Oxy
+ * `oxyServices.createLinkedClient(...).client` as-is: every method resolves to
+ * the PARSED RESPONSE BODY directly (not a `{ data }` envelope). Consumers pass
+ * that Oxy client straight through — no per-app adapter.
+ */
+export interface HttpClient {
+  get: (url: string, config?: HttpRequestConfig) => Promise<Record<string, unknown>>;
+  post: (url: string, data?: Record<string, unknown> | FormData, config?: HttpRequestConfig) => Promise<Record<string, unknown>>;
+  patch: (url: string, data?: Record<string, unknown>, config?: HttpRequestConfig) => Promise<Record<string, unknown>>;
+  delete: (url: string, config?: HttpRequestConfig) => Promise<Record<string, unknown>>;
+}
+
+export interface FileDownloadService {
+  getFileDownloadUrl?(fileId: string, variant?: string, expiresIn?: number): string;
+  getFileDownloadUrlAsync?(fileId: string, variant?: string, expiresIn?: number): Promise<string>;
+}

package/src/live/validation.ts

@@ -0,0 +1,279 @@
+import { z } from 'zod';
+
+// --- Podcast queue ---
+
+/**
+ * One podcast episode queued behind the current stream. `episodeId` is the
+ * opaque Syra episode handle; `syraPodcastId` (when present) identifies its show.
+ * The playable audio URL is never carried here — it is resolved server-side at
+ * play-time.
+ */
+export const ZPodcastQueueItem = z.object({
+  syraPodcastId: z.string().optional(),
+  episodeId: z.string(),
+}).passthrough();
+
+export type PodcastQueueItem = z.infer<typeof ZPodcastQueueItem>;
+
+// --- Room (replaces Space) ---
+
+export const ZRoom = z.object({
+  _id: z.string(),
+  id: z.string().optional(),
+  title: z.string(),
+  description: z.string().nullish(),
+
+  // Ownership
+  ownerType: z.enum(['profile', 'house', 'agora']).default('profile'),
+  host: z.string(),
+  houseId: z.string().optional().nullable(),
+  createdByAdmin: z.string().optional().nullable(),
+
+  // Classification
+  type: z.enum(['talk', 'stage', 'broadcast']).default('talk'),
+  broadcastKind: z.enum(['user', 'agora']).optional().nullable(),
+
+  // Lifecycle
+  status: z.enum(['scheduled', 'live', 'ended']),
+  scheduledStart: z.string().nullish(),
+  startedAt: z.string().nullish(),
+  endedAt: z.string().nullish(),
+
+  // Participation
+  speakerPermission: z.enum(['everyone', 'followers', 'invited']).nullish(),
+  participants: z.array(z.string()).default([]),
+  speakers: z.array(z.string()).default([]),
+  maxParticipants: z.number().default(100),
+
+  // Content
+  topic: z.string().nullish(),
+  tags: z.array(z.string()).optional(),
+  archived: z.boolean().optional().default(false),
+  seriesId: z.string().nullish(),
+
+  // Stats
+  stats: z.object({
+    peakListeners: z.number(),
+    totalJoined: z.number(),
+  }).optional(),
+
+  // Streaming
+  activeIngressId: z.string().nullish(),
+  activeStreamUrl: z.string().nullish(),
+  streamTitle: z.string().nullish(),
+  streamImage: z.string().nullish(),
+  streamDescription: z.string().nullish(),
+  rtmpUrl: z.string().nullish(),
+  rtmpStreamKey: z.string().nullish(),
+  // Stream progress + podcast lifecycle (shared contract with the backend).
+  // `streamStartedAt` is an ISO timestamp; `streamDurationSec` is the current
+  // stream's total length in seconds when known (e.g. a podcast episode);
+  // `podcastQueue` holds the episodes queued behind the current one.
+  streamStartedAt: z.string().nullish(),
+  streamDurationSec: z.number().nullish(),
+  podcastQueue: z.array(ZPodcastQueueItem).nullish(),
+
+  // Recording
+  recordingEnabled: z.boolean().optional().default(true),
+  recordingEgressId: z.string().nullish(),
+
+  createdAt: z.string(),
+}).passthrough();
+
+export type Room = z.infer<typeof ZRoom>;
+
+// --- Room Participant ---
+
+export const ZRoomParticipant = z.object({
+  userId: z.string(),
+  role: z.enum(['host', 'speaker', 'listener']),
+  isMuted: z.boolean(),
+  joinedAt: z.string(),
+}).passthrough();
+
+export type RoomParticipant = z.infer<typeof ZRoomParticipant>;
+
+// --- House ---
+
+export const ZHouseMember = z.object({
+  userId: z.string(),
+  role: z.enum(['owner', 'admin', 'host', 'member']),
+  joinedAt: z.string(),
+}).passthrough();
+
+export type HouseMember = z.infer<typeof ZHouseMember>;
+
+export const ZHouse = z.object({
+  _id: z.string(),
+  id: z.string().optional(),
+  name: z.string(),
+  description: z.string().optional(),
+  avatar: z.string().optional().nullable(),
+  coverImage: z.string().optional().nullable(),
+  members: z.array(ZHouseMember).default([]),
+  createdBy: z.string(),
+  isPublic: z.boolean().default(true),
+  tags: z.array(z.string()).optional(),
+  createdAt: z.string(),
+}).passthrough();
+
+export type House = z.infer<typeof ZHouse>;
+
+// --- Series ---
+
+export const ZRecurrence = z.object({
+  type: z.enum(['daily', 'weekly', 'biweekly', 'monthly']),
+  dayOfWeek: z.number().min(0).max(6).optional(),
+  dayOfMonth: z.number().min(1).max(31).optional(),
+  time: z.string().regex(/^\d{2}:\d{2}$/),
+  timezone: z.string().default('UTC'),
+}).passthrough();
+
+export type Recurrence = z.infer<typeof ZRecurrence>;
+
+export const ZRoomTemplate = z.object({
+  titlePattern: z.string(),
+  type: z.enum(['talk', 'stage', 'broadcast']).default('talk'),
+  description: z.string().optional(),
+  maxParticipants: z.number().default(100),
+  speakerPermission: z.enum(['everyone', 'followers', 'invited']).default('invited'),
+  tags: z.array(z.string()).optional(),
+}).passthrough();
+
+export type RoomTemplate = z.infer<typeof ZRoomTemplate>;
+
+export const ZSeriesEpisode = z.object({
+  roomId: z.string(),
+  scheduledStart: z.string(),
+  episodeNumber: z.number(),
+}).passthrough();
+
+export type SeriesEpisode = z.infer<typeof ZSeriesEpisode>;
+
+export const ZSeries = z.object({
+  _id: z.string(),
+  id: z.string().optional(),
+  title: z.string(),
+  description: z.string().optional(),
+  coverImage: z.string().optional().nullable(),
+  houseId: z.string().optional().nullable(),
+  createdBy: z.string(),
+  recurrence: ZRecurrence,
+  roomTemplate: ZRoomTemplate,
+  episodes: z.array(ZSeriesEpisode).default([]),
+  nextEpisodeNumber: z.number().default(1),
+  isActive: z.boolean().default(true),
+  createdAt: z.string(),
+}).passthrough();
+
+export type Series = z.infer<typeof ZSeries>;
+
+// --- Recording ---
+
+export const ZRecording = z.object({
+  _id: z.string(),
+  roomId: z.string(),
+  roomTitle: z.string(),
+  host: z.string(),
+  status: z.enum(['recording', 'processing', 'ready', 'failed', 'deleted']),
+  egressId: z.string(),
+  objectKey: z.string(),
+  fileSize: z.number().nullish(),
+  durationMs: z.number().nullish(),
+  startedAt: z.string(),
+  stoppedAt: z.string().nullish(),
+  access: z.enum(['public', 'participants']).default('public'),
+  participantIds: z.array(z.string()).default([]),
+  expiresAt: z.string(),
+  createdAt: z.string(),
+}).passthrough();
+
+export type Recording = z.infer<typeof ZRecording>;
+
+// --- Stream responses ---
+
+export const ZStartStreamResponse = z.object({
+  ingressId: z.string(),
+  url: z.string(),
+}).passthrough();
+
+export const ZGenerateStreamKeyResponse = z.object({
+  rtmpUrl: z.string(),
+  streamKey: z.string(),
+}).passthrough();
+
+export const ZStreamInfo = z.object({
+  title: z.string().optional(),
+  image: z.string().optional(),
+  description: z.string().optional(),
+}).passthrough();
+
+export type StreamInfo = z.infer<typeof ZStreamInfo>;
+
+// --- Room attachment for posts ---
+
+export const ZRoomAttachment = z.object({
+  roomId: z.string(),
+  title: z.string(),
+  status: z.enum(['scheduled', 'live', 'ended']).optional(),
+  type: z.enum(['talk', 'stage', 'broadcast']).optional(),
+  topic: z.string().optional(),
+  host: z.string().optional(),
+}).passthrough();
+
+export type RoomAttachment = z.infer<typeof ZRoomAttachment>;
+
+// --- Validators ---
+
+export function validateRoom(data: unknown): Room | null {
+  const result = ZRoom.safeParse(data);
+  if (result.success) return result.data;
+  console.warn('[live] Invalid Room:', result.error.issues[0]);
+  return null;
+}
+
+export function validateRooms(items: unknown[]): Room[] {
+  if (!Array.isArray(items)) return [];
+  const valid: Room[] = [];
+  for (const item of items) {
+    const parsed = ZRoom.safeParse(item);
+    if (parsed.success) {
+      valid.push(parsed.data);
+    } else {
+      console.warn('[live] Dropping invalid room:', parsed.error.issues[0]);
+    }
+  }
+  return valid;
+}
+
+export function validateHouse(data: unknown): House | null {
+  const result = ZHouse.safeParse(data);
+  if (result.success) return result.data;
+  console.warn('[live] Invalid House:', result.error.issues[0]);
+  return null;
+}
+
+export function validateRecording(data: unknown): Recording | null {
+  const result = ZRecording.safeParse(data);
+  if (result.success) return result.data;
+  console.warn('[live] Invalid Recording:', result.error.issues[0]);
+  return null;
+}
+
+export function validateRecordings(items: unknown[]): Recording[] {
+  if (!Array.isArray(items)) return [];
+  const valid: Recording[] = [];
+  for (const item of items) {
+    const parsed = ZRecording.safeParse(item);
+    if (parsed.success) valid.push(parsed.data);
+  }
+  return valid;
+}
+
+export function validateSeries(data: unknown): Series | null {
+  const result = ZSeries.safeParse(data);
+  if (result.success) return result.data;
+  console.warn('[live] Invalid Series:', result.error.issues[0]);
+  return null;
+}
+

package/src/schema.ts

@@ -69,3 +69,37 @@ export const podcastSummarySchema = z.object({
   imageSourceUrl: z.string().optional(),
 });
 export type PodcastSummary = z.infer<typeof podcastSummarySchema>;
+
+/**
+ * The summary view of a podcast EPISODE returned by the public podcast endpoints
+ * (`GET /api/podcasts/:id/episodes`, `GET /api/episodes/:id`) — just enough to
+ * list an episode and stream its audio.
+ *
+ * `enclosureUrl` is the direct audio file URL (e.g.
+ * `https://api.fastcast.ai/audio/<guid>.mp3`) and is REQUIRED: an episode with
+ * no enclosure is unplayable, so a row missing it is treated as malformed and
+ * dropped rather than surfaced as a dead entry. `enclosureType` /
+ * `enclosureLength` describe that file (MIME type and byte length); `duration`
+ * is the runtime in seconds and `pubDate` the ISO publish timestamp.
+ *
+ * Artwork mirrors the podcast SHOW: `image` is the re-hosted Syra image id
+ * (resolved via `/api/images/:id`); `imageSizes` is the multi-resolution variant
+ * set (each variant `url` is `/api/images/:id`); `imageSourceUrl` keeps the
+ * original external artwork URL as an absolute fallback when re-hosting has not
+ * run yet.
+ */
+export const episodeSummarySchema = z.object({
+  id: z.string(),
+  podcastId: z.string(),
+  title: z.string(),
+  description: z.string().optional(),
+  enclosureUrl: z.string(),
+  enclosureType: z.string().optional(),
+  enclosureLength: z.number().optional(),
+  duration: z.number().optional(),
+  pubDate: z.string().optional(),
+  image: z.string().optional(),
+  imageSizes: coverArtSizesSchema.optional(),
+  imageSourceUrl: z.string().optional(),
+});
+export type EpisodeSummary = z.infer<typeof episodeSummarySchema>;

package/dist/cjs/client.js

@@ -1,185 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.DEFAULT_SYRA_WEB_BASE_URL = exports.DEFAULT_SYRA_BASE_URL = void 0;
-exports.createSyraClient = createSyraClient;
-const schema_1 = require("./schema");
-const errors_1 = require("./errors");
-/** Default base URL of the public Syra API. */
-exports.DEFAULT_SYRA_BASE_URL = 'https://api.syra.fm';
-/** Default base URL of the Syra web app, used for deep links. */
-exports.DEFAULT_SYRA_WEB_BASE_URL = 'https://syra.fm';
-/** Order used to pick the best available artwork variant when none is named. */
-const ARTWORK_FALLBACK_ORDER = [
-    'original',
-    'xxlarge',
-    'xlarge',
-    'large',
-    'medium',
-    'small',
-];
-const OBJECT_ID_PATTERN = /^[a-f\d]{24}$/i;
-/** Read a finite number from an unknown response field, else a fallback. */
-function numberOr(value, fallback) {
-    return typeof value === 'number' && Number.isFinite(value) ? value : fallback;
-}
-/**
- * Create a headless client for the public Syra API. Public reads only — there
- * is no authentication in this version.
- */
-function createSyraClient(options = {}) {
-    const baseURL = (options.baseURL ?? exports.DEFAULT_SYRA_BASE_URL).replace(/\/+$/, '');
-    const webBaseURL = (options.webBaseURL ?? exports.DEFAULT_SYRA_WEB_BASE_URL).replace(/\/+$/, '');
-    function resolveFetch() {
-        if (options.fetch) {
-            return options.fetch;
-        }
-        const globalFetch = globalThis.fetch;
-        if (typeof globalFetch === 'function') {
-            return globalFetch.bind(globalThis);
-        }
-        throw new Error('@syra.fm/sdk: no global fetch is available. Pass `fetch` in createSyraClient options, ' +
-            'or run on Node 18+, a browser, or React Native.');
-    }
-    async function getJson(path) {
-        const doFetch = resolveFetch();
-        const response = await doFetch(`${baseURL}${path}`, {
-            headers: { Accept: 'application/json' },
-        });
-        if (!response.ok) {
-            throw new errors_1.SyraApiError(response.status, `Syra API request failed: ${response.status} ${response.statusText} (${path})`);
-        }
-        return response.json();
-    }
-    function resolveImageRef(ref) {
-        if (!ref) {
-            return undefined;
-        }
-        if (/^https?:\/\//i.test(ref)) {
-            return ref;
-        }
-        if (ref.startsWith('/api/images/')) {
-            return `${baseURL}${ref}`;
-        }
-        if (OBJECT_ID_PATTERN.test(ref)) {
-            return `${baseURL}/api/images/${ref}`;
-        }
-        return undefined;
-    }
-    return {
-        async searchTracks(query, searchOptions = {}) {
-            const params = new URLSearchParams({ q: query, category: 'tracks' });
-            if (typeof searchOptions.limit === 'number') {
-                params.set('limit', String(searchOptions.limit));
-            }
-            if (typeof searchOptions.offset === 'number') {
-                params.set('offset', String(searchOptions.offset));
-            }
-            const json = (await getJson(`/api/search?${params.toString()}`));
-            const rawTracks = Array.isArray(json?.results?.tracks) ? json.results.tracks : [];
-            const items = [];
-            for (const raw of rawTracks) {
-                // A single malformed catalog row must not fail the whole search.
-                const parsed = schema_1.trackSummarySchema.safeParse(raw);
-                if (parsed.success && parsed.data.previewAvailable === true) {
-                    items.push(parsed.data);
-                }
-            }
-            return {
-                items,
-                // `hasMore` is sourced from the backend's pagination over the FULL result
-                // set; the client-side preview filter above may shrink `items` below
-                // `limit`, but must NOT corrupt `hasMore` (else a page whose tail was
-                // filtered out would falsely report the end of the catalog).
-                hasMore: json?.hasMore === true,
-                limit: numberOr(json?.limit, searchOptions.limit ?? rawTracks.length),
-                offset: numberOr(json?.offset, searchOptions.offset ?? 0),
-            };
-        },
-        async getTrack(id) {
-            const json = await getJson(`/api/tracks/${encodeURIComponent(id)}`);
-            return schema_1.trackSummarySchema.parse(json);
-        },
-        previewUrl(id, startSec = 0) {
-            const safeStart = Number.isFinite(startSec) ? Math.max(0, Math.trunc(startSec)) : 0;
-            return `${baseURL}/api/preview/${encodeURIComponent(id)}.mp3?start=${safeStart}`;
-        },
-        artworkUrl(source, size) {
-            if (typeof source === 'string') {
-                return resolveImageRef(source);
-            }
-            if (size && source.coverArtSizes) {
-                const resolved = resolveImageRef(source.coverArtSizes[size]?.url);
-                if (resolved) {
-                    return resolved;
-                }
-            }
-            const fromCoverArt = resolveImageRef(source.coverArt);
-            if (fromCoverArt) {
-                return fromCoverArt;
-            }
-            if (source.coverArtSizes) {
-                for (const key of ARTWORK_FALLBACK_ORDER) {
-                    const resolved = resolveImageRef(source.coverArtSizes[key]?.url);
-                    if (resolved) {
-                        return resolved;
-                    }
-                }
-            }
-            return undefined;
-        },
-        async searchPodcasts(query, searchOptions = {}) {
-            const params = new URLSearchParams({ q: query });
-            if (typeof searchOptions.limit === 'number') {
-                params.set('limit', String(searchOptions.limit));
-            }
-            if (typeof searchOptions.offset === 'number') {
-                params.set('offset', String(searchOptions.offset));
-            }
-            const json = (await getJson(`/api/podcasts/search?${params.toString()}`));
-            const rawPodcasts = Array.isArray(json?.data) ? json.data : [];
-            const items = [];
-            for (const raw of rawPodcasts) {
-                // A single malformed catalog row must not fail the whole search.
-                const parsed = schema_1.podcastSummarySchema.safeParse(raw);
-                if (parsed.success) {
-                    items.push(parsed.data);
-                }
-            }
-            return {
-                items,
-                // `hasMore` reflects the backend's pagination over the full result set.
-                hasMore: json?.hasMore === true,
-                limit: numberOr(json?.limit, searchOptions.limit ?? rawPodcasts.length),
-                offset: numberOr(json?.offset, searchOptions.offset ?? 0),
-            };
-        },
-        async getPodcast(id) {
-            const json = (await getJson(`/api/podcasts/${encodeURIComponent(id)}`));
-            return schema_1.podcastSummarySchema.parse(json?.data?.podcast);
-        },
-        podcastUrl(id) {
-            return `${webBaseURL}/podcasts/${encodeURIComponent(id)}`;
-        },
-        podcastArtworkUrl(source, size) {
-            if (size && source.imageSizes) {
-                const resolved = resolveImageRef(source.imageSizes[size]?.url);
-                if (resolved) {
-                    return resolved;
-                }
-            }
-            const fromImage = resolveImageRef(source.image);
-            if (fromImage) {
-                return fromImage;
-            }
-            if (source.imageSizes) {
-                for (const key of ARTWORK_FALLBACK_ORDER) {
-                    const resolved = resolveImageRef(source.imageSizes[key]?.url);
-                    if (resolved) {
-                        return resolved;
-                    }
-                }
-            }
-            return resolveImageRef(source.imageSourceUrl);
-        },
-    };
-}

package/dist/cjs/errors.js

@@ -1,16 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.SyraApiError = void 0;
-/**
- * Error thrown when the Syra API returns a non-2xx response.
- */
-class SyraApiError extends Error {
-    constructor(status, message) {
-        super(message);
-        this.name = 'SyraApiError';
-        this.status = status;
-        // Restore the prototype chain when targeting ES5-ish runtimes.
-        Object.setPrototypeOf(this, SyraApiError.prototype);
-    }
-}
-exports.SyraApiError = SyraApiError;

package/dist/cjs/index.js

@@ -1,14 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.SyraApiError = exports.coverArtVariantSchema = exports.coverArtSizesSchema = exports.podcastSummarySchema = exports.trackSummarySchema = exports.DEFAULT_SYRA_WEB_BASE_URL = exports.DEFAULT_SYRA_BASE_URL = exports.createSyraClient = void 0;
-var client_1 = require("./client");
-Object.defineProperty(exports, "createSyraClient", { enumerable: true, get: function () { return client_1.createSyraClient; } });
-Object.defineProperty(exports, "DEFAULT_SYRA_BASE_URL", { enumerable: true, get: function () { return client_1.DEFAULT_SYRA_BASE_URL; } });
-Object.defineProperty(exports, "DEFAULT_SYRA_WEB_BASE_URL", { enumerable: true, get: function () { return client_1.DEFAULT_SYRA_WEB_BASE_URL; } });
-var schema_1 = require("./schema");
-Object.defineProperty(exports, "trackSummarySchema", { enumerable: true, get: function () { return schema_1.trackSummarySchema; } });
-Object.defineProperty(exports, "podcastSummarySchema", { enumerable: true, get: function () { return schema_1.podcastSummarySchema; } });
-Object.defineProperty(exports, "coverArtSizesSchema", { enumerable: true, get: function () { return schema_1.coverArtSizesSchema; } });
-Object.defineProperty(exports, "coverArtVariantSchema", { enumerable: true, get: function () { return schema_1.coverArtVariantSchema; } });
-var errors_1 = require("./errors");
-Object.defineProperty(exports, "SyraApiError", { enumerable: true, get: function () { return errors_1.SyraApiError; } });

package/dist/cjs/package.json

@@ -1,3 +0,0 @@
-{
-  "type": "commonjs"
-}