Files
sdk/api_meet.go

886 lines
32 KiB
Go

/*
Hanzo Cloud API
The Hanzo Cloud API as a customer calls it: every operation under /v1/ except the operator's admin product, relay routes, legacy spellings and capabilities still reached by flag. Tagged by product: the first path segment after /v1/.
API version: v1
*/
// Code generated by OpenAPI Generator (https://openapi-generator.tech); DO NOT EDIT.
package hanzoai
import (
"bytes"
"context"
"io"
"net/http"
"net/url"
)
// MeetAPIService MeetAPI service
type MeetAPIService service
type MeetAPIGetMeetHealthRequest struct {
ctx context.Context
ApiService *MeetAPIService
}
func (r MeetAPIGetMeetHealthRequest) Execute() (*MeetMeetHealth, *http.Response, error) {
return r.ApiService.GetMeetHealthExecute(r)
}
/*
GetMeetHealth Reports whether the office can mint join tokens.
Reports whether the office can mint join tokens.
It reports whether this deployment holds the LiveKit key pair it needs:
ready:true with 200 when tokens can be minted, the SAME body with ready:false,
status "degraded" and 503 when they cannot — so a probe and a dashboard both
read the degraded state instead of someone grepping a boot log.
It takes no credential and is reachable on every public host, so it withholds
both the reason and the signing key's name on purpose: ready is the whole
dashboard fact, and the reason — which names the key file and the Secret — is
written to the boot log where an operator already is.
@param ctx context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background().
@return MeetAPIGetMeetHealthRequest
*/
func (a *MeetAPIService) GetMeetHealth(ctx context.Context) MeetAPIGetMeetHealthRequest {
return MeetAPIGetMeetHealthRequest{
ApiService: a,
ctx: ctx,
}
}
// Execute executes the request
//
// @return MeetMeetHealth
func (a *MeetAPIService) GetMeetHealthExecute(r MeetAPIGetMeetHealthRequest) (*MeetMeetHealth, *http.Response, error) {
var (
localVarHTTPMethod = http.MethodGet
localVarPostBody interface{}
formFiles []formFile
localVarReturnValue *MeetMeetHealth
)
localBasePath, err := a.client.cfg.ServerURLWithContext(r.ctx, "MeetAPIService.GetMeetHealth")
if err != nil {
return localVarReturnValue, nil, &GenericOpenAPIError{error: err.Error()}
}
localVarPath := localBasePath + "/v1/meet/health"
localVarHeaderParams := make(map[string]string)
localVarQueryParams := url.Values{}
localVarFormParams := url.Values{}
// to determine the Content-Type header
localVarHTTPContentTypes := []string{}
// set Content-Type header
localVarHTTPContentType := selectHeaderContentType(localVarHTTPContentTypes)
if localVarHTTPContentType != "" {
localVarHeaderParams["Content-Type"] = localVarHTTPContentType
}
// to determine the Accept header
localVarHTTPHeaderAccepts := []string{"application/json", "application/problem+json"}
// set Accept header
localVarHTTPHeaderAccept := selectHeaderAccept(localVarHTTPHeaderAccepts)
if localVarHTTPHeaderAccept != "" {
localVarHeaderParams["Accept"] = localVarHTTPHeaderAccept
}
req, err := a.client.prepareRequest(r.ctx, localVarPath, localVarHTTPMethod, localVarPostBody, localVarHeaderParams, localVarQueryParams, localVarFormParams, formFiles)
if err != nil {
return localVarReturnValue, nil, err
}
localVarHTTPResponse, err := a.client.callAPI(req)
if err != nil || localVarHTTPResponse == nil {
return localVarReturnValue, localVarHTTPResponse, err
}
localVarBody, err := io.ReadAll(localVarHTTPResponse.Body)
localVarHTTPResponse.Body.Close()
localVarHTTPResponse.Body = io.NopCloser(bytes.NewBuffer(localVarBody))
if err != nil {
return localVarReturnValue, localVarHTTPResponse, err
}
if localVarHTTPResponse.StatusCode >= 300 {
newErr := &GenericOpenAPIError{
body: localVarBody,
error: localVarHTTPResponse.Status,
}
if localVarHTTPResponse.StatusCode == 503 {
var v MeetMeetHealth
err = a.client.decode(&v, localVarBody, localVarHTTPResponse.Header.Get("Content-Type"))
if err != nil {
newErr.error = err.Error()
return localVarReturnValue, localVarHTTPResponse, newErr
}
newErr.error = formatErrorMessage(localVarHTTPResponse.Status, &v)
newErr.model = v
return localVarReturnValue, localVarHTTPResponse, newErr
}
var v ProblemDetails
err = a.client.decode(&v, localVarBody, localVarHTTPResponse.Header.Get("Content-Type"))
if err != nil {
newErr.error = err.Error()
return localVarReturnValue, localVarHTTPResponse, newErr
}
newErr.error = formatErrorMessage(localVarHTTPResponse.Status, &v)
newErr.model = v
return localVarReturnValue, localVarHTTPResponse, newErr
}
err = a.client.decode(&localVarReturnValue, localVarBody, localVarHTTPResponse.Header.Get("Content-Type"))
if err != nil {
newErr := &GenericOpenAPIError{
body: localVarBody,
error: err.Error(),
}
return localVarReturnValue, localVarHTTPResponse, newErr
}
return localVarReturnValue, localVarHTTPResponse, nil
}
type MeetAPIGetMeetSessionRequest struct {
ctx context.Context
ApiService *MeetAPIService
}
func (r MeetAPIGetMeetSessionRequest) Execute() (*http.Response, error) {
return r.ApiService.GetMeetSessionExecute(r)
}
/*
GetMeetSession What this caller may open a room in
Answers the three facts the native lobby cannot know on its own: the identity a seat would be taken under, the LiveKit address the browser dials, and the spaces this caller may open a room in.
It is the SAME decision getToken makes, asked before the room exists rather than after it is named. A room is bound to its tenant by its name's leading space segment, and only a space this answer lists will be admitted — so the lobby offers exactly what the mint would grant, and a person is never shown a room they would then be refused. Spaces the caller holds only a guest role in are omitted for that reason.
An empty list is a real answer, not a fault: an IAM identity with no space has no room to open, and the lobby says so instead of failing.
`ws` is empty when this deployment has not been told where its media plane is (LIVEKIT_WS). Token minting is unaffected — the published office client supplies its own address — so this is a degraded native UI, not a degraded service, and the lobby refuses to dial rather than guessing a host.
@param ctx context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background().
@return MeetAPIGetMeetSessionRequest
*/
func (a *MeetAPIService) GetMeetSession(ctx context.Context) MeetAPIGetMeetSessionRequest {
return MeetAPIGetMeetSessionRequest{
ApiService: a,
ctx: ctx,
}
}
// Execute executes the request
func (a *MeetAPIService) GetMeetSessionExecute(r MeetAPIGetMeetSessionRequest) (*http.Response, error) {
var (
localVarHTTPMethod = http.MethodGet
localVarPostBody interface{}
formFiles []formFile
)
localBasePath, err := a.client.cfg.ServerURLWithContext(r.ctx, "MeetAPIService.GetMeetSession")
if err != nil {
return nil, &GenericOpenAPIError{error: err.Error()}
}
localVarPath := localBasePath + "/v1/meet/session"
localVarHeaderParams := make(map[string]string)
localVarQueryParams := url.Values{}
localVarFormParams := url.Values{}
// to determine the Content-Type header
localVarHTTPContentTypes := []string{}
// set Content-Type header
localVarHTTPContentType := selectHeaderContentType(localVarHTTPContentTypes)
if localVarHTTPContentType != "" {
localVarHeaderParams["Content-Type"] = localVarHTTPContentType
}
// to determine the Accept header
localVarHTTPHeaderAccepts := []string{}
// set Accept header
localVarHTTPHeaderAccept := selectHeaderAccept(localVarHTTPHeaderAccepts)
if localVarHTTPHeaderAccept != "" {
localVarHeaderParams["Accept"] = localVarHTTPHeaderAccept
}
req, err := a.client.prepareRequest(r.ctx, localVarPath, localVarHTTPMethod, localVarPostBody, localVarHeaderParams, localVarQueryParams, localVarFormParams, formFiles)
if err != nil {
return nil, err
}
localVarHTTPResponse, err := a.client.callAPI(req)
if err != nil || localVarHTTPResponse == nil {
return localVarHTTPResponse, err
}
localVarBody, err := io.ReadAll(localVarHTTPResponse.Body)
localVarHTTPResponse.Body.Close()
localVarHTTPResponse.Body = io.NopCloser(bytes.NewBuffer(localVarBody))
if err != nil {
return localVarHTTPResponse, err
}
if localVarHTTPResponse.StatusCode >= 300 {
newErr := &GenericOpenAPIError{
body: localVarBody,
error: localVarHTTPResponse.Status,
}
return localVarHTTPResponse, newErr
}
return localVarHTTPResponse, nil
}
type MeetAPIMeetCallRequest struct {
ctx context.Context
ApiService *MeetAPIService
space *string
channel *string
}
// Space is the space uuid holding the channel, as GET /v1/team/channels reports it. It is the segment the caller's membership is checked against.
func (r MeetAPIMeetCallRequest) Space(space string) MeetAPIMeetCallRequest {
r.space = &space
return r
}
// Channel is the channel's own id within that space, as GET /v1/team/channels reports it. It is opaque here: meet keeps no channels and cannot say whether one exists, only whether this caller may be seated in the space holding it.
func (r MeetAPIMeetCallRequest) Channel(channel string) MeetAPIMeetCallRequest {
r.channel = &channel
return r
}
func (r MeetAPIMeetCallRequest) Execute() (*MeetVenue, *http.Response, error) {
return r.ApiService.MeetCallExecute(r)
}
/*
MeetCall Where a room's call happens
Answers where a channel's call happens, for a caller who may join it.
It is the "resolved at render" half of HIP-0523 §12: a surface showing a channel
asks for the channel's call at the moment it draws one, rather than reading a
media room name someone stored on the channel. Nothing here is persisted and nothing is
created — a media room begins existing when the first participant connects and
stops when the last leaves, so there is no call to create and none to clean up.
AUTHORIZATION IS THE JOIN DECISION, unchanged and shared. It delegates to
state.admits, the same function POST /v1/meet/getToken and all three recording
operations admit on, so a caller who is told where a call is, is a caller who
could have joined it. Answering the address to someone who cannot join would make
this a space-membership oracle for anyone who can guess a channel id.
It deliberately does NOT report whether a call is in progress. That is a fact the
media server holds and this binary would have to ask for it over the network,
which is a different decision with a different failure mode — and reporting
"nobody is in this call" when the question could not be asked would be exactly the
unknown-rendered-as-zero this surface refuses elsewhere.
@param ctx context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background().
@return MeetAPIMeetCallRequest
*/
func (a *MeetAPIService) MeetCall(ctx context.Context) MeetAPIMeetCallRequest {
return MeetAPIMeetCallRequest{
ApiService: a,
ctx: ctx,
}
}
// Execute executes the request
//
// @return MeetVenue
func (a *MeetAPIService) MeetCallExecute(r MeetAPIMeetCallRequest) (*MeetVenue, *http.Response, error) {
var (
localVarHTTPMethod = http.MethodGet
localVarPostBody interface{}
formFiles []formFile
localVarReturnValue *MeetVenue
)
localBasePath, err := a.client.cfg.ServerURLWithContext(r.ctx, "MeetAPIService.MeetCall")
if err != nil {
return localVarReturnValue, nil, &GenericOpenAPIError{error: err.Error()}
}
localVarPath := localBasePath + "/v1/meet/call"
localVarHeaderParams := make(map[string]string)
localVarQueryParams := url.Values{}
localVarFormParams := url.Values{}
if r.space == nil {
return localVarReturnValue, nil, reportError("space is required and must be specified")
}
if r.channel == nil {
return localVarReturnValue, nil, reportError("channel is required and must be specified")
}
parameterAddToHeaderOrQuery(localVarQueryParams, "space", r.space, "form", "")
parameterAddToHeaderOrQuery(localVarQueryParams, "channel", r.channel, "form", "")
// to determine the Content-Type header
localVarHTTPContentTypes := []string{}
// set Content-Type header
localVarHTTPContentType := selectHeaderContentType(localVarHTTPContentTypes)
if localVarHTTPContentType != "" {
localVarHeaderParams["Content-Type"] = localVarHTTPContentType
}
// to determine the Accept header
localVarHTTPHeaderAccepts := []string{"application/json", "application/problem+json"}
// set Accept header
localVarHTTPHeaderAccept := selectHeaderAccept(localVarHTTPHeaderAccepts)
if localVarHTTPHeaderAccept != "" {
localVarHeaderParams["Accept"] = localVarHTTPHeaderAccept
}
req, err := a.client.prepareRequest(r.ctx, localVarPath, localVarHTTPMethod, localVarPostBody, localVarHeaderParams, localVarQueryParams, localVarFormParams, formFiles)
if err != nil {
return localVarReturnValue, nil, err
}
localVarHTTPResponse, err := a.client.callAPI(req)
if err != nil || localVarHTTPResponse == nil {
return localVarReturnValue, localVarHTTPResponse, err
}
localVarBody, err := io.ReadAll(localVarHTTPResponse.Body)
localVarHTTPResponse.Body.Close()
localVarHTTPResponse.Body = io.NopCloser(bytes.NewBuffer(localVarBody))
if err != nil {
return localVarReturnValue, localVarHTTPResponse, err
}
if localVarHTTPResponse.StatusCode >= 300 {
newErr := &GenericOpenAPIError{
body: localVarBody,
error: localVarHTTPResponse.Status,
}
var v ProblemDetails
err = a.client.decode(&v, localVarBody, localVarHTTPResponse.Header.Get("Content-Type"))
if err != nil {
newErr.error = err.Error()
return localVarReturnValue, localVarHTTPResponse, newErr
}
newErr.error = formatErrorMessage(localVarHTTPResponse.Status, &v)
newErr.model = v
return localVarReturnValue, localVarHTTPResponse, newErr
}
err = a.client.decode(&localVarReturnValue, localVarBody, localVarHTTPResponse.Header.Get("Content-Type"))
if err != nil {
newErr := &GenericOpenAPIError{
body: localVarBody,
error: err.Error(),
}
return localVarReturnValue, localVarHTTPResponse, newErr
}
return localVarReturnValue, localVarHTTPResponse, nil
}
type MeetAPIMeetRecordReadRequest struct {
ctx context.Context
ApiService *MeetAPIService
room *string
}
// Room is the LiveKit room, named the way the office client names one (`<space>_<name>_<id>`). Its leading segment is what binds the room to a tenant, and it is the segment the caller's membership is checked against.
func (r MeetAPIMeetRecordReadRequest) Room(room string) MeetAPIMeetRecordReadRequest {
r.room = &room
return r
}
func (r MeetAPIMeetRecordReadRequest) Execute() (*MeetRecording, *http.Response, error) {
return r.ApiService.MeetRecordReadExecute(r)
}
/*
MeetRecordRead What is being recorded in a room, and where the file goes
Answers what is being recorded in a room, and where the file went.
It reports the recording that is RUNNING, and once none is, the most recent one
the media server still holds — with its final status and its object. That second
case is the one that matters for finding a file: the answer to a start is the
only other place the location appears, and a client that lost it, or a colleague
who was not the one to press record, has nowhere else to look.
It is behind the same check as starting one: where a recording of a private
conversation is kept is a fact about that conversation, so it is told to the
people the room admits and to nobody else.
@param ctx context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background().
@return MeetAPIMeetRecordReadRequest
*/
func (a *MeetAPIService) MeetRecordRead(ctx context.Context) MeetAPIMeetRecordReadRequest {
return MeetAPIMeetRecordReadRequest{
ApiService: a,
ctx: ctx,
}
}
// Execute executes the request
//
// @return MeetRecording
func (a *MeetAPIService) MeetRecordReadExecute(r MeetAPIMeetRecordReadRequest) (*MeetRecording, *http.Response, error) {
var (
localVarHTTPMethod = http.MethodGet
localVarPostBody interface{}
formFiles []formFile
localVarReturnValue *MeetRecording
)
localBasePath, err := a.client.cfg.ServerURLWithContext(r.ctx, "MeetAPIService.MeetRecordRead")
if err != nil {
return localVarReturnValue, nil, &GenericOpenAPIError{error: err.Error()}
}
localVarPath := localBasePath + "/v1/meet/record"
localVarHeaderParams := make(map[string]string)
localVarQueryParams := url.Values{}
localVarFormParams := url.Values{}
if r.room == nil {
return localVarReturnValue, nil, reportError("room is required and must be specified")
}
parameterAddToHeaderOrQuery(localVarQueryParams, "room", r.room, "form", "")
// to determine the Content-Type header
localVarHTTPContentTypes := []string{}
// set Content-Type header
localVarHTTPContentType := selectHeaderContentType(localVarHTTPContentTypes)
if localVarHTTPContentType != "" {
localVarHeaderParams["Content-Type"] = localVarHTTPContentType
}
// to determine the Accept header
localVarHTTPHeaderAccepts := []string{"application/json", "application/problem+json"}
// set Accept header
localVarHTTPHeaderAccept := selectHeaderAccept(localVarHTTPHeaderAccepts)
if localVarHTTPHeaderAccept != "" {
localVarHeaderParams["Accept"] = localVarHTTPHeaderAccept
}
req, err := a.client.prepareRequest(r.ctx, localVarPath, localVarHTTPMethod, localVarPostBody, localVarHeaderParams, localVarQueryParams, localVarFormParams, formFiles)
if err != nil {
return localVarReturnValue, nil, err
}
localVarHTTPResponse, err := a.client.callAPI(req)
if err != nil || localVarHTTPResponse == nil {
return localVarReturnValue, localVarHTTPResponse, err
}
localVarBody, err := io.ReadAll(localVarHTTPResponse.Body)
localVarHTTPResponse.Body.Close()
localVarHTTPResponse.Body = io.NopCloser(bytes.NewBuffer(localVarBody))
if err != nil {
return localVarReturnValue, localVarHTTPResponse, err
}
if localVarHTTPResponse.StatusCode >= 300 {
newErr := &GenericOpenAPIError{
body: localVarBody,
error: localVarHTTPResponse.Status,
}
var v ProblemDetails
err = a.client.decode(&v, localVarBody, localVarHTTPResponse.Header.Get("Content-Type"))
if err != nil {
newErr.error = err.Error()
return localVarReturnValue, localVarHTTPResponse, newErr
}
newErr.error = formatErrorMessage(localVarHTTPResponse.Status, &v)
newErr.model = v
return localVarReturnValue, localVarHTTPResponse, newErr
}
err = a.client.decode(&localVarReturnValue, localVarBody, localVarHTTPResponse.Header.Get("Content-Type"))
if err != nil {
newErr := &GenericOpenAPIError{
body: localVarBody,
error: err.Error(),
}
return localVarReturnValue, localVarHTTPResponse, newErr
}
return localVarReturnValue, localVarHTTPResponse, nil
}
type MeetAPIMeetRecordStartRequest struct {
ctx context.Context
ApiService *MeetAPIService
meetRecordIn *MeetRecordIn
}
func (r MeetAPIMeetRecordStartRequest) MeetRecordIn(meetRecordIn MeetRecordIn) MeetAPIMeetRecordStartRequest {
r.meetRecordIn = &meetRecordIn
return r
}
func (r MeetAPIMeetRecordStartRequest) Execute() (*MeetRecording, *http.Response, error) {
return r.ApiService.MeetRecordStartExecute(r)
}
/*
MeetRecordStart Start recording a room, or return the recording already running
Begins recording a room, or hands back the recording already running.
A recording is a durable artifact of a conversation, so only someone this room
would admit may make one: the caller is authorized by the SAME decision
/v1/meet/getToken makes about the same room, and refused with the same 401.
A SECOND START RETURNS THE FIRST rather than refusing it. There is at most one
recording per room and this operation's job is to establish that there is one —
which is already true when a colleague, or the caller's own double-click,
started it a moment ago. The answer is the same shape either way, naming the
recording that is actually running, so a client never has to tell the two cases
apart to find the id.
A deployment with no media server address or no object store answers 503 naming
which, because a recording that silently does not happen is worse than one that
is refused. The reason reaches only a caller this room already admits.
@param ctx context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background().
@return MeetAPIMeetRecordStartRequest
*/
func (a *MeetAPIService) MeetRecordStart(ctx context.Context) MeetAPIMeetRecordStartRequest {
return MeetAPIMeetRecordStartRequest{
ApiService: a,
ctx: ctx,
}
}
// Execute executes the request
//
// @return MeetRecording
func (a *MeetAPIService) MeetRecordStartExecute(r MeetAPIMeetRecordStartRequest) (*MeetRecording, *http.Response, error) {
var (
localVarHTTPMethod = http.MethodPost
localVarPostBody interface{}
formFiles []formFile
localVarReturnValue *MeetRecording
)
localBasePath, err := a.client.cfg.ServerURLWithContext(r.ctx, "MeetAPIService.MeetRecordStart")
if err != nil {
return localVarReturnValue, nil, &GenericOpenAPIError{error: err.Error()}
}
localVarPath := localBasePath + "/v1/meet/record"
localVarHeaderParams := make(map[string]string)
localVarQueryParams := url.Values{}
localVarFormParams := url.Values{}
if r.meetRecordIn == nil {
return localVarReturnValue, nil, reportError("meetRecordIn is required and must be specified")
}
// to determine the Content-Type header
localVarHTTPContentTypes := []string{"application/json"}
// set Content-Type header
localVarHTTPContentType := selectHeaderContentType(localVarHTTPContentTypes)
if localVarHTTPContentType != "" {
localVarHeaderParams["Content-Type"] = localVarHTTPContentType
}
// to determine the Accept header
localVarHTTPHeaderAccepts := []string{"application/json", "application/problem+json"}
// set Accept header
localVarHTTPHeaderAccept := selectHeaderAccept(localVarHTTPHeaderAccepts)
if localVarHTTPHeaderAccept != "" {
localVarHeaderParams["Accept"] = localVarHTTPHeaderAccept
}
// body params
localVarPostBody = r.meetRecordIn
req, err := a.client.prepareRequest(r.ctx, localVarPath, localVarHTTPMethod, localVarPostBody, localVarHeaderParams, localVarQueryParams, localVarFormParams, formFiles)
if err != nil {
return localVarReturnValue, nil, err
}
localVarHTTPResponse, err := a.client.callAPI(req)
if err != nil || localVarHTTPResponse == nil {
return localVarReturnValue, localVarHTTPResponse, err
}
localVarBody, err := io.ReadAll(localVarHTTPResponse.Body)
localVarHTTPResponse.Body.Close()
localVarHTTPResponse.Body = io.NopCloser(bytes.NewBuffer(localVarBody))
if err != nil {
return localVarReturnValue, localVarHTTPResponse, err
}
if localVarHTTPResponse.StatusCode >= 300 {
newErr := &GenericOpenAPIError{
body: localVarBody,
error: localVarHTTPResponse.Status,
}
var v ProblemDetails
err = a.client.decode(&v, localVarBody, localVarHTTPResponse.Header.Get("Content-Type"))
if err != nil {
newErr.error = err.Error()
return localVarReturnValue, localVarHTTPResponse, newErr
}
newErr.error = formatErrorMessage(localVarHTTPResponse.Status, &v)
newErr.model = v
return localVarReturnValue, localVarHTTPResponse, newErr
}
err = a.client.decode(&localVarReturnValue, localVarBody, localVarHTTPResponse.Header.Get("Content-Type"))
if err != nil {
newErr := &GenericOpenAPIError{
body: localVarBody,
error: err.Error(),
}
return localVarReturnValue, localVarHTTPResponse, newErr
}
return localVarReturnValue, localVarHTTPResponse, nil
}
type MeetAPIMeetRecordStopRequest struct {
ctx context.Context
ApiService *MeetAPIService
room *string
}
// Room is the LiveKit room, named the way the office client names one (`<space>_<name>_<id>`). Its leading segment is what binds the room to a tenant, and it is the segment the caller's membership is checked against.
func (r MeetAPIMeetRecordStopRequest) Room(room string) MeetAPIMeetRecordStopRequest {
r.room = &room
return r
}
func (r MeetAPIMeetRecordStopRequest) Execute() (*MeetRecording, *http.Response, error) {
return r.ApiService.MeetRecordStopExecute(r)
}
/*
MeetRecordStop Stop a room's recording
Ends a room's recording — EVERY one of them.
Whoever the room admits may stop it, including someone who did not start it:
a person being recorded has to be able to end it, and a rule that only the
starter may stop would deny exactly that. Stopping is free — a caller made to
pay to stop being recorded would be paying for the wrong thing.
200 MEANS THE ROOM IS NOT BEING RECORDED, and that is why this ends all of them
rather than the first. "At most one per room" is an invariant this surface wants
and cannot impose: reading the list and starting are two calls, and two replicas
racing through that window both start. When the list comes back holding two, two
is the truth — and ending one while answering 200 tells the person withdrawing
consent that it stopped while a second worker keeps writing. A stop that cannot
finish the job says so instead.
Stopping a room that is not being recorded is not an error. The answer names the
room with no recording on it, which is the state the caller asked for.
@param ctx context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background().
@return MeetAPIMeetRecordStopRequest
*/
func (a *MeetAPIService) MeetRecordStop(ctx context.Context) MeetAPIMeetRecordStopRequest {
return MeetAPIMeetRecordStopRequest{
ApiService: a,
ctx: ctx,
}
}
// Execute executes the request
//
// @return MeetRecording
func (a *MeetAPIService) MeetRecordStopExecute(r MeetAPIMeetRecordStopRequest) (*MeetRecording, *http.Response, error) {
var (
localVarHTTPMethod = http.MethodDelete
localVarPostBody interface{}
formFiles []formFile
localVarReturnValue *MeetRecording
)
localBasePath, err := a.client.cfg.ServerURLWithContext(r.ctx, "MeetAPIService.MeetRecordStop")
if err != nil {
return localVarReturnValue, nil, &GenericOpenAPIError{error: err.Error()}
}
localVarPath := localBasePath + "/v1/meet/record"
localVarHeaderParams := make(map[string]string)
localVarQueryParams := url.Values{}
localVarFormParams := url.Values{}
if r.room == nil {
return localVarReturnValue, nil, reportError("room is required and must be specified")
}
parameterAddToHeaderOrQuery(localVarQueryParams, "room", r.room, "form", "")
// to determine the Content-Type header
localVarHTTPContentTypes := []string{}
// set Content-Type header
localVarHTTPContentType := selectHeaderContentType(localVarHTTPContentTypes)
if localVarHTTPContentType != "" {
localVarHeaderParams["Content-Type"] = localVarHTTPContentType
}
// to determine the Accept header
localVarHTTPHeaderAccepts := []string{"application/json", "application/problem+json"}
// set Accept header
localVarHTTPHeaderAccept := selectHeaderAccept(localVarHTTPHeaderAccepts)
if localVarHTTPHeaderAccept != "" {
localVarHeaderParams["Accept"] = localVarHTTPHeaderAccept
}
req, err := a.client.prepareRequest(r.ctx, localVarPath, localVarHTTPMethod, localVarPostBody, localVarHeaderParams, localVarQueryParams, localVarFormParams, formFiles)
if err != nil {
return localVarReturnValue, nil, err
}
localVarHTTPResponse, err := a.client.callAPI(req)
if err != nil || localVarHTTPResponse == nil {
return localVarReturnValue, localVarHTTPResponse, err
}
localVarBody, err := io.ReadAll(localVarHTTPResponse.Body)
localVarHTTPResponse.Body.Close()
localVarHTTPResponse.Body = io.NopCloser(bytes.NewBuffer(localVarBody))
if err != nil {
return localVarReturnValue, localVarHTTPResponse, err
}
if localVarHTTPResponse.StatusCode >= 300 {
newErr := &GenericOpenAPIError{
body: localVarBody,
error: localVarHTTPResponse.Status,
}
var v ProblemDetails
err = a.client.decode(&v, localVarBody, localVarHTTPResponse.Header.Get("Content-Type"))
if err != nil {
newErr.error = err.Error()
return localVarReturnValue, localVarHTTPResponse, newErr
}
newErr.error = formatErrorMessage(localVarHTTPResponse.Status, &v)
newErr.model = v
return localVarReturnValue, localVarHTTPResponse, newErr
}
err = a.client.decode(&localVarReturnValue, localVarBody, localVarHTTPResponse.Header.Get("Content-Type"))
if err != nil {
newErr := &GenericOpenAPIError{
body: localVarBody,
error: err.Error(),
}
return localVarReturnValue, localVarHTTPResponse, newErr
}
return localVarReturnValue, localVarHTTPResponse, nil
}
type MeetAPIPostMeetGettokenRequest struct {
ctx context.Context
ApiService *MeetAPIService
}
func (r MeetAPIPostMeetGettokenRequest) Execute() (*http.Response, error) {
return r.ApiService.PostMeetGettokenExecute(r)
}
/*
PostMeetGettoken Mint a join token for one video room
Answers with a LiveKit join token for exactly the room named in the body. The body is the RAW token as text/plain — one opaque string, not JSON and not wrapped in an envelope, which is what the office client reads.
The caller presents its space session as a Bearer. Every clause is a refusal: the session must verify, its SIGNED space claim must equal the room's leading name segment — rooms are named `<space>_<room>_<id>`, and that prefix is the only thing binding a room to a tenant — and the session must carry a privileged space role, so a guest is refused rather than seated.
The participant identity is the SESSION'S, never the body's. `_id` is accepted for compatibility with the published client bundle and deliberately ignored: LiveKit treats the identity as unique and ejects a duplicate, so honouring a caller-chosen one would let anyone in a space kick out a colleague and impersonate them. `participantName` is a display name only.
An unconfigured deployment answers 503 under its own name rather than 404, and the refusal states only that the office is unconfigured — the reason names key material and stays in the boot log.
@param ctx context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background().
@return MeetAPIPostMeetGettokenRequest
*/
func (a *MeetAPIService) PostMeetGettoken(ctx context.Context) MeetAPIPostMeetGettokenRequest {
return MeetAPIPostMeetGettokenRequest{
ApiService: a,
ctx: ctx,
}
}
// Execute executes the request
func (a *MeetAPIService) PostMeetGettokenExecute(r MeetAPIPostMeetGettokenRequest) (*http.Response, error) {
var (
localVarHTTPMethod = http.MethodPost
localVarPostBody interface{}
formFiles []formFile
)
localBasePath, err := a.client.cfg.ServerURLWithContext(r.ctx, "MeetAPIService.PostMeetGettoken")
if err != nil {
return nil, &GenericOpenAPIError{error: err.Error()}
}
localVarPath := localBasePath + "/v1/meet/getToken"
localVarHeaderParams := make(map[string]string)
localVarQueryParams := url.Values{}
localVarFormParams := url.Values{}
// to determine the Content-Type header
localVarHTTPContentTypes := []string{}
// set Content-Type header
localVarHTTPContentType := selectHeaderContentType(localVarHTTPContentTypes)
if localVarHTTPContentType != "" {
localVarHeaderParams["Content-Type"] = localVarHTTPContentType
}
// to determine the Accept header
localVarHTTPHeaderAccepts := []string{}
// set Accept header
localVarHTTPHeaderAccept := selectHeaderAccept(localVarHTTPHeaderAccepts)
if localVarHTTPHeaderAccept != "" {
localVarHeaderParams["Accept"] = localVarHTTPHeaderAccept
}
req, err := a.client.prepareRequest(r.ctx, localVarPath, localVarHTTPMethod, localVarPostBody, localVarHeaderParams, localVarQueryParams, localVarFormParams, formFiles)
if err != nil {
return nil, err
}
localVarHTTPResponse, err := a.client.callAPI(req)
if err != nil || localVarHTTPResponse == nil {
return localVarHTTPResponse, err
}
localVarBody, err := io.ReadAll(localVarHTTPResponse.Body)
localVarHTTPResponse.Body.Close()
localVarHTTPResponse.Body = io.NopCloser(bytes.NewBuffer(localVarBody))
if err != nil {
return localVarHTTPResponse, err
}
if localVarHTTPResponse.StatusCode >= 300 {
newErr := &GenericOpenAPIError{
body: localVarBody,
error: localVarHTTPResponse.Status,
}
return localVarHTTPResponse, newErr
}
return localVarHTTPResponse, nil
}