@q9labsai/chalk-client 5.0.1 → 5.2.0

package/dist/{chunk-2HJIJVE2.js → chunk-HO4745TX.js}

@@ -1,5 +1,13 @@
 // src/generated/schemas.ts
 import { Schema, SchemaGetter } from "effect";
+var ChalkCodePointLimits = {
+  "CreateSpaceRequest.name": 120,
+  "CreateTenantRequest.external_id": 512,
+  "ProblemReportRequest.description": 1e3,
+  "ProblemReportRequest.diagnostics": 2e3,
+  "Tenant.external_id": 512,
+  "UpdateSpaceRequest.name": 120
+};
 var isCodePointLengthBetween = (minimum, maximum) => Schema.makeFilter(
   (input) => {
     const length = Array.from(input).length;
@@ -262,7 +270,7 @@ var CreateSpaceRequestSchema = Schema.Struct({
   maximum_episode_duration_seconds: Schema.Number,
   media_plane: Schema.optional(Schema.String.check(Schema.isMinLength(1))),
   metadata: Schema.optional(Schema.Unknown),
-  name: Schema.String.check(Schema.isMinLength(1)),
+  name: Schema.String.check(isCodePointLengthBetween(1, 120)),
   recording_policy: Schema.optional(Schema.NullOr(Schema.String.check(Schema.isMinLength(1)))),
   recurring_policy: Schema.optional(Schema.Unknown),
   slug: Schema.String.check(Schema.isMinLength(1)),
@@ -420,6 +428,9 @@ var MembershipListSchema = Schema.Struct({
   memberships: Schema.Array(MembershipSchema),
   pagination: PaginationSchema
 });
+var ParticipantJoinCancellationSchema = Schema.Struct({
+  cancelled: Schema.Boolean
+});
 var ParticipantLifecycleSchema = Schema.Struct({
   access: Schema.optional(Schema.NullOr(AccessGrantSchema)),
   admission_request: Schema.optional(
@@ -489,7 +500,19 @@ var PrepareRecordingRequestSchema = Schema.Struct({
   expected_revision: Schema.Number,
   starts_at: DateTimeStringSchema
 });
+var ProblemReportAvailabilitySchema = Schema.Struct({
+  available: Schema.Boolean
+});
+var ProblemReportRequestSchema = Schema.Struct({
+  description: Schema.String.check(isCodePointLengthBetween(1, 1e3), Schema.isPattern(new RegExp("[^\\t\\n\\v\\f\\r \\u0085\\u00a0\\u1680\\u2000-\\u200a\\u2028\\u2029\\u202f\\u205f\\u3000]"))),
+  diagnostics: Schema.optional(Schema.String.check(isCodePointLengthBetween(0, 2e3)))
+});
+var ProblemReportSentSchema = Schema.Struct({
+  sent: Schema.Boolean
+});
 var PublicAdmissionRequestSchema = Schema.Struct({
+  decision_action: Schema.optional(Schema.String),
+  decision_state: Schema.String,
   display_name: Schema.String,
   expires_at: DateTimeStringSchema,
   request_handle: Schema.String,
@@ -542,6 +565,8 @@ var RecordingSourceSchema = Schema.Struct({
   stop_reason: Schema.optional(Schema.Literal("duration_limit"))
 });
 var RecordingTranscriptionPreparationSchema = Schema.Struct({
+  expires_at: Schema.optional(Schema.NullOr(DateTimeStringSchema)),
+  failure_code: Schema.optional(Schema.String),
   status: Schema.Literals(["none", "pending", "ready", "failed", "expired"])
 });
 var RecordingSchema = Schema.Struct({
@@ -641,6 +666,40 @@ var SpaceSchema = Schema.Struct({
   transcription_policy: Schema.String,
   updated_at: DateTimeStringSchema
 });
+var SpaceActivityListSchema = Schema.Struct({
+  spaces: Schema.Array(
+    Schema.Struct({
+      archived: Schema.Boolean,
+      latest_episode: Schema.NullOr(
+        Schema.Struct({
+          ended_at: Schema.NullOr(DateTimeStringSchema),
+          episode_id: EpisodeIdSchema,
+          started_at: DateTimeStringSchema,
+          status: Schema.String
+        })
+      ),
+      live_episode: Schema.NullOr(
+        Schema.Struct({
+          episode_id: EpisodeIdSchema,
+          participant_count: Schema.Number,
+          participants: Schema.Array(
+            Schema.Struct({
+              display_name: Schema.String,
+              participant_id: ParticipantIdSchema
+            })
+          )
+        })
+      ),
+      recent_participants: Schema.Array(
+        Schema.Struct({
+          display_name: Schema.String,
+          participant_id: ParticipantIdSchema
+        })
+      ),
+      space_id: SpaceIdSchema
+    })
+  )
+});
 var SpaceListSchema = Schema.Struct({
   pagination: PaginationSchema,
   spaces: Schema.Array(SpaceSchema)
@@ -698,6 +757,7 @@ var TenantSchema = Schema.Struct({
   media_plane_provider_config: Schema.NullOr(MediaPlaneProviderConfigSchema),
   name: Schema.String,
   provider_policy_version: Schema.String,
+  recording_render_mode: Schema.Literals(["on_demand", "automatic"]),
   recording_retention_seconds: Schema.Number,
   storage_provider_config: Schema.NullOr(StorageProviderConfigSchema),
   transcript_retention_seconds: Schema.Number,
@@ -786,7 +846,7 @@ var UpdateSpaceRequestSchema = Schema.Struct({
   maximum_episode_duration_seconds: Schema.optional(Schema.Number),
   media_plane: Schema.optional(Schema.String.check(Schema.isMinLength(1))),
   metadata: Schema.optional(Schema.Unknown),
-  name: Schema.optional(Schema.String.check(Schema.isMinLength(1))),
+  name: Schema.optional(Schema.String.check(isCodePointLengthBetween(1, 120))),
   recording_policy: Schema.optional(Schema.String.check(Schema.isMinLength(1))),
   recurring_policy: Schema.optional(Schema.Unknown),
   slug: Schema.optional(Schema.String.check(Schema.isMinLength(1))),
@@ -803,6 +863,7 @@ var UpdateTenantRequestSchema = Schema.Struct({
   media_plane_provider_config: Schema.optional(Schema.NullOr(MediaPlaneProviderConfigSchema)),
   name: Schema.optional(Schema.String.check(Schema.isMinLength(1))),
   provider_policy_version: Schema.optional(Schema.String.check(Schema.isMinLength(1))),
+  recording_render_mode: Schema.optional(Schema.Literals(["on_demand", "automatic"])),
   recording_retention_seconds: Schema.optional(Schema.NullOr(Schema.Number)),
   storage_provider_config: Schema.optional(Schema.NullOr(StorageProviderConfigSchema)),
   transcript_retention_seconds: Schema.optional(Schema.NullOr(Schema.Number)),
@@ -1028,6 +1089,18 @@ var ArriveBySpacePublicInvite429ResponseHeadersSchema = Schema.Struct({
   "X-RateLimit-Limit": RateLimitLimitHeaderSchema,
   "X-RateLimit-Remaining": RateLimitRemainingHeaderSchema
 });
+var CancelEpisodeParticipantJoinPathParamsSchema = Schema.Struct({
+  episode_id: EpisodeIdSchema,
+  participant_id: ParticipantIdSchema,
+  space_id: SpaceIdSchema,
+  tenant_id: TenantIdSchema
+});
+var CancelEpisodeParticipantJoinResponseSchema = ParticipantJoinCancellationSchema;
+var CancelEpisodeParticipantJoin429ResponseHeadersSchema = Schema.Struct({
+  "Retry-After": RetryAfterHeaderSchema,
+  "X-RateLimit-Limit": RateLimitLimitHeaderSchema,
+  "X-RateLimit-Remaining": RateLimitRemainingHeaderSchema
+});
 var CancelSpaceRecordingPreparationPathParamsSchema = Schema.Struct({
   space_id: SpaceIdSchema,
   tenant_id: TenantIdSchema
@@ -1243,6 +1316,10 @@ var GetEpisodeAttendance429ResponseHeadersSchema = Schema.Struct({
   "X-RateLimit-Limit": RateLimitLimitHeaderSchema,
   "X-RateLimit-Remaining": RateLimitRemainingHeaderSchema
 });
+var GetProblemReportAvailabilityPathParamsSchema = Schema.Struct({
+  tenant_id: TenantIdSchema
+});
+var GetProblemReportAvailabilityResponseSchema = ProblemReportAvailabilitySchema;
 var GetRecordingPathParamsSchema = Schema.Struct({
   recording_id: RecordingIdSchema,
   tenant_id: TenantIdSchema
@@ -1413,6 +1490,18 @@ var ListRecordingsQueryParamsSchema = Schema.Struct({
   space_id: Schema.optional(SpaceIdSchema)
 });
 var ListRecordingsResponseSchema = RecordingListSchema;
+var ListSpaceActivityPathParamsSchema = Schema.Struct({
+  tenant_id: TenantIdSchema
+});
+var ListSpaceActivityQueryParamsSchema = Schema.Struct({
+  space_ids: Schema.String
+});
+var ListSpaceActivityResponseSchema = SpaceActivityListSchema;
+var ListSpaceActivity429ResponseHeadersSchema = Schema.Struct({
+  "Retry-After": RetryAfterHeaderSchema,
+  "X-RateLimit-Limit": RateLimitLimitHeaderSchema,
+  "X-RateLimit-Remaining": RateLimitRemainingHeaderSchema
+});
 var ListSpaceLiveEpisodesPathParamsSchema = Schema.Struct({
   tenant_id: TenantIdSchema
 });
@@ -1678,6 +1767,16 @@ var RotateWebhookEndpointSecret429ResponseHeadersSchema = Schema.Struct({
   "X-RateLimit-Limit": RateLimitLimitHeaderSchema,
   "X-RateLimit-Remaining": RateLimitRemainingHeaderSchema
 });
+var SendProblemReportPathParamsSchema = Schema.Struct({
+  tenant_id: TenantIdSchema
+});
+var SendProblemReportRequestBodySchema = ProblemReportRequestSchema;
+var SendProblemReportResponseSchema = ProblemReportSentSchema;
+var SendProblemReport429ResponseHeadersSchema = Schema.Struct({
+  "Retry-After": RetryAfterHeaderSchema,
+  "X-RateLimit-Limit": RateLimitLimitHeaderSchema,
+  "X-RateLimit-Remaining": RateLimitRemainingHeaderSchema
+});
 var SetEpisodeDeadlinePathParamsSchema = Schema.Struct({
   episode_id: EpisodeIdSchema,
   space_id: SpaceIdSchema,
@@ -2277,6 +2376,253 @@ var MediaConnectionNotFoundErrorSchema = MediaConnectionNotFoundErrorWireSchema.
     encode: SchemaGetter.transform((error) => ({ error: error.error }))
   })
 );
+var MediaTokenExpiredError = class extends Schema.TaggedErrorClass()("MediaTokenExpiredError", {
+  error: Schema.Struct({
+    code: Schema.Literal("media_token.expired"),
+    message: Schema.String
+  })
+}) {
+};
+var MediaTokenExpiredErrorWireSchema = Schema.Struct({
+  error: Schema.Struct({
+    code: Schema.Literal("media_token.expired"),
+    message: Schema.String
+  })
+});
+var MediaTokenExpiredErrorSchema = MediaTokenExpiredErrorWireSchema.pipe(
+  Schema.decodeTo(MediaTokenExpiredError, {
+    decode: SchemaGetter.transform((wire) => ({ _tag: "MediaTokenExpiredError", ...wire })),
+    encode: SchemaGetter.transform((error) => ({ error: error.error }))
+  })
+);
+var MediaTokenInvalidAudienceError = class extends Schema.TaggedErrorClass()("MediaTokenInvalidAudienceError", {
+  error: Schema.Struct({
+    code: Schema.Literal("media_token.invalid_audience"),
+    message: Schema.String
+  })
+}) {
+};
+var MediaTokenInvalidAudienceErrorWireSchema = Schema.Struct({
+  error: Schema.Struct({
+    code: Schema.Literal("media_token.invalid_audience"),
+    message: Schema.String
+  })
+});
+var MediaTokenInvalidAudienceErrorSchema = MediaTokenInvalidAudienceErrorWireSchema.pipe(
+  Schema.decodeTo(MediaTokenInvalidAudienceError, {
+    decode: SchemaGetter.transform((wire) => ({ _tag: "MediaTokenInvalidAudienceError", ...wire })),
+    encode: SchemaGetter.transform((error) => ({ error: error.error }))
+  })
+);
+var MediaTokenInvalidHeaderError = class extends Schema.TaggedErrorClass()("MediaTokenInvalidHeaderError", {
+  error: Schema.Struct({
+    code: Schema.Literal("media_token.invalid_header"),
+    message: Schema.String
+  })
+}) {
+};
+var MediaTokenInvalidHeaderErrorWireSchema = Schema.Struct({
+  error: Schema.Struct({
+    code: Schema.Literal("media_token.invalid_header"),
+    message: Schema.String
+  })
+});
+var MediaTokenInvalidHeaderErrorSchema = MediaTokenInvalidHeaderErrorWireSchema.pipe(
+  Schema.decodeTo(MediaTokenInvalidHeaderError, {
+    decode: SchemaGetter.transform((wire) => ({ _tag: "MediaTokenInvalidHeaderError", ...wire })),
+    encode: SchemaGetter.transform((error) => ({ error: error.error }))
+  })
+);
+var MediaTokenInvalidIssuerError = class extends Schema.TaggedErrorClass()("MediaTokenInvalidIssuerError", {
+  error: Schema.Struct({
+    code: Schema.Literal("media_token.invalid_issuer"),
+    message: Schema.String
+  })
+}) {
+};
+var MediaTokenInvalidIssuerErrorWireSchema = Schema.Struct({
+  error: Schema.Struct({
+    code: Schema.Literal("media_token.invalid_issuer"),
+    message: Schema.String
+  })
+});
+var MediaTokenInvalidIssuerErrorSchema = MediaTokenInvalidIssuerErrorWireSchema.pipe(
+  Schema.decodeTo(MediaTokenInvalidIssuerError, {
+    decode: SchemaGetter.transform((wire) => ({ _tag: "MediaTokenInvalidIssuerError", ...wire })),
+    encode: SchemaGetter.transform((error) => ({ error: error.error }))
+  })
+);
+var MediaTokenInvalidSignatureError = class extends Schema.TaggedErrorClass()("MediaTokenInvalidSignatureError", {
+  error: Schema.Struct({
+    code: Schema.Literal("media_token.invalid_signature"),
+    message: Schema.String
+  })
+}) {
+};
+var MediaTokenInvalidSignatureErrorWireSchema = Schema.Struct({
+  error: Schema.Struct({
+    code: Schema.Literal("media_token.invalid_signature"),
+    message: Schema.String
+  })
+});
+var MediaTokenInvalidSignatureErrorSchema = MediaTokenInvalidSignatureErrorWireSchema.pipe(
+  Schema.decodeTo(MediaTokenInvalidSignatureError, {
+    decode: SchemaGetter.transform((wire) => ({ _tag: "MediaTokenInvalidSignatureError", ...wire })),
+    encode: SchemaGetter.transform((error) => ({ error: error.error }))
+  })
+);
+var MediaTokenInvalidSubjectError = class extends Schema.TaggedErrorClass()("MediaTokenInvalidSubjectError", {
+  error: Schema.Struct({
+    code: Schema.Literal("media_token.invalid_subject"),
+    message: Schema.String
+  })
+}) {
+};
+var MediaTokenInvalidSubjectErrorWireSchema = Schema.Struct({
+  error: Schema.Struct({
+    code: Schema.Literal("media_token.invalid_subject"),
+    message: Schema.String
+  })
+});
+var MediaTokenInvalidSubjectErrorSchema = MediaTokenInvalidSubjectErrorWireSchema.pipe(
+  Schema.decodeTo(MediaTokenInvalidSubjectError, {
+    decode: SchemaGetter.transform((wire) => ({ _tag: "MediaTokenInvalidSubjectError", ...wire })),
+    encode: SchemaGetter.transform((error) => ({ error: error.error }))
+  })
+);
+var MediaTokenInvalidTimeClaimsError = class extends Schema.TaggedErrorClass()("MediaTokenInvalidTimeClaimsError", {
+  error: Schema.Struct({
+    code: Schema.Literal("media_token.invalid_time_claims"),
+    message: Schema.String
+  })
+}) {
+};
+var MediaTokenInvalidTimeClaimsErrorWireSchema = Schema.Struct({
+  error: Schema.Struct({
+    code: Schema.Literal("media_token.invalid_time_claims"),
+    message: Schema.String
+  })
+});
+var MediaTokenInvalidTimeClaimsErrorSchema = MediaTokenInvalidTimeClaimsErrorWireSchema.pipe(
+  Schema.decodeTo(MediaTokenInvalidTimeClaimsError, {
+    decode: SchemaGetter.transform((wire) => ({ _tag: "MediaTokenInvalidTimeClaimsError", ...wire })),
+    encode: SchemaGetter.transform((error) => ({ error: error.error }))
+  })
+);
+var MediaTokenLifetimeExceededError = class extends Schema.TaggedErrorClass()("MediaTokenLifetimeExceededError", {
+  error: Schema.Struct({
+    code: Schema.Literal("media_token.lifetime_exceeded"),
+    message: Schema.String
+  })
+}) {
+};
+var MediaTokenLifetimeExceededErrorWireSchema = Schema.Struct({
+  error: Schema.Struct({
+    code: Schema.Literal("media_token.lifetime_exceeded"),
+    message: Schema.String
+  })
+});
+var MediaTokenLifetimeExceededErrorSchema = MediaTokenLifetimeExceededErrorWireSchema.pipe(
+  Schema.decodeTo(MediaTokenLifetimeExceededError, {
+    decode: SchemaGetter.transform((wire) => ({ _tag: "MediaTokenLifetimeExceededError", ...wire })),
+    encode: SchemaGetter.transform((error) => ({ error: error.error }))
+  })
+);
+var MediaTokenMalformedError = class extends Schema.TaggedErrorClass()("MediaTokenMalformedError", {
+  error: Schema.Struct({
+    code: Schema.Literal("media_token.malformed"),
+    message: Schema.String
+  })
+}) {
+};
+var MediaTokenMalformedErrorWireSchema = Schema.Struct({
+  error: Schema.Struct({
+    code: Schema.Literal("media_token.malformed"),
+    message: Schema.String
+  })
+});
+var MediaTokenMalformedErrorSchema = MediaTokenMalformedErrorWireSchema.pipe(
+  Schema.decodeTo(MediaTokenMalformedError, {
+    decode: SchemaGetter.transform((wire) => ({ _tag: "MediaTokenMalformedError", ...wire })),
+    encode: SchemaGetter.transform((error) => ({ error: error.error }))
+  })
+);
+var MediaTokenNotYetValidError = class extends Schema.TaggedErrorClass()("MediaTokenNotYetValidError", {
+  error: Schema.Struct({
+    code: Schema.Literal("media_token.not_yet_valid"),
+    message: Schema.String
+  })
+}) {
+};
+var MediaTokenNotYetValidErrorWireSchema = Schema.Struct({
+  error: Schema.Struct({
+    code: Schema.Literal("media_token.not_yet_valid"),
+    message: Schema.String
+  })
+});
+var MediaTokenNotYetValidErrorSchema = MediaTokenNotYetValidErrorWireSchema.pipe(
+  Schema.decodeTo(MediaTokenNotYetValidError, {
+    decode: SchemaGetter.transform((wire) => ({ _tag: "MediaTokenNotYetValidError", ...wire })),
+    encode: SchemaGetter.transform((error) => ({ error: error.error }))
+  })
+);
+var MediaTokenRequiredError = class extends Schema.TaggedErrorClass()("MediaTokenRequiredError", {
+  error: Schema.Struct({
+    code: Schema.Literal("media_token.required"),
+    message: Schema.String
+  })
+}) {
+};
+var MediaTokenRequiredErrorWireSchema = Schema.Struct({
+  error: Schema.Struct({
+    code: Schema.Literal("media_token.required"),
+    message: Schema.String
+  })
+});
+var MediaTokenRequiredErrorSchema = MediaTokenRequiredErrorWireSchema.pipe(
+  Schema.decodeTo(MediaTokenRequiredError, {
+    decode: SchemaGetter.transform((wire) => ({ _tag: "MediaTokenRequiredError", ...wire })),
+    encode: SchemaGetter.transform((error) => ({ error: error.error }))
+  })
+);
+var MediaTokenSubjectMismatchError = class extends Schema.TaggedErrorClass()("MediaTokenSubjectMismatchError", {
+  error: Schema.Struct({
+    code: Schema.Literal("media_token.subject_mismatch"),
+    message: Schema.String
+  })
+}) {
+};
+var MediaTokenSubjectMismatchErrorWireSchema = Schema.Struct({
+  error: Schema.Struct({
+    code: Schema.Literal("media_token.subject_mismatch"),
+    message: Schema.String
+  })
+});
+var MediaTokenSubjectMismatchErrorSchema = MediaTokenSubjectMismatchErrorWireSchema.pipe(
+  Schema.decodeTo(MediaTokenSubjectMismatchError, {
+    decode: SchemaGetter.transform((wire) => ({ _tag: "MediaTokenSubjectMismatchError", ...wire })),
+    encode: SchemaGetter.transform((error) => ({ error: error.error }))
+  })
+);
+var MediaTokenUnknownKeyError = class extends Schema.TaggedErrorClass()("MediaTokenUnknownKeyError", {
+  error: Schema.Struct({
+    code: Schema.Literal("media_token.unknown_key"),
+    message: Schema.String
+  })
+}) {
+};
+var MediaTokenUnknownKeyErrorWireSchema = Schema.Struct({
+  error: Schema.Struct({
+    code: Schema.Literal("media_token.unknown_key"),
+    message: Schema.String
+  })
+});
+var MediaTokenUnknownKeyErrorSchema = MediaTokenUnknownKeyErrorWireSchema.pipe(
+  Schema.decodeTo(MediaTokenUnknownKeyError, {
+    decode: SchemaGetter.transform((wire) => ({ _tag: "MediaTokenUnknownKeyError", ...wire })),
+    encode: SchemaGetter.transform((error) => ({ error: error.error }))
+  })
+);
 var MediaUnavailableError = class extends Schema.TaggedErrorClass()("MediaUnavailableError", {
   error: Schema.Struct({
     code: Schema.Literal("media.unavailable"),
@@ -2410,6 +2756,25 @@ var PaginationInvalidPageSizeErrorSchema = PaginationInvalidPageSizeErrorWireSch
     encode: SchemaGetter.transform((error) => ({ error: error.error }))
   })
 );
+var ParticipantConnectionSupersededError = class extends Schema.TaggedErrorClass()("ParticipantConnectionSupersededError", {
+  error: Schema.Struct({
+    code: Schema.Literal("participant.connection_superseded"),
+    message: Schema.String
+  })
+}) {
+};
+var ParticipantConnectionSupersededErrorWireSchema = Schema.Struct({
+  error: Schema.Struct({
+    code: Schema.Literal("participant.connection_superseded"),
+    message: Schema.String
+  })
+});
+var ParticipantConnectionSupersededErrorSchema = ParticipantConnectionSupersededErrorWireSchema.pipe(
+  Schema.decodeTo(ParticipantConnectionSupersededError, {
+    decode: SchemaGetter.transform((wire) => ({ _tag: "ParticipantConnectionSupersededError", ...wire })),
+    encode: SchemaGetter.transform((error) => ({ error: error.error }))
+  })
+);
 var ParticipantGenerationMismatchError = class extends Schema.TaggedErrorClass()("ParticipantGenerationMismatchError", {
   error: Schema.Struct({
     code: Schema.Literal("participant.generation_mismatch"),
@@ -2657,6 +3022,44 @@ var RecordingPreparationPolicyDeniedErrorSchema = RecordingPreparationPolicyDeni
     encode: SchemaGetter.transform((error) => ({ error: error.error }))
   })
 );
+var ReportsDeliveryFailedError = class extends Schema.TaggedErrorClass()("ReportsDeliveryFailedError", {
+  error: Schema.Struct({
+    code: Schema.Literal("reports.delivery_failed"),
+    message: Schema.String
+  })
+}) {
+};
+var ReportsDeliveryFailedErrorWireSchema = Schema.Struct({
+  error: Schema.Struct({
+    code: Schema.Literal("reports.delivery_failed"),
+    message: Schema.String
+  })
+});
+var ReportsDeliveryFailedErrorSchema = ReportsDeliveryFailedErrorWireSchema.pipe(
+  Schema.decodeTo(ReportsDeliveryFailedError, {
+    decode: SchemaGetter.transform((wire) => ({ _tag: "ReportsDeliveryFailedError", ...wire })),
+    encode: SchemaGetter.transform((error) => ({ error: error.error }))
+  })
+);
+var ReportsUnavailableError = class extends Schema.TaggedErrorClass()("ReportsUnavailableError", {
+  error: Schema.Struct({
+    code: Schema.Literal("reports.unavailable"),
+    message: Schema.String
+  })
+}) {
+};
+var ReportsUnavailableErrorWireSchema = Schema.Struct({
+  error: Schema.Struct({
+    code: Schema.Literal("reports.unavailable"),
+    message: Schema.String
+  })
+});
+var ReportsUnavailableErrorSchema = ReportsUnavailableErrorWireSchema.pipe(
+  Schema.decodeTo(ReportsUnavailableError, {
+    decode: SchemaGetter.transform((wire) => ({ _tag: "ReportsUnavailableError", ...wire })),
+    encode: SchemaGetter.transform((error) => ({ error: error.error }))
+  })
+);
 var RequestIdempotencyConflictError = class extends Schema.TaggedErrorClass()("RequestIdempotencyConflictError", {
   error: Schema.Struct({
     code: Schema.Literal("request.idempotency_conflict"),
@@ -3711,6 +4114,17 @@ var ArriveBySpacePublicInviteErrorSchema = Schema.Union([
   SpacePublicInviteUnavailableErrorSchema,
   TenantLiveEpisodeLimitReachedErrorSchema
 ]);
+var CancelEpisodeParticipantJoinErrorSchema = Schema.Union([
+  AccessForbiddenErrorSchema,
+  AccessUnauthenticatedErrorSchema,
+  EpisodeInvalidIdErrorSchema,
+  ParticipantInvalidIdErrorSchema,
+  RequestInvalidErrorSchema,
+  RequestRateLimitedErrorSchema,
+  ServiceInternalErrorSchema,
+  ServiceUnavailableErrorSchema,
+  SpaceInvalidIdErrorSchema
+]);
 var CancelSpaceRecordingPreparationErrorSchema = Schema.Union([
   AccessForbiddenErrorSchema,
   AccessUnauthenticatedErrorSchema,
@@ -4000,6 +4414,7 @@ var GetEpisodeErrorSchema = Schema.Union([
   SpaceNotFoundErrorSchema,
   TenantInvalidIdErrorSchema
 ]);
+var GetProblemReportAvailabilityErrorSchema = TenantInvalidIdErrorSchema;
 var GetRecordingErrorSchema = Schema.Union([AccessForbiddenErrorSchema, AccessUnauthenticatedErrorSchema, RecordingInvalidIdErrorSchema, RecordingNotFoundErrorSchema, ServiceInternalErrorSchema, ServiceUnavailableErrorSchema, TenantInvalidIdErrorSchema]);
 var GetSpaceErrorSchema = Schema.Union([AccessForbiddenErrorSchema, AccessUnauthenticatedErrorSchema, ServiceInternalErrorSchema, ServiceUnavailableErrorSchema, SpaceInvalidIdErrorSchema, SpaceNotFoundErrorSchema, TenantInvalidIdErrorSchema]);
 var GetSpacePublicInviteArrivalErrorSchema = Schema.Union([
@@ -4113,7 +4528,21 @@ var IssueAccessGrantErrorSchema = Schema.Union([
   AccessForbiddenErrorSchema,
   AccessUnauthenticatedErrorSchema,
   EpisodeInvalidIdErrorSchema,
+  MediaTokenExpiredErrorSchema,
+  MediaTokenInvalidAudienceErrorSchema,
+  MediaTokenInvalidHeaderErrorSchema,
+  MediaTokenInvalidIssuerErrorSchema,
+  MediaTokenInvalidSignatureErrorSchema,
+  MediaTokenInvalidSubjectErrorSchema,
+  MediaTokenInvalidTimeClaimsErrorSchema,
+  MediaTokenLifetimeExceededErrorSchema,
+  MediaTokenMalformedErrorSchema,
+  MediaTokenNotYetValidErrorSchema,
+  MediaTokenRequiredErrorSchema,
+  MediaTokenSubjectMismatchErrorSchema,
+  MediaTokenUnknownKeyErrorSchema,
   MediaUnavailableErrorSchema,
+  ParticipantConnectionSupersededErrorSchema,
   ParticipantGenerationMismatchErrorSchema,
   ParticipantInvalidIdErrorSchema,
   ParticipantNotFoundErrorSchema,
@@ -4190,6 +4619,7 @@ var ListRecordingsErrorSchema = Schema.Union([
   SpaceInvalidIdErrorSchema,
   TenantInvalidIdErrorSchema
 ]);
+var ListSpaceActivityErrorSchema = Schema.Union([AccessForbiddenErrorSchema, AccessUnauthenticatedErrorSchema, EpisodeInvalidSpaceIdsErrorSchema, RequestRateLimitedErrorSchema, ServiceInternalErrorSchema, ServiceUnavailableErrorSchema, SpaceNotFoundErrorSchema, TenantInvalidIdErrorSchema]);
 var ListSpaceLiveEpisodesErrorSchema = Schema.Union([
   AccessForbiddenErrorSchema,
   AccessUnauthenticatedErrorSchema,
@@ -4462,6 +4892,18 @@ var RotateWebhookEndpointSecretErrorSchema = Schema.Union([
   WebhookInvalidUrlErrorSchema,
   WebhookUnsafeUrlErrorSchema
 ]);
+var SendProblemReportErrorSchema = Schema.Union([
+  AccessForbiddenErrorSchema,
+  AccessUnauthenticatedErrorSchema,
+  ReportsDeliveryFailedErrorSchema,
+  ReportsUnavailableErrorSchema,
+  RequestInvalidErrorSchema,
+  RequestPayloadTooLargeErrorSchema,
+  RequestRateLimitedErrorSchema,
+  ServiceInternalErrorSchema,
+  ServiceUnavailableErrorSchema,
+  TenantInvalidIdErrorSchema
+]);
 var SetEpisodeDeadlineErrorSchema = Schema.Union([
   AccessForbiddenErrorSchema,
   AccessUnauthenticatedErrorSchema,
@@ -4600,6 +5042,7 @@ var ChalkOperationPolicies = {
   approveSpacePublicAdmissionRequest: { rateLimit: { limit: 60, policy: "v1.authenticated.write", windowSeconds: 60 } },
   archiveSpace: { rateLimit: { limit: 60, policy: "v1.authenticated.write", windowSeconds: 60 } },
   arriveBySpacePublicInvite: { maxBodyBytes: 1048576, rateLimit: { limit: 60, policy: "v1.authenticated.write", windowSeconds: 60 } },
+  cancelEpisodeParticipantJoin: { rateLimit: { limit: 60, policy: "v1.authenticated.write", windowSeconds: 60 } },
   cancelSpaceRecordingPreparation: { maxBodyBytes: 1048576, rateLimit: { limit: 60, policy: "v1.authenticated.write", windowSeconds: 60 } },
   closeCloudflareSFUTracks: { maxBodyBytes: 1048576, rateLimit: { limit: 60, policy: "v1.authenticated.write", windowSeconds: 60 } },
   createAPIKey: { maxBodyBytes: 1048576, rateLimit: { limit: 60, policy: "v1.authenticated.write", windowSeconds: 60 } },
@@ -4619,8 +5062,8 @@ var ChalkOperationPolicies = {
   findTenantByExternalID: { rateLimit: { limit: 300, policy: "v1.authenticated.read", windowSeconds: 60 } },
   getEpisode: { rateLimit: { limit: 300, policy: "v1.authenticated.read", windowSeconds: 60 } },
   getEpisodeAttendance: { rateLimit: { limit: 300, policy: "v1.authenticated.read", windowSeconds: 60 } },
-  getSpacePublicInvite: { rateLimit: { limit: 60, policy: "v1.authenticated.write", windowSeconds: 60 } },
-  getSpacePublicInviteArrival: { rateLimit: { limit: 60, policy: "v1.authenticated.write", windowSeconds: 60 } },
+  getSpacePublicInvite: { rateLimit: { limit: 300, policy: "v1.authenticated.read", windowSeconds: 60 } },
+  getSpacePublicInviteArrival: { rateLimit: { limit: 300, policy: "v1.authenticated.read", windowSeconds: 60 } },
   getTenant: { rateLimit: { limit: 300, policy: "v1.authenticated.read", windowSeconds: 60 } },
   getWebhookDelivery: { rateLimit: { limit: 300, policy: "v1.webhooks.read", windowSeconds: 60 } },
   getWebhookEndpoint: { rateLimit: { limit: 300, policy: "v1.webhooks.read", windowSeconds: 60 } },
@@ -4629,8 +5072,9 @@ var ChalkOperationPolicies = {
   issueEpisodeParticipantSyncToken: { rateLimit: { limit: 300, policy: "v1.authenticated.read", windowSeconds: 60 } },
   leaveSpacePublicInviteArrival: { rateLimit: { limit: 60, policy: "v1.authenticated.write", windowSeconds: 60 } },
   listEpisodes: { rateLimit: { limit: 300, policy: "v1.authenticated.read", windowSeconds: 60 } },
+  listSpaceActivity: { rateLimit: { limit: 300, policy: "v1.authenticated.read", windowSeconds: 60 } },
   listSpaceLiveEpisodes: { rateLimit: { limit: 300, policy: "v1.authenticated.read", windowSeconds: 60 } },
-  listSpacePublicAdmissionRequests: { rateLimit: { limit: 60, policy: "v1.authenticated.write", windowSeconds: 60 } },
+  listSpacePublicAdmissionRequests: { rateLimit: { limit: 300, policy: "v1.authenticated.read", windowSeconds: 60 } },
   listTenants: { rateLimit: { limit: 300, policy: "v1.authenticated.read", windowSeconds: 60 } },
   listWebhookDeliveries: { rateLimit: { limit: 300, policy: "v1.webhooks.read", windowSeconds: 60 } },
   listWebhookEndpoints: { rateLimit: { limit: 300, policy: "v1.webhooks.read", windowSeconds: 60 } },
@@ -4648,6 +5092,7 @@ var ChalkOperationPolicies = {
   rotateAPIKey: { maxBodyBytes: 1048576, rateLimit: { limit: 60, policy: "v1.authenticated.write", windowSeconds: 60 } },
   rotateSpacePublicInvite: { rateLimit: { limit: 60, policy: "v1.authenticated.write", windowSeconds: 60 } },
   rotateWebhookEndpointSecret: { maxBodyBytes: 1048576, rateLimit: { limit: 60, policy: "v1.authenticated.write", windowSeconds: 60 } },
+  sendProblemReport: { maxBodyBytes: 37024, rateLimit: { limit: 3, policy: "problem_reports.participant", windowSeconds: 3600 } },
   setEpisodeDeadline: { maxBodyBytes: 1048576, rateLimit: { limit: 60, policy: "v1.authenticated.write", windowSeconds: 60 } },
   testWebhookEndpoint: { rateLimit: { limit: 60, policy: "v1.authenticated.write", windowSeconds: 60 } },
   updateMembership: { maxBodyBytes: 1048576, rateLimit: { limit: 60, policy: "v1.authenticated.write", windowSeconds: 60 } },
@@ -4832,6 +5277,12 @@ var defaultGroup = HttpApiGroup.make("default").add(
       ServiceUnavailableErrorSchema.pipe(HttpApiSchema.status(503))
     ]
   })
+).add(
+  HttpApiEndpoint.get("getProblemReportAvailability", "/v1/tenants/:tenant_id/problem-reports/availability", {
+    params: GetProblemReportAvailabilityPathParamsSchema,
+    success: GetProblemReportAvailabilityResponseSchema.pipe(HttpApiSchema.status(200)),
+    error: [TenantInvalidIdErrorSchema.pipe(HttpApiSchema.status(400))]
+  })
 ).add(
   HttpApiEndpoint.get("getWebhookDelivery", "/v1/tenants/:tenant_id/webhook-endpoints/:endpoint_id/deliveries/:delivery_id", {
     params: GetWebhookDeliveryPathParamsSchema,
@@ -4915,13 +5366,27 @@ var defaultGroup = HttpApiGroup.make("default").add(
     success: IssueAccessGrantResponseSchema.pipe(HttpApiSchema.status(201)),
     error: [
       EpisodeInvalidIdErrorSchema.pipe(HttpApiSchema.status(400)),
+      MediaTokenInvalidHeaderErrorSchema.pipe(HttpApiSchema.status(400)),
+      MediaTokenInvalidSubjectErrorSchema.pipe(HttpApiSchema.status(400)),
+      MediaTokenInvalidTimeClaimsErrorSchema.pipe(HttpApiSchema.status(400)),
+      MediaTokenLifetimeExceededErrorSchema.pipe(HttpApiSchema.status(400)),
+      MediaTokenMalformedErrorSchema.pipe(HttpApiSchema.status(400)),
+      MediaTokenRequiredErrorSchema.pipe(HttpApiSchema.status(400)),
       ParticipantInvalidIdErrorSchema.pipe(HttpApiSchema.status(400)),
       RequestInvalidErrorSchema.pipe(HttpApiSchema.status(400)),
       SpaceInvalidIdErrorSchema.pipe(HttpApiSchema.status(400)),
       TenantInvalidIdErrorSchema.pipe(HttpApiSchema.status(400)),
       AccessUnauthenticatedErrorSchema.pipe(HttpApiSchema.status(401)),
+      MediaTokenExpiredErrorSchema.pipe(HttpApiSchema.status(401)),
+      MediaTokenInvalidAudienceErrorSchema.pipe(HttpApiSchema.status(401)),
+      MediaTokenInvalidIssuerErrorSchema.pipe(HttpApiSchema.status(401)),
+      MediaTokenInvalidSignatureErrorSchema.pipe(HttpApiSchema.status(401)),
+      MediaTokenNotYetValidErrorSchema.pipe(HttpApiSchema.status(401)),
+      MediaTokenUnknownKeyErrorSchema.pipe(HttpApiSchema.status(401)),
       AccessForbiddenErrorSchema.pipe(HttpApiSchema.status(403)),
+      MediaTokenSubjectMismatchErrorSchema.pipe(HttpApiSchema.status(403)),
       ParticipantNotFoundErrorSchema.pipe(HttpApiSchema.status(404)),
+      ParticipantConnectionSupersededErrorSchema.pipe(HttpApiSchema.status(409)),
       ParticipantGenerationMismatchErrorSchema.pipe(HttpApiSchema.status(409)),
       RequestPayloadTooLargeErrorSchema.pipe(HttpApiSchema.status(413)),
       RequestRateLimitedErrorSchema.pipe(HttpApiSchema.status(429)),
@@ -5135,6 +5600,24 @@ var defaultGroup = HttpApiGroup.make("default").add(
       ServiceUnavailableErrorSchema.pipe(HttpApiSchema.status(503))
     ]
   })
+).add(
+  HttpApiEndpoint.post("sendProblemReport", "/v1/tenants/:tenant_id/problem-reports", {
+    params: SendProblemReportPathParamsSchema,
+    payload: SendProblemReportRequestBodySchema,
+    success: SendProblemReportResponseSchema.pipe(HttpApiSchema.status(200)),
+    error: [
+      RequestInvalidErrorSchema.pipe(HttpApiSchema.status(400)),
+      TenantInvalidIdErrorSchema.pipe(HttpApiSchema.status(400)),
+      AccessUnauthenticatedErrorSchema.pipe(HttpApiSchema.status(401)),
+      AccessForbiddenErrorSchema.pipe(HttpApiSchema.status(403)),
+      RequestPayloadTooLargeErrorSchema.pipe(HttpApiSchema.status(413)),
+      RequestRateLimitedErrorSchema.pipe(HttpApiSchema.status(429)),
+      ServiceInternalErrorSchema.pipe(HttpApiSchema.status(500)),
+      ReportsDeliveryFailedErrorSchema.pipe(HttpApiSchema.status(502)),
+      ReportsUnavailableErrorSchema.pipe(HttpApiSchema.status(503)),
+      ServiceUnavailableErrorSchema.pipe(HttpApiSchema.status(503))
+    ]
+  })
 ).add(
   HttpApiEndpoint.post("testWebhookEndpoint", "/v1/tenants/:tenant_id/webhook-endpoints/:endpoint_id/test", {
     params: TestWebhookEndpointPathParamsSchema,
@@ -5231,6 +5714,22 @@ var episodesGroup = HttpApiGroup.make("episodes").add(
       ServiceUnavailableErrorSchema.pipe(HttpApiSchema.status(503))
     ]
   })
+).add(
+  HttpApiEndpoint.post("cancelEpisodeParticipantJoin", "/v1/tenants/:tenant_id/spaces/:space_id/episodes/:episode_id/participants/:participant_id/cancel-join", {
+    params: CancelEpisodeParticipantJoinPathParamsSchema,
+    success: CancelEpisodeParticipantJoinResponseSchema.pipe(HttpApiSchema.status(200)),
+    error: [
+      EpisodeInvalidIdErrorSchema.pipe(HttpApiSchema.status(400)),
+      ParticipantInvalidIdErrorSchema.pipe(HttpApiSchema.status(400)),
+      RequestInvalidErrorSchema.pipe(HttpApiSchema.status(400)),
+      SpaceInvalidIdErrorSchema.pipe(HttpApiSchema.status(400)),
+      AccessUnauthenticatedErrorSchema.pipe(HttpApiSchema.status(401)),
+      AccessForbiddenErrorSchema.pipe(HttpApiSchema.status(403)),
+      RequestRateLimitedErrorSchema.pipe(HttpApiSchema.status(429)),
+      ServiceInternalErrorSchema.pipe(HttpApiSchema.status(500)),
+      ServiceUnavailableErrorSchema.pipe(HttpApiSchema.status(503))
+    ]
+  })
 ).add(
   HttpApiEndpoint.post("createEpisode", "/v1/tenants/:tenant_id/spaces/:space_id/episodes", {
     params: CreateEpisodePathParamsSchema,
@@ -5765,6 +6264,22 @@ var spacesGroup = HttpApiGroup.make("spaces").add(
       ServiceUnavailableErrorSchema.pipe(HttpApiSchema.status(503))
     ]
   })
+).add(
+  HttpApiEndpoint.get("listSpaceActivity", "/v1/tenants/:tenant_id/space-activity", {
+    params: ListSpaceActivityPathParamsSchema,
+    query: ListSpaceActivityQueryParamsSchema,
+    success: ListSpaceActivityResponseSchema.pipe(HttpApiSchema.status(200)),
+    error: [
+      EpisodeInvalidSpaceIdsErrorSchema.pipe(HttpApiSchema.status(400)),
+      TenantInvalidIdErrorSchema.pipe(HttpApiSchema.status(400)),
+      AccessUnauthenticatedErrorSchema.pipe(HttpApiSchema.status(401)),
+      AccessForbiddenErrorSchema.pipe(HttpApiSchema.status(403)),
+      SpaceNotFoundErrorSchema.pipe(HttpApiSchema.status(404)),
+      RequestRateLimitedErrorSchema.pipe(HttpApiSchema.status(429)),
+      ServiceInternalErrorSchema.pipe(HttpApiSchema.status(500)),
+      ServiceUnavailableErrorSchema.pipe(HttpApiSchema.status(503))
+    ]
+  })
 ).add(
   HttpApiEndpoint.get("listSpacePublicAdmissionRequests", "/v1/tenants/:tenant_id/spaces/:space_id/public-admission-requests", {
     params: ListSpacePublicAdmissionRequestsPathParamsSchema,
@@ -6335,6 +6850,7 @@ function isRecord(value) {
 }
 
 export {
+  ChalkCodePointLimits,
   DateTimeStringSchema,
   UserIdSchema,
   UUIDSchema,
@@ -6387,9 +6903,13 @@ export {
   MembershipIdSchema,
   MembershipSchema,
   MembershipListSchema,
+  ParticipantJoinCancellationSchema,
   ParticipantLifecycleSchema,
   ParticipantRemovalSchema,
   PrepareRecordingRequestSchema,
+  ProblemReportAvailabilitySchema,
+  ProblemReportRequestSchema,
+  ProblemReportSentSchema,
   PublicAdmissionRequestSchema,
   PublicAdmissionRequestPageSchema,
   PublicSpaceArrivalSchema,
@@ -6412,6 +6932,7 @@ export {
   RotateWebhookSecretResponseSchema,
   SetEpisodeDeadlineRequestSchema,
   SpaceSchema,
+  SpaceActivityListSchema,
   SpaceListSchema,
   SpaceLiveEpisodeListSchema,
   SpacePublicInviteSchema,
@@ -6462,6 +6983,9 @@ export {
   ArriveBySpacePublicInviteRequestBodySchema,
   ArriveBySpacePublicInviteResponseSchema,
   ArriveBySpacePublicInvite429ResponseHeadersSchema,
+  CancelEpisodeParticipantJoinPathParamsSchema,
+  CancelEpisodeParticipantJoinResponseSchema,
+  CancelEpisodeParticipantJoin429ResponseHeadersSchema,
   CancelSpaceRecordingPreparationPathParamsSchema,
   CancelSpaceRecordingPreparationRequestBodySchema,
   CancelSpaceRecordingPreparationResponseSchema,
@@ -6535,6 +7059,8 @@ export {
   GetEpisodeAttendancePathParamsSchema,
   GetEpisodeAttendanceResponseSchema,
   GetEpisodeAttendance429ResponseHeadersSchema,
+  GetProblemReportAvailabilityPathParamsSchema,
+  GetProblemReportAvailabilityResponseSchema,
   GetRecordingPathParamsSchema,
   GetRecordingResponseSchema,
   GetSpacePathParamsSchema,
@@ -6590,6 +7116,10 @@ export {
   ListRecordingsPathParamsSchema,
   ListRecordingsQueryParamsSchema,
   ListRecordingsResponseSchema,
+  ListSpaceActivityPathParamsSchema,
+  ListSpaceActivityQueryParamsSchema,
+  ListSpaceActivityResponseSchema,
+  ListSpaceActivity429ResponseHeadersSchema,
   ListSpaceLiveEpisodesPathParamsSchema,
   ListSpaceLiveEpisodesQueryParamsSchema,
   ListSpaceLiveEpisodesResponseSchema,
@@ -6669,6 +7199,10 @@ export {
   RotateWebhookEndpointSecretRequestBodySchema,
   RotateWebhookEndpointSecretResponseSchema,
   RotateWebhookEndpointSecret429ResponseHeadersSchema,
+  SendProblemReportPathParamsSchema,
+  SendProblemReportRequestBodySchema,
+  SendProblemReportResponseSchema,
+  SendProblemReport429ResponseHeadersSchema,
   SetEpisodeDeadlinePathParamsSchema,
   SetEpisodeDeadlineRequestHeadersSchema,
   SetEpisodeDeadlineRequestBodySchema,
@@ -6780,6 +7314,45 @@ export {
   MediaConnectionNotFoundError,
   MediaConnectionNotFoundErrorWireSchema,
   MediaConnectionNotFoundErrorSchema,
+  MediaTokenExpiredError,
+  MediaTokenExpiredErrorWireSchema,
+  MediaTokenExpiredErrorSchema,
+  MediaTokenInvalidAudienceError,
+  MediaTokenInvalidAudienceErrorWireSchema,
+  MediaTokenInvalidAudienceErrorSchema,
+  MediaTokenInvalidHeaderError,
+  MediaTokenInvalidHeaderErrorWireSchema,
+  MediaTokenInvalidHeaderErrorSchema,
+  MediaTokenInvalidIssuerError,
+  MediaTokenInvalidIssuerErrorWireSchema,
+  MediaTokenInvalidIssuerErrorSchema,
+  MediaTokenInvalidSignatureError,
+  MediaTokenInvalidSignatureErrorWireSchema,
+  MediaTokenInvalidSignatureErrorSchema,
+  MediaTokenInvalidSubjectError,
+  MediaTokenInvalidSubjectErrorWireSchema,
+  MediaTokenInvalidSubjectErrorSchema,
+  MediaTokenInvalidTimeClaimsError,
+  MediaTokenInvalidTimeClaimsErrorWireSchema,
+  MediaTokenInvalidTimeClaimsErrorSchema,
+  MediaTokenLifetimeExceededError,
+  MediaTokenLifetimeExceededErrorWireSchema,
+  MediaTokenLifetimeExceededErrorSchema,
+  MediaTokenMalformedError,
+  MediaTokenMalformedErrorWireSchema,
+  MediaTokenMalformedErrorSchema,
+  MediaTokenNotYetValidError,
+  MediaTokenNotYetValidErrorWireSchema,
+  MediaTokenNotYetValidErrorSchema,
+  MediaTokenRequiredError,
+  MediaTokenRequiredErrorWireSchema,
+  MediaTokenRequiredErrorSchema,
+  MediaTokenSubjectMismatchError,
+  MediaTokenSubjectMismatchErrorWireSchema,
+  MediaTokenSubjectMismatchErrorSchema,
+  MediaTokenUnknownKeyError,
+  MediaTokenUnknownKeyErrorWireSchema,
+  MediaTokenUnknownKeyErrorSchema,
   MediaUnavailableError,
   MediaUnavailableErrorWireSchema,
   MediaUnavailableErrorSchema,
@@ -6801,6 +7374,9 @@ export {
   PaginationInvalidPageSizeError,
   PaginationInvalidPageSizeErrorWireSchema,
   PaginationInvalidPageSizeErrorSchema,
+  ParticipantConnectionSupersededError,
+  ParticipantConnectionSupersededErrorWireSchema,
+  ParticipantConnectionSupersededErrorSchema,
   ParticipantGenerationMismatchError,
   ParticipantGenerationMismatchErrorWireSchema,
   ParticipantGenerationMismatchErrorSchema,
@@ -6840,6 +7416,12 @@ export {
   RecordingPreparationPolicyDeniedError,
   RecordingPreparationPolicyDeniedErrorWireSchema,
   RecordingPreparationPolicyDeniedErrorSchema,
+  ReportsDeliveryFailedError,
+  ReportsDeliveryFailedErrorWireSchema,
+  ReportsDeliveryFailedErrorSchema,
+  ReportsUnavailableError,
+  ReportsUnavailableErrorWireSchema,
+  ReportsUnavailableErrorSchema,
   RequestIdempotencyConflictError,
   RequestIdempotencyConflictErrorWireSchema,
   RequestIdempotencyConflictErrorSchema,
@@ -7001,6 +7583,7 @@ export {
   ApproveSpacePublicAdmissionRequestErrorSchema,
   ArchiveSpaceErrorSchema,
   ArriveBySpacePublicInviteErrorSchema,
+  CancelEpisodeParticipantJoinErrorSchema,
   CancelSpaceRecordingPreparationErrorSchema,
   CloseCloudflareSFUTracksErrorSchema,
   CreateAPIKeyErrorSchema,
@@ -7021,6 +7604,7 @@ export {
   GetChatAttachmentDownloadErrorSchema,
   GetEpisodeAttendanceErrorSchema,
   GetEpisodeErrorSchema,
+  GetProblemReportAvailabilityErrorSchema,
   GetRecordingErrorSchema,
   GetSpaceErrorSchema,
   GetSpacePublicInviteArrivalErrorSchema,
@@ -7041,6 +7625,7 @@ export {
   ListEpisodesErrorSchema,
   ListMembershipsErrorSchema,
   ListRecordingsErrorSchema,
+  ListSpaceActivityErrorSchema,
   ListSpaceLiveEpisodesErrorSchema,
   ListSpacePublicAdmissionRequestsErrorSchema,
   ListSpacesErrorSchema,
@@ -7062,6 +7647,7 @@ export {
   RotateAPIKeyErrorSchema,
   RotateSpacePublicInviteErrorSchema,
   RotateWebhookEndpointSecretErrorSchema,
+  SendProblemReportErrorSchema,
   SetEpisodeDeadlineErrorSchema,
   TestWebhookEndpointErrorSchema,
   UpdateMembershipErrorSchema,