mirror of
https://github.com/Monadical-SAS/reflector.git
synced 2025-12-20 20:29:06 +00:00
* feat: calendar integration
* feat: add ICS calendar API endpoints for room configuration and sync
* feat: add Celery background tasks for ICS sync
* feat: implement Phase 2 - Multiple active meetings per room with grace period
This commit adds support for multiple concurrent meetings per room, implementing
grace period logic and improved meeting lifecycle management for calendar integration.
## Database Changes
- Remove unique constraint preventing multiple active meetings per room
- Add last_participant_left_at field to track when meeting becomes empty
- Add grace_period_minutes field (default: 15) for configurable grace period
## Meeting Controller Enhancements
- Add get_all_active_for_room() to retrieve all active meetings for a room
- Add get_active_by_calendar_event() to find meetings by calendar event ID
- Maintain backward compatibility with existing get_active() method
## New API Endpoints
- GET /rooms/{room_name}/meetings/active - List all active meetings
- POST /rooms/{room_name}/meetings/{meeting_id}/join - Join specific meeting
## Meeting Lifecycle Improvements
- 15-minute grace period after last participant leaves
- Automatic reactivation when participant rejoins during grace period
- Force close calendar meetings 30 minutes after scheduled end time
- Update process_meetings task to handle multiple active meetings
## Whereby Integration
- Clear grace period when participants join via webhook events
- Track participant count for grace period management
## Testing
- Add comprehensive tests for multiple active meetings
- Test grace period behavior and participant rejoin scenarios
- Test calendar meeting force closure logic
- All 5 new tests passing
This enables proper calendar integration with overlapping meetings while
preventing accidental meeting closures through the grace period mechanism.
* feat: implement frontend for calendar integration (Phase 3 & 4)
- Created MeetingSelection component for choosing between multiple active meetings
- Shows both active meetings and upcoming calendar events (30 min ahead)
- Displays meeting metadata with privacy controls (owner-only details)
- Supports creation of unscheduled meetings alongside calendar meetings
- Added waiting page for users joining before scheduled start time
- Shows countdown timer until meeting begins
- Auto-transitions to meeting when calendar event becomes active
- Handles early joining with proper routing
- Created collapsible info panel showing meeting details
- Displays calendar metadata (title, description, attendees)
- Shows participant count and duration
- Privacy-aware: sensitive info only visible to room owners
- Integrated ICS settings into room configuration dialog
- Test connection functionality with immediate feedback
- Manual sync trigger with detailed results
- Shows last sync time and ETag for monitoring
- Configurable sync intervals (1 min to 1 hour)
- New /room/{roomName} route for meeting selection
- Waiting room at /room/{roomName}/wait?eventId={id}
- Classic room page at /{roomName} with meeting info
- Uses sessionStorage to pass selected meeting between pages
- Added new endpoints for active/upcoming meetings
- Regenerated TypeScript client with latest OpenAPI spec
- Proper error handling and loading states
- Auto-refresh every 30 seconds for live updates
- Color-coded badges for meeting status
- Attendee status indicators (accepted/declined/tentative)
- Responsive design with Chakra UI components
- Clear visual hierarchy between active and upcoming meetings
- Smart truncation for long attendee lists
This completes the frontend implementation for calendar integration,
enabling users to seamlessly join scheduled meetings from their
calendar applications.
* WIP: Migrate calendar integration frontend to React Query
- Migrate all calendar components from useApi to React Query hooks
- Fix Chakra UI v3 compatibility issues (Card, Progress, spacing props, leftIcon)
- Update backend Meeting model to include calendar fields
- Replace imperative API calls with declarative React Query patterns
- Remove old OpenAPI generated files that conflict with new structure
* fix: alembic migrations
* feat: add calendar migration
* feat: update ics, first version working
* feat: implement tabbed interface for room edit dialog
- Add General, Calendar, and Share tabs to organize room settings
- Move ICS settings to dedicated Calendar tab
- Move Zulip configuration to Share tab
- Keep basic room settings and webhooks in General tab
- Remove redundant migration file
- Fix Chakra UI v3 compatibility issues in calendar components
🤖 Generated with [Claude Code](https://claude.ai/code)
Co-Authored-By: Claude <noreply@anthropic.com>
* fix: infinite loop
* feat: improve ICS calendar sync UX and fix room URL matching
- Replace "Test Connection" button with "Force Sync" button (Edit Room only)
- Show detailed sync results: total events downloaded vs room matches
- Remove emoticons and auto-hide timeout for cleaner UX
- Fix room URL matching to use UI_BASE_URL instead of BASE_URL
- Replace FaSync icon with LuRefreshCw for consistency
- Clear sync results when dialog closes or Force Sync pressed
- Update tests to reflect UI_BASE_URL change and exact URL matching
🤖 Generated with [Claude Code](https://claude.ai/code)
Co-Authored-By: Claude <noreply@anthropic.com>
* feat: reorganize room edit dialog and fix Force Sync button
- Move WebHook configuration from General to dedicated WebHook tab
- Add WebHook tab after Share tab in room edit dialog
- Fix Force Sync button not appearing by adding missing isEditing prop
- Fix indentation issues in MeetingSelection component
🤖 Generated with [Claude Code](https://claude.ai/code)
Co-Authored-By: Claude <noreply@anthropic.com>
* feat: complete calendar integration with UI improvements and code cleanup
Calendar Integration Tasks:
- Update upcoming meetings window from 30 to 120 minutes
- Include currently happening events in upcoming meetings API
- Create shared time utility functions (formatDateTime, formatCountdown, formatStartedAgo)
- Improve ongoing meetings UI logic with proper time detection
- Fix backend code organization and remove excessive documentation
UI/UX Improvements:
- Restructure room page layout using MinimalHeader pattern
- Remove borders from header and footer elements
- Change button text from "Leave Meeting" to "Leave Room"
- Remove "Back to Reflector" footer for cleaner design
- Extract WaitPageClient component for better separation
Backend Changes:
- calendar_events.py: Fix import organization and extend timing window
- rooms.py: Update API default from 30 to 120 minutes
- Enhanced test coverage for ongoing meeting scenarios
Frontend Changes:
- MinimalHeader: Add onLeave prop for custom navigation
- MeetingSelection: Complete layout restructure with shared utilities
- timeUtils: New shared utility file for consistent time formatting
🤖 Generated with [Claude Code](https://claude.ai/code)
Co-Authored-By: Claude <noreply@anthropic.com>
* feat: remove wait page and simplify Join button with 5-minute disable logic
- Remove entire wait page directory and associated files
- Update handleJoinUpcoming to create unscheduled meeting directly
- Simplify Join button to single state:
- Always shows "Join" text
- Blue when meeting can be joined (ongoing or within 5 minutes)
- Gray/disabled when more than 5 minutes away
- Remove confusing "Join Now", "Join Early" text variations
🤖 Generated with [Claude Code](https://claude.ai/code)
Co-Authored-By: Claude <noreply@anthropic.com>
* feat: improve calendar integration and meeting UI
- Refactor ICS sync tasks to use @asynctask decorator for cleaner async handling
- Extract meeting creation logic into reusable function
- Improve meeting selection UI with distinct current/upcoming sections
- Add early join functionality for upcoming meetings within 5-minute window
- Simplify non-ICS room workflow with direct Whereby embed
- Fix import paths and component organization
🤖 Generated with [Claude Code](https://claude.ai/code)
Co-Authored-By: Claude <noreply@anthropic.com>
* feat: restore original recording consent functionality
- Remove custom ConsentDialogButton and WherebyEmbed components
- Merge RoomClient logic back into main room page
- Restore original consent UI: blue button with toast modal
- Maintain calendar integration features for ICS-enabled rooms
- Add consent-handler.md documentation of original functionality
- Preserve focus management and accessibility features
* fix: redirect Join Now button to local meeting page
- Change handleJoinDirect to use onMeetingSelect instead of opening external URL
- Join Now button now navigates to /{roomName}/{meetingId} instead of whereby.com
- Maintains proper routing within the application
* feat: remove restrictive message for non-owners in private rooms
- Remove confusing message about room owner permissions
- Cleaner UI for all users regardless of ownership status
- Users will only see available meetings and join options
* feat: improve meeting selection UI for better readability
- Limit page content to max 800px width for better 4K display readability
- Remove LIVE tag badge for cleaner interface
- Remove shadow from main live meeting box
- Remove blue border and hover effects for minimal design
- Change background to neutral gray for less visual noise
* feat: add room by name endpoint for non-authenticated access
- Add GET /rooms/name/{room_name} backend endpoint
- Endpoint supports non-authenticated access for public rooms
- Returns RoomDetails with webhook fields hidden for non-owners
- Update useRoomGetByName hook to use new direct endpoint
- Remove authentication requirement from frontend hook
- Regenerate API client types
Fixes: Non-authenticated users can now access room lobbies
* feat: add friendly message when no meetings are ongoing
- Show centered message with calendar icon when no meetings are active
- Message text: 'No meetings right now' with helpful description
- Contextual text for owners/shared rooms mentioning quick meeting option
- Consistent gray styling matching the rest of the interface
- Only displays when both currentMeetings and upcomingMeetings are empty
* style: center no meetings message and remove background
- Change from Box to Flex with flex=1 for vertical centering
- Remove gray background, border radius, and padding
- Message now appears cleanly centered in available space
- Maintains horizontal and vertical centering
* feat: move Create Meeting button to header
- Remove 'Start a Quick Meeting' box from main content area
- Add showCreateButton and onCreateMeeting props to MinimalHeader
- Create Meeting button now appears in header left of Leave Room
- Only shows for room owners or shared room users
- Update no meetings message to remove reference to quick meeting below
- Cleaner, more accessible UI with actions in the header
* style: change room title and no meetings text to pure black
- Update room title in MinimalHeader from gray.700 to black
- Update 'No meetings right now' text from gray.700 to black
- Improves visual hierarchy and readability
- Consistent with other pages' styling
* style: linting
* fix: remove plan files
* fix: alembic migration with named foreign keys
* feat: add SyncStatus enum and refactor ICS sync to use rooms controller
- Add SyncStatus enum to replace string literals in ICS sync status
- Replace direct SQL queries in worker with rooms_controller.get_ics_enabled()
- Improve type safety and maintainability of ICS sync code
- Enum values: SUCCESS, UNCHANGED, ERROR, SKIPPED maintain backward compatibility
* refactor: remove unnecessary docstring from get_ics_enabled method
The function name is self-explanatory
* fix: import top level
* feat: use Literal type for ICSStatus.status field
- Changed ICSStatus.status from str to Literal['enabled', 'disabled']
- Improves type safety and API documentation
* feat: update TypeScript definitions for ICSStatus Literal type
- OpenAPI generation now properly reflects Literal['enabled', 'disabled'] type
- Improves type safety for frontend consumers of the API
- Applied automatic formatting via pre-commit hooks
* refactor: replace loguru with structlog in ics_sync service
- Replace loguru import with structlog in services/ics_sync.py
- Update logging calls to use structlog's structured format with keyword args
- Maintains consistency with other services using structlog
- Changes: logger.info(f'...') -> logger.info('...', key=value) format
* chore: remove loguru dependency and improve type annotations
- Remove loguru from dependencies in pyproject.toml (replaced with structlog)
- Update meeting controller methods to properly return Optional types
- Update dependency lock file after loguru removal
* fix: resolve pyflakes warnings in ics_sync and meetings modules
Remove unused imports and variables to clean up code quality
* Remove grace period logic and improve meeting deactivation
- Removed grace_period_minutes and last_participant_left_at fields
- Simplified deactivation logic based on actual usage patterns:
* Active sessions: Keep meeting active regardless of scheduled time
* Calendar meetings: Wait until scheduled end if unused, deactivate immediately once used and empty
* On-the-fly meetings: Deactivate immediately when empty
- Created migration to drop unused database columns
- Updated tests to remove grace period test cases
* Update test to match new deactivation logic for calendar meetings
* fix: remove unwanted file
* fix: incompleted changes from EVENT_WINDOW*
* fix: update room ICS API tests to include required webhook fields and correct URL
- Add webhook_url and webhook_secret fields to room creation tests
- Fix room URL matching in ICS sync test to use UI_BASE_URL instead of BASE_URL
- Aligns test with actual API requirements and ICS sync service implementation
* fix: add Redis distributed locking to prevent race conditions in process_meetings
- Implement per-meeting locks using Redis to prevent concurrent processing
- Add lock extension after slow API calls (Whereby) to handle long-running operations
- Use redis-py's built-in lock.extend() with replace_ttl=True for simple TTL refresh
- Track and log skipped meetings when locked by other workers
- Document SSRF analysis showing it's low-risk due to async worker isolation
This prevents multiple workers from processing the same meeting simultaneously,
which could cause state corruption or duplicate deactivations.
* refactor: rename MinimalHeader to MeetingMinimalHeader for clarity
* fix: minor code quality improvements - add emoji constants, fix type safety, cleanup comments
* fix: database migration
* self-pr review
* self-pr review
* self-pr review treeshake
* fix: local fixes
* fix: creation of meeting
* fix: meeting selection create button
* compile fix
* fix: meeting selection responsive
* fix: rework process logic for meeting
* fix: meeting useEffect frontend-only dedupe (#647)
* meeting useEffect frontend-only dedupe
* format
* also get room by name backend fix
---------
Co-authored-by: Igor Loskutov <igor.loskutoff@gmail.com>
* invalidate meeting list on new meeting
* test fix
* room url copy button for ics
* calendar refresh quick action icon
* remove work.md
* meeting page frontend fixes
* hide number of meeting participants
* Revert "hide number of meeting participants"
This reverts commit 38906c5d1a.
* ui bits
* ui bits
* remove log
* room name typing stricten
* feat: protect atomic operation involving external service with redlock
---------
Co-authored-by: Claude <noreply@anthropic.com>
Co-authored-by: Igor Monadical <igor@monadical.com>
Co-authored-by: Igor Loskutov <igor.loskutoff@gmail.com>
2987 lines
66 KiB
TypeScript
2987 lines
66 KiB
TypeScript
/**
|
|
* This file was auto-generated by openapi-typescript.
|
|
* Do not make direct changes to the file.
|
|
*/
|
|
|
|
export interface paths {
|
|
"/metrics": {
|
|
parameters: {
|
|
query?: never;
|
|
header?: never;
|
|
path?: never;
|
|
cookie?: never;
|
|
};
|
|
/**
|
|
* Metrics
|
|
* @description Endpoint that serves Prometheus metrics.
|
|
*/
|
|
get: operations["metrics"];
|
|
put?: never;
|
|
post?: never;
|
|
delete?: never;
|
|
options?: never;
|
|
head?: never;
|
|
patch?: never;
|
|
trace?: never;
|
|
};
|
|
"/v1/meetings/{meeting_id}/consent": {
|
|
parameters: {
|
|
query?: never;
|
|
header?: never;
|
|
path?: never;
|
|
cookie?: never;
|
|
};
|
|
get?: never;
|
|
put?: never;
|
|
/** Meeting Audio Consent */
|
|
post: operations["v1_meeting_audio_consent"];
|
|
delete?: never;
|
|
options?: never;
|
|
head?: never;
|
|
patch?: never;
|
|
trace?: never;
|
|
};
|
|
"/v1/meetings/{meeting_id}/deactivate": {
|
|
parameters: {
|
|
query?: never;
|
|
header?: never;
|
|
path?: never;
|
|
cookie?: never;
|
|
};
|
|
get?: never;
|
|
put?: never;
|
|
post?: never;
|
|
delete?: never;
|
|
options?: never;
|
|
head?: never;
|
|
/** Meeting Deactivate */
|
|
patch: operations["v1_meeting_deactivate"];
|
|
trace?: never;
|
|
};
|
|
"/v1/rooms": {
|
|
parameters: {
|
|
query?: never;
|
|
header?: never;
|
|
path?: never;
|
|
cookie?: never;
|
|
};
|
|
/** Rooms List */
|
|
get: operations["v1_rooms_list"];
|
|
put?: never;
|
|
/** Rooms Create */
|
|
post: operations["v1_rooms_create"];
|
|
delete?: never;
|
|
options?: never;
|
|
head?: never;
|
|
patch?: never;
|
|
trace?: never;
|
|
};
|
|
"/v1/rooms/{room_id}": {
|
|
parameters: {
|
|
query?: never;
|
|
header?: never;
|
|
path?: never;
|
|
cookie?: never;
|
|
};
|
|
/** Rooms Get */
|
|
get: operations["v1_rooms_get"];
|
|
put?: never;
|
|
post?: never;
|
|
/** Rooms Delete */
|
|
delete: operations["v1_rooms_delete"];
|
|
options?: never;
|
|
head?: never;
|
|
/** Rooms Update */
|
|
patch: operations["v1_rooms_update"];
|
|
trace?: never;
|
|
};
|
|
"/v1/rooms/name/{room_name}": {
|
|
parameters: {
|
|
query?: never;
|
|
header?: never;
|
|
path?: never;
|
|
cookie?: never;
|
|
};
|
|
/** Rooms Get By Name */
|
|
get: operations["v1_rooms_get_by_name"];
|
|
put?: never;
|
|
post?: never;
|
|
delete?: never;
|
|
options?: never;
|
|
head?: never;
|
|
patch?: never;
|
|
trace?: never;
|
|
};
|
|
"/v1/rooms/{room_name}/meeting": {
|
|
parameters: {
|
|
query?: never;
|
|
header?: never;
|
|
path?: never;
|
|
cookie?: never;
|
|
};
|
|
get?: never;
|
|
put?: never;
|
|
/** Rooms Create Meeting */
|
|
post: operations["v1_rooms_create_meeting"];
|
|
delete?: never;
|
|
options?: never;
|
|
head?: never;
|
|
patch?: never;
|
|
trace?: never;
|
|
};
|
|
"/v1/rooms/{room_id}/webhook/test": {
|
|
parameters: {
|
|
query?: never;
|
|
header?: never;
|
|
path?: never;
|
|
cookie?: never;
|
|
};
|
|
get?: never;
|
|
put?: never;
|
|
/**
|
|
* Rooms Test Webhook
|
|
* @description Test webhook configuration by sending a sample payload.
|
|
*/
|
|
post: operations["v1_rooms_test_webhook"];
|
|
delete?: never;
|
|
options?: never;
|
|
head?: never;
|
|
patch?: never;
|
|
trace?: never;
|
|
};
|
|
"/v1/rooms/{room_name}/ics/sync": {
|
|
parameters: {
|
|
query?: never;
|
|
header?: never;
|
|
path?: never;
|
|
cookie?: never;
|
|
};
|
|
get?: never;
|
|
put?: never;
|
|
/** Rooms Sync Ics */
|
|
post: operations["v1_rooms_sync_ics"];
|
|
delete?: never;
|
|
options?: never;
|
|
head?: never;
|
|
patch?: never;
|
|
trace?: never;
|
|
};
|
|
"/v1/rooms/{room_name}/ics/status": {
|
|
parameters: {
|
|
query?: never;
|
|
header?: never;
|
|
path?: never;
|
|
cookie?: never;
|
|
};
|
|
/** Rooms Ics Status */
|
|
get: operations["v1_rooms_ics_status"];
|
|
put?: never;
|
|
post?: never;
|
|
delete?: never;
|
|
options?: never;
|
|
head?: never;
|
|
patch?: never;
|
|
trace?: never;
|
|
};
|
|
"/v1/rooms/{room_name}/meetings": {
|
|
parameters: {
|
|
query?: never;
|
|
header?: never;
|
|
path?: never;
|
|
cookie?: never;
|
|
};
|
|
/** Rooms List Meetings */
|
|
get: operations["v1_rooms_list_meetings"];
|
|
put?: never;
|
|
post?: never;
|
|
delete?: never;
|
|
options?: never;
|
|
head?: never;
|
|
patch?: never;
|
|
trace?: never;
|
|
};
|
|
"/v1/rooms/{room_name}/meetings/upcoming": {
|
|
parameters: {
|
|
query?: never;
|
|
header?: never;
|
|
path?: never;
|
|
cookie?: never;
|
|
};
|
|
/** Rooms List Upcoming Meetings */
|
|
get: operations["v1_rooms_list_upcoming_meetings"];
|
|
put?: never;
|
|
post?: never;
|
|
delete?: never;
|
|
options?: never;
|
|
head?: never;
|
|
patch?: never;
|
|
trace?: never;
|
|
};
|
|
"/v1/rooms/{room_name}/meetings/active": {
|
|
parameters: {
|
|
query?: never;
|
|
header?: never;
|
|
path?: never;
|
|
cookie?: never;
|
|
};
|
|
/** Rooms List Active Meetings */
|
|
get: operations["v1_rooms_list_active_meetings"];
|
|
put?: never;
|
|
post?: never;
|
|
delete?: never;
|
|
options?: never;
|
|
head?: never;
|
|
patch?: never;
|
|
trace?: never;
|
|
};
|
|
"/v1/rooms/{room_name}/meetings/{meeting_id}": {
|
|
parameters: {
|
|
query?: never;
|
|
header?: never;
|
|
path?: never;
|
|
cookie?: never;
|
|
};
|
|
/**
|
|
* Rooms Get Meeting
|
|
* @description Get a single meeting by ID within a specific room.
|
|
*/
|
|
get: operations["v1_rooms_get_meeting"];
|
|
put?: never;
|
|
post?: never;
|
|
delete?: never;
|
|
options?: never;
|
|
head?: never;
|
|
patch?: never;
|
|
trace?: never;
|
|
};
|
|
"/v1/rooms/{room_name}/meetings/{meeting_id}/join": {
|
|
parameters: {
|
|
query?: never;
|
|
header?: never;
|
|
path?: never;
|
|
cookie?: never;
|
|
};
|
|
get?: never;
|
|
put?: never;
|
|
/** Rooms Join Meeting */
|
|
post: operations["v1_rooms_join_meeting"];
|
|
delete?: never;
|
|
options?: never;
|
|
head?: never;
|
|
patch?: never;
|
|
trace?: never;
|
|
};
|
|
"/v1/transcripts": {
|
|
parameters: {
|
|
query?: never;
|
|
header?: never;
|
|
path?: never;
|
|
cookie?: never;
|
|
};
|
|
/** Transcripts List */
|
|
get: operations["v1_transcripts_list"];
|
|
put?: never;
|
|
/** Transcripts Create */
|
|
post: operations["v1_transcripts_create"];
|
|
delete?: never;
|
|
options?: never;
|
|
head?: never;
|
|
patch?: never;
|
|
trace?: never;
|
|
};
|
|
"/v1/transcripts/search": {
|
|
parameters: {
|
|
query?: never;
|
|
header?: never;
|
|
path?: never;
|
|
cookie?: never;
|
|
};
|
|
/**
|
|
* Transcripts Search
|
|
* @description Full-text search across transcript titles and content.
|
|
*/
|
|
get: operations["v1_transcripts_search"];
|
|
put?: never;
|
|
post?: never;
|
|
delete?: never;
|
|
options?: never;
|
|
head?: never;
|
|
patch?: never;
|
|
trace?: never;
|
|
};
|
|
"/v1/transcripts/{transcript_id}": {
|
|
parameters: {
|
|
query?: never;
|
|
header?: never;
|
|
path?: never;
|
|
cookie?: never;
|
|
};
|
|
/** Transcript Get */
|
|
get: operations["v1_transcript_get"];
|
|
put?: never;
|
|
post?: never;
|
|
/** Transcript Delete */
|
|
delete: operations["v1_transcript_delete"];
|
|
options?: never;
|
|
head?: never;
|
|
/** Transcript Update */
|
|
patch: operations["v1_transcript_update"];
|
|
trace?: never;
|
|
};
|
|
"/v1/transcripts/{transcript_id}/topics": {
|
|
parameters: {
|
|
query?: never;
|
|
header?: never;
|
|
path?: never;
|
|
cookie?: never;
|
|
};
|
|
/** Transcript Get Topics */
|
|
get: operations["v1_transcript_get_topics"];
|
|
put?: never;
|
|
post?: never;
|
|
delete?: never;
|
|
options?: never;
|
|
head?: never;
|
|
patch?: never;
|
|
trace?: never;
|
|
};
|
|
"/v1/transcripts/{transcript_id}/topics/with-words": {
|
|
parameters: {
|
|
query?: never;
|
|
header?: never;
|
|
path?: never;
|
|
cookie?: never;
|
|
};
|
|
/** Transcript Get Topics With Words */
|
|
get: operations["v1_transcript_get_topics_with_words"];
|
|
put?: never;
|
|
post?: never;
|
|
delete?: never;
|
|
options?: never;
|
|
head?: never;
|
|
patch?: never;
|
|
trace?: never;
|
|
};
|
|
"/v1/transcripts/{transcript_id}/topics/{topic_id}/words-per-speaker": {
|
|
parameters: {
|
|
query?: never;
|
|
header?: never;
|
|
path?: never;
|
|
cookie?: never;
|
|
};
|
|
/** Transcript Get Topics With Words Per Speaker */
|
|
get: operations["v1_transcript_get_topics_with_words_per_speaker"];
|
|
put?: never;
|
|
post?: never;
|
|
delete?: never;
|
|
options?: never;
|
|
head?: never;
|
|
patch?: never;
|
|
trace?: never;
|
|
};
|
|
"/v1/transcripts/{transcript_id}/zulip": {
|
|
parameters: {
|
|
query?: never;
|
|
header?: never;
|
|
path?: never;
|
|
cookie?: never;
|
|
};
|
|
get?: never;
|
|
put?: never;
|
|
/** Transcript Post To Zulip */
|
|
post: operations["v1_transcript_post_to_zulip"];
|
|
delete?: never;
|
|
options?: never;
|
|
head?: never;
|
|
patch?: never;
|
|
trace?: never;
|
|
};
|
|
"/v1/transcripts/{transcript_id}/audio/mp3": {
|
|
parameters: {
|
|
query?: never;
|
|
header?: never;
|
|
path?: never;
|
|
cookie?: never;
|
|
};
|
|
/** Transcript Get Audio Mp3 */
|
|
get: operations["v1_transcript_get_audio_mp3"];
|
|
put?: never;
|
|
post?: never;
|
|
delete?: never;
|
|
options?: never;
|
|
/** Transcript Get Audio Mp3 */
|
|
head: operations["v1_transcript_head_audio_mp3"];
|
|
patch?: never;
|
|
trace?: never;
|
|
};
|
|
"/v1/transcripts/{transcript_id}/audio/waveform": {
|
|
parameters: {
|
|
query?: never;
|
|
header?: never;
|
|
path?: never;
|
|
cookie?: never;
|
|
};
|
|
/** Transcript Get Audio Waveform */
|
|
get: operations["v1_transcript_get_audio_waveform"];
|
|
put?: never;
|
|
post?: never;
|
|
delete?: never;
|
|
options?: never;
|
|
head?: never;
|
|
patch?: never;
|
|
trace?: never;
|
|
};
|
|
"/v1/transcripts/{transcript_id}/participants": {
|
|
parameters: {
|
|
query?: never;
|
|
header?: never;
|
|
path?: never;
|
|
cookie?: never;
|
|
};
|
|
/** Transcript Get Participants */
|
|
get: operations["v1_transcript_get_participants"];
|
|
put?: never;
|
|
/** Transcript Add Participant */
|
|
post: operations["v1_transcript_add_participant"];
|
|
delete?: never;
|
|
options?: never;
|
|
head?: never;
|
|
patch?: never;
|
|
trace?: never;
|
|
};
|
|
"/v1/transcripts/{transcript_id}/participants/{participant_id}": {
|
|
parameters: {
|
|
query?: never;
|
|
header?: never;
|
|
path?: never;
|
|
cookie?: never;
|
|
};
|
|
/** Transcript Get Participant */
|
|
get: operations["v1_transcript_get_participant"];
|
|
put?: never;
|
|
post?: never;
|
|
/** Transcript Delete Participant */
|
|
delete: operations["v1_transcript_delete_participant"];
|
|
options?: never;
|
|
head?: never;
|
|
/** Transcript Update Participant */
|
|
patch: operations["v1_transcript_update_participant"];
|
|
trace?: never;
|
|
};
|
|
"/v1/transcripts/{transcript_id}/speaker/assign": {
|
|
parameters: {
|
|
query?: never;
|
|
header?: never;
|
|
path?: never;
|
|
cookie?: never;
|
|
};
|
|
get?: never;
|
|
put?: never;
|
|
post?: never;
|
|
delete?: never;
|
|
options?: never;
|
|
head?: never;
|
|
/** Transcript Assign Speaker */
|
|
patch: operations["v1_transcript_assign_speaker"];
|
|
trace?: never;
|
|
};
|
|
"/v1/transcripts/{transcript_id}/speaker/merge": {
|
|
parameters: {
|
|
query?: never;
|
|
header?: never;
|
|
path?: never;
|
|
cookie?: never;
|
|
};
|
|
get?: never;
|
|
put?: never;
|
|
post?: never;
|
|
delete?: never;
|
|
options?: never;
|
|
head?: never;
|
|
/** Transcript Merge Speaker */
|
|
patch: operations["v1_transcript_merge_speaker"];
|
|
trace?: never;
|
|
};
|
|
"/v1/transcripts/{transcript_id}/record/upload": {
|
|
parameters: {
|
|
query?: never;
|
|
header?: never;
|
|
path?: never;
|
|
cookie?: never;
|
|
};
|
|
get?: never;
|
|
put?: never;
|
|
/** Transcript Record Upload */
|
|
post: operations["v1_transcript_record_upload"];
|
|
delete?: never;
|
|
options?: never;
|
|
head?: never;
|
|
patch?: never;
|
|
trace?: never;
|
|
};
|
|
"/v1/transcripts/{transcript_id}/events": {
|
|
parameters: {
|
|
query?: never;
|
|
header?: never;
|
|
path?: never;
|
|
cookie?: never;
|
|
};
|
|
/** Transcript Get Websocket Events */
|
|
get: operations["v1_transcript_get_websocket_events"];
|
|
put?: never;
|
|
post?: never;
|
|
delete?: never;
|
|
options?: never;
|
|
head?: never;
|
|
patch?: never;
|
|
trace?: never;
|
|
};
|
|
"/v1/transcripts/{transcript_id}/record/webrtc": {
|
|
parameters: {
|
|
query?: never;
|
|
header?: never;
|
|
path?: never;
|
|
cookie?: never;
|
|
};
|
|
get?: never;
|
|
put?: never;
|
|
/** Transcript Record Webrtc */
|
|
post: operations["v1_transcript_record_webrtc"];
|
|
delete?: never;
|
|
options?: never;
|
|
head?: never;
|
|
patch?: never;
|
|
trace?: never;
|
|
};
|
|
"/v1/transcripts/{transcript_id}/process": {
|
|
parameters: {
|
|
query?: never;
|
|
header?: never;
|
|
path?: never;
|
|
cookie?: never;
|
|
};
|
|
get?: never;
|
|
put?: never;
|
|
/** Transcript Process */
|
|
post: operations["v1_transcript_process"];
|
|
delete?: never;
|
|
options?: never;
|
|
head?: never;
|
|
patch?: never;
|
|
trace?: never;
|
|
};
|
|
"/v1/me": {
|
|
parameters: {
|
|
query?: never;
|
|
header?: never;
|
|
path?: never;
|
|
cookie?: never;
|
|
};
|
|
/** User Me */
|
|
get: operations["v1_user_me"];
|
|
put?: never;
|
|
post?: never;
|
|
delete?: never;
|
|
options?: never;
|
|
head?: never;
|
|
patch?: never;
|
|
trace?: never;
|
|
};
|
|
"/v1/zulip/streams": {
|
|
parameters: {
|
|
query?: never;
|
|
header?: never;
|
|
path?: never;
|
|
cookie?: never;
|
|
};
|
|
/**
|
|
* Zulip Get Streams
|
|
* @description Get all Zulip streams.
|
|
*/
|
|
get: operations["v1_zulip_get_streams"];
|
|
put?: never;
|
|
post?: never;
|
|
delete?: never;
|
|
options?: never;
|
|
head?: never;
|
|
patch?: never;
|
|
trace?: never;
|
|
};
|
|
"/v1/zulip/streams/{stream_id}/topics": {
|
|
parameters: {
|
|
query?: never;
|
|
header?: never;
|
|
path?: never;
|
|
cookie?: never;
|
|
};
|
|
/**
|
|
* Zulip Get Topics
|
|
* @description Get all topics for a specific Zulip stream.
|
|
*/
|
|
get: operations["v1_zulip_get_topics"];
|
|
put?: never;
|
|
post?: never;
|
|
delete?: never;
|
|
options?: never;
|
|
head?: never;
|
|
patch?: never;
|
|
trace?: never;
|
|
};
|
|
"/v1/whereby": {
|
|
parameters: {
|
|
query?: never;
|
|
header?: never;
|
|
path?: never;
|
|
cookie?: never;
|
|
};
|
|
get?: never;
|
|
put?: never;
|
|
/** Whereby Webhook */
|
|
post: operations["v1_whereby_webhook"];
|
|
delete?: never;
|
|
options?: never;
|
|
head?: never;
|
|
patch?: never;
|
|
trace?: never;
|
|
};
|
|
}
|
|
export type webhooks = Record<string, never>;
|
|
export interface components {
|
|
schemas: {
|
|
/** AudioWaveform */
|
|
AudioWaveform: {
|
|
/** Data */
|
|
data: number[];
|
|
};
|
|
/** Body_transcript_record_upload_v1_transcripts__transcript_id__record_upload_post */
|
|
Body_transcript_record_upload_v1_transcripts__transcript_id__record_upload_post: {
|
|
/**
|
|
* Chunk
|
|
* Format: binary
|
|
*/
|
|
chunk: string;
|
|
};
|
|
/** CalendarEventResponse */
|
|
CalendarEventResponse: {
|
|
/** Id */
|
|
id: string;
|
|
/** Room Id */
|
|
room_id: string;
|
|
/** Ics Uid */
|
|
ics_uid: string;
|
|
/** Title */
|
|
title?: string | null;
|
|
/** Description */
|
|
description?: string | null;
|
|
/**
|
|
* Start Time
|
|
* Format: date-time
|
|
*/
|
|
start_time: string;
|
|
/**
|
|
* End Time
|
|
* Format: date-time
|
|
*/
|
|
end_time: string;
|
|
/** Attendees */
|
|
attendees?:
|
|
| {
|
|
[key: string]: unknown;
|
|
}[]
|
|
| null;
|
|
/** Location */
|
|
location?: string | null;
|
|
/**
|
|
* Last Synced
|
|
* Format: date-time
|
|
*/
|
|
last_synced: string;
|
|
/**
|
|
* Created At
|
|
* Format: date-time
|
|
*/
|
|
created_at: string;
|
|
/**
|
|
* Updated At
|
|
* Format: date-time
|
|
*/
|
|
updated_at: string;
|
|
};
|
|
/** CreateParticipant */
|
|
CreateParticipant: {
|
|
/** Speaker */
|
|
speaker?: number | null;
|
|
/** Name */
|
|
name: string;
|
|
};
|
|
/** CreateRoom */
|
|
CreateRoom: {
|
|
/** Name */
|
|
name: string;
|
|
/** Zulip Auto Post */
|
|
zulip_auto_post: boolean;
|
|
/** Zulip Stream */
|
|
zulip_stream: string;
|
|
/** Zulip Topic */
|
|
zulip_topic: string;
|
|
/** Is Locked */
|
|
is_locked: boolean;
|
|
/** Room Mode */
|
|
room_mode: string;
|
|
/** Recording Type */
|
|
recording_type: string;
|
|
/** Recording Trigger */
|
|
recording_trigger: string;
|
|
/** Is Shared */
|
|
is_shared: boolean;
|
|
/** Webhook Url */
|
|
webhook_url: string;
|
|
/** Webhook Secret */
|
|
webhook_secret: string;
|
|
/** Ics Url */
|
|
ics_url?: string | null;
|
|
/**
|
|
* Ics Fetch Interval
|
|
* @default 300
|
|
*/
|
|
ics_fetch_interval: number;
|
|
/**
|
|
* Ics Enabled
|
|
* @default false
|
|
*/
|
|
ics_enabled: boolean;
|
|
};
|
|
/** CreateRoomMeeting */
|
|
CreateRoomMeeting: {
|
|
/**
|
|
* Allow Duplicated
|
|
* @default false
|
|
*/
|
|
allow_duplicated: boolean | null;
|
|
};
|
|
/** CreateTranscript */
|
|
CreateTranscript: {
|
|
/** Name */
|
|
name: string;
|
|
/**
|
|
* Source Language
|
|
* @default en
|
|
*/
|
|
source_language: string;
|
|
/**
|
|
* Target Language
|
|
* @default en
|
|
*/
|
|
target_language: string;
|
|
source_kind?: components["schemas"]["SourceKind"] | null;
|
|
};
|
|
/** DeletionStatus */
|
|
DeletionStatus: {
|
|
/** Status */
|
|
status: string;
|
|
};
|
|
/** GetTranscript */
|
|
GetTranscript: {
|
|
/** Id */
|
|
id: string;
|
|
/** User Id */
|
|
user_id: string | null;
|
|
/** Name */
|
|
name: string;
|
|
/**
|
|
* Status
|
|
* @enum {string}
|
|
*/
|
|
status:
|
|
| "idle"
|
|
| "uploaded"
|
|
| "recording"
|
|
| "processing"
|
|
| "error"
|
|
| "ended";
|
|
/** Locked */
|
|
locked: boolean;
|
|
/** Duration */
|
|
duration: number;
|
|
/** Title */
|
|
title: string | null;
|
|
/** Short Summary */
|
|
short_summary: string | null;
|
|
/** Long Summary */
|
|
long_summary: string | null;
|
|
/** Created At */
|
|
created_at: string;
|
|
/**
|
|
* Share Mode
|
|
* @default private
|
|
*/
|
|
share_mode: string;
|
|
/** Source Language */
|
|
source_language: string | null;
|
|
/** Target Language */
|
|
target_language: string | null;
|
|
/** Reviewed */
|
|
reviewed: boolean;
|
|
/** Meeting Id */
|
|
meeting_id: string | null;
|
|
source_kind: components["schemas"]["SourceKind"];
|
|
/** Room Id */
|
|
room_id?: string | null;
|
|
/** Room Name */
|
|
room_name?: string | null;
|
|
/** Audio Deleted */
|
|
audio_deleted?: boolean | null;
|
|
/** Participants */
|
|
participants: components["schemas"]["TranscriptParticipant"][] | null;
|
|
};
|
|
/** GetTranscriptMinimal */
|
|
GetTranscriptMinimal: {
|
|
/** Id */
|
|
id: string;
|
|
/** User Id */
|
|
user_id: string | null;
|
|
/** Name */
|
|
name: string;
|
|
/**
|
|
* Status
|
|
* @enum {string}
|
|
*/
|
|
status:
|
|
| "idle"
|
|
| "uploaded"
|
|
| "recording"
|
|
| "processing"
|
|
| "error"
|
|
| "ended";
|
|
/** Locked */
|
|
locked: boolean;
|
|
/** Duration */
|
|
duration: number;
|
|
/** Title */
|
|
title: string | null;
|
|
/** Short Summary */
|
|
short_summary: string | null;
|
|
/** Long Summary */
|
|
long_summary: string | null;
|
|
/** Created At */
|
|
created_at: string;
|
|
/**
|
|
* Share Mode
|
|
* @default private
|
|
*/
|
|
share_mode: string;
|
|
/** Source Language */
|
|
source_language: string | null;
|
|
/** Target Language */
|
|
target_language: string | null;
|
|
/** Reviewed */
|
|
reviewed: boolean;
|
|
/** Meeting Id */
|
|
meeting_id: string | null;
|
|
source_kind: components["schemas"]["SourceKind"];
|
|
/** Room Id */
|
|
room_id?: string | null;
|
|
/** Room Name */
|
|
room_name?: string | null;
|
|
/** Audio Deleted */
|
|
audio_deleted?: boolean | null;
|
|
};
|
|
/** GetTranscriptSegmentTopic */
|
|
GetTranscriptSegmentTopic: {
|
|
/** Text */
|
|
text: string;
|
|
/** Start */
|
|
start: number;
|
|
/** Speaker */
|
|
speaker: number;
|
|
};
|
|
/** GetTranscriptTopic */
|
|
GetTranscriptTopic: {
|
|
/** Id */
|
|
id: string;
|
|
/** Title */
|
|
title: string;
|
|
/** Summary */
|
|
summary: string;
|
|
/** Timestamp */
|
|
timestamp: number;
|
|
/** Duration */
|
|
duration: number | null;
|
|
/** Transcript */
|
|
transcript: string;
|
|
/**
|
|
* Segments
|
|
* @default []
|
|
*/
|
|
segments: components["schemas"]["GetTranscriptSegmentTopic"][];
|
|
};
|
|
/** GetTranscriptTopicWithWords */
|
|
GetTranscriptTopicWithWords: {
|
|
/** Id */
|
|
id: string;
|
|
/** Title */
|
|
title: string;
|
|
/** Summary */
|
|
summary: string;
|
|
/** Timestamp */
|
|
timestamp: number;
|
|
/** Duration */
|
|
duration: number | null;
|
|
/** Transcript */
|
|
transcript: string;
|
|
/**
|
|
* Segments
|
|
* @default []
|
|
*/
|
|
segments: components["schemas"]["GetTranscriptSegmentTopic"][];
|
|
/**
|
|
* Words
|
|
* @default []
|
|
*/
|
|
words: components["schemas"]["Word"][];
|
|
};
|
|
/** GetTranscriptTopicWithWordsPerSpeaker */
|
|
GetTranscriptTopicWithWordsPerSpeaker: {
|
|
/** Id */
|
|
id: string;
|
|
/** Title */
|
|
title: string;
|
|
/** Summary */
|
|
summary: string;
|
|
/** Timestamp */
|
|
timestamp: number;
|
|
/** Duration */
|
|
duration: number | null;
|
|
/** Transcript */
|
|
transcript: string;
|
|
/**
|
|
* Segments
|
|
* @default []
|
|
*/
|
|
segments: components["schemas"]["GetTranscriptSegmentTopic"][];
|
|
/**
|
|
* Words Per Speaker
|
|
* @default []
|
|
*/
|
|
words_per_speaker: components["schemas"]["SpeakerWords"][];
|
|
};
|
|
/** HTTPValidationError */
|
|
HTTPValidationError: {
|
|
/** Detail */
|
|
detail?: components["schemas"]["ValidationError"][];
|
|
};
|
|
/** ICSStatus */
|
|
ICSStatus: {
|
|
/**
|
|
* Status
|
|
* @enum {string}
|
|
*/
|
|
status: "enabled" | "disabled";
|
|
/** Last Sync */
|
|
last_sync?: string | null;
|
|
/** Next Sync */
|
|
next_sync?: string | null;
|
|
/** Last Etag */
|
|
last_etag?: string | null;
|
|
/**
|
|
* Events Count
|
|
* @default 0
|
|
*/
|
|
events_count: number;
|
|
};
|
|
/** ICSSyncResult */
|
|
ICSSyncResult: {
|
|
status: components["schemas"]["SyncStatus"];
|
|
/** Hash */
|
|
hash?: string | null;
|
|
/**
|
|
* Events Found
|
|
* @default 0
|
|
*/
|
|
events_found: number;
|
|
/**
|
|
* Total Events
|
|
* @default 0
|
|
*/
|
|
total_events: number;
|
|
/**
|
|
* Events Created
|
|
* @default 0
|
|
*/
|
|
events_created: number;
|
|
/**
|
|
* Events Updated
|
|
* @default 0
|
|
*/
|
|
events_updated: number;
|
|
/**
|
|
* Events Deleted
|
|
* @default 0
|
|
*/
|
|
events_deleted: number;
|
|
/** Error */
|
|
error?: string | null;
|
|
/** Reason */
|
|
reason?: string | null;
|
|
};
|
|
/** Meeting */
|
|
Meeting: {
|
|
/** Id */
|
|
id: string;
|
|
/** Room Name */
|
|
room_name: string;
|
|
/** Room Url */
|
|
room_url: string;
|
|
/** Host Room Url */
|
|
host_room_url: string;
|
|
/**
|
|
* Start Date
|
|
* Format: date-time
|
|
*/
|
|
start_date: string;
|
|
/**
|
|
* End Date
|
|
* Format: date-time
|
|
*/
|
|
end_date: string;
|
|
/** User Id */
|
|
user_id?: string | null;
|
|
/** Room Id */
|
|
room_id?: string | null;
|
|
/**
|
|
* Is Locked
|
|
* @default false
|
|
*/
|
|
is_locked: boolean;
|
|
/**
|
|
* Room Mode
|
|
* @default normal
|
|
* @enum {string}
|
|
*/
|
|
room_mode: "normal" | "group";
|
|
/**
|
|
* Recording Type
|
|
* @default cloud
|
|
* @enum {string}
|
|
*/
|
|
recording_type: "none" | "local" | "cloud";
|
|
/**
|
|
* Recording Trigger
|
|
* @default automatic-2nd-participant
|
|
* @enum {string}
|
|
*/
|
|
recording_trigger:
|
|
| "none"
|
|
| "prompt"
|
|
| "automatic"
|
|
| "automatic-2nd-participant";
|
|
/**
|
|
* Num Clients
|
|
* @default 0
|
|
*/
|
|
num_clients: number;
|
|
/**
|
|
* Is Active
|
|
* @default true
|
|
*/
|
|
is_active: boolean;
|
|
/** Calendar Event Id */
|
|
calendar_event_id?: string | null;
|
|
/** Calendar Metadata */
|
|
calendar_metadata?: {
|
|
[key: string]: unknown;
|
|
} | null;
|
|
};
|
|
/** MeetingConsentRequest */
|
|
MeetingConsentRequest: {
|
|
/** Consent Given */
|
|
consent_given: boolean;
|
|
};
|
|
/** Page[GetTranscriptMinimal] */
|
|
Page_GetTranscriptMinimal_: {
|
|
/** Items */
|
|
items: components["schemas"]["GetTranscriptMinimal"][];
|
|
/** Total */
|
|
total?: number | null;
|
|
/** Page */
|
|
page: number | null;
|
|
/** Size */
|
|
size: number | null;
|
|
/** Pages */
|
|
pages?: number | null;
|
|
};
|
|
/** Page[RoomDetails] */
|
|
Page_RoomDetails_: {
|
|
/** Items */
|
|
items: components["schemas"]["RoomDetails"][];
|
|
/** Total */
|
|
total?: number | null;
|
|
/** Page */
|
|
page: number | null;
|
|
/** Size */
|
|
size: number | null;
|
|
/** Pages */
|
|
pages?: number | null;
|
|
};
|
|
/** Participant */
|
|
Participant: {
|
|
/** Id */
|
|
id: string;
|
|
/** Speaker */
|
|
speaker: number | null;
|
|
/** Name */
|
|
name: string;
|
|
};
|
|
/** Room */
|
|
Room: {
|
|
/** Id */
|
|
id: string;
|
|
/** Name */
|
|
name: string;
|
|
/** User Id */
|
|
user_id: string;
|
|
/**
|
|
* Created At
|
|
* Format: date-time
|
|
*/
|
|
created_at: string;
|
|
/** Zulip Auto Post */
|
|
zulip_auto_post: boolean;
|
|
/** Zulip Stream */
|
|
zulip_stream: string;
|
|
/** Zulip Topic */
|
|
zulip_topic: string;
|
|
/** Is Locked */
|
|
is_locked: boolean;
|
|
/** Room Mode */
|
|
room_mode: string;
|
|
/** Recording Type */
|
|
recording_type: string;
|
|
/** Recording Trigger */
|
|
recording_trigger: string;
|
|
/** Is Shared */
|
|
is_shared: boolean;
|
|
/** Ics Url */
|
|
ics_url?: string | null;
|
|
/**
|
|
* Ics Fetch Interval
|
|
* @default 300
|
|
*/
|
|
ics_fetch_interval: number;
|
|
/**
|
|
* Ics Enabled
|
|
* @default false
|
|
*/
|
|
ics_enabled: boolean;
|
|
/** Ics Last Sync */
|
|
ics_last_sync?: string | null;
|
|
/** Ics Last Etag */
|
|
ics_last_etag?: string | null;
|
|
};
|
|
/** RoomDetails */
|
|
RoomDetails: {
|
|
/** Id */
|
|
id: string;
|
|
/** Name */
|
|
name: string;
|
|
/** User Id */
|
|
user_id: string;
|
|
/**
|
|
* Created At
|
|
* Format: date-time
|
|
*/
|
|
created_at: string;
|
|
/** Zulip Auto Post */
|
|
zulip_auto_post: boolean;
|
|
/** Zulip Stream */
|
|
zulip_stream: string;
|
|
/** Zulip Topic */
|
|
zulip_topic: string;
|
|
/** Is Locked */
|
|
is_locked: boolean;
|
|
/** Room Mode */
|
|
room_mode: string;
|
|
/** Recording Type */
|
|
recording_type: string;
|
|
/** Recording Trigger */
|
|
recording_trigger: string;
|
|
/** Is Shared */
|
|
is_shared: boolean;
|
|
/** Ics Url */
|
|
ics_url?: string | null;
|
|
/**
|
|
* Ics Fetch Interval
|
|
* @default 300
|
|
*/
|
|
ics_fetch_interval: number;
|
|
/**
|
|
* Ics Enabled
|
|
* @default false
|
|
*/
|
|
ics_enabled: boolean;
|
|
/** Ics Last Sync */
|
|
ics_last_sync?: string | null;
|
|
/** Ics Last Etag */
|
|
ics_last_etag?: string | null;
|
|
/** Webhook Url */
|
|
webhook_url: string | null;
|
|
/** Webhook Secret */
|
|
webhook_secret: string | null;
|
|
};
|
|
/** RtcOffer */
|
|
RtcOffer: {
|
|
/** Sdp */
|
|
sdp: string;
|
|
/** Type */
|
|
type: string;
|
|
};
|
|
/** SearchResponse */
|
|
SearchResponse: {
|
|
/** Results */
|
|
results: components["schemas"]["SearchResult"][];
|
|
/**
|
|
* Total
|
|
* @description Total number of search results
|
|
*/
|
|
total: number;
|
|
/** Query */
|
|
query?: string | null;
|
|
/**
|
|
* Limit
|
|
* @description Results per page
|
|
*/
|
|
limit: number;
|
|
/**
|
|
* Offset
|
|
* @description Number of results to skip
|
|
*/
|
|
offset: number;
|
|
};
|
|
/**
|
|
* SearchResult
|
|
* @description Public search result model with computed fields.
|
|
*/
|
|
SearchResult: {
|
|
/** Id */
|
|
id: string;
|
|
/** Title */
|
|
title?: string | null;
|
|
/** User Id */
|
|
user_id?: string | null;
|
|
/** Room Id */
|
|
room_id?: string | null;
|
|
/** Room Name */
|
|
room_name?: string | null;
|
|
source_kind: components["schemas"]["SourceKind"];
|
|
/** Created At */
|
|
created_at: string;
|
|
/**
|
|
* Status
|
|
* @enum {string}
|
|
*/
|
|
status:
|
|
| "idle"
|
|
| "uploaded"
|
|
| "recording"
|
|
| "processing"
|
|
| "error"
|
|
| "ended";
|
|
/** Rank */
|
|
rank: number;
|
|
/**
|
|
* Duration
|
|
* @description Duration in seconds
|
|
*/
|
|
duration: number | null;
|
|
/**
|
|
* Search Snippets
|
|
* @description Text snippets around search matches
|
|
*/
|
|
search_snippets: string[];
|
|
/**
|
|
* Total Match Count
|
|
* @description Total number of matches found in the transcript
|
|
* @default 0
|
|
*/
|
|
total_match_count: number;
|
|
};
|
|
/**
|
|
* SourceKind
|
|
* @enum {string}
|
|
*/
|
|
SourceKind: "room" | "live" | "file";
|
|
/** SpeakerAssignment */
|
|
SpeakerAssignment: {
|
|
/** Speaker */
|
|
speaker?: number | null;
|
|
/** Participant */
|
|
participant?: string | null;
|
|
/** Timestamp From */
|
|
timestamp_from: number;
|
|
/** Timestamp To */
|
|
timestamp_to: number;
|
|
};
|
|
/** SpeakerAssignmentStatus */
|
|
SpeakerAssignmentStatus: {
|
|
/** Status */
|
|
status: string;
|
|
};
|
|
/** SpeakerMerge */
|
|
SpeakerMerge: {
|
|
/** Speaker From */
|
|
speaker_from: number;
|
|
/** Speaker To */
|
|
speaker_to: number;
|
|
};
|
|
/** SpeakerWords */
|
|
SpeakerWords: {
|
|
/** Speaker */
|
|
speaker: number;
|
|
/** Words */
|
|
words: components["schemas"]["Word"][];
|
|
};
|
|
/** Stream */
|
|
Stream: {
|
|
/** Stream Id */
|
|
stream_id: number;
|
|
/** Name */
|
|
name: string;
|
|
};
|
|
/**
|
|
* SyncStatus
|
|
* @enum {string}
|
|
*/
|
|
SyncStatus: "success" | "unchanged" | "error" | "skipped";
|
|
/** Topic */
|
|
Topic: {
|
|
/** Name */
|
|
name: string;
|
|
};
|
|
/** TranscriptParticipant */
|
|
TranscriptParticipant: {
|
|
/** Id */
|
|
id?: string;
|
|
/** Speaker */
|
|
speaker: number | null;
|
|
/** Name */
|
|
name: string;
|
|
};
|
|
/** UpdateParticipant */
|
|
UpdateParticipant: {
|
|
/** Speaker */
|
|
speaker?: number | null;
|
|
/** Name */
|
|
name?: string | null;
|
|
};
|
|
/** UpdateRoom */
|
|
UpdateRoom: {
|
|
/** Name */
|
|
name?: string | null;
|
|
/** Zulip Auto Post */
|
|
zulip_auto_post?: boolean | null;
|
|
/** Zulip Stream */
|
|
zulip_stream?: string | null;
|
|
/** Zulip Topic */
|
|
zulip_topic?: string | null;
|
|
/** Is Locked */
|
|
is_locked?: boolean | null;
|
|
/** Room Mode */
|
|
room_mode?: string | null;
|
|
/** Recording Type */
|
|
recording_type?: string | null;
|
|
/** Recording Trigger */
|
|
recording_trigger?: string | null;
|
|
/** Is Shared */
|
|
is_shared?: boolean | null;
|
|
/** Webhook Url */
|
|
webhook_url?: string | null;
|
|
/** Webhook Secret */
|
|
webhook_secret?: string | null;
|
|
/** Ics Url */
|
|
ics_url?: string | null;
|
|
/** Ics Fetch Interval */
|
|
ics_fetch_interval?: number | null;
|
|
/** Ics Enabled */
|
|
ics_enabled?: boolean | null;
|
|
};
|
|
/** UpdateTranscript */
|
|
UpdateTranscript: {
|
|
/** Name */
|
|
name?: string | null;
|
|
/** Locked */
|
|
locked?: boolean | null;
|
|
/** Title */
|
|
title?: string | null;
|
|
/** Short Summary */
|
|
short_summary?: string | null;
|
|
/** Long Summary */
|
|
long_summary?: string | null;
|
|
/** Share Mode */
|
|
share_mode?: ("public" | "semi-private" | "private") | null;
|
|
/** Participants */
|
|
participants?: components["schemas"]["TranscriptParticipant"][] | null;
|
|
/** Reviewed */
|
|
reviewed?: boolean | null;
|
|
/** Audio Deleted */
|
|
audio_deleted?: boolean | null;
|
|
};
|
|
/** UserInfo */
|
|
UserInfo: {
|
|
/** Sub */
|
|
sub: string;
|
|
/** Email */
|
|
email: string | null;
|
|
/** Email Verified */
|
|
email_verified: boolean | null;
|
|
};
|
|
/** ValidationError */
|
|
ValidationError: {
|
|
/** Location */
|
|
loc: (string | number)[];
|
|
/** Message */
|
|
msg: string;
|
|
/** Error Type */
|
|
type: string;
|
|
};
|
|
/** WebhookTestResult */
|
|
WebhookTestResult: {
|
|
/** Success */
|
|
success: boolean;
|
|
/**
|
|
* Message
|
|
* @default
|
|
*/
|
|
message: string;
|
|
/**
|
|
* Error
|
|
* @default
|
|
*/
|
|
error: string;
|
|
/** Status Code */
|
|
status_code?: number | null;
|
|
/** Response Preview */
|
|
response_preview?: string | null;
|
|
};
|
|
/** WherebyWebhookEvent */
|
|
WherebyWebhookEvent: {
|
|
/** Apiversion */
|
|
apiVersion: string;
|
|
/** Id */
|
|
id: string;
|
|
/**
|
|
* Createdat
|
|
* Format: date-time
|
|
*/
|
|
createdAt: string;
|
|
/** Type */
|
|
type: string;
|
|
/** Data */
|
|
data: {
|
|
[key: string]: unknown;
|
|
};
|
|
};
|
|
/** Word */
|
|
Word: {
|
|
/** Text */
|
|
text: string;
|
|
/**
|
|
* Start
|
|
* @description Time in seconds with float part
|
|
*/
|
|
start: number;
|
|
/**
|
|
* End
|
|
* @description Time in seconds with float part
|
|
*/
|
|
end: number;
|
|
/**
|
|
* Speaker
|
|
* @default 0
|
|
*/
|
|
speaker: number;
|
|
};
|
|
};
|
|
responses: never;
|
|
parameters: never;
|
|
requestBodies: never;
|
|
headers: never;
|
|
pathItems: never;
|
|
}
|
|
export type $defs = Record<string, never>;
|
|
export interface operations {
|
|
metrics: {
|
|
parameters: {
|
|
query?: never;
|
|
header?: never;
|
|
path?: never;
|
|
cookie?: never;
|
|
};
|
|
requestBody?: never;
|
|
responses: {
|
|
/** @description Successful Response */
|
|
200: {
|
|
headers: {
|
|
[name: string]: unknown;
|
|
};
|
|
content: {
|
|
"application/json": unknown;
|
|
};
|
|
};
|
|
};
|
|
};
|
|
v1_meeting_audio_consent: {
|
|
parameters: {
|
|
query?: never;
|
|
header?: never;
|
|
path: {
|
|
meeting_id: string;
|
|
};
|
|
cookie?: never;
|
|
};
|
|
requestBody: {
|
|
content: {
|
|
"application/json": components["schemas"]["MeetingConsentRequest"];
|
|
};
|
|
};
|
|
responses: {
|
|
/** @description Successful Response */
|
|
200: {
|
|
headers: {
|
|
[name: string]: unknown;
|
|
};
|
|
content: {
|
|
"application/json": unknown;
|
|
};
|
|
};
|
|
/** @description Validation Error */
|
|
422: {
|
|
headers: {
|
|
[name: string]: unknown;
|
|
};
|
|
content: {
|
|
"application/json": components["schemas"]["HTTPValidationError"];
|
|
};
|
|
};
|
|
};
|
|
};
|
|
v1_meeting_deactivate: {
|
|
parameters: {
|
|
query?: never;
|
|
header?: never;
|
|
path: {
|
|
meeting_id: string;
|
|
};
|
|
cookie?: never;
|
|
};
|
|
requestBody?: never;
|
|
responses: {
|
|
/** @description Successful Response */
|
|
200: {
|
|
headers: {
|
|
[name: string]: unknown;
|
|
};
|
|
content: {
|
|
"application/json": unknown;
|
|
};
|
|
};
|
|
/** @description Validation Error */
|
|
422: {
|
|
headers: {
|
|
[name: string]: unknown;
|
|
};
|
|
content: {
|
|
"application/json": components["schemas"]["HTTPValidationError"];
|
|
};
|
|
};
|
|
};
|
|
};
|
|
v1_rooms_list: {
|
|
parameters: {
|
|
query?: {
|
|
/** @description Page number */
|
|
page?: number;
|
|
/** @description Page size */
|
|
size?: number;
|
|
};
|
|
header?: never;
|
|
path?: never;
|
|
cookie?: never;
|
|
};
|
|
requestBody?: never;
|
|
responses: {
|
|
/** @description Successful Response */
|
|
200: {
|
|
headers: {
|
|
[name: string]: unknown;
|
|
};
|
|
content: {
|
|
"application/json": components["schemas"]["Page_RoomDetails_"];
|
|
};
|
|
};
|
|
/** @description Validation Error */
|
|
422: {
|
|
headers: {
|
|
[name: string]: unknown;
|
|
};
|
|
content: {
|
|
"application/json": components["schemas"]["HTTPValidationError"];
|
|
};
|
|
};
|
|
};
|
|
};
|
|
v1_rooms_create: {
|
|
parameters: {
|
|
query?: never;
|
|
header?: never;
|
|
path?: never;
|
|
cookie?: never;
|
|
};
|
|
requestBody: {
|
|
content: {
|
|
"application/json": components["schemas"]["CreateRoom"];
|
|
};
|
|
};
|
|
responses: {
|
|
/** @description Successful Response */
|
|
200: {
|
|
headers: {
|
|
[name: string]: unknown;
|
|
};
|
|
content: {
|
|
"application/json": components["schemas"]["Room"];
|
|
};
|
|
};
|
|
/** @description Validation Error */
|
|
422: {
|
|
headers: {
|
|
[name: string]: unknown;
|
|
};
|
|
content: {
|
|
"application/json": components["schemas"]["HTTPValidationError"];
|
|
};
|
|
};
|
|
};
|
|
};
|
|
v1_rooms_get: {
|
|
parameters: {
|
|
query?: never;
|
|
header?: never;
|
|
path: {
|
|
room_id: string;
|
|
};
|
|
cookie?: never;
|
|
};
|
|
requestBody?: never;
|
|
responses: {
|
|
/** @description Successful Response */
|
|
200: {
|
|
headers: {
|
|
[name: string]: unknown;
|
|
};
|
|
content: {
|
|
"application/json": components["schemas"]["RoomDetails"];
|
|
};
|
|
};
|
|
/** @description Validation Error */
|
|
422: {
|
|
headers: {
|
|
[name: string]: unknown;
|
|
};
|
|
content: {
|
|
"application/json": components["schemas"]["HTTPValidationError"];
|
|
};
|
|
};
|
|
};
|
|
};
|
|
v1_rooms_delete: {
|
|
parameters: {
|
|
query?: never;
|
|
header?: never;
|
|
path: {
|
|
room_id: string;
|
|
};
|
|
cookie?: never;
|
|
};
|
|
requestBody?: never;
|
|
responses: {
|
|
/** @description Successful Response */
|
|
200: {
|
|
headers: {
|
|
[name: string]: unknown;
|
|
};
|
|
content: {
|
|
"application/json": components["schemas"]["DeletionStatus"];
|
|
};
|
|
};
|
|
/** @description Validation Error */
|
|
422: {
|
|
headers: {
|
|
[name: string]: unknown;
|
|
};
|
|
content: {
|
|
"application/json": components["schemas"]["HTTPValidationError"];
|
|
};
|
|
};
|
|
};
|
|
};
|
|
v1_rooms_update: {
|
|
parameters: {
|
|
query?: never;
|
|
header?: never;
|
|
path: {
|
|
room_id: string;
|
|
};
|
|
cookie?: never;
|
|
};
|
|
requestBody: {
|
|
content: {
|
|
"application/json": components["schemas"]["UpdateRoom"];
|
|
};
|
|
};
|
|
responses: {
|
|
/** @description Successful Response */
|
|
200: {
|
|
headers: {
|
|
[name: string]: unknown;
|
|
};
|
|
content: {
|
|
"application/json": components["schemas"]["RoomDetails"];
|
|
};
|
|
};
|
|
/** @description Validation Error */
|
|
422: {
|
|
headers: {
|
|
[name: string]: unknown;
|
|
};
|
|
content: {
|
|
"application/json": components["schemas"]["HTTPValidationError"];
|
|
};
|
|
};
|
|
};
|
|
};
|
|
v1_rooms_get_by_name: {
|
|
parameters: {
|
|
query?: never;
|
|
header?: never;
|
|
path: {
|
|
room_name: string;
|
|
};
|
|
cookie?: never;
|
|
};
|
|
requestBody?: never;
|
|
responses: {
|
|
/** @description Successful Response */
|
|
200: {
|
|
headers: {
|
|
[name: string]: unknown;
|
|
};
|
|
content: {
|
|
"application/json": components["schemas"]["RoomDetails"];
|
|
};
|
|
};
|
|
/** @description Validation Error */
|
|
422: {
|
|
headers: {
|
|
[name: string]: unknown;
|
|
};
|
|
content: {
|
|
"application/json": components["schemas"]["HTTPValidationError"];
|
|
};
|
|
};
|
|
};
|
|
};
|
|
v1_rooms_create_meeting: {
|
|
parameters: {
|
|
query?: never;
|
|
header?: never;
|
|
path: {
|
|
room_name: string;
|
|
};
|
|
cookie?: never;
|
|
};
|
|
requestBody: {
|
|
content: {
|
|
"application/json": components["schemas"]["CreateRoomMeeting"];
|
|
};
|
|
};
|
|
responses: {
|
|
/** @description Successful Response */
|
|
200: {
|
|
headers: {
|
|
[name: string]: unknown;
|
|
};
|
|
content: {
|
|
"application/json": components["schemas"]["Meeting"];
|
|
};
|
|
};
|
|
/** @description Validation Error */
|
|
422: {
|
|
headers: {
|
|
[name: string]: unknown;
|
|
};
|
|
content: {
|
|
"application/json": components["schemas"]["HTTPValidationError"];
|
|
};
|
|
};
|
|
};
|
|
};
|
|
v1_rooms_test_webhook: {
|
|
parameters: {
|
|
query?: never;
|
|
header?: never;
|
|
path: {
|
|
room_id: string;
|
|
};
|
|
cookie?: never;
|
|
};
|
|
requestBody?: never;
|
|
responses: {
|
|
/** @description Successful Response */
|
|
200: {
|
|
headers: {
|
|
[name: string]: unknown;
|
|
};
|
|
content: {
|
|
"application/json": components["schemas"]["WebhookTestResult"];
|
|
};
|
|
};
|
|
/** @description Validation Error */
|
|
422: {
|
|
headers: {
|
|
[name: string]: unknown;
|
|
};
|
|
content: {
|
|
"application/json": components["schemas"]["HTTPValidationError"];
|
|
};
|
|
};
|
|
};
|
|
};
|
|
v1_rooms_sync_ics: {
|
|
parameters: {
|
|
query?: never;
|
|
header?: never;
|
|
path: {
|
|
room_name: string;
|
|
};
|
|
cookie?: never;
|
|
};
|
|
requestBody?: never;
|
|
responses: {
|
|
/** @description Successful Response */
|
|
200: {
|
|
headers: {
|
|
[name: string]: unknown;
|
|
};
|
|
content: {
|
|
"application/json": components["schemas"]["ICSSyncResult"];
|
|
};
|
|
};
|
|
/** @description Validation Error */
|
|
422: {
|
|
headers: {
|
|
[name: string]: unknown;
|
|
};
|
|
content: {
|
|
"application/json": components["schemas"]["HTTPValidationError"];
|
|
};
|
|
};
|
|
};
|
|
};
|
|
v1_rooms_ics_status: {
|
|
parameters: {
|
|
query?: never;
|
|
header?: never;
|
|
path: {
|
|
room_name: string;
|
|
};
|
|
cookie?: never;
|
|
};
|
|
requestBody?: never;
|
|
responses: {
|
|
/** @description Successful Response */
|
|
200: {
|
|
headers: {
|
|
[name: string]: unknown;
|
|
};
|
|
content: {
|
|
"application/json": components["schemas"]["ICSStatus"];
|
|
};
|
|
};
|
|
/** @description Validation Error */
|
|
422: {
|
|
headers: {
|
|
[name: string]: unknown;
|
|
};
|
|
content: {
|
|
"application/json": components["schemas"]["HTTPValidationError"];
|
|
};
|
|
};
|
|
};
|
|
};
|
|
v1_rooms_list_meetings: {
|
|
parameters: {
|
|
query?: never;
|
|
header?: never;
|
|
path: {
|
|
room_name: string;
|
|
};
|
|
cookie?: never;
|
|
};
|
|
requestBody?: never;
|
|
responses: {
|
|
/** @description Successful Response */
|
|
200: {
|
|
headers: {
|
|
[name: string]: unknown;
|
|
};
|
|
content: {
|
|
"application/json": components["schemas"]["CalendarEventResponse"][];
|
|
};
|
|
};
|
|
/** @description Validation Error */
|
|
422: {
|
|
headers: {
|
|
[name: string]: unknown;
|
|
};
|
|
content: {
|
|
"application/json": components["schemas"]["HTTPValidationError"];
|
|
};
|
|
};
|
|
};
|
|
};
|
|
v1_rooms_list_upcoming_meetings: {
|
|
parameters: {
|
|
query?: {
|
|
minutes_ahead?: number;
|
|
};
|
|
header?: never;
|
|
path: {
|
|
room_name: string;
|
|
};
|
|
cookie?: never;
|
|
};
|
|
requestBody?: never;
|
|
responses: {
|
|
/** @description Successful Response */
|
|
200: {
|
|
headers: {
|
|
[name: string]: unknown;
|
|
};
|
|
content: {
|
|
"application/json": components["schemas"]["CalendarEventResponse"][];
|
|
};
|
|
};
|
|
/** @description Validation Error */
|
|
422: {
|
|
headers: {
|
|
[name: string]: unknown;
|
|
};
|
|
content: {
|
|
"application/json": components["schemas"]["HTTPValidationError"];
|
|
};
|
|
};
|
|
};
|
|
};
|
|
v1_rooms_list_active_meetings: {
|
|
parameters: {
|
|
query?: never;
|
|
header?: never;
|
|
path: {
|
|
room_name: string;
|
|
};
|
|
cookie?: never;
|
|
};
|
|
requestBody?: never;
|
|
responses: {
|
|
/** @description Successful Response */
|
|
200: {
|
|
headers: {
|
|
[name: string]: unknown;
|
|
};
|
|
content: {
|
|
"application/json": components["schemas"]["Meeting"][];
|
|
};
|
|
};
|
|
/** @description Validation Error */
|
|
422: {
|
|
headers: {
|
|
[name: string]: unknown;
|
|
};
|
|
content: {
|
|
"application/json": components["schemas"]["HTTPValidationError"];
|
|
};
|
|
};
|
|
};
|
|
};
|
|
v1_rooms_get_meeting: {
|
|
parameters: {
|
|
query?: never;
|
|
header?: never;
|
|
path: {
|
|
room_name: string;
|
|
meeting_id: string;
|
|
};
|
|
cookie?: never;
|
|
};
|
|
requestBody?: never;
|
|
responses: {
|
|
/** @description Successful Response */
|
|
200: {
|
|
headers: {
|
|
[name: string]: unknown;
|
|
};
|
|
content: {
|
|
"application/json": components["schemas"]["Meeting"];
|
|
};
|
|
};
|
|
/** @description Validation Error */
|
|
422: {
|
|
headers: {
|
|
[name: string]: unknown;
|
|
};
|
|
content: {
|
|
"application/json": components["schemas"]["HTTPValidationError"];
|
|
};
|
|
};
|
|
};
|
|
};
|
|
v1_rooms_join_meeting: {
|
|
parameters: {
|
|
query?: never;
|
|
header?: never;
|
|
path: {
|
|
room_name: string;
|
|
meeting_id: string;
|
|
};
|
|
cookie?: never;
|
|
};
|
|
requestBody?: never;
|
|
responses: {
|
|
/** @description Successful Response */
|
|
200: {
|
|
headers: {
|
|
[name: string]: unknown;
|
|
};
|
|
content: {
|
|
"application/json": components["schemas"]["Meeting"];
|
|
};
|
|
};
|
|
/** @description Validation Error */
|
|
422: {
|
|
headers: {
|
|
[name: string]: unknown;
|
|
};
|
|
content: {
|
|
"application/json": components["schemas"]["HTTPValidationError"];
|
|
};
|
|
};
|
|
};
|
|
};
|
|
v1_transcripts_list: {
|
|
parameters: {
|
|
query?: {
|
|
source_kind?: components["schemas"]["SourceKind"] | null;
|
|
room_id?: string | null;
|
|
search_term?: string | null;
|
|
/** @description Page number */
|
|
page?: number;
|
|
/** @description Page size */
|
|
size?: number;
|
|
};
|
|
header?: never;
|
|
path?: never;
|
|
cookie?: never;
|
|
};
|
|
requestBody?: never;
|
|
responses: {
|
|
/** @description Successful Response */
|
|
200: {
|
|
headers: {
|
|
[name: string]: unknown;
|
|
};
|
|
content: {
|
|
"application/json": components["schemas"]["Page_GetTranscriptMinimal_"];
|
|
};
|
|
};
|
|
/** @description Validation Error */
|
|
422: {
|
|
headers: {
|
|
[name: string]: unknown;
|
|
};
|
|
content: {
|
|
"application/json": components["schemas"]["HTTPValidationError"];
|
|
};
|
|
};
|
|
};
|
|
};
|
|
v1_transcripts_create: {
|
|
parameters: {
|
|
query?: never;
|
|
header?: never;
|
|
path?: never;
|
|
cookie?: never;
|
|
};
|
|
requestBody: {
|
|
content: {
|
|
"application/json": components["schemas"]["CreateTranscript"];
|
|
};
|
|
};
|
|
responses: {
|
|
/** @description Successful Response */
|
|
200: {
|
|
headers: {
|
|
[name: string]: unknown;
|
|
};
|
|
content: {
|
|
"application/json": components["schemas"]["GetTranscript"];
|
|
};
|
|
};
|
|
/** @description Validation Error */
|
|
422: {
|
|
headers: {
|
|
[name: string]: unknown;
|
|
};
|
|
content: {
|
|
"application/json": components["schemas"]["HTTPValidationError"];
|
|
};
|
|
};
|
|
};
|
|
};
|
|
v1_transcripts_search: {
|
|
parameters: {
|
|
query: {
|
|
/** @description Search query text */
|
|
q: string;
|
|
/** @description Results per page */
|
|
limit?: number;
|
|
/** @description Number of results to skip */
|
|
offset?: number;
|
|
room_id?: string | null;
|
|
source_kind?: components["schemas"]["SourceKind"] | null;
|
|
};
|
|
header?: never;
|
|
path?: never;
|
|
cookie?: never;
|
|
};
|
|
requestBody?: never;
|
|
responses: {
|
|
/** @description Successful Response */
|
|
200: {
|
|
headers: {
|
|
[name: string]: unknown;
|
|
};
|
|
content: {
|
|
"application/json": components["schemas"]["SearchResponse"];
|
|
};
|
|
};
|
|
/** @description Validation Error */
|
|
422: {
|
|
headers: {
|
|
[name: string]: unknown;
|
|
};
|
|
content: {
|
|
"application/json": components["schemas"]["HTTPValidationError"];
|
|
};
|
|
};
|
|
};
|
|
};
|
|
v1_transcript_get: {
|
|
parameters: {
|
|
query?: never;
|
|
header?: never;
|
|
path: {
|
|
transcript_id: string;
|
|
};
|
|
cookie?: never;
|
|
};
|
|
requestBody?: never;
|
|
responses: {
|
|
/** @description Successful Response */
|
|
200: {
|
|
headers: {
|
|
[name: string]: unknown;
|
|
};
|
|
content: {
|
|
"application/json": components["schemas"]["GetTranscript"];
|
|
};
|
|
};
|
|
/** @description Validation Error */
|
|
422: {
|
|
headers: {
|
|
[name: string]: unknown;
|
|
};
|
|
content: {
|
|
"application/json": components["schemas"]["HTTPValidationError"];
|
|
};
|
|
};
|
|
};
|
|
};
|
|
v1_transcript_delete: {
|
|
parameters: {
|
|
query?: never;
|
|
header?: never;
|
|
path: {
|
|
transcript_id: string;
|
|
};
|
|
cookie?: never;
|
|
};
|
|
requestBody?: never;
|
|
responses: {
|
|
/** @description Successful Response */
|
|
200: {
|
|
headers: {
|
|
[name: string]: unknown;
|
|
};
|
|
content: {
|
|
"application/json": components["schemas"]["DeletionStatus"];
|
|
};
|
|
};
|
|
/** @description Validation Error */
|
|
422: {
|
|
headers: {
|
|
[name: string]: unknown;
|
|
};
|
|
content: {
|
|
"application/json": components["schemas"]["HTTPValidationError"];
|
|
};
|
|
};
|
|
};
|
|
};
|
|
v1_transcript_update: {
|
|
parameters: {
|
|
query?: never;
|
|
header?: never;
|
|
path: {
|
|
transcript_id: string;
|
|
};
|
|
cookie?: never;
|
|
};
|
|
requestBody: {
|
|
content: {
|
|
"application/json": components["schemas"]["UpdateTranscript"];
|
|
};
|
|
};
|
|
responses: {
|
|
/** @description Successful Response */
|
|
200: {
|
|
headers: {
|
|
[name: string]: unknown;
|
|
};
|
|
content: {
|
|
"application/json": components["schemas"]["GetTranscript"];
|
|
};
|
|
};
|
|
/** @description Validation Error */
|
|
422: {
|
|
headers: {
|
|
[name: string]: unknown;
|
|
};
|
|
content: {
|
|
"application/json": components["schemas"]["HTTPValidationError"];
|
|
};
|
|
};
|
|
};
|
|
};
|
|
v1_transcript_get_topics: {
|
|
parameters: {
|
|
query?: never;
|
|
header?: never;
|
|
path: {
|
|
transcript_id: string;
|
|
};
|
|
cookie?: never;
|
|
};
|
|
requestBody?: never;
|
|
responses: {
|
|
/** @description Successful Response */
|
|
200: {
|
|
headers: {
|
|
[name: string]: unknown;
|
|
};
|
|
content: {
|
|
"application/json": components["schemas"]["GetTranscriptTopic"][];
|
|
};
|
|
};
|
|
/** @description Validation Error */
|
|
422: {
|
|
headers: {
|
|
[name: string]: unknown;
|
|
};
|
|
content: {
|
|
"application/json": components["schemas"]["HTTPValidationError"];
|
|
};
|
|
};
|
|
};
|
|
};
|
|
v1_transcript_get_topics_with_words: {
|
|
parameters: {
|
|
query?: never;
|
|
header?: never;
|
|
path: {
|
|
transcript_id: string;
|
|
};
|
|
cookie?: never;
|
|
};
|
|
requestBody?: never;
|
|
responses: {
|
|
/** @description Successful Response */
|
|
200: {
|
|
headers: {
|
|
[name: string]: unknown;
|
|
};
|
|
content: {
|
|
"application/json": components["schemas"]["GetTranscriptTopicWithWords"][];
|
|
};
|
|
};
|
|
/** @description Validation Error */
|
|
422: {
|
|
headers: {
|
|
[name: string]: unknown;
|
|
};
|
|
content: {
|
|
"application/json": components["schemas"]["HTTPValidationError"];
|
|
};
|
|
};
|
|
};
|
|
};
|
|
v1_transcript_get_topics_with_words_per_speaker: {
|
|
parameters: {
|
|
query?: never;
|
|
header?: never;
|
|
path: {
|
|
transcript_id: string;
|
|
topic_id: string;
|
|
};
|
|
cookie?: never;
|
|
};
|
|
requestBody?: never;
|
|
responses: {
|
|
/** @description Successful Response */
|
|
200: {
|
|
headers: {
|
|
[name: string]: unknown;
|
|
};
|
|
content: {
|
|
"application/json": components["schemas"]["GetTranscriptTopicWithWordsPerSpeaker"];
|
|
};
|
|
};
|
|
/** @description Validation Error */
|
|
422: {
|
|
headers: {
|
|
[name: string]: unknown;
|
|
};
|
|
content: {
|
|
"application/json": components["schemas"]["HTTPValidationError"];
|
|
};
|
|
};
|
|
};
|
|
};
|
|
v1_transcript_post_to_zulip: {
|
|
parameters: {
|
|
query: {
|
|
stream: string;
|
|
topic: string;
|
|
include_topics: boolean;
|
|
};
|
|
header?: never;
|
|
path: {
|
|
transcript_id: string;
|
|
};
|
|
cookie?: never;
|
|
};
|
|
requestBody?: never;
|
|
responses: {
|
|
/** @description Successful Response */
|
|
200: {
|
|
headers: {
|
|
[name: string]: unknown;
|
|
};
|
|
content: {
|
|
"application/json": unknown;
|
|
};
|
|
};
|
|
/** @description Validation Error */
|
|
422: {
|
|
headers: {
|
|
[name: string]: unknown;
|
|
};
|
|
content: {
|
|
"application/json": components["schemas"]["HTTPValidationError"];
|
|
};
|
|
};
|
|
};
|
|
};
|
|
v1_transcript_get_audio_mp3: {
|
|
parameters: {
|
|
query?: {
|
|
token?: string | null;
|
|
};
|
|
header?: never;
|
|
path: {
|
|
transcript_id: string;
|
|
};
|
|
cookie?: never;
|
|
};
|
|
requestBody?: never;
|
|
responses: {
|
|
/** @description Successful Response */
|
|
200: {
|
|
headers: {
|
|
[name: string]: unknown;
|
|
};
|
|
content: {
|
|
"application/json": unknown;
|
|
};
|
|
};
|
|
/** @description Validation Error */
|
|
422: {
|
|
headers: {
|
|
[name: string]: unknown;
|
|
};
|
|
content: {
|
|
"application/json": components["schemas"]["HTTPValidationError"];
|
|
};
|
|
};
|
|
};
|
|
};
|
|
v1_transcript_head_audio_mp3: {
|
|
parameters: {
|
|
query?: {
|
|
token?: string | null;
|
|
};
|
|
header?: never;
|
|
path: {
|
|
transcript_id: string;
|
|
};
|
|
cookie?: never;
|
|
};
|
|
requestBody?: never;
|
|
responses: {
|
|
/** @description Successful Response */
|
|
200: {
|
|
headers: {
|
|
[name: string]: unknown;
|
|
};
|
|
content: {
|
|
"application/json": unknown;
|
|
};
|
|
};
|
|
/** @description Validation Error */
|
|
422: {
|
|
headers: {
|
|
[name: string]: unknown;
|
|
};
|
|
content: {
|
|
"application/json": components["schemas"]["HTTPValidationError"];
|
|
};
|
|
};
|
|
};
|
|
};
|
|
v1_transcript_get_audio_waveform: {
|
|
parameters: {
|
|
query?: never;
|
|
header?: never;
|
|
path: {
|
|
transcript_id: string;
|
|
};
|
|
cookie?: never;
|
|
};
|
|
requestBody?: never;
|
|
responses: {
|
|
/** @description Successful Response */
|
|
200: {
|
|
headers: {
|
|
[name: string]: unknown;
|
|
};
|
|
content: {
|
|
"application/json": components["schemas"]["AudioWaveform"];
|
|
};
|
|
};
|
|
/** @description Validation Error */
|
|
422: {
|
|
headers: {
|
|
[name: string]: unknown;
|
|
};
|
|
content: {
|
|
"application/json": components["schemas"]["HTTPValidationError"];
|
|
};
|
|
};
|
|
};
|
|
};
|
|
v1_transcript_get_participants: {
|
|
parameters: {
|
|
query?: never;
|
|
header?: never;
|
|
path: {
|
|
transcript_id: string;
|
|
};
|
|
cookie?: never;
|
|
};
|
|
requestBody?: never;
|
|
responses: {
|
|
/** @description Successful Response */
|
|
200: {
|
|
headers: {
|
|
[name: string]: unknown;
|
|
};
|
|
content: {
|
|
"application/json": components["schemas"]["Participant"][];
|
|
};
|
|
};
|
|
/** @description Validation Error */
|
|
422: {
|
|
headers: {
|
|
[name: string]: unknown;
|
|
};
|
|
content: {
|
|
"application/json": components["schemas"]["HTTPValidationError"];
|
|
};
|
|
};
|
|
};
|
|
};
|
|
v1_transcript_add_participant: {
|
|
parameters: {
|
|
query?: never;
|
|
header?: never;
|
|
path: {
|
|
transcript_id: string;
|
|
};
|
|
cookie?: never;
|
|
};
|
|
requestBody: {
|
|
content: {
|
|
"application/json": components["schemas"]["CreateParticipant"];
|
|
};
|
|
};
|
|
responses: {
|
|
/** @description Successful Response */
|
|
200: {
|
|
headers: {
|
|
[name: string]: unknown;
|
|
};
|
|
content: {
|
|
"application/json": components["schemas"]["Participant"];
|
|
};
|
|
};
|
|
/** @description Validation Error */
|
|
422: {
|
|
headers: {
|
|
[name: string]: unknown;
|
|
};
|
|
content: {
|
|
"application/json": components["schemas"]["HTTPValidationError"];
|
|
};
|
|
};
|
|
};
|
|
};
|
|
v1_transcript_get_participant: {
|
|
parameters: {
|
|
query?: never;
|
|
header?: never;
|
|
path: {
|
|
transcript_id: string;
|
|
participant_id: string;
|
|
};
|
|
cookie?: never;
|
|
};
|
|
requestBody?: never;
|
|
responses: {
|
|
/** @description Successful Response */
|
|
200: {
|
|
headers: {
|
|
[name: string]: unknown;
|
|
};
|
|
content: {
|
|
"application/json": components["schemas"]["Participant"];
|
|
};
|
|
};
|
|
/** @description Validation Error */
|
|
422: {
|
|
headers: {
|
|
[name: string]: unknown;
|
|
};
|
|
content: {
|
|
"application/json": components["schemas"]["HTTPValidationError"];
|
|
};
|
|
};
|
|
};
|
|
};
|
|
v1_transcript_delete_participant: {
|
|
parameters: {
|
|
query?: never;
|
|
header?: never;
|
|
path: {
|
|
transcript_id: string;
|
|
participant_id: string;
|
|
};
|
|
cookie?: never;
|
|
};
|
|
requestBody?: never;
|
|
responses: {
|
|
/** @description Successful Response */
|
|
200: {
|
|
headers: {
|
|
[name: string]: unknown;
|
|
};
|
|
content: {
|
|
"application/json": components["schemas"]["DeletionStatus"];
|
|
};
|
|
};
|
|
/** @description Validation Error */
|
|
422: {
|
|
headers: {
|
|
[name: string]: unknown;
|
|
};
|
|
content: {
|
|
"application/json": components["schemas"]["HTTPValidationError"];
|
|
};
|
|
};
|
|
};
|
|
};
|
|
v1_transcript_update_participant: {
|
|
parameters: {
|
|
query?: never;
|
|
header?: never;
|
|
path: {
|
|
transcript_id: string;
|
|
participant_id: string;
|
|
};
|
|
cookie?: never;
|
|
};
|
|
requestBody: {
|
|
content: {
|
|
"application/json": components["schemas"]["UpdateParticipant"];
|
|
};
|
|
};
|
|
responses: {
|
|
/** @description Successful Response */
|
|
200: {
|
|
headers: {
|
|
[name: string]: unknown;
|
|
};
|
|
content: {
|
|
"application/json": components["schemas"]["Participant"];
|
|
};
|
|
};
|
|
/** @description Validation Error */
|
|
422: {
|
|
headers: {
|
|
[name: string]: unknown;
|
|
};
|
|
content: {
|
|
"application/json": components["schemas"]["HTTPValidationError"];
|
|
};
|
|
};
|
|
};
|
|
};
|
|
v1_transcript_assign_speaker: {
|
|
parameters: {
|
|
query?: never;
|
|
header?: never;
|
|
path: {
|
|
transcript_id: string;
|
|
};
|
|
cookie?: never;
|
|
};
|
|
requestBody: {
|
|
content: {
|
|
"application/json": components["schemas"]["SpeakerAssignment"];
|
|
};
|
|
};
|
|
responses: {
|
|
/** @description Successful Response */
|
|
200: {
|
|
headers: {
|
|
[name: string]: unknown;
|
|
};
|
|
content: {
|
|
"application/json": components["schemas"]["SpeakerAssignmentStatus"];
|
|
};
|
|
};
|
|
/** @description Validation Error */
|
|
422: {
|
|
headers: {
|
|
[name: string]: unknown;
|
|
};
|
|
content: {
|
|
"application/json": components["schemas"]["HTTPValidationError"];
|
|
};
|
|
};
|
|
};
|
|
};
|
|
v1_transcript_merge_speaker: {
|
|
parameters: {
|
|
query?: never;
|
|
header?: never;
|
|
path: {
|
|
transcript_id: string;
|
|
};
|
|
cookie?: never;
|
|
};
|
|
requestBody: {
|
|
content: {
|
|
"application/json": components["schemas"]["SpeakerMerge"];
|
|
};
|
|
};
|
|
responses: {
|
|
/** @description Successful Response */
|
|
200: {
|
|
headers: {
|
|
[name: string]: unknown;
|
|
};
|
|
content: {
|
|
"application/json": components["schemas"]["SpeakerAssignmentStatus"];
|
|
};
|
|
};
|
|
/** @description Validation Error */
|
|
422: {
|
|
headers: {
|
|
[name: string]: unknown;
|
|
};
|
|
content: {
|
|
"application/json": components["schemas"]["HTTPValidationError"];
|
|
};
|
|
};
|
|
};
|
|
};
|
|
v1_transcript_record_upload: {
|
|
parameters: {
|
|
query: {
|
|
chunk_number: number;
|
|
total_chunks: number;
|
|
};
|
|
header?: never;
|
|
path: {
|
|
transcript_id: string;
|
|
};
|
|
cookie?: never;
|
|
};
|
|
requestBody: {
|
|
content: {
|
|
"multipart/form-data": components["schemas"]["Body_transcript_record_upload_v1_transcripts__transcript_id__record_upload_post"];
|
|
};
|
|
};
|
|
responses: {
|
|
/** @description Successful Response */
|
|
200: {
|
|
headers: {
|
|
[name: string]: unknown;
|
|
};
|
|
content: {
|
|
"application/json": unknown;
|
|
};
|
|
};
|
|
/** @description Validation Error */
|
|
422: {
|
|
headers: {
|
|
[name: string]: unknown;
|
|
};
|
|
content: {
|
|
"application/json": components["schemas"]["HTTPValidationError"];
|
|
};
|
|
};
|
|
};
|
|
};
|
|
v1_transcript_get_websocket_events: {
|
|
parameters: {
|
|
query?: never;
|
|
header?: never;
|
|
path: {
|
|
transcript_id: string;
|
|
};
|
|
cookie?: never;
|
|
};
|
|
requestBody?: never;
|
|
responses: {
|
|
/** @description Successful Response */
|
|
200: {
|
|
headers: {
|
|
[name: string]: unknown;
|
|
};
|
|
content: {
|
|
"application/json": unknown;
|
|
};
|
|
};
|
|
/** @description Validation Error */
|
|
422: {
|
|
headers: {
|
|
[name: string]: unknown;
|
|
};
|
|
content: {
|
|
"application/json": components["schemas"]["HTTPValidationError"];
|
|
};
|
|
};
|
|
};
|
|
};
|
|
v1_transcript_record_webrtc: {
|
|
parameters: {
|
|
query?: never;
|
|
header?: never;
|
|
path: {
|
|
transcript_id: string;
|
|
};
|
|
cookie?: never;
|
|
};
|
|
requestBody: {
|
|
content: {
|
|
"application/json": components["schemas"]["RtcOffer"];
|
|
};
|
|
};
|
|
responses: {
|
|
/** @description Successful Response */
|
|
200: {
|
|
headers: {
|
|
[name: string]: unknown;
|
|
};
|
|
content: {
|
|
"application/json": unknown;
|
|
};
|
|
};
|
|
/** @description Validation Error */
|
|
422: {
|
|
headers: {
|
|
[name: string]: unknown;
|
|
};
|
|
content: {
|
|
"application/json": components["schemas"]["HTTPValidationError"];
|
|
};
|
|
};
|
|
};
|
|
};
|
|
v1_transcript_process: {
|
|
parameters: {
|
|
query?: never;
|
|
header?: never;
|
|
path: {
|
|
transcript_id: string;
|
|
};
|
|
cookie?: never;
|
|
};
|
|
requestBody?: never;
|
|
responses: {
|
|
/** @description Successful Response */
|
|
200: {
|
|
headers: {
|
|
[name: string]: unknown;
|
|
};
|
|
content: {
|
|
"application/json": unknown;
|
|
};
|
|
};
|
|
/** @description Validation Error */
|
|
422: {
|
|
headers: {
|
|
[name: string]: unknown;
|
|
};
|
|
content: {
|
|
"application/json": components["schemas"]["HTTPValidationError"];
|
|
};
|
|
};
|
|
};
|
|
};
|
|
v1_user_me: {
|
|
parameters: {
|
|
query?: never;
|
|
header?: never;
|
|
path?: never;
|
|
cookie?: never;
|
|
};
|
|
requestBody?: never;
|
|
responses: {
|
|
/** @description Successful Response */
|
|
200: {
|
|
headers: {
|
|
[name: string]: unknown;
|
|
};
|
|
content: {
|
|
"application/json": components["schemas"]["UserInfo"] | null;
|
|
};
|
|
};
|
|
};
|
|
};
|
|
v1_zulip_get_streams: {
|
|
parameters: {
|
|
query?: never;
|
|
header?: never;
|
|
path?: never;
|
|
cookie?: never;
|
|
};
|
|
requestBody?: never;
|
|
responses: {
|
|
/** @description Successful Response */
|
|
200: {
|
|
headers: {
|
|
[name: string]: unknown;
|
|
};
|
|
content: {
|
|
"application/json": components["schemas"]["Stream"][];
|
|
};
|
|
};
|
|
};
|
|
};
|
|
v1_zulip_get_topics: {
|
|
parameters: {
|
|
query?: never;
|
|
header?: never;
|
|
path: {
|
|
stream_id: number;
|
|
};
|
|
cookie?: never;
|
|
};
|
|
requestBody?: never;
|
|
responses: {
|
|
/** @description Successful Response */
|
|
200: {
|
|
headers: {
|
|
[name: string]: unknown;
|
|
};
|
|
content: {
|
|
"application/json": components["schemas"]["Topic"][];
|
|
};
|
|
};
|
|
/** @description Validation Error */
|
|
422: {
|
|
headers: {
|
|
[name: string]: unknown;
|
|
};
|
|
content: {
|
|
"application/json": components["schemas"]["HTTPValidationError"];
|
|
};
|
|
};
|
|
};
|
|
};
|
|
v1_whereby_webhook: {
|
|
parameters: {
|
|
query?: never;
|
|
header?: never;
|
|
path?: never;
|
|
cookie?: never;
|
|
};
|
|
requestBody: {
|
|
content: {
|
|
"application/json": components["schemas"]["WherebyWebhookEvent"];
|
|
};
|
|
};
|
|
responses: {
|
|
/** @description Successful Response */
|
|
200: {
|
|
headers: {
|
|
[name: string]: unknown;
|
|
};
|
|
content: {
|
|
"application/json": unknown;
|
|
};
|
|
};
|
|
/** @description Validation Error */
|
|
422: {
|
|
headers: {
|
|
[name: string]: unknown;
|
|
};
|
|
content: {
|
|
"application/json": components["schemas"]["HTTPValidationError"];
|
|
};
|
|
};
|
|
};
|
|
};
|
|
}
|