@studyfetch/sdk 0.1.0-alpha.1

package/src/resources/v1/embed/component.ts

@@ -0,0 +1,74 @@
+// File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+import { APIResource } from '../../../core/resource';
+import { APIPromise } from '../../../core/api-promise';
+import { buildHeaders } from '../../../internal/headers';
+import { RequestOptions } from '../../../internal/request-options';
+import { path } from '../../../internal/utils/path';
+
+export class Component extends APIResource {
+  /**
+   * Get component data for embed
+   *
+   * @example
+   * ```ts
+   * await client.v1.embed.component.retrieve('componentId', {
+   *   token: 'token',
+   * });
+   * ```
+   */
+  retrieve(componentID: string, query: ComponentRetrieveParams, options?: RequestOptions): APIPromise<void> {
+    return this._client.get(path`/api/v1/embed/component/${componentID}`, {
+      query,
+      ...options,
+      headers: buildHeaders([{ Accept: '*/*' }, options?.headers]),
+    });
+  }
+
+  /**
+   * Process embed interaction
+   *
+   * @example
+   * ```ts
+   * await client.v1.embed.component.interact('componentId', {
+   *   token: 'token',
+   *   body: 'body',
+   * });
+   * ```
+   */
+  interact(componentID: string, params: ComponentInteractParams, options?: RequestOptions): APIPromise<void> {
+    const { token, body } = params;
+    return this._client.post(path`/api/v1/embed/component/${componentID}/interact`, {
+      query: { token },
+      body: body,
+      ...options,
+      headers: buildHeaders([{ Accept: '*/*' }, options?.headers]),
+    });
+  }
+}
+
+export interface ComponentRetrieveParams {
+  /**
+   * Embed token
+   */
+  token: string;
+}
+
+export interface ComponentInteractParams {
+  /**
+   * Query param: Embed token
+   */
+  token: string;
+
+  /**
+   * Body param:
+   */
+  body: string;
+}
+
+export declare namespace Component {
+  export {
+    type ComponentRetrieveParams as ComponentRetrieveParams,
+    type ComponentInteractParams as ComponentInteractParams,
+  };
+}

package/src/resources/v1/embed/embed.ts

@@ -0,0 +1,85 @@
+// File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+import { APIResource } from '../../../core/resource';
+import * as ComponentAPI from './component';
+import { Component, ComponentInteractParams, ComponentRetrieveParams } from './component';
+import { APIPromise } from '../../../core/api-promise';
+import { buildHeaders } from '../../../internal/headers';
+import { RequestOptions } from '../../../internal/request-options';
+
+export class Embed extends APIResource {
+  component: ComponentAPI.Component = new ComponentAPI.Component(this._client);
+
+  /**
+   * Get theme CSS for embed
+   *
+   * @example
+   * ```ts
+   * await client.v1.embed.getTheme({ token: 'token' });
+   * ```
+   */
+  getTheme(query: EmbedGetThemeParams, options?: RequestOptions): APIPromise<void> {
+    return this._client.get('/api/v1/embed/theme', {
+      query,
+      ...options,
+      headers: buildHeaders([{ Accept: '*/*' }, options?.headers]),
+    });
+  }
+
+  /**
+   * Health check endpoint
+   *
+   * @example
+   * ```ts
+   * await client.v1.embed.healthCheck();
+   * ```
+   */
+  healthCheck(options?: RequestOptions): APIPromise<void> {
+    return this._client.get('/api/v1/embed/health', {
+      ...options,
+      headers: buildHeaders([{ Accept: '*/*' }, options?.headers]),
+    });
+  }
+
+  /**
+   * Verify embed token
+   *
+   * @example
+   * ```ts
+   * await client.v1.embed.verify({ token: 'token' });
+   * ```
+   */
+  verify(query: EmbedVerifyParams, options?: RequestOptions): APIPromise<void> {
+    return this._client.get('/api/v1/embed/verify', {
+      query,
+      ...options,
+      headers: buildHeaders([{ Accept: '*/*' }, options?.headers]),
+    });
+  }
+}
+
+export interface EmbedGetThemeParams {
+  /**
+   * Embed token
+   */
+  token: string;
+}
+
+export interface EmbedVerifyParams {
+  /**
+   * Embed token to verify
+   */
+  token: string;
+}
+
+Embed.Component = Component;
+
+export declare namespace Embed {
+  export { type EmbedGetThemeParams as EmbedGetThemeParams, type EmbedVerifyParams as EmbedVerifyParams };
+
+  export {
+    Component as Component,
+    type ComponentRetrieveParams as ComponentRetrieveParams,
+    type ComponentInteractParams as ComponentInteractParams,
+  };
+}

package/src/resources/v1/embed/index.ts

@@ -0,0 +1,4 @@
+// File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+export { Component, type ComponentRetrieveParams, type ComponentInteractParams } from './component';
+export { Embed, type EmbedGetThemeParams, type EmbedVerifyParams } from './embed';

package/src/resources/v1/embed.ts

@@ -0,0 +1,3 @@
+// File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+export * from './embed/index';

package/src/resources/v1/explainers.ts

