yoto-nodejs-client 0.0.1

package/lib/api-endpoints/auth.d.ts

@@ -0,0 +1,56 @@
+export function getAuthorizeUrl({ audience, scope, responseType, clientId, redirectUri, state, nonce, prompt, maxAge, codeChallenge, codeChallengeMethod }: {
+    audience?: string | undefined;
+    scope?: string | undefined;
+    responseType: "code" | "token" | "id_token" | "code token" | "code id_token" | "token id_token" | "code token id_token";
+    clientId: string;
+    redirectUri: string;
+    state: string;
+    nonce?: string | undefined;
+    prompt?: "none" | "login" | "consent" | "select_account" | undefined;
+    maxAge?: number | undefined;
+    codeChallenge?: string | undefined;
+    codeChallengeMethod?: "S256" | "plain" | undefined;
+}): string;
+export function exchangeToken({ grantType, code, redirectUri, refreshToken, clientId, clientSecret, scope, codeVerifier, deviceCode, audience, userAgent, requestOptions }: {
+    grantType: "authorization_code" | "refresh_token" | "client_credentials" | "urn:ietf:params:oauth:grant-type:device_code";
+    code?: string | undefined;
+    redirectUri?: string | undefined;
+    refreshToken?: string | undefined;
+    clientId?: string | undefined;
+    clientSecret?: string | undefined;
+    scope?: string | undefined;
+    codeVerifier?: string | undefined;
+    deviceCode?: string | undefined;
+    audience?: string | undefined;
+    userAgent?: string | undefined;
+    requestOptions?: ({
+        dispatcher?: import("undici").Dispatcher;
+    } & Omit<import("undici").Dispatcher.RequestOptions<unknown>, "origin" | "path" | "method"> & Partial<Pick<import("undici").Dispatcher.RequestOptions<null>, "method">>) | undefined;
+}): Promise<YotoTokenResponse>;
+export function requestDeviceCode({ clientId, scope, audience, userAgent, requestOptions }: {
+    clientId: string;
+    scope?: string | undefined;
+    audience?: string | undefined;
+    userAgent?: string | undefined;
+    requestOptions?: ({
+        dispatcher?: import("undici").Dispatcher;
+    } & Omit<import("undici").Dispatcher.RequestOptions<unknown>, "origin" | "path" | "method"> & Partial<Pick<import("undici").Dispatcher.RequestOptions<null>, "method">>) | undefined;
+}): Promise<YotoDeviceCodeResponse>;
+export type YotoTokenResponse = {
+    access_token: string;
+    token_type: string;
+    expires_in: number;
+    refresh_token?: string;
+    scope?: string;
+    id_token?: string;
+    expires_at?: number;
+};
+export type YotoDeviceCodeResponse = {
+    device_code: string;
+    user_code: string;
+    verification_uri: string;
+    verification_uri_complete?: string;
+    expires_in: number;
+    interval: number;
+};
+//# sourceMappingURL=auth.d.ts.map

package/lib/api-endpoints/auth.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"auth.d.ts","sourceRoot":"","sources":["auth.js"],"names":[],"mappings":"AA4BA,4JAbG;IAA0B,QAAQ;IACR,KAAK;IAC6F,YAAY,EAA/H,MAAM,GAAG,OAAO,GAAG,UAAU,GAAG,YAAY,GAAG,eAAe,GAAG,gBAAgB,GAAG,qBAAqB;IACzF,QAAQ,EAAxB,MAAM;IACU,WAAW,EAA3B,MAAM;IACU,KAAK,EAArB,MAAM;IACW,KAAK;IACoC,MAAM;IAC/C,MAAM;IACN,aAAa;IACH,mBAAmB;CACvD,GAAS,MAAM,CA+BjB;AAgCD,4KAdG;IAAiI,SAAS,EAAjI,oBAAoB,GAAG,eAAe,GAAG,oBAAoB,GAAG,8CAA8C;IAC7F,IAAI;IACJ,WAAW;IACX,YAAY;IACZ,QAAQ;IACR,YAAY;IACZ,KAAK;IACL,YAAY;IACZ,UAAU;IACV,QAAQ;IACR,SAAS;IACD,cAAc;;;CAChD,GAAS,OAAO,CAAC,iBAAiB,CAAC,CAoErC;AAwBD,4FAPG;IAAyB,QAAQ,EAAxB,MAAM;IACW,KAAK;IACL,QAAQ;IACR,SAAS;IACD,cAAc;;;CAChD,GAAS,OAAO,CAAC,sBAAsB,CAAC,CA+B1C;;kBAlJa,MAAM;gBACN,MAAM;gBACN,MAAM;oBACN,MAAM;YACN,MAAM;eACN,MAAM;iBACN,MAAM;;;iBA4FN,MAAM;eACN,MAAM;sBACN,MAAM;gCACN,MAAM;gBACN,MAAM;cACN,MAAM"}

package/lib/api-endpoints/auth.js

@@ -0,0 +1,209 @@
+/**
+ * @import { RequestOptions } from './helpers.js'
+ */
+import { request } from 'undici'
+import { defaultHeaders, handleBadResponse, mergeRequestOptions, YotoAPIError } from './helpers.js'
+import { DEFAULT_SCOPE, DEFAULT_AUDIENCE, YOTO_LOGIN_URL } from './constants.js'
+
+// ============================================================================
+// Authentication: Authentication endpoints for browser-based and device flows
+// ============================================================================
+
+/**
+ * Redirects the user to Yoto's login page to begin the OAuth2 Authorization Code flow.
+ * @see https://yoto.dev/api/get-authorize/
+ * @param  {object} options
+ * @param  {string} [options.audience='https://api.yotoplay.com']    Audience for the token
+ * @param  {string} [options.scope='openid profile offline_access']       Requested scopes
+ * @param  {'code' | 'token' | 'id_token' | 'code token' | 'code id_token' | 'token id_token' | 'code token id_token'} options.responseType  Required response type
+ * @param  {string} options.clientId    Required client ID
+ * @param  {string} options.redirectUri Required redirect URI
+ * @param  {string} options.state       Required opaque value for preventing CSRF attacks
+ * @param  {string} [options.nonce]     String value to prevent replay attacks
+ * @param  {'none' | 'login' | 'consent' | 'select_account'} [options.prompt]  Authorization server prompt behavior
+ * @param  {number} [options.maxAge]    Maximum authentication age in seconds
+ * @param  {string} [options.codeChallenge]  PKCE code challenge
+ * @param  {'S256' | 'plain'} [options.codeChallengeMethod]  PKCE code challenge method
+ * @return {string} The authorization URL to redirect the user to
+ */
+export function getAuthorizeUrl ({
+  audience = DEFAULT_AUDIENCE,
+  scope = DEFAULT_SCOPE,
+  responseType,
+  clientId,
+  redirectUri,
+  state,
+  nonce,
+  prompt,
+  maxAge,
+  codeChallenge,
+  codeChallengeMethod
+}) {
+  const requestUrl = new URL('/authorize', YOTO_LOGIN_URL)
+
+  requestUrl.searchParams.set('audience', audience)
+  requestUrl.searchParams.set('scope', scope)
+  requestUrl.searchParams.set('response_type', responseType)
+  requestUrl.searchParams.set('client_id', clientId)
+  requestUrl.searchParams.set('redirect_uri', redirectUri)
+  requestUrl.searchParams.set('state', state)
+
+  if (nonce) requestUrl.searchParams.set('nonce', nonce)
+  if (prompt) requestUrl.searchParams.set('prompt', prompt)
+  if (maxAge !== undefined) requestUrl.searchParams.set('max_age', maxAge.toString())
+  if (codeChallenge) requestUrl.searchParams.set('code_challenge', codeChallenge)
+  if (codeChallengeMethod) requestUrl.searchParams.set('code_challenge_method', codeChallengeMethod)
+
+  return requestUrl.toString()
+}
+
+/**
+ * @see https://yoto.dev/api/post-oauth-token/
+ * @typedef {Object} YotoTokenResponse
+ * @property {string} access_token
+ * @property {string} token_type
+ * @property {number} expires_in
+ * @property {string} [refresh_token]
+ * @property {string} [scope]
+ * @property {string} [id_token]
+ * @property {number} [expires_at]
+ */
+
+/**
+ * Exchange authorization code or refresh token for access tokens.
+ * @see https://yoto.dev/api/post-oauth-token/
+ * @param  {object} options
+ * @param  {'authorization_code' | 'refresh_token' | 'client_credentials' | 'urn:ietf:params:oauth:grant-type:device_code'} options.grantType  Required grant type
+ * @param  {string} [options.code]  Authorization code (required for authorization_code grant)
+ * @param  {string} [options.redirectUri]  Redirect URI (required for authorization_code grant if used in authorize request)
+ * @param  {string} [options.refreshToken]  Refresh token (required for refresh_token grant)
+ * @param  {string} [options.clientId]  Client ID
+ * @param  {string} [options.clientSecret]  Client secret
+ * @param  {string} [options.scope]  Requested scope
+ * @param  {string} [options.codeVerifier]  PKCE code verifier (if code_challenge was used)
+ * @param  {string} [options.deviceCode]  Device code (required for device_code grant)
+ * @param  {string} [options.audience='https://api.yotoplay.com']  Audience for the token
+ * @param  {string} [options.userAgent]  Optional user agent string
+ * @param  {RequestOptions} [options.requestOptions]  Additional undici request options
+ * @return {Promise<YotoTokenResponse>} Token response
+ */
+export async function exchangeToken ({
+  grantType,
+  code,
+  redirectUri,
+  refreshToken,
+  clientId,
+  clientSecret,
+  scope,
+  codeVerifier,
+  deviceCode,
+  audience = DEFAULT_AUDIENCE,
+  userAgent,
+  requestOptions
+}) {
+  const requestUrl = new URL('/oauth/token', YOTO_LOGIN_URL)
+
+  const formData = new URLSearchParams()
+  formData.set('grant_type', grantType)
+
+  if (grantType === 'authorization_code') {
+    if (!code) throw new Error('code is required for authorization_code grant')
+    formData.set('code', code)
+    if (redirectUri) formData.set('redirect_uri', redirectUri)
+    if (codeVerifier) formData.set('code_verifier', codeVerifier)
+  } else if (grantType === 'refresh_token') {
+    if (!refreshToken) throw new Error('refreshToken is required for refresh_token grant')
+    formData.set('refresh_token', refreshToken)
+  } else if (grantType === 'urn:ietf:params:oauth:grant-type:device_code') {
+    if (!deviceCode) throw new Error('deviceCode is required for device_code grant')
+    formData.set('device_code', deviceCode)
+  }
+
+  if (clientId) formData.set('client_id', clientId)
+  if (clientSecret) formData.set('client_secret', clientSecret)
+  if (scope) formData.set('scope', scope)
+  if (audience) formData.set('audience', audience)
+
+  const headers = {
+    ...defaultHeaders({ userAgent }),
+    'Content-Type': 'application/x-www-form-urlencoded'
+  }
+
+  const response = await request(requestUrl, mergeRequestOptions({
+    method: 'POST',
+    headers,
+    body: formData.toString()
+  }, requestOptions))
+
+  // For device_code grant, always parse JSON first so error details are available
+  // 403 errors with authorization_pending/slow_down are expected during polling
+  if (grantType === 'urn:ietf:params:oauth:grant-type:device_code') {
+    /** @type {any} */
+    const rawResponse = await response.body.json()
+
+    if (response.statusCode > 299) {
+      throw new YotoAPIError(response, rawResponse, { grantType })
+    }
+
+    const responseBody = /** @type {YotoTokenResponse} */ (rawResponse)
+    return responseBody
+  }
+
+  await handleBadResponse(response, { grantType })
+
+  const responseBody = /** @type {YotoTokenResponse} */ (await response.body.json())
+  return responseBody
+}
+
+/**
+ * @see https://yoto.dev/api/post-oauth-device-code/
+ * @typedef {Object} YotoDeviceCodeResponse
+ * @property {string} device_code - The device verification code
+ * @property {string} user_code - The code displayed to the user
+ * @property {string} verification_uri - The URL where the user should enter the user_code
+ * @property {string} [verification_uri_complete] - The verification URL with the code included
+ * @property {number} expires_in - The lifetime of the device code in seconds
+ * @property {number} interval - Minimum polling interval in seconds
+ */
+
+/**
+ * Start the OAuth2 Device Authorization flow for CLI/server-side applications.
+ * @see https://yoto.dev/api/post-oauth-device-code/
+ * @param  {object} options
+ * @param  {string} options.clientId  Required client ID
+ * @param  {string} [options.scope='openid profile offline_access']     Requested scopes
+ * @param  {string} [options.audience='https://api.yotoplay.com']  Audience for the token
+ * @param  {string} [options.userAgent]  Optional user agent string
+ * @param  {RequestOptions} [options.requestOptions]  Additional undici request options
+ * @return {Promise<YotoDeviceCodeResponse>} Device code response with user_code and verification_uri
+ */
+export async function requestDeviceCode ({
+  clientId,
+  scope = DEFAULT_SCOPE,
+  audience = DEFAULT_AUDIENCE,
+  userAgent,
+  requestOptions
+}) {
+  const requestUrl = new URL('/oauth/device/code', YOTO_LOGIN_URL)
+
+  const formData = new URLSearchParams()
+  formData.set('client_id', clientId)
+  formData.set('scope', scope)
+  formData.set('audience', audience)
+
+  const headers = {
+    ...defaultHeaders({ userAgent }),
+    'Content-Type': 'application/x-www-form-urlencoded'
+  }
+
+  const response = await request(requestUrl, mergeRequestOptions({
+    method: 'POST',
+    headers,
+    body: formData.toString()
+  }, requestOptions))
+
+  await handleBadResponse(response, { clientId })
+
+  const responseBody = /** @type {YotoDeviceCodeResponse} */ (await response.body.json())
+  return responseBody
+}

package/lib/api-endpoints/auth.test.js

@@ -0,0 +1,27 @@
+import test from 'node:test'
+import assert from 'node:assert'
+import { exchangeToken } from './auth.js'
+import { YotoAPIError } from './helpers.js'
+import { loadTestTokens } from './test-helpers.js'
+
+const { clientId } = loadTestTokens()
+
+test('exchangeToken - refresh flow', async (t) => {
+  await t.test('should fail with invalid refresh token', async () => {
+    await assert.rejects(
+      async () => {
+        await exchangeToken({
+          grantType: 'refresh_token',
+          refreshToken: 'invalid-refresh-token',
+          clientId
+        })
+      },
+      (err) => {
+        assert.ok(err instanceof YotoAPIError, 'Should throw YotoAPIError')
+        assert.ok(err.statusCode, 'Error should have statusCode')
+        assert.ok(err.body, 'Error should have body')
+        return true
+      }
+    )
+  })
+})

package/lib/api-endpoints/constants.d.ts

@@ -0,0 +1,6 @@
+export const DEFAULT_CLIENT_ID: "ix91Qy0B4uA8187JhI0tQbQQ5I5nUKYh";
+export const DEFAULT_AUDIENCE: "https://api.yotoplay.com";
+export const DEFAULT_SCOPE: "openid profile offline_access";
+export const YOTO_API_URL: "https://api.yotoplay.com";
+export const YOTO_LOGIN_URL: "https://login.yotoplay.com";
+//# sourceMappingURL=constants.d.ts.map

package/lib/api-endpoints/constants.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"constants.d.ts","sourceRoot":"","sources":["constants.js"],"names":[],"mappings":"AAKA,gCAAiC,kCAAkC,CAAA;AAMnE,+BAAgC,0BAA0B,CAAA;AAO1D,4BAA6B,+BAA+B,CAAA;AAM5D,2BAA4B,0BAA0B,CAAA;AAMtD,6BAA8B,4BAA4B,CAAA"}

package/lib/api-endpoints/constants.js

@@ -0,0 +1,31 @@
+/**
+ * Default OAuth client ID for testing and development
+ * This is a public client ID provided by Yoto for development purposes
+ * @constant {string}
+ */
+export const DEFAULT_CLIENT_ID = 'ix91Qy0B4uA8187JhI0tQbQQ5I5nUKYh'
+
+/**
+ * Default OAuth audience for Yoto API
+ * @constant {string}
+ */
+export const DEFAULT_AUDIENCE = 'https://api.yotoplay.com'
+
+/**
+ * Default OAuth scope for Yoto API
+ * Includes OpenID Connect, profile information, and offline access (refresh tokens)
+ * @constant {string}
+ */
+export const DEFAULT_SCOPE = 'openid profile offline_access'
+
+/**
+ * Yoto API base URL
+ * @constant {string}
+ */
+export const YOTO_API_URL = 'https://api.yotoplay.com'
+
+/**
+ * Yoto login/authentication base URL
+ * @constant {string}
+ */
+export const YOTO_LOGIN_URL = 'https://login.yotoplay.com'

package/lib/api-endpoints/content.d.ts

@@ -0,0 +1,275 @@
+export function getContent({ accessToken, userAgent, requestOptions, cardId, timezone, signingType, playable }: {
+    accessToken: string;
+    cardId: string;
+    timezone?: string | undefined;
+    signingType?: string | undefined;
+    playable?: boolean | undefined;
+    userAgent?: string | undefined;
+    requestOptions?: ({
+        dispatcher?: import("undici").Dispatcher;
+    } & Omit<import("undici").Dispatcher.RequestOptions<unknown>, "origin" | "path" | "method"> & Partial<Pick<import("undici").Dispatcher.RequestOptions<null>, "method">>) | undefined;
+}): Promise<YotoContentResponse>;
+export function getUserMyoContent({ accessToken, userAgent, requestOptions, showDeleted }: {
+    accessToken: string;
+    showDeleted?: boolean | undefined;
+    userAgent?: string | undefined;
+    requestOptions?: ({
+        dispatcher?: import("undici").Dispatcher;
+    } & Omit<import("undici").Dispatcher.RequestOptions<unknown>, "origin" | "path" | "method"> & Partial<Pick<import("undici").Dispatcher.RequestOptions<null>, "method">>) | undefined;
+}): Promise<YotoMyoContentResponse>;
+export function createOrUpdateContent({ accessToken, userAgent, requestOptions, content }: {
+    accessToken: string;
+    content: YotoCreateOrUpdateContentRequest;
+    userAgent?: string | undefined;
+    requestOptions?: ({
+        dispatcher?: import("undici").Dispatcher;
+    } & Omit<import("undici").Dispatcher.RequestOptions<unknown>, "origin" | "path" | "method"> & Partial<Pick<import("undici").Dispatcher.RequestOptions<null>, "method">>) | undefined;
+}): Promise<YotoCreateOrUpdateContentResponse>;
+export function deleteContent({ accessToken, userAgent, requestOptions, cardId }: {
+    accessToken: string;
+    cardId: string;
+    userAgent?: string | undefined;
+    requestOptions?: ({
+        dispatcher?: import("undici").Dispatcher;
+    } & Omit<import("undici").Dispatcher.RequestOptions<unknown>, "origin" | "path" | "method"> & Partial<Pick<import("undici").Dispatcher.RequestOptions<null>, "method">>) | undefined;
+}): Promise<YotoDeleteContentResponse>;
+export type YotoCategory = "none" | "stories" | "music" | "radio" | "podcast" | "sfx" | "activities" | "alarms";
+export type YotoAudioFormat = "mp3" | "aac" | "opus" | "ogg";
+export type YotoLanguage = "en" | "en-gb" | "en-us" | "fr" | "fr-fr" | "es" | "es-es" | "es-419" | "de" | "it";
+export type YotoStatusName = "new" | "inprogress" | "complete" | "live" | "archived";
+export type YotoPlaybackDirection = "DESC" | "ASC";
+export type YotoPlaybackType = "linear" | "interactive";
+export type YotoTrackDisplay = {
+    icon16x16: string;
+};
+export type YotoTrackType = "audio" | "stream";
+export type YotoChannels = "stereo" | "mono";
+export type YotoTrack = {
+    key: string;
+    title: string;
+    trackUrl: string;
+    format: YotoAudioFormat;
+    type: YotoTrackType;
+    overlayLabel: string;
+    duration: number;
+    fileSize: number;
+    channels: YotoChannels;
+    ambient: any | null;
+    display: YotoTrackDisplay;
+    uid?: string | null;
+    overlayLabelOverride?: string | null;
+};
+export type YotoChapterDisplay = {
+    icon16x16: string;
+};
+export type YotoChapter = {
+    key: string;
+    title: string;
+    tracks: YotoTrack[];
+    display: YotoChapterDisplay;
+    overlayLabel: string;
+    duration: number;
+    fileSize: number;
+    availableFrom: any | null;
+    ambient: any | null;
+    defaultTrackDisplay: string | null;
+    defaultTrackAmbient: string | null;
+    overlayLabelOverride?: string | null;
+    startTime?: number;
+};
+export type YotoEditSettings = {
+    autoOverlayLabels: string;
+    editKeys: boolean;
+    transcodeAudioUploads: boolean;
+};
+export type YotoMetadata = {
+    category: YotoCategory;
+    cover: {
+        imageL: string | null;
+    };
+    media: YotoMedia;
+    accent?: string;
+    addToFamilyLibrary?: boolean;
+    author?: string;
+    copyright?: string;
+    description?: string;
+    genre?: string[];
+    languages?: YotoLanguage[];
+    maxAge?: number;
+    minAge?: number;
+    musicType?: string[];
+    note?: string;
+    order?: string;
+    audioPreviewUrl?: string;
+    readBy?: string;
+    share?: boolean;
+    status?: YotoStatus;
+    tags?: string[];
+    feedUrl?: string;
+    numEpisodes?: number;
+    playbackDirection?: YotoPlaybackDirection;
+};
+export type YotoMedia = {
+    duration: number;
+    fileSize: number;
+    hasStreams: boolean;
+};
+export type YotoContentConfig = {
+    autoadvance?: string;
+    onlineOnly?: boolean;
+    shuffle?: YotoShuffle[];
+    trackNumberOverlayTimeout?: number;
+    resumeTimeout?: number;
+    systemActivity?: boolean;
+};
+export type YotoShuffle = {
+    end: number;
+    limit: number;
+    start: number;
+};
+export type YotoContentCover = {
+    imageL: string | null;
+};
+export type YotoMyoEditSettings = {
+    autoOverlayLabels: string;
+    editKeys: boolean;
+    podcastTrackDisplay?: YotoPodcastTrackDisplay;
+    podcastType?: string;
+};
+export type YotoPodcastTrackDisplay = {
+    icon16x16: string;
+};
+export type YotoStatus = {
+    name: YotoStatusName;
+    updatedAt: string;
+};
+export type YotoSharing = {
+    linkCreatedAt: string;
+    linkUrl: string;
+    shareCount: number;
+    shareLimit: number;
+};
+export type YotoClubAvailability = {
+    store: string;
+};
+export type YotoContentResponse = {
+    card: YotoCard;
+};
+export type YotoCard = {
+    cardId: string;
+    content: YotoContent;
+    createdAt: string;
+    creatorEmail: string;
+    deleted: boolean;
+    metadata: YotoMetadata;
+    shareLimit: number;
+    shareLinkCreatedAt: string;
+    slug: string;
+    title: string;
+    updatedAt: string;
+    userId: string;
+    tags?: string[];
+};
+export type YotoContent = {
+    activity: string;
+    chapters: YotoChapter[];
+    config: YotoContentConfig;
+    editSettings: YotoEditSettings;
+    version: string;
+    playbackType?: YotoPlaybackType;
+};
+export type YotoMyoContentResponse = {
+    cards: YotoMyoCard[];
+};
+export type YotoMyoCard = {
+    availability: string;
+    cardId: string;
+    clubAvailability?: YotoClubAvailability[];
+    content: YotoMyoContent;
+    createdAt: string;
+    deleted: boolean;
+    metadata: YotoMyoMetadata;
+    shareLinkCreatedAt?: string;
+    shareLinkUrl?: string;
+    sharing?: YotoSharing;
+    slug: string;
+    sortkey?: string;
+    title: string;
+    updatedAt: string;
+    userId: string;
+};
+export type YotoMyoContent = {
+    activity: string;
+    config: YotoContentConfig;
+    cover?: YotoContentCover;
+    editSettings: YotoMyoEditSettings;
+    hidden?: boolean;
+    restricted?: boolean;
+    version: string;
+    playbackType?: YotoPlaybackType;
+};
+export type YotoMyoMetadata = {
+    category: YotoCategory;
+    cover?: YotoContentCover;
+    media: YotoMedia;
+    accent?: string;
+    addToFamilyLibrary?: boolean;
+    author?: string;
+    copyright?: string;
+    description?: string;
+    genre?: string[];
+    languages?: YotoLanguage[];
+    maxAge?: number;
+    minAge?: number;
+    musicType?: string[];
+    note?: string;
+    order?: any;
+    previewAudio?: string;
+    audioPreviewUrl?: string;
+    readBy?: string;
+    share?: boolean;
+    status?: YotoStatus;
+    tags?: string[];
+    feedUrl?: string | null;
+    numEpisodes?: number;
+    playbackDirection?: YotoPlaybackDirection;
+    hidden?: boolean;
+    list?: any[];
+};
+export type YotoCreateOrUpdateContentRequest = {
+    cardId?: string;
+    title: string;
+    content: YotoContentInput;
+    metadata?: YotoMetadataInput;
+};
+export type YotoContentInput = {
+    chapters?: YotoChapter[];
+    config?: YotoContentConfig;
+    playbackType?: string;
+};
+export type YotoMetadataInput = {
+    description?: string;
+    title?: string;
+};
+export type YotoCreateOrUpdateContentResponse = {
+    card: YotoCreatedCard;
+};
+export type YotoCreatedCard = {
+    _id: string;
+    cardId: string;
+    content: YotoCreatedContent;
+    createdAt: string;
+    metadata: Object;
+    title: string;
+    updatedAt: string;
+    userId: string;
+};
+export type YotoCreatedContent = {
+    chapters: YotoChapter[];
+    config: YotoContentConfig;
+    playbackType: string;
+};
+export type YotoDeleteContentResponse = {
+    status: string;
+};
+//# sourceMappingURL=content.d.ts.map

package/lib/api-endpoints/content.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"content.d.ts","sourceRoot":"","sources":["content.js"],"names":[],"mappings":"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"}