@lap v0.3
# Machine-readable API spec. Each @endpoint block is one API call.
@api langfuse
@auth Bearer basic
@endpoints 87
@hint download_for_search
@toc api(87)

@endpoint GET /api/public/annotation-queues
@optional {page: int, limit: int}
@returns(200) {data: [map], meta: map{page: int, limit: int, totalItems: int, totalPages: int}}
@errors {400, 401, 403, 404, 405}

@endpoint POST /api/public/annotation-queues
@required {name: str, scoreConfigIds: [str]}
@optional {description: str}
@returns(200) {id: str, name: str, description: str?, scoreConfigIds: [str], createdAt: str(date-time), updatedAt: str(date-time)}
@errors {400, 401, 403, 404, 405}

@endpoint GET /api/public/annotation-queues/{queueId}
@required {queueId: str}
@returns(200) {id: str, name: str, description: str?, scoreConfigIds: [str], createdAt: str(date-time), updatedAt: str(date-time)}
@errors {400, 401, 403, 404, 405}

@endpoint GET /api/public/annotation-queues/{queueId}/items
@required {queueId: str}
@optional {status: str, page: int, limit: int}
@returns(200) {data: [map], meta: map{page: int, limit: int, totalItems: int, totalPages: int}}
@errors {400, 401, 403, 404, 405}

@endpoint POST /api/public/annotation-queues/{queueId}/items
@required {queueId: str, objectId: str, objectType: str(TRACE/OBSERVATION/SESSION)}
@optional {status: str(PENDING/COMPLETED)}
@returns(200) {id: str, queueId: str, objectId: str, objectType: str, status: str, completedAt: str(date-time)?, createdAt: str(date-time), updatedAt: str(date-time)}
@errors {400, 401, 403, 404, 405}

@endpoint GET /api/public/annotation-queues/{queueId}/items/{itemId}
@required {queueId: str, itemId: str}
@returns(200) {id: str, queueId: str, objectId: str, objectType: str, status: str, completedAt: str(date-time)?, createdAt: str(date-time), updatedAt: str(date-time)}
@errors {400, 401, 403, 404, 405}

@endpoint PATCH /api/public/annotation-queues/{queueId}/items/{itemId}
@required {queueId: str, itemId: str}
@optional {status: str(PENDING/COMPLETED)}
@returns(200) {id: str, queueId: str, objectId: str, objectType: str, status: str, completedAt: str(date-time)?, createdAt: str(date-time), updatedAt: str(date-time)}
@errors {400, 401, 403, 404, 405}

@endpoint DELETE /api/public/annotation-queues/{queueId}/items/{itemId}
@required {queueId: str, itemId: str}
@returns(200) {success: bool, message: str}
@errors {400, 401, 403, 404, 405}

@endpoint POST /api/public/annotation-queues/{queueId}/assignments
@required {queueId: str, userId: str}
@returns(200) {userId: str, queueId: str, projectId: str}
@errors {400, 401, 403, 404, 405}

@endpoint DELETE /api/public/annotation-queues/{queueId}/assignments
@required {queueId: str, userId: str}
@returns(200) {success: bool}
@errors {400, 401, 403, 404, 405}

@endpoint GET /api/public/integrations/blob-storage
@returns(200) {data: [map]}
@errors {400, 401, 403, 404, 405}

@endpoint PUT /api/public/integrations/blob-storage
@required {projectId: str, type: str(S3/S3_COMPATIBLE/AZURE_BLOB_STORAGE), bucketName: str, region: str, exportFrequency: str(hourly/daily/weekly), enabled: bool, forcePathStyle: bool, fileType: str(JSON/CSV/JSONL), exportMode: str(FULL_HISTORY/FROM_TODAY/FROM_CUSTOM_DATE)}
@optional {endpoint: str, accessKeyId: str, secretAccessKey: str, prefix: str, exportStartDate: str(date-time)}
@returns(200) {id: str, projectId: str, type: str, bucketName: str, endpoint: str?, region: str, accessKeyId: str?, prefix: str, exportFrequency: str, enabled: bool, forcePathStyle: bool, fileType: str, exportMode: str, exportStartDate: str(date-time)?, nextSyncAt: str(date-time)?, lastSyncAt: str(date-time)?, lastError: str?, lastErrorAt: str(date-time)?, createdAt: str(date-time), updatedAt: str(date-time)}
@errors {400, 401, 403, 404, 405}