@@ -0,0 +1,54 @@
+// File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+import { APIResource } from '../../core/resource';
+import { APIPromise } from '../../core/api-promise';
+import { buildHeaders } from '../../internal/headers';
+import { RequestOptions } from '../../internal/request-options';
+
+export class Explainers extends APIResource {
+  /**
+   * Create explainers component
+   *
+   * @example
+   * ```ts
+   * await client.v1.explainers.create();
+   * ```
+   */
+  create(body: ExplainerCreateParams, options?: RequestOptions): APIPromise<void> {
+    return this._client.post('/api/v1/explainers/create', {
+      body,
+      ...options,
+      headers: buildHeaders([{ Accept: '*/*' }, options?.headers]),
+    });
+  }
+
+  /**
+   * Handle webhook events
+   *
+   * @example
+   * ```ts
+   * await client.v1.explainers.handleWebhook({ body: 'body' });
+   * ```
+   */
+  handleWebhook(params: ExplainerHandleWebhookParams, options?: RequestOptions): APIPromise<void> {
+    const { body } = params;
+    return this._client.post('/api/v1/explainers/webhook', {
+      body: body,
+      ...options,
+      headers: buildHeaders([{ Accept: '*/*' }, options?.headers]),
+    });
+  }
+}
+
+export interface ExplainerCreateParams {}
+
+export interface ExplainerHandleWebhookParams {
+  body: string;
+}
+
+export declare namespace Explainers {
+  export {
+    type ExplainerCreateParams as ExplainerCreateParams,
+    type ExplainerHandleWebhookParams as ExplainerHandleWebhookParams,
+  };
+}

package/src/resources/v1/flashcards.ts

@@ -0,0 +1,354 @@
+// File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+import { APIResource } from '../../core/resource';
+import { APIPromise } from '../../core/api-promise';
+import { buildHeaders } from '../../internal/headers';
+import { RequestOptions } from '../../internal/request-options';
+import { path } from '../../internal/utils/path';
+
+export class Flashcards extends APIResource {
+  /**
+   * Process multiple flashcard operations
+   *
+   * @example
+   * ```ts
+   * const response = await client.v1.flashcards.batchProcess(
+   *   'componentId',
+   *   { operations: [{ action: 'rate', cardId: 'cardId' }] },
+   * );
+   * ```
+   */
+  batchProcess(
+    componentID: string,
+    body: FlashcardBatchProcessParams,
+    options?: RequestOptions,
+  ): APIPromise<FlashcardBatchProcessResponse> {
+    return this._client.post(path`/api/v1/flashcards/${componentID}/batch`, { body, ...options });
+  }
+
+  /**
+   * Get spaced repetition algorithm info
+   *
+   * @example
+   * ```ts
+   * const response =
+   *   await client.v1.flashcards.getAlgorithmInfo();
+   * ```
+   */
+  getAlgorithmInfo(options?: RequestOptions): APIPromise<FlashcardGetAlgorithmInfoResponse> {
+    return this._client.get('/api/v1/flashcards/algorithm', options);
+  }
+
+  /**
+   * Get all flashcards for component
+   *
+   * @example
+   * ```ts
+   * await client.v1.flashcards.getAll('componentId');
+   * ```
+   */
+  getAll(
+    componentID: string,
+    query: FlashcardGetAllParams | null | undefined = {},
+    options?: RequestOptions,
+  ): APIPromise<void> {
+    return this._client.get(path`/api/v1/flashcards/${componentID}/all`, {
+      query,
+      ...options,
+      headers: buildHeaders([{ Accept: '*/*' }, options?.headers]),
+    });
+  }
+
+  /**
+   * Get due flashcards for review
+   *
+   * @example
+   * ```ts
+   * await client.v1.flashcards.getDue('componentId', {
+   *   groupId: 'groupId',
+   * });
+   * ```
+   */
+  getDue(componentID: string, query: FlashcardGetDueParams, options?: RequestOptions): APIPromise<void> {
+    return this._client.get(path`/api/v1/flashcards/${componentID}/due`, {
+      query,
+      ...options,
+      headers: buildHeaders([{ Accept: '*/*' }, options?.headers]),
+    });
+  }
+
+  /**
+   * Get flashcard statistics
+   *
+   * @example
+   * ```ts
+   * await client.v1.flashcards.getStats('componentId');
+   * ```
+   */
+  getStats(
+    componentID: string,
+    query: FlashcardGetStatsParams | null | undefined = {},
+    options?: RequestOptions,
+  ): APIPromise<void> {
+    return this._client.get(path`/api/v1/flashcards/${componentID}/stats`, {
+      query,
+      ...options,
+      headers: buildHeaders([{ Accept: '*/*' }, options?.headers]),
+    });
+  }
+
+  /**
+   * Get available flashcard types
+   *
+   * @example
+   * ```ts
+   * const response = await client.v1.flashcards.getTypes();
+   * ```
+   */
+  getTypes(options?: RequestOptions): APIPromise<FlashcardGetTypesResponse> {
+    return this._client.get('/api/v1/flashcards/types', options);
+  }
+
+  /**
+   * Rate a flashcard
+   *
+   * @example
+   * ```ts
+   * await client.v1.flashcards.rate('componentId', {
+   *   cardId: 'cardId',
+   *   rating: 0,
+   * });
+   * ```
+   */
+  rate(componentID: string, body: FlashcardRateParams, options?: RequestOptions): APIPromise<void> {
+    return this._client.post(path`/api/v1/flashcards/${componentID}/rate`, {
+      body,
+      ...options,
+      headers: buildHeaders([{ Accept: '*/*' }, options?.headers]),
+    });
+  }
+}
+
+export interface FlashcardBatchProcessResponse {
+  /**
+   * Failed operations
+   */
+  failed?: number;
+
+  /**
+   * Total operations processed
+   */
+  processed?: number;
+
+  results?: Array<FlashcardBatchProcessResponse.Result>;
+
+  /**
+   * Overall success
+   */
+  success?: boolean;
+
+  /**
+   * Successful operations
+   */
+  successful?: number;
+}
+
+export namespace FlashcardBatchProcessResponse {
+  export interface Result {
+    /**
+     * Flashcard ID
+     */
+    cardId: string;
+
+    /**
+     * Operation success
+     */
+    success: boolean;
+
+    /**
+     * Error message if failed
+     */
+    error?: string;
+
+    /**
+     * Operation result
+     */
+    result?: unknown;
+  }
+}
+
+export interface FlashcardGetAlgorithmInfoResponse {
+  /**
+   * Algorithm name
+   */
+  algorithm?: string;
+
+  intervals?: FlashcardGetAlgorithmInfoResponse.Intervals;
+
+  phases?: { [key: string]: string };
+
+  ratings?: { [key: string]: FlashcardGetAlgorithmInfoResponse.Ratings };
+}
+
+export namespace FlashcardGetAlgorithmInfoResponse {
+  export interface Intervals {
+    /**
+     * Description of graduated intervals
+     */
+    graduated?: string;
+
+    /**
+     * Description of lapse intervals
+     */
+    lapse?: string;
+
+    /**
+     * Learning intervals in minutes
+     */
+    learning?: Array<number>;
+  }
+
+  export interface Ratings {
+    /**
+     * Rating description
+     */
+    description: string;
+
+    /**
+     * Rating name
+     */
+    name: string;
+  }
+}
+
+export interface FlashcardGetTypesResponse {
+  descriptions?: { [key: string]: string };
+
+  /**
+   * List of flashcard types
+   */
+  types?: Array<string>;
+}
+
+export interface FlashcardBatchProcessParams {
+  operations: Array<FlashcardBatchProcessParams.Operation>;
+
+  /**
+   * Group ID (optional)
+   */
+  groupId?: string;
+
+  /**
+   * User ID (optional)
+   */
+  userId?: string;
+}
+
+export namespace FlashcardBatchProcessParams {
+  export interface Operation {
+    action: 'rate' | 'get_due' | 'get_all' | 'get_stats';
+
+    /**
+     * Flashcard ID
+     */
+    cardId: string;
+
+    /**
+     * Group ID (optional)
+     */
+    groupId?: string;
+
+    /**
+     * Rating for rate action (0-3)
+     */
+    rating?: number;
+
+    /**
+     * User ID (optional)
+     */
+    userId?: string;
+  }
+}
+
+export interface FlashcardGetAllParams {
+  /**
+   * Group ID
+   */
+  groupId?: string;
+
+  /**
+   * Max number of cards
+   */
+  limit?: number;
+
+  /**
+   * Offset
+   */
+  offset?: number;
+
+  /**
+   * User ID
+   */
+  userId?: string;
+}
+
+export interface FlashcardGetDueParams {
+  groupId: string;
+
+  /**
+   * Max number of cards
+   */
+  limit?: number;
+
+  /**
+   * User ID
+   */
+  userId?: string;
+}
+
+export interface FlashcardGetStatsParams {
+  /**
+   * Group ID
+   */
+  groupId?: string;
+
+  /**
+   * User ID
+   */
+  userId?: string;
+}
+
+export interface FlashcardRateParams {
+  /**
+   * Flashcard ID
+   */
+  cardId: string;
+
+  /**
+   * Rating (0-3)
+   */
+  rating: number;
+
+  /**
+   * Group ID (optional)
+   */
+  groupId?: string;
+
+  /**
+   * User ID (optional)
+   */
+  userId?: string;
+}
+
+export declare namespace Flashcards {
+  export {
+    type FlashcardBatchProcessResponse as FlashcardBatchProcessResponse,
+    type FlashcardGetAlgorithmInfoResponse as FlashcardGetAlgorithmInfoResponse,
+    type FlashcardGetTypesResponse as FlashcardGetTypesResponse,
+    type FlashcardBatchProcessParams as FlashcardBatchProcessParams,
+    type FlashcardGetAllParams as FlashcardGetAllParams,
+    type FlashcardGetDueParams as FlashcardGetDueParams,
+    type FlashcardGetStatsParams as FlashcardGetStatsParams,
+    type FlashcardRateParams as FlashcardRateParams,
+  };
+}