@endpoint GET /api/public/integrations/blob-storage/{id}
@required {id: str}
@returns(200) {id: str, projectId: str, syncStatus: str, enabled: bool, lastSyncAt: str(date-time)?, nextSyncAt: str(date-time)?, lastError: str?, lastErrorAt: str(date-time)?}
@errors {400, 401, 403, 404, 405}

@endpoint DELETE /api/public/integrations/blob-storage/{id}
@required {id: str}
@returns(200) {message: str}
@errors {400, 401, 403, 404, 405}

@endpoint POST /api/public/comments
@required {projectId: str, objectType: str, objectId: str, content: str}
@optional {authorUserId: str}
@returns(200) {id: str}
@errors {400, 401, 403, 404, 405}

@endpoint GET /api/public/comments
@optional {page: int, limit: int, objectType: str, objectId: str, authorUserId: str}
@returns(200) {data: [map], meta: map{page: int, limit: int, totalItems: int, totalPages: int}}
@errors {400, 401, 403, 404, 405}

@endpoint GET /api/public/comments/{commentId}
@required {commentId: str}
@returns(200) {id: str, projectId: str, createdAt: str(date-time), updatedAt: str(date-time), objectType: str, objectId: str, content: str, authorUserId: str?}
@errors {400, 401, 403, 404, 405}

@endpoint POST /api/public/dataset-items
@required {datasetName: str}
@optional {input: any, expectedOutput: any, metadata: any, sourceTraceId: str, sourceObservationId: str, id: str, status: str(ACTIVE/ARCHIVED)}
@returns(200) {id: str, status: str, input: any, expectedOutput: any, metadata: any, sourceTraceId: str?, sourceObservationId: str?, datasetId: str, datasetName: str, createdAt: str(date-time), updatedAt: str(date-time)}
@errors {400, 401, 403, 404, 405}

@endpoint GET /api/public/dataset-items
@optional {datasetName: str, sourceTraceId: str, sourceObservationId: str, version: str(date-time), page: int, limit: int}
@returns(200) {data: [map], meta: map{page: int, limit: int, totalItems: int, totalPages: int}}
@errors {400, 401, 403, 404, 405}

@endpoint GET /api/public/dataset-items/{id}
@required {id: str}
@returns(200) {id: str, status: str, input: any, expectedOutput: any, metadata: any, sourceTraceId: str?, sourceObservationId: str?, datasetId: str, datasetName: str, createdAt: str(date-time), updatedAt: str(date-time)}
@errors {400, 401, 403, 404, 405}

@endpoint DELETE /api/public/dataset-items/{id}
@required {id: str}
@returns(200) {message: str}
@errors {400, 401, 403, 404, 405}

@endpoint POST /api/public/dataset-run-items
@required {runName: str, datasetItemId: str}
@optional {runDescription: str, metadata: any, observationId: str, traceId: str, datasetVersion: str(date-time), createdAt: str(date-time)}
@returns(200) {id: str, datasetRunId: str, datasetRunName: str, datasetItemId: str, traceId: str, observationId: str?, createdAt: str(date-time), updatedAt: str(date-time)}
@errors {400, 401, 403, 404, 405}

@endpoint GET /api/public/dataset-run-items
@required {datasetId: str, runName: str}
@optional {page: int, limit: int}
@returns(200) {data: [map], meta: map{page: int, limit: int, totalItems: int, totalPages: int}}
@errors {400, 401, 403, 404, 405}

@endpoint GET /api/public/v2/datasets
@optional {page: int, limit: int}
@returns(200) {data: [map], meta: map{page: int, limit: int, totalItems: int, totalPages: int}}
@errors {400, 401, 403, 404, 405}

@endpoint POST /api/public/v2/datasets
@required {name: str}
@optional {description: str, metadata: any, inputSchema: any, expectedOutputSchema: any}
@returns(200) {id: str, name: str, description: str?, metadata: any, inputSchema: any?, expectedOutputSchema: any?, projectId: str, createdAt: str(date-time), updatedAt: str(date-time)}
@errors {400, 401, 403, 404, 405}

@endpoint GET /api/public/v2/datasets/{datasetName}
@required {datasetName: str}
@returns(200) {id: str, name: str, description: str?, metadata: any, inputSchema: any?, expectedOutputSchema: any?, projectId: str, createdAt: str(date-time), updatedAt: str(date-time)}
@errors {400, 401, 403, 404, 405}

@endpoint GET /api/public/datasets/{datasetName}/runs/{runName}
@required {datasetName: str, runName: str}
@returns(200) {datasetRunItems: [map]}
@errors {400, 401, 403, 404, 405}

@endpoint DELETE /api/public/datasets/{datasetName}/runs/{runName}
@required {datasetName: str, runName: str}
@returns(200) {message: str}
@errors {400, 401, 403, 404, 405}

@endpoint GET /api/public/datasets/{datasetName}/runs
@required {datasetName: str}
@optional {page: int, limit: int}
@returns(200) {data: [map], meta: map{page: int, limit: int, totalItems: int, totalPages: int}}
@errors {400, 401, 403, 404, 405}

@endpoint GET /api/public/health
@returns(200) {version: str, status: str}
@errors {400, 401, 403, 404, 405, 503}

@endpoint POST /api/public/ingestion
@required {batch: [any]}
@optional {metadata: any}
@returns(207) {successes: [map], errors: [map]}
@errors {400, 401, 403, 404, 405}

@endpoint GET /api/public/metrics
@required {query: str}
@returns(200) {data: [map]}
@errors {400, 401, 403, 404, 405}

@endpoint GET /api/public/observations/{observationId}
@required {observationId: str}
@returns(200) {promptName: str?, promptVersion: int?, modelId: str?, inputPrice: num(double)?, outputPrice: num(double)?, totalPrice: num(double)?, calculatedInputCost: num(double)?, calculatedOutputCost: num(double)?, calculatedTotalCost: num(double)?, latency: num(double)?, timeToFirstToken: num(double)?}
@errors {400, 401, 403, 404, 405}

@endpoint GET /api/public/observations
@optional {page: int, limit: int, name: str, userId: str, type: str, traceId: str, level: str, parentObservationId: str, environment: [str], fromStartTime: str(date-time), toStartTime: str(date-time), version: str, filter: str}
@returns(200) {data: [map], meta: map{page: int, limit: int, totalItems: int, totalPages: int}}
@errors {400, 401, 403, 404, 405}

@endpoint POST /api/public/scores
@required {name: str, value: any}
@optional {id: str, traceId: str, sessionId: str, observationId: str, datasetRunId: str, comment: str, metadata: map, environment: str, queueId: str, dataType: str(NUMERIC/BOOLEAN/CATEGORICAL/CORRECTION), configId: str}
@returns(200) {id: str}
@errors {400, 401, 403, 404, 405}

@endpoint DELETE /api/public/scores/{scoreId}
@required {scoreId: str}
@returns(204)
@errors {400, 401, 403, 404, 405}

@endpoint GET /api/public/llm-connections
@optional {page: int, limit: int}
@returns(200) {data: [map], meta: map{page: int, limit: int, totalItems: int, totalPages: int}}
@errors {400, 401, 403, 404, 405}

@endpoint PUT /api/public/llm-connections
@required {provider: str, adapter: str(anthropic/openai/azure/bedrock/google-vertex-ai/google-ai-studio), secretKey: str}
@optional {baseURL: str, customModels: [str], withDefaultModels: bool, extraHeaders: map, config: map}
@returns(200) {id: str, provider: str, adapter: str, displaySecretKey: str, baseURL: str?, customModels: [str], withDefaultModels: bool, extraHeaderKeys: [str], config: map?, createdAt: str(date-time), updatedAt: str(date-time)}
@errors {400, 401, 403, 404, 405}

@endpoint GET /api/public/media/{mediaId}
@required {mediaId: str}
@returns(200) {mediaId: str, contentType: str, contentLength: int, uploadedAt: str(date-time), url: str, urlExpiry: str}
@errors {400, 401, 403, 404, 405}

@endpoint PATCH /api/public/media/{mediaId}
@required {mediaId: str, uploadedAt: str(date-time), uploadHttpStatus: int}
@optional {uploadHttpError: str, uploadTimeMs: int}
@returns(204)
@errors {400, 401, 403, 404, 405}

@endpoint POST /api/public/media
@required {traceId: str, contentType: str(image/png/image/jpeg/image/jpg/image/webp/image/gif/image/svg+xml/image/tiff/image/bmp/image/avif/image/heic/audio/mpeg/audio/mp3/audio/wav/audio/ogg/audio/oga/audio/aac/audio/mp4/audio/flac/audio/opus/audio/webm/video/mp4/video/webm/video/ogg/video/mpeg/video/quicktime/video/x-msvideo/video/x-matroska/text/plain/text/html/text/css/text/csv/text/markdown/text/x-python/application/javascript/text/x-typescript/application/x-yaml/application/pdf/application/msword/application/vnd.ms-excel/application/vnd.openxmlformats-officedocument.spreadsheetml.sheet/application/zip/application/json/application/xml/application/octet-stream/application/vnd.openxmlformats-officedocument.wordprocessingml.document/application/vnd.openxmlformats-officedocument.presentationml.presentation/application/rtf/application/x-ndjson/application/vnd.apache.parquet/application/gzip/application/x-tar/application/x-7z-compressed), contentLength: int, sha256Hash: str, field: str}
@optional {observationId: str}
@returns(200) {uploadUrl: str?, mediaId: str}
@errors {400, 401, 403, 404, 405}

@endpoint GET /api/public/v2/metrics
@required {query: str}
@returns(200) {data: [map]}
@errors {400, 401, 403, 404, 405}

@endpoint POST /api/public/models
@required {modelName: str, matchPattern: str}
@optional {startDate: str(date-time), unit: str(CHARACTERS/TOKENS/MILLISECONDS/SECONDS/IMAGES/REQUESTS), inputPrice: num(double), outputPrice: num(double), totalPrice: num(double), pricingTiers: [map{name!: str, isDefault!: bool, priority!: int, conditions!: [map], prices!: map}], tokenizerId: str, tokenizerConfig: any}
@returns(200) {id: str, modelName: str, matchPattern: str, startDate: str(date-time)?, unit: str, inputPrice: num(double)?, outputPrice: num(double)?, totalPrice: num(double)?, tokenizerId: str?, tokenizerConfig: any, isLangfuseManaged: bool, createdAt: str(date-time), prices: map, pricingTiers: [map]}
@errors {400, 401, 403, 404, 405}

@endpoint GET /api/public/models
@optional {page: int, limit: int}
@returns(200) {data: [map], meta: map{page: int, limit: int, totalItems: int, totalPages: int}}
@errors {400, 401, 403, 404, 405}

@endpoint GET /api/public/models/{id}
@required {id: str}
@returns(200) {id: str, modelName: str, matchPattern: str, startDate: str(date-time)?, unit: str, inputPrice: num(double)?, outputPrice: num(double)?, totalPrice: num(double)?, tokenizerId: str?, tokenizerConfig: any, isLangfuseManaged: bool, createdAt: str(date-time), prices: map, pricingTiers: [map]}
@errors {400, 401, 403, 404, 405}

@endpoint DELETE /api/public/models/{id}
@required {id: str}
@returns(204)
@errors {400, 401, 403, 404, 405}

@endpoint GET /api/public/v2/observations
@optional {fields: str, expandMetadata: str, limit: int, cursor: str, parseIoAsJson: bool, name: str, userId: str, type: str, traceId: str, level: str, parentObservationId: str, environment: [str], fromStartTime: str(date-time), toStartTime: str(date-time), version: str, filter: str}
@returns(200) {data: [map], meta: map{cursor: str?}}
@errors {400, 401, 403, 404, 405}

@endpoint POST /api/public/otel/v1/traces
@required {resourceSpans: [map{resource: map, scopeSpans: [map]}]}
@returns(200)
@errors {400, 401, 403, 404, 405}

@endpoint GET /api/public/organizations/memberships
@returns(200) {memberships: [map]}
@errors {400, 401, 403, 404, 405}

@endpoint PUT /api/public/organizations/memberships
@required {userId: str, role: str(OWNER/ADMIN/MEMBER/VIEWER)}
@returns(200) {userId: str, role: str, email: str, name: str}
@errors {400, 401, 403, 404, 405}

@endpoint DELETE /api/public/organizations/memberships
@required {userId: str}
@returns(200) {message: str, userId: str}
@errors {400, 401, 403, 404, 405}

@endpoint GET /api/public/projects/{projectId}/memberships
@required {projectId: str}
@returns(200) {memberships: [map]}
@errors {400, 401, 403, 404, 405}

@endpoint PUT /api/public/projects/{projectId}/memberships
@required {projectId: str, userId: str, role: str(OWNER/ADMIN/MEMBER/VIEWER)}
@returns(200) {userId: str, role: str, email: str, name: str}
@errors {400, 401, 403, 404, 405}

@endpoint DELETE /api/public/projects/{projectId}/memberships
@required {projectId: str, userId: str}
@returns(200) {message: str, userId: str}
@errors {400, 401, 403, 404, 405}

@endpoint GET /api/public/organizations/projects
@returns(200) {projects: [map]}
@errors {400, 401, 403, 404, 405}

@endpoint GET /api/public/organizations/apiKeys
@returns(200) {apiKeys: [map]}
@errors {400, 401, 403, 404, 405}

@endpoint GET /api/public/projects
@returns(200) {data: [map]}
@errors {400, 401, 403, 404, 405}

@endpoint POST /api/public/projects
@required {name: str, retention: int}
@optional {metadata: map}
@returns(200) {id: str, name: str, organization: map{id: str, name: str}, metadata: map, retentionDays: int?}
@errors {400, 401, 403, 404, 405}

@endpoint PUT /api/public/projects/{projectId}
@required {projectId: str, name: str}
@optional {metadata: map, retention: int}
@returns(200) {id: str, name: str, organization: map{id: str, name: str}, metadata: map, retentionDays: int?}
@errors {400, 401, 403, 404, 405}

@endpoint DELETE /api/public/projects/{projectId}
@required {projectId: str}
@returns(202) {success: bool, message: str}
@errors {400, 401, 403, 404, 405}

@endpoint GET /api/public/projects/{projectId}/apiKeys
@required {projectId: str}
@returns(200) {apiKeys: [map]}
@errors {400, 401, 403, 404, 405}

@endpoint POST /api/public/projects/{projectId}/apiKeys
@required {projectId: str}
@optional {note: str, publicKey: str, secretKey: str}
@returns(200) {id: str, createdAt: str(date-time), publicKey: str, secretKey: str, displaySecretKey: str, note: str?}
@errors {400, 401, 403, 404, 405}

@endpoint DELETE /api/public/projects/{projectId}/apiKeys/{apiKeyId}
@required {projectId: str, apiKeyId: str}
@returns(200) {success: bool}
@errors {400, 401, 403, 404, 405}

@endpoint PATCH /api/public/v2/prompts/{name}/versions/{version}
@required {name: str, version: int, newLabels: [str]}
@returns(200)
@errors {400, 401, 403, 404, 405}

@endpoint GET /api/public/v2/prompts/{promptName}
@required {promptName: str}
@optional {version: int, label: str, resolve: bool}
@returns(200)
@errors {400, 401, 403, 404, 405}

@endpoint DELETE /api/public/v2/prompts/{promptName}
@required {promptName: str}
@optional {label: str, version: int}
@returns(204)
@errors {400, 401, 403, 404, 405}

@endpoint GET /api/public/v2/prompts
@optional {name: str, label: str, tag: str, page: int, limit: int, fromUpdatedAt: str(date-time), toUpdatedAt: str(date-time)}
@returns(200) {data: [map], meta: map{page: int, limit: int, totalItems: int, totalPages: int}}
@errors {400, 401, 403, 404, 405}

@endpoint POST /api/public/v2/prompts
@returns(200)
@errors {400, 401, 403, 404, 405}

@endpoint GET /api/public/scim/ServiceProviderConfig
@returns(200) {schemas: [str], documentationUri: str, patch: map{supported: bool}, bulk: map{supported: bool, maxOperations: int, maxPayloadSize: int}, filter: map{supported: bool, maxResults: int}, changePassword: map{supported: bool}, sort: map{supported: bool}, etag: map{supported: bool}, authenticationSchemes: [map], meta: map{resourceType: str, location: str}}
@errors {400, 401, 403, 404, 405}

@endpoint GET /api/public/scim/ResourceTypes
@returns(200) {schemas: [str], totalResults: int, Resources: [map]}
@errors {400, 401, 403, 404, 405}

@endpoint GET /api/public/scim/Schemas
@returns(200) {schemas: [str], totalResults: int, Resources: [map]}
@errors {400, 401, 403, 404, 405}

@endpoint GET /api/public/scim/Users
@optional {filter: str, startIndex: int, count: int}
@returns(200) {schemas: [str], totalResults: int, startIndex: int, itemsPerPage: int, Resources: [map]}
@errors {400, 401, 403, 404, 405}

@endpoint POST /api/public/scim/Users
@required {userName: str, name: map{formatted: str}}
@optional {emails: [map{primary!: bool, value!: str, type!: str}], active: bool, password: str}
@returns(200) {schemas: [str], id: str, userName: str, name: map{formatted: str?}, emails: [map], meta: map{resourceType: str, created: str?, lastModified: str?}}
@errors {400, 401, 403, 404, 405}

@endpoint GET /api/public/scim/Users/{userId}
@required {userId: str}
@returns(200) {schemas: [str], id: str, userName: str, name: map{formatted: str?}, emails: [map], meta: map{resourceType: str, created: str?, lastModified: str?}}
@errors {400, 401, 403, 404, 405}

@endpoint DELETE /api/public/scim/Users/{userId}
@required {userId: str}
@returns(200)
@errors {400, 401, 403, 404, 405}

@endpoint POST /api/public/score-configs
@required {name: str, dataType: str(NUMERIC/BOOLEAN/CATEGORICAL)}
@optional {categories: [map{value!: num(double), label!: str}], minValue: num(double), maxValue: num(double), description: str}
@returns(200) {id: str, name: str, createdAt: str(date-time), updatedAt: str(date-time), projectId: str, dataType: str, isArchived: bool, minValue: num(double)?, maxValue: num(double)?, categories: [map]?, description: str?}
@errors {400, 401, 403, 404, 405}

@endpoint GET /api/public/score-configs
@optional {page: int, limit: int}
@returns(200) {data: [map], meta: map{page: int, limit: int, totalItems: int, totalPages: int}}
@errors {400, 401, 403, 404, 405}

@endpoint GET /api/public/score-configs/{configId}
@required {configId: str}
@returns(200) {id: str, name: str, createdAt: str(date-time), updatedAt: str(date-time), projectId: str, dataType: str, isArchived: bool, minValue: num(double)?, maxValue: num(double)?, categories: [map]?, description: str?}
@errors {400, 401, 403, 404, 405}

@endpoint PATCH /api/public/score-configs/{configId}
@required {configId: str}
@optional {isArchived: bool, name: str, categories: [map{value!: num(double), label!: str}], minValue: num(double), maxValue: num(double), description: str}
@returns(200) {id: str, name: str, createdAt: str(date-time), updatedAt: str(date-time), projectId: str, dataType: str, isArchived: bool, minValue: num(double)?, maxValue: num(double)?, categories: [map]?, description: str?}
@errors {400, 401, 403, 404, 405}

@endpoint GET /api/public/v2/scores
@optional {page: int, limit: int, userId: str, name: str, fromTimestamp: str(date-time), toTimestamp: str(date-time), environment: [str], source: str, operator: str, value: num(double), scoreIds: str, configId: str, sessionId: str, datasetRunId: str, traceId: str, observationId: str, queueId: str, dataType: str, traceTags: [str], fields: str, filter: str}
@returns(200) {data: [any], meta: map{page: int, limit: int, totalItems: int, totalPages: int}}
@errors {400, 401, 403, 404, 405}

@endpoint GET /api/public/v2/scores/{scoreId}
@required {scoreId: str}
@returns(200)
@errors {400, 401, 403, 404, 405}

@endpoint GET /api/public/sessions
@optional {page: int, limit: int, fromTimestamp: str(date-time), toTimestamp: str(date-time), environment: [str]}
@returns(200) {data: [map], meta: map{page: int, limit: int, totalItems: int, totalPages: int}}
@errors {400, 401, 403, 404, 405}

@endpoint GET /api/public/sessions/{sessionId}
@required {sessionId: str}
@returns(200) {traces: [map]}
@errors {400, 401, 403, 404, 405}

@endpoint GET /api/public/traces/{traceId}
@required {traceId: str}
@returns(200) {htmlPath: str, latency: num(double)?, totalCost: num(double)?, observations: [map], scores: [any]}
@errors {400, 401, 403, 404, 405}

@endpoint DELETE /api/public/traces/{traceId}
@required {traceId: str}
@returns(200) {message: str}
@errors {400, 401, 403, 404, 405}

@endpoint GET /api/public/traces
@optional {page: int, limit: int, userId: str, name: str, sessionId: str, fromTimestamp: str(date-time), toTimestamp: str(date-time), orderBy: str, tags: [str], version: str, release: str, environment: [str], fields: str, filter: str}
@returns(200) {data: [map], meta: map{page: int, limit: int, totalItems: int, totalPages: int}}
@errors {400, 401, 403, 404, 405}

@endpoint DELETE /api/public/traces
@required {traceIds: [str]}
@returns(200) {message: str}
@errors {400, 401, 403, 404, 405}

@end