@distilled.cloud/cloudflare 0.2.5-alpha2 → 0.3.0-alpha

package/src/services/waiting-rooms.ts

@@ -5,6 +5,7 @@
  * DO NOT EDIT - regenerate with: bun scripts/generate.ts --service waiting-rooms
  */
 
+import * as stream from "effect/Stream";
 import * as Schema from "effect/Schema";
 import type * as HttpClient from "effect/unstable/http/HttpClient";
 import * as API from "../client/api.ts";
@@ -116,28 +117,30 @@ export const GetEventResponse = /*@__PURE__*/ /*#__PURE__*/ Schema.Struct({
       Schema.Null,
     ]),
   ),
-}).pipe(
-  Schema.encodeKeys({
-    id: "id",
-    createdOn: "created_on",
-    customPageHtml: "custom_page_html",
-    description: "description",
-    disableSessionRenewal: "disable_session_renewal",
-    eventEndTime: "event_end_time",
-    eventStartTime: "event_start_time",
-    modifiedOn: "modified_on",
-    name: "name",
-    newUsersPerMinute: "new_users_per_minute",
-    prequeueStartTime: "prequeue_start_time",
-    queueingMethod: "queueing_method",
-    sessionDuration: "session_duration",
-    shuffleAtEventStart: "shuffle_at_event_start",
-    suspended: "suspended",
-    totalActiveUsers: "total_active_users",
-    turnstileAction: "turnstile_action",
-    turnstileMode: "turnstile_mode",
-  }),
-) as unknown as Schema.Schema<GetEventResponse>;
+})
+  .pipe(
+    Schema.encodeKeys({
+      id: "id",
+      createdOn: "created_on",
+      customPageHtml: "custom_page_html",
+      description: "description",
+      disableSessionRenewal: "disable_session_renewal",
+      eventEndTime: "event_end_time",
+      eventStartTime: "event_start_time",
+      modifiedOn: "modified_on",
+      name: "name",
+      newUsersPerMinute: "new_users_per_minute",
+      prequeueStartTime: "prequeue_start_time",
+      queueingMethod: "queueing_method",
+      sessionDuration: "session_duration",
+      shuffleAtEventStart: "shuffle_at_event_start",
+      suspended: "suspended",
+      totalActiveUsers: "total_active_users",
+      turnstileAction: "turnstile_action",
+      turnstileMode: "turnstile_mode",
+    }),
+  )
+  .pipe(T.ResponsePath("result")) as unknown as Schema.Schema<GetEventResponse>;
 
 export type GetEventError = DefaultErrors;
 
@@ -168,113 +171,188 @@ export const ListEventsRequest = /*@__PURE__*/ /*#__PURE__*/ Schema.Struct({
   }),
 ) as unknown as Schema.Schema<ListEventsRequest>;
 
-export type ListEventsResponse = {
-  id?: string | null;
-  createdOn?: string | null;
-  customPageHtml?: string | null;
-  description?: string | null;
-  disableSessionRenewal?: boolean | null;
-  eventEndTime?: string | null;
-  eventStartTime?: string | null;
-  modifiedOn?: string | null;
-  name?: string | null;
-  newUsersPerMinute?: number | null;
-  prequeueStartTime?: string | null;
-  queueingMethod?: string | null;
-  sessionDuration?: number | null;
-  shuffleAtEventStart?: boolean | null;
-  suspended?: boolean | null;
-  totalActiveUsers?: number | null;
-  turnstileAction?: "log" | "infinite_queue" | null;
-  turnstileMode?:
-    | "off"
-    | "invisible"
-    | "visible_non_interactive"
-    | "visible_managed"
-    | null;
-}[];
+export interface ListEventsResponse {
+  result: {
+    id?: string | null;
+    createdOn?: string | null;
+    customPageHtml?: string | null;
+    description?: string | null;
+    disableSessionRenewal?: boolean | null;
+    eventEndTime?: string | null;
+    eventStartTime?: string | null;
+    modifiedOn?: string | null;
+    name?: string | null;
+    newUsersPerMinute?: number | null;
+    prequeueStartTime?: string | null;
+    queueingMethod?: string | null;
+    sessionDuration?: number | null;
+    shuffleAtEventStart?: boolean | null;
+    suspended?: boolean | null;
+    totalActiveUsers?: number | null;
+    turnstileAction?: "log" | "infinite_queue" | null;
+    turnstileMode?:
+      | "off"
+      | "invisible"
+      | "visible_non_interactive"
+      | "visible_managed"
+      | null;
+  }[];
+  resultInfo: {
+    count?: number | null;
+    page?: number | null;
+    perPage?: number | null;
+    totalCount?: number | null;
+  };
+}
 
-export const ListEventsResponse = /*@__PURE__*/ /*#__PURE__*/ Schema.Array(
-  Schema.Struct({
-    id: Schema.optional(Schema.Union([Schema.String, Schema.Null])),
-    createdOn: Schema.optional(Schema.Union([Schema.String, Schema.Null])),
-    customPageHtml: Schema.optional(Schema.Union([Schema.String, Schema.Null])),
-    description: Schema.optional(Schema.Union([Schema.String, Schema.Null])),
-    disableSessionRenewal: Schema.optional(
-      Schema.Union([Schema.Boolean, Schema.Null]),
-    ),
-    eventEndTime: Schema.optional(Schema.Union([Schema.String, Schema.Null])),
-    eventStartTime: Schema.optional(Schema.Union([Schema.String, Schema.Null])),
-    modifiedOn: Schema.optional(Schema.Union([Schema.String, Schema.Null])),
-    name: Schema.optional(Schema.Union([Schema.String, Schema.Null])),
-    newUsersPerMinute: Schema.optional(
-      Schema.Union([Schema.Number, Schema.Null]),
-    ),
-    prequeueStartTime: Schema.optional(
-      Schema.Union([Schema.String, Schema.Null]),
-    ),
-    queueingMethod: Schema.optional(Schema.Union([Schema.String, Schema.Null])),
-    sessionDuration: Schema.optional(
-      Schema.Union([Schema.Number, Schema.Null]),
-    ),
-    shuffleAtEventStart: Schema.optional(
-      Schema.Union([Schema.Boolean, Schema.Null]),
-    ),
-    suspended: Schema.optional(Schema.Union([Schema.Boolean, Schema.Null])),
-    totalActiveUsers: Schema.optional(
-      Schema.Union([Schema.Number, Schema.Null]),
-    ),
-    turnstileAction: Schema.optional(
-      Schema.Union([
-        Schema.Literal("log"),
-        Schema.Literal("infinite_queue"),
-        Schema.Null,
-      ]),
-    ),
-    turnstileMode: Schema.optional(
-      Schema.Union([
-        Schema.Literal("off"),
-        Schema.Literal("invisible"),
-        Schema.Literal("visible_non_interactive"),
-        Schema.Literal("visible_managed"),
-        Schema.Null,
-      ]),
+export const ListEventsResponse = /*@__PURE__*/ /*#__PURE__*/ Schema.Struct({
+  result: Schema.Array(
+    Schema.Struct({
+      id: Schema.optional(Schema.Union([Schema.String, Schema.Null])),
+      createdOn: Schema.optional(Schema.Union([Schema.String, Schema.Null])),
+      customPageHtml: Schema.optional(
+        Schema.Union([Schema.String, Schema.Null]),
+      ),
+      description: Schema.optional(Schema.Union([Schema.String, Schema.Null])),
+      disableSessionRenewal: Schema.optional(
+        Schema.Union([Schema.Boolean, Schema.Null]),
+      ),
+      eventEndTime: Schema.optional(Schema.Union([Schema.String, Schema.Null])),
+      eventStartTime: Schema.optional(
+        Schema.Union([Schema.String, Schema.Null]),
+      ),
+      modifiedOn: Schema.optional(Schema.Union([Schema.String, Schema.Null])),
+      name: Schema.optional(Schema.Union([Schema.String, Schema.Null])),
+      newUsersPerMinute: Schema.optional(
+        Schema.Union([Schema.Number, Schema.Null]),
+      ),
+      prequeueStartTime: Schema.optional(
+        Schema.Union([Schema.String, Schema.Null]),
+      ),
+      queueingMethod: Schema.optional(
+        Schema.Union([Schema.String, Schema.Null]),
+      ),
+      sessionDuration: Schema.optional(
+        Schema.Union([Schema.Number, Schema.Null]),
+      ),
+      shuffleAtEventStart: Schema.optional(
+        Schema.Union([Schema.Boolean, Schema.Null]),
+      ),
+      suspended: Schema.optional(Schema.Union([Schema.Boolean, Schema.Null])),
+      totalActiveUsers: Schema.optional(
+        Schema.Union([Schema.Number, Schema.Null]),
+      ),
+      turnstileAction: Schema.optional(
+        Schema.Union([
+          Schema.Literal("log"),
+          Schema.Literal("infinite_queue"),
+          Schema.Null,
+        ]),
+      ),
+      turnstileMode: Schema.optional(
+        Schema.Union([
+          Schema.Literal("off"),
+          Schema.Literal("invisible"),
+          Schema.Literal("visible_non_interactive"),
+          Schema.Literal("visible_managed"),
+          Schema.Null,
+        ]),
+      ),
+    }).pipe(
+      Schema.encodeKeys({
+        id: "id",
+        createdOn: "created_on",
+        customPageHtml: "custom_page_html",
+        description: "description",
+        disableSessionRenewal: "disable_session_renewal",
+        eventEndTime: "event_end_time",
+        eventStartTime: "event_start_time",
+        modifiedOn: "modified_on",
+        name: "name",
+        newUsersPerMinute: "new_users_per_minute",
+        prequeueStartTime: "prequeue_start_time",
+        queueingMethod: "queueing_method",
+        sessionDuration: "session_duration",
+        shuffleAtEventStart: "shuffle_at_event_start",
+        suspended: "suspended",
+        totalActiveUsers: "total_active_users",
+        turnstileAction: "turnstile_action",
+        turnstileMode: "turnstile_mode",
+      }),
     ),
+  ),
+  resultInfo: Schema.Struct({
+    count: Schema.optional(Schema.Union([Schema.Number, Schema.Null])),
+    page: Schema.optional(Schema.Union([Schema.Number, Schema.Null])),
+    perPage: Schema.optional(Schema.Union([Schema.Number, Schema.Null])),
+    totalCount: Schema.optional(Schema.Union([Schema.Number, Schema.Null])),
   }).pipe(
     Schema.encodeKeys({
-      id: "id",
-      createdOn: "created_on",
-      customPageHtml: "custom_page_html",
-      description: "description",
-      disableSessionRenewal: "disable_session_renewal",
-      eventEndTime: "event_end_time",
-      eventStartTime: "event_start_time",
-      modifiedOn: "modified_on",
-      name: "name",
-      newUsersPerMinute: "new_users_per_minute",
-      prequeueStartTime: "prequeue_start_time",
-      queueingMethod: "queueing_method",
-      sessionDuration: "session_duration",
-      shuffleAtEventStart: "shuffle_at_event_start",
-      suspended: "suspended",
-      totalActiveUsers: "total_active_users",
-      turnstileAction: "turnstile_action",
-      turnstileMode: "turnstile_mode",
+      count: "count",
+      page: "page",
+      perPage: "per_page",
+      totalCount: "total_count",
     }),
   ),
+}).pipe(
+  Schema.encodeKeys({ result: "result", resultInfo: "result_info" }),
 ) as unknown as Schema.Schema<ListEventsResponse>;
 
 export type ListEventsError = DefaultErrors;
 
-export const listEvents: API.OperationMethod<
+export const listEvents: API.PaginatedOperationMethod<
   ListEventsRequest,
   ListEventsResponse,
   ListEventsError,
   Credentials | HttpClient.HttpClient
-> = /*@__PURE__*/ /*#__PURE__*/ API.make(() => ({
+> & {
+  pages: (
+    input: ListEventsRequest,
+  ) => stream.Stream<
+    ListEventsResponse,
+    ListEventsError,
+    Credentials | HttpClient.HttpClient
+  >;
+  items: (input: ListEventsRequest) => stream.Stream<
+    {
+      id?: string | null;
+      createdOn?: string | null;
+      customPageHtml?: string | null;
+      description?: string | null;
+      disableSessionRenewal?: boolean | null;
+      eventEndTime?: string | null;
+      eventStartTime?: string | null;
+      modifiedOn?: string | null;
+      name?: string | null;
+      newUsersPerMinute?: number | null;
+      prequeueStartTime?: string | null;
+      queueingMethod?: string | null;
+      sessionDuration?: number | null;
+      shuffleAtEventStart?: boolean | null;
+      suspended?: boolean | null;
+      totalActiveUsers?: number | null;
+      turnstileAction?: "log" | "infinite_queue" | null;
+      turnstileMode?:
+        | "off"
+        | "invisible"
+        | "visible_non_interactive"
+        | "visible_managed"
+        | null;
+    },
+    ListEventsError,
+    Credentials | HttpClient.HttpClient
+  >;
+} = /*@__PURE__*/ /*#__PURE__*/ API.makePaginated(() => ({
   input: ListEventsRequest,
   output: ListEventsResponse,
   errors: [],
+  pagination: {
+    mode: "page",
+    inputToken: "page",
+    outputToken: "resultInfo.page",
+    items: "result",
+    pageSize: "perPage",
+  } as const,
 }));
 
 export interface CreateEventRequest {
@@ -462,28 +540,32 @@ export const CreateEventResponse = /*@__PURE__*/ /*#__PURE__*/ Schema.Struct({
       Schema.Null,
     ]),
   ),
-}).pipe(
-  Schema.encodeKeys({
-    id: "id",
-    createdOn: "created_on",
-    customPageHtml: "custom_page_html",
-    description: "description",
-    disableSessionRenewal: "disable_session_renewal",
-    eventEndTime: "event_end_time",
-    eventStartTime: "event_start_time",
-    modifiedOn: "modified_on",
-    name: "name",
-    newUsersPerMinute: "new_users_per_minute",
-    prequeueStartTime: "prequeue_start_time",
-    queueingMethod: "queueing_method",
-    sessionDuration: "session_duration",
-    shuffleAtEventStart: "shuffle_at_event_start",
-    suspended: "suspended",
-    totalActiveUsers: "total_active_users",
-    turnstileAction: "turnstile_action",
-    turnstileMode: "turnstile_mode",
-  }),
-) as unknown as Schema.Schema<CreateEventResponse>;
+})
+  .pipe(
+    Schema.encodeKeys({
+      id: "id",
+      createdOn: "created_on",
+      customPageHtml: "custom_page_html",
+      description: "description",
+      disableSessionRenewal: "disable_session_renewal",
+      eventEndTime: "event_end_time",
+      eventStartTime: "event_start_time",
+      modifiedOn: "modified_on",
+      name: "name",
+      newUsersPerMinute: "new_users_per_minute",
+      prequeueStartTime: "prequeue_start_time",
+      queueingMethod: "queueing_method",
+      sessionDuration: "session_duration",
+      shuffleAtEventStart: "shuffle_at_event_start",
+      suspended: "suspended",
+      totalActiveUsers: "total_active_users",
+      turnstileAction: "turnstile_action",
+      turnstileMode: "turnstile_mode",
+    }),
+  )
+  .pipe(
+    T.ResponsePath("result"),
+  ) as unknown as Schema.Schema<CreateEventResponse>;
 
 export type CreateEventError = DefaultErrors;
 
@@ -685,28 +767,32 @@ export const UpdateEventResponse = /*@__PURE__*/ /*#__PURE__*/ Schema.Struct({
       Schema.Null,
     ]),
   ),
-}).pipe(
-  Schema.encodeKeys({
-    id: "id",
-    createdOn: "created_on",
-    customPageHtml: "custom_page_html",
-    description: "description",
-    disableSessionRenewal: "disable_session_renewal",
-    eventEndTime: "event_end_time",
-    eventStartTime: "event_start_time",
-    modifiedOn: "modified_on",
-    name: "name",
-    newUsersPerMinute: "new_users_per_minute",
-    prequeueStartTime: "prequeue_start_time",
-    queueingMethod: "queueing_method",
-    sessionDuration: "session_duration",
-    shuffleAtEventStart: "shuffle_at_event_start",
-    suspended: "suspended",
-    totalActiveUsers: "total_active_users",
-    turnstileAction: "turnstile_action",
-    turnstileMode: "turnstile_mode",
-  }),
-) as unknown as Schema.Schema<UpdateEventResponse>;
+})
+  .pipe(
+    Schema.encodeKeys({
+      id: "id",
+      createdOn: "created_on",
+      customPageHtml: "custom_page_html",
+      description: "description",
+      disableSessionRenewal: "disable_session_renewal",
+      eventEndTime: "event_end_time",
+      eventStartTime: "event_start_time",
+      modifiedOn: "modified_on",
+      name: "name",
+      newUsersPerMinute: "new_users_per_minute",
+      prequeueStartTime: "prequeue_start_time",
+      queueingMethod: "queueing_method",
+      sessionDuration: "session_duration",
+      shuffleAtEventStart: "shuffle_at_event_start",
+      suspended: "suspended",
+      totalActiveUsers: "total_active_users",
+      turnstileAction: "turnstile_action",
+      turnstileMode: "turnstile_mode",
+    }),
+  )
+  .pipe(
+    T.ResponsePath("result"),
+  ) as unknown as Schema.Schema<UpdateEventResponse>;
 
 export type UpdateEventError = DefaultErrors;
 
@@ -908,28 +994,32 @@ export const PatchEventResponse = /*@__PURE__*/ /*#__PURE__*/ Schema.Struct({
       Schema.Null,
     ]),
   ),
-}).pipe(
-  Schema.encodeKeys({
-    id: "id",
-    createdOn: "created_on",
-    customPageHtml: "custom_page_html",
-    description: "description",
-    disableSessionRenewal: "disable_session_renewal",
-    eventEndTime: "event_end_time",
-    eventStartTime: "event_start_time",
-    modifiedOn: "modified_on",
-    name: "name",
-    newUsersPerMinute: "new_users_per_minute",
-    prequeueStartTime: "prequeue_start_time",
-    queueingMethod: "queueing_method",
-    sessionDuration: "session_duration",
-    shuffleAtEventStart: "shuffle_at_event_start",
-    suspended: "suspended",
-    totalActiveUsers: "total_active_users",
-    turnstileAction: "turnstile_action",
-    turnstileMode: "turnstile_mode",
-  }),
-) as unknown as Schema.Schema<PatchEventResponse>;
+})
+  .pipe(
+    Schema.encodeKeys({
+      id: "id",
+      createdOn: "created_on",
+      customPageHtml: "custom_page_html",
+      description: "description",
+      disableSessionRenewal: "disable_session_renewal",
+      eventEndTime: "event_end_time",
+      eventStartTime: "event_start_time",
+      modifiedOn: "modified_on",
+      name: "name",
+      newUsersPerMinute: "new_users_per_minute",
+      prequeueStartTime: "prequeue_start_time",
+      queueingMethod: "queueing_method",
+      sessionDuration: "session_duration",
+      shuffleAtEventStart: "shuffle_at_event_start",
+      suspended: "suspended",
+      totalActiveUsers: "total_active_users",
+      turnstileAction: "turnstile_action",
+      turnstileMode: "turnstile_mode",
+    }),
+  )
+  .pipe(
+    T.ResponsePath("result"),
+  ) as unknown as Schema.Schema<PatchEventResponse>;
 
 export type PatchEventError = DefaultErrors;
 
@@ -968,7 +1058,9 @@ export interface DeleteEventResponse {
 
 export const DeleteEventResponse = /*@__PURE__*/ /*#__PURE__*/ Schema.Struct({
   id: Schema.optional(Schema.Union([Schema.String, Schema.Null])),
-}) as unknown as Schema.Schema<DeleteEventResponse>;
+}).pipe(
+  T.ResponsePath("result"),
+) as unknown as Schema.Schema<DeleteEventResponse>;
 
 export type DeleteEventError = DefaultErrors;
 
@@ -1062,26 +1154,30 @@ export const GetEventDetailResponse = /*@__PURE__*/ /*#__PURE__*/ Schema.Struct(
       Schema.Union([Schema.Number, Schema.Null]),
     ),
   },
-).pipe(
-  Schema.encodeKeys({
-    id: "id",
-    createdOn: "created_on",
-    customPageHtml: "custom_page_html",
-    description: "description",
-    disableSessionRenewal: "disable_session_renewal",
-    eventEndTime: "event_end_time",
-    eventStartTime: "event_start_time",
-    modifiedOn: "modified_on",
-    name: "name",
-    newUsersPerMinute: "new_users_per_minute",
-    prequeueStartTime: "prequeue_start_time",
-    queueingMethod: "queueing_method",
-    sessionDuration: "session_duration",
-    shuffleAtEventStart: "shuffle_at_event_start",
-    suspended: "suspended",
-    totalActiveUsers: "total_active_users",
-  }),
-) as unknown as Schema.Schema<GetEventDetailResponse>;
+)
+  .pipe(
+    Schema.encodeKeys({
+      id: "id",
+      createdOn: "created_on",
+      customPageHtml: "custom_page_html",
+      description: "description",
+      disableSessionRenewal: "disable_session_renewal",
+      eventEndTime: "event_end_time",
+      eventStartTime: "event_start_time",
+      modifiedOn: "modified_on",
+      name: "name",
+      newUsersPerMinute: "new_users_per_minute",
+      prequeueStartTime: "prequeue_start_time",
+      queueingMethod: "queueing_method",
+      sessionDuration: "session_duration",
+      shuffleAtEventStart: "shuffle_at_event_start",
+      suspended: "suspended",
+      totalActiveUsers: "total_active_users",
+    }),
+  )
+  .pipe(
+    T.ResponsePath("result"),
+  ) as unknown as Schema.Schema<GetEventDetailResponse>;
 
 export type GetEventDetailError = DefaultErrors;
 
@@ -1122,9 +1218,11 @@ export interface PreviewPageResponse {
 
 export const PreviewPageResponse = /*@__PURE__*/ /*#__PURE__*/ Schema.Struct({
   previewUrl: Schema.optional(Schema.Union([Schema.String, Schema.Null])),
-}).pipe(
-  Schema.encodeKeys({ previewUrl: "preview_url" }),
-) as unknown as Schema.Schema<PreviewPageResponse>;
+})
+  .pipe(Schema.encodeKeys({ previewUrl: "preview_url" }))
+  .pipe(
+    T.ResponsePath("result"),
+  ) as unknown as Schema.Schema<PreviewPageResponse>;
 
 export type PreviewPageError = DefaultErrors;
 
@@ -1159,51 +1257,80 @@ export const GetRuleRequest = /*@__PURE__*/ /*#__PURE__*/ Schema.Struct({
   }),
 ) as unknown as Schema.Schema<GetRuleRequest>;
 
-export type GetRuleResponse = {
-  id?: string | null;
-  action?: "bypass_waiting_room" | null;
-  description?: string | null;
-  enabled?: boolean | null;
-  expression?: string | null;
-  lastUpdated?: string | null;
-  version?: string | null;
-}[];
-
-export const GetRuleResponse = /*@__PURE__*/ /*#__PURE__*/ Schema.Array(
-  Schema.Struct({
-    id: Schema.optional(Schema.Union([Schema.String, Schema.Null])),
-    action: Schema.optional(
-      Schema.Union([Schema.Literal("bypass_waiting_room"), Schema.Null]),
+export interface GetRuleResponse {
+  result: {
+    id?: string | null;
+    action?: "bypass_waiting_room" | null;
+    description?: string | null;
+    enabled?: boolean | null;
+    expression?: string | null;
+    lastUpdated?: string | null;
+    version?: string | null;
+  }[];
+}
+
+export const GetRuleResponse = /*@__PURE__*/ /*#__PURE__*/ Schema.Struct({
+  result: Schema.Array(
+    Schema.Struct({
+      id: Schema.optional(Schema.Union([Schema.String, Schema.Null])),
+      action: Schema.optional(
+        Schema.Union([Schema.Literal("bypass_waiting_room"), Schema.Null]),
+      ),
+      description: Schema.optional(Schema.Union([Schema.String, Schema.Null])),
+      enabled: Schema.optional(Schema.Union([Schema.Boolean, Schema.Null])),
+      expression: Schema.optional(Schema.Union([Schema.String, Schema.Null])),
+      lastUpdated: Schema.optional(Schema.Union([Schema.String, Schema.Null])),
+      version: Schema.optional(Schema.Union([Schema.String, Schema.Null])),
+    }).pipe(
+      Schema.encodeKeys({
+        id: "id",
+        action: "action",
+        description: "description",
+        enabled: "enabled",
+        expression: "expression",
+        lastUpdated: "last_updated",
+        version: "version",
+      }),
     ),
-    description: Schema.optional(Schema.Union([Schema.String, Schema.Null])),
-    enabled: Schema.optional(Schema.Union([Schema.Boolean, Schema.Null])),
-    expression: Schema.optional(Schema.Union([Schema.String, Schema.Null])),
-    lastUpdated: Schema.optional(Schema.Union([Schema.String, Schema.Null])),
-    version: Schema.optional(Schema.Union([Schema.String, Schema.Null])),
-  }).pipe(
-    Schema.encodeKeys({
-      id: "id",
-      action: "action",
-      description: "description",
-      enabled: "enabled",
-      expression: "expression",
-      lastUpdated: "last_updated",
-      version: "version",
-    }),
   ),
-) as unknown as Schema.Schema<GetRuleResponse>;
+}) as unknown as Schema.Schema<GetRuleResponse>;
 
 export type GetRuleError = DefaultErrors;
 
-export const getRule: API.OperationMethod<
+export const getRule: API.PaginatedOperationMethod<
   GetRuleRequest,
   GetRuleResponse,
   GetRuleError,
   Credentials | HttpClient.HttpClient
-> = /*@__PURE__*/ /*#__PURE__*/ API.make(() => ({
+> & {
+  pages: (
+    input: GetRuleRequest,
+  ) => stream.Stream<
+    GetRuleResponse,
+    GetRuleError,
+    Credentials | HttpClient.HttpClient
+  >;
+  items: (input: GetRuleRequest) => stream.Stream<
+    {
+      id?: string | null;
+      action?: "bypass_waiting_room" | null;
+      description?: string | null;
+      enabled?: boolean | null;
+      expression?: string | null;
+      lastUpdated?: string | null;
+      version?: string | null;
+    },
+    GetRuleError,
+    Credentials | HttpClient.HttpClient
+  >;
+} = /*@__PURE__*/ /*#__PURE__*/ API.makePaginated(() => ({
   input: GetRuleRequest,
   output: GetRuleResponse,
   errors: [],
+  pagination: {
+    mode: "single",
+    items: "result",
+  } as const,
 }));
 
 export interface CreateRuleRequest {
@@ -1235,51 +1362,80 @@ export const CreateRuleRequest = /*@__PURE__*/ /*#__PURE__*/ Schema.Struct({
   }),
 ) as unknown as Schema.Schema<CreateRuleRequest>;
 
-export type CreateRuleResponse = {
-  id?: string | null;
-  action?: "bypass_waiting_room" | null;
-  description?: string | null;
-  enabled?: boolean | null;
-  expression?: string | null;
-  lastUpdated?: string | null;
-  version?: string | null;
-}[];
-
-export const CreateRuleResponse = /*@__PURE__*/ /*#__PURE__*/ Schema.Array(
-  Schema.Struct({
-    id: Schema.optional(Schema.Union([Schema.String, Schema.Null])),
-    action: Schema.optional(
-      Schema.Union([Schema.Literal("bypass_waiting_room"), Schema.Null]),
+export interface CreateRuleResponse {
+  result: {
+    id?: string | null;
+    action?: "bypass_waiting_room" | null;
+    description?: string | null;
+    enabled?: boolean | null;
+    expression?: string | null;
+    lastUpdated?: string | null;
+    version?: string | null;
+  }[];
+}
+
+export const CreateRuleResponse = /*@__PURE__*/ /*#__PURE__*/ Schema.Struct({
+  result: Schema.Array(
+    Schema.Struct({
+      id: Schema.optional(Schema.Union([Schema.String, Schema.Null])),
+      action: Schema.optional(
+        Schema.Union([Schema.Literal("bypass_waiting_room"), Schema.Null]),
+      ),
+      description: Schema.optional(Schema.Union([Schema.String, Schema.Null])),
+      enabled: Schema.optional(Schema.Union([Schema.Boolean, Schema.Null])),
+      expression: Schema.optional(Schema.Union([Schema.String, Schema.Null])),
+      lastUpdated: Schema.optional(Schema.Union([Schema.String, Schema.Null])),
+      version: Schema.optional(Schema.Union([Schema.String, Schema.Null])),
+    }).pipe(
+      Schema.encodeKeys({
+        id: "id",
+        action: "action",
+        description: "description",
+        enabled: "enabled",
+        expression: "expression",
+        lastUpdated: "last_updated",
+        version: "version",
+      }),
     ),
-    description: Schema.optional(Schema.Union([Schema.String, Schema.Null])),
-    enabled: Schema.optional(Schema.Union([Schema.Boolean, Schema.Null])),
-    expression: Schema.optional(Schema.Union([Schema.String, Schema.Null])),
-    lastUpdated: Schema.optional(Schema.Union([Schema.String, Schema.Null])),
-    version: Schema.optional(Schema.Union([Schema.String, Schema.Null])),
-  }).pipe(
-    Schema.encodeKeys({
-      id: "id",
-      action: "action",
-      description: "description",
-      enabled: "enabled",
-      expression: "expression",
-      lastUpdated: "last_updated",
-      version: "version",
-    }),
   ),
-) as unknown as Schema.Schema<CreateRuleResponse>;
+}) as unknown as Schema.Schema<CreateRuleResponse>;
 
 export type CreateRuleError = DefaultErrors;
 
-export const createRule: API.OperationMethod<
+export const createRule: API.PaginatedOperationMethod<
   CreateRuleRequest,
   CreateRuleResponse,
   CreateRuleError,
   Credentials | HttpClient.HttpClient
-> = /*@__PURE__*/ /*#__PURE__*/ API.make(() => ({
+> & {
+  pages: (
+    input: CreateRuleRequest,
+  ) => stream.Stream<
+    CreateRuleResponse,
+    CreateRuleError,
+    Credentials | HttpClient.HttpClient
+  >;
+  items: (input: CreateRuleRequest) => stream.Stream<
+    {
+      id?: string | null;
+      action?: "bypass_waiting_room" | null;
+      description?: string | null;
+      enabled?: boolean | null;
+      expression?: string | null;
+      lastUpdated?: string | null;
+      version?: string | null;
+    },
+    CreateRuleError,
+    Credentials | HttpClient.HttpClient
+  >;
+} = /*@__PURE__*/ /*#__PURE__*/ API.makePaginated(() => ({
   input: CreateRuleRequest,
   output: CreateRuleResponse,
   errors: [],
+  pagination: {
+    mode: "single",
+    items: "result",
+  } as const,
 }));
 
 export interface UpdateRuleRequest {
@@ -1313,51 +1469,80 @@ export const UpdateRuleRequest = /*@__PURE__*/ /*#__PURE__*/ Schema.Struct({
   }),
 ) as unknown as Schema.Schema<UpdateRuleRequest>;
 
-export type UpdateRuleResponse = {
-  id?: string | null;
-  action?: "bypass_waiting_room" | null;
-  description?: string | null;
-  enabled?: boolean | null;
-  expression?: string | null;
-  lastUpdated?: string | null;
-  version?: string | null;
-}[];
-
-export const UpdateRuleResponse = /*@__PURE__*/ /*#__PURE__*/ Schema.Array(
-  Schema.Struct({
-    id: Schema.optional(Schema.Union([Schema.String, Schema.Null])),
-    action: Schema.optional(
-      Schema.Union([Schema.Literal("bypass_waiting_room"), Schema.Null]),
+export interface UpdateRuleResponse {
+  result: {
+    id?: string | null;
+    action?: "bypass_waiting_room" | null;
+    description?: string | null;
+    enabled?: boolean | null;
+    expression?: string | null;
+    lastUpdated?: string | null;
+    version?: string | null;
+  }[];
+}
+
+export const UpdateRuleResponse = /*@__PURE__*/ /*#__PURE__*/ Schema.Struct({
+  result: Schema.Array(
+    Schema.Struct({
+      id: Schema.optional(Schema.Union([Schema.String, Schema.Null])),
+      action: Schema.optional(
+        Schema.Union([Schema.Literal("bypass_waiting_room"), Schema.Null]),
+      ),
+      description: Schema.optional(Schema.Union([Schema.String, Schema.Null])),
+      enabled: Schema.optional(Schema.Union([Schema.Boolean, Schema.Null])),
+      expression: Schema.optional(Schema.Union([Schema.String, Schema.Null])),
+      lastUpdated: Schema.optional(Schema.Union([Schema.String, Schema.Null])),
+      version: Schema.optional(Schema.Union([Schema.String, Schema.Null])),
+    }).pipe(
+      Schema.encodeKeys({
+        id: "id",
+        action: "action",
+        description: "description",
+        enabled: "enabled",
+        expression: "expression",
+        lastUpdated: "last_updated",
+        version: "version",
+      }),
     ),
-    description: Schema.optional(Schema.Union([Schema.String, Schema.Null])),
-    enabled: Schema.optional(Schema.Union([Schema.Boolean, Schema.Null])),
-    expression: Schema.optional(Schema.Union([Schema.String, Schema.Null])),
-    lastUpdated: Schema.optional(Schema.Union([Schema.String, Schema.Null])),
-    version: Schema.optional(Schema.Union([Schema.String, Schema.Null])),
-  }).pipe(
-    Schema.encodeKeys({
-      id: "id",
-      action: "action",
-      description: "description",
-      enabled: "enabled",
-      expression: "expression",
-      lastUpdated: "last_updated",
-      version: "version",
-    }),
   ),
-) as unknown as Schema.Schema<UpdateRuleResponse>;
+}) as unknown as Schema.Schema<UpdateRuleResponse>;
 
 export type UpdateRuleError = DefaultErrors;
 
-export const updateRule: API.OperationMethod<
+export const updateRule: API.PaginatedOperationMethod<
   UpdateRuleRequest,
   UpdateRuleResponse,
   UpdateRuleError,
   Credentials | HttpClient.HttpClient
-> = /*@__PURE__*/ /*#__PURE__*/ API.make(() => ({
+> & {
+  pages: (
+    input: UpdateRuleRequest,
+  ) => stream.Stream<
+    UpdateRuleResponse,
+    UpdateRuleError,
+    Credentials | HttpClient.HttpClient
+  >;
+  items: (input: UpdateRuleRequest) => stream.Stream<
+    {
+      id?: string | null;
+      action?: "bypass_waiting_room" | null;
+      description?: string | null;
+      enabled?: boolean | null;
+      expression?: string | null;
+      lastUpdated?: string | null;
+      version?: string | null;
+    },
+    UpdateRuleError,
+    Credentials | HttpClient.HttpClient
+  >;
+} = /*@__PURE__*/ /*#__PURE__*/ API.makePaginated(() => ({
   input: UpdateRuleRequest,
   output: UpdateRuleResponse,
   errors: [],
+  pagination: {
+    mode: "single",
+    items: "result",
+  } as const,
 }));
 
 export interface PatchRuleRequest {
@@ -1405,51 +1590,80 @@ export const PatchRuleRequest = /*@__PURE__*/ /*#__PURE__*/ Schema.Struct({
   }),
 ) as unknown as Schema.Schema<PatchRuleRequest>;
 
-export type PatchRuleResponse = {
-  id?: string | null;
-  action?: "bypass_waiting_room" | null;
-  description?: string | null;
-  enabled?: boolean | null;
-  expression?: string | null;
-  lastUpdated?: string | null;
-  version?: string | null;
-}[];
-
-export const PatchRuleResponse = /*@__PURE__*/ /*#__PURE__*/ Schema.Array(
-  Schema.Struct({
-    id: Schema.optional(Schema.Union([Schema.String, Schema.Null])),
-    action: Schema.optional(
-      Schema.Union([Schema.Literal("bypass_waiting_room"), Schema.Null]),
+export interface PatchRuleResponse {
+  result: {
+    id?: string | null;
+    action?: "bypass_waiting_room" | null;
+    description?: string | null;
+    enabled?: boolean | null;
+    expression?: string | null;
+    lastUpdated?: string | null;
+    version?: string | null;
+  }[];
+}
+
+export const PatchRuleResponse = /*@__PURE__*/ /*#__PURE__*/ Schema.Struct({
+  result: Schema.Array(
+    Schema.Struct({
+      id: Schema.optional(Schema.Union([Schema.String, Schema.Null])),
+      action: Schema.optional(
+        Schema.Union([Schema.Literal("bypass_waiting_room"), Schema.Null]),
+      ),
+      description: Schema.optional(Schema.Union([Schema.String, Schema.Null])),
+      enabled: Schema.optional(Schema.Union([Schema.Boolean, Schema.Null])),
+      expression: Schema.optional(Schema.Union([Schema.String, Schema.Null])),
+      lastUpdated: Schema.optional(Schema.Union([Schema.String, Schema.Null])),
+      version: Schema.optional(Schema.Union([Schema.String, Schema.Null])),
+    }).pipe(
+      Schema.encodeKeys({
+        id: "id",
+        action: "action",
+        description: "description",
+        enabled: "enabled",
+        expression: "expression",
+        lastUpdated: "last_updated",
+        version: "version",
+      }),
     ),
-    description: Schema.optional(Schema.Union([Schema.String, Schema.Null])),
-    enabled: Schema.optional(Schema.Union([Schema.Boolean, Schema.Null])),
-    expression: Schema.optional(Schema.Union([Schema.String, Schema.Null])),
-    lastUpdated: Schema.optional(Schema.Union([Schema.String, Schema.Null])),
-    version: Schema.optional(Schema.Union([Schema.String, Schema.Null])),
-  }).pipe(
-    Schema.encodeKeys({
-      id: "id",
-      action: "action",
-      description: "description",
-      enabled: "enabled",
-      expression: "expression",
-      lastUpdated: "last_updated",
-      version: "version",
-    }),
   ),
-) as unknown as Schema.Schema<PatchRuleResponse>;
+}) as unknown as Schema.Schema<PatchRuleResponse>;
 
 export type PatchRuleError = DefaultErrors;
 
-export const patchRule: API.OperationMethod<
+export const patchRule: API.PaginatedOperationMethod<
   PatchRuleRequest,
   PatchRuleResponse,
   PatchRuleError,
   Credentials | HttpClient.HttpClient
-> = /*@__PURE__*/ /*#__PURE__*/ API.make(() => ({
+> & {
+  pages: (
+    input: PatchRuleRequest,
+  ) => stream.Stream<
+    PatchRuleResponse,
+    PatchRuleError,
+    Credentials | HttpClient.HttpClient
+  >;
+  items: (input: PatchRuleRequest) => stream.Stream<
+    {
+      id?: string | null;
+      action?: "bypass_waiting_room" | null;
+      description?: string | null;
+      enabled?: boolean | null;
+      expression?: string | null;
+      lastUpdated?: string | null;
+      version?: string | null;
+    },
+    PatchRuleError,
+    Credentials | HttpClient.HttpClient
+  >;
+} = /*@__PURE__*/ /*#__PURE__*/ API.makePaginated(() => ({
   input: PatchRuleRequest,
   output: PatchRuleResponse,
   errors: [],
+  pagination: {
+    mode: "single",
+    items: "result",
+  } as const,
 }));
 
 export interface DeleteRuleRequest {
@@ -1470,51 +1684,80 @@ export const DeleteRuleRequest = /*@__PURE__*/ /*#__PURE__*/ Schema.Struct({
   }),
 ) as unknown as Schema.Schema<DeleteRuleRequest>;
 
-export type DeleteRuleResponse = {
-  id?: string | null;
-  action?: "bypass_waiting_room" | null;
-  description?: string | null;
-  enabled?: boolean | null;
-  expression?: string | null;
-  lastUpdated?: string | null;
-  version?: string | null;
-}[];
-
-export const DeleteRuleResponse = /*@__PURE__*/ /*#__PURE__*/ Schema.Array(
-  Schema.Struct({
-    id: Schema.optional(Schema.Union([Schema.String, Schema.Null])),
-    action: Schema.optional(
-      Schema.Union([Schema.Literal("bypass_waiting_room"), Schema.Null]),
+export interface DeleteRuleResponse {
+  result: {
+    id?: string | null;
+    action?: "bypass_waiting_room" | null;
+    description?: string | null;
+    enabled?: boolean | null;
+    expression?: string | null;
+    lastUpdated?: string | null;
+    version?: string | null;
+  }[];
+}
+
+export const DeleteRuleResponse = /*@__PURE__*/ /*#__PURE__*/ Schema.Struct({
+  result: Schema.Array(
+    Schema.Struct({
+      id: Schema.optional(Schema.Union([Schema.String, Schema.Null])),
+      action: Schema.optional(
+        Schema.Union([Schema.Literal("bypass_waiting_room"), Schema.Null]),
+      ),
+      description: Schema.optional(Schema.Union([Schema.String, Schema.Null])),
+      enabled: Schema.optional(Schema.Union([Schema.Boolean, Schema.Null])),
+      expression: Schema.optional(Schema.Union([Schema.String, Schema.Null])),
+      lastUpdated: Schema.optional(Schema.Union([Schema.String, Schema.Null])),
+      version: Schema.optional(Schema.Union([Schema.String, Schema.Null])),
+    }).pipe(
+      Schema.encodeKeys({
+        id: "id",
+        action: "action",
+        description: "description",
+        enabled: "enabled",
+        expression: "expression",
+        lastUpdated: "last_updated",
+        version: "version",
+      }),
     ),
-    description: Schema.optional(Schema.Union([Schema.String, Schema.Null])),
-    enabled: Schema.optional(Schema.Union([Schema.Boolean, Schema.Null])),
-    expression: Schema.optional(Schema.Union([Schema.String, Schema.Null])),
-    lastUpdated: Schema.optional(Schema.Union([Schema.String, Schema.Null])),
-    version: Schema.optional(Schema.Union([Schema.String, Schema.Null])),
-  }).pipe(
-    Schema.encodeKeys({
-      id: "id",
-      action: "action",
-      description: "description",
-      enabled: "enabled",
-      expression: "expression",
-      lastUpdated: "last_updated",
-      version: "version",
-    }),
   ),
-) as unknown as Schema.Schema<DeleteRuleResponse>;
+}) as unknown as Schema.Schema<DeleteRuleResponse>;
 
 export type DeleteRuleError = DefaultErrors;
 
-export const deleteRule: API.OperationMethod<
+export const deleteRule: API.PaginatedOperationMethod<
   DeleteRuleRequest,
   DeleteRuleResponse,
   DeleteRuleError,
   Credentials | HttpClient.HttpClient
-> = /*@__PURE__*/ /*#__PURE__*/ API.make(() => ({
+> & {
+  pages: (
+    input: DeleteRuleRequest,
+  ) => stream.Stream<
+    DeleteRuleResponse,
+    DeleteRuleError,
+    Credentials | HttpClient.HttpClient
+  >;
+  items: (input: DeleteRuleRequest) => stream.Stream<
+    {
+      id?: string | null;
+      action?: "bypass_waiting_room" | null;
+      description?: string | null;
+      enabled?: boolean | null;
+      expression?: string | null;
+      lastUpdated?: string | null;
+      version?: string | null;
+    },
+    DeleteRuleError,
+    Credentials | HttpClient.HttpClient
+  >;
+} = /*@__PURE__*/ /*#__PURE__*/ API.makePaginated(() => ({
   input: DeleteRuleRequest,
   output: DeleteRuleResponse,
   errors: [],
+  pagination: {
+    mode: "single",
+    items: "result",
+  } as const,
 }));
 
 // =============================================================================
@@ -1539,11 +1782,15 @@ export interface GetSettingResponse {
 
 export const GetSettingResponse = /*@__PURE__*/ /*#__PURE__*/ Schema.Struct({
   searchEngineCrawlerBypass: Schema.Boolean,
-}).pipe(
-  Schema.encodeKeys({
-    searchEngineCrawlerBypass: "search_engine_crawler_bypass",
-  }),
-) as unknown as Schema.Schema<GetSettingResponse>;
+})
+  .pipe(
+    Schema.encodeKeys({
+      searchEngineCrawlerBypass: "search_engine_crawler_bypass",
+    }),
+  )
+  .pipe(
+    T.ResponsePath("result"),
+  ) as unknown as Schema.Schema<GetSettingResponse>;
 
 export type GetSettingError = DefaultErrors;
 
@@ -1582,11 +1829,15 @@ export interface PutSettingResponse {
 
 export const PutSettingResponse = /*@__PURE__*/ /*#__PURE__*/ Schema.Struct({
   searchEngineCrawlerBypass: Schema.Boolean,
-}).pipe(
-  Schema.encodeKeys({
-    searchEngineCrawlerBypass: "search_engine_crawler_bypass",
-  }),
-) as unknown as Schema.Schema<PutSettingResponse>;
+})
+  .pipe(
+    Schema.encodeKeys({
+      searchEngineCrawlerBypass: "search_engine_crawler_bypass",
+    }),
+  )
+  .pipe(
+    T.ResponsePath("result"),
+  ) as unknown as Schema.Schema<PutSettingResponse>;
 
 export type PutSettingError = DefaultErrors;
 
@@ -1625,11 +1876,15 @@ export interface PatchSettingResponse {
 
 export const PatchSettingResponse = /*@__PURE__*/ /*#__PURE__*/ Schema.Struct({
   searchEngineCrawlerBypass: Schema.Boolean,
-}).pipe(
-  Schema.encodeKeys({
-    searchEngineCrawlerBypass: "search_engine_crawler_bypass",
-  }),
-) as unknown as Schema.Schema<PatchSettingResponse>;
+})
+  .pipe(
+    Schema.encodeKeys({
+      searchEngineCrawlerBypass: "search_engine_crawler_bypass",
+    }),
+  )
+  .pipe(
+    T.ResponsePath("result"),
+  ) as unknown as Schema.Schema<PatchSettingResponse>;
 
 export type PatchSettingError = DefaultErrors;
 
@@ -1699,15 +1954,19 @@ export const GetStatusResponse = /*@__PURE__*/ /*#__PURE__*/ Schema.Struct({
       Schema.Null,
     ]),
   ),
-}).pipe(
-  Schema.encodeKeys({
-    estimatedQueuedUsers: "estimated_queued_users",
-    estimatedTotalActiveUsers: "estimated_total_active_users",
-    eventId: "event_id",
-    maxEstimatedTimeMinutes: "max_estimated_time_minutes",
-    status: "status",
-  }),
-) as unknown as Schema.Schema<GetStatusResponse>;
+})
+  .pipe(
+    Schema.encodeKeys({
+      estimatedQueuedUsers: "estimated_queued_users",
+      estimatedTotalActiveUsers: "estimated_total_active_users",
+      eventId: "event_id",
+      maxEstimatedTimeMinutes: "max_estimated_time_minutes",
+      status: "status",
+    }),
+  )
+  .pipe(
+    T.ResponsePath("result"),
+  ) as unknown as Schema.Schema<GetStatusResponse>;
 
 export type GetStatusError = DefaultErrors;
 
@@ -1977,36 +2236,40 @@ export const GetWaitingRoomResponse = /*@__PURE__*/ /*#__PURE__*/ Schema.Struct(
       ]),
     ),
   },
-).pipe(
-  Schema.encodeKeys({
-    id: "id",
-    additionalRoutes: "additional_routes",
-    cookieAttributes: "cookie_attributes",
-    cookieSuffix: "cookie_suffix",
-    createdOn: "created_on",
-    customPageHtml: "custom_page_html",
-    defaultTemplateLanguage: "default_template_language",
-    description: "description",
-    disableSessionRenewal: "disable_session_renewal",
-    enabledOriginCommands: "enabled_origin_commands",
-    host: "host",
-    jsonResponseEnabled: "json_response_enabled",
-    modifiedOn: "modified_on",
-    name: "name",
-    newUsersPerMinute: "new_users_per_minute",
-    nextEventPrequeueStartTime: "next_event_prequeue_start_time",
-    nextEventStartTime: "next_event_start_time",
-    path: "path",
-    queueAll: "queue_all",
-    queueingMethod: "queueing_method",
-    queueingStatusCode: "queueing_status_code",
-    sessionDuration: "session_duration",
-    suspended: "suspended",
-    totalActiveUsers: "total_active_users",
-    turnstileAction: "turnstile_action",
-    turnstileMode: "turnstile_mode",
-  }),
-) as unknown as Schema.Schema<GetWaitingRoomResponse>;
+)
+  .pipe(
+    Schema.encodeKeys({
+      id: "id",
+      additionalRoutes: "additional_routes",
+      cookieAttributes: "cookie_attributes",
+      cookieSuffix: "cookie_suffix",
+      createdOn: "created_on",
+      customPageHtml: "custom_page_html",
+      defaultTemplateLanguage: "default_template_language",
+      description: "description",
+      disableSessionRenewal: "disable_session_renewal",
+      enabledOriginCommands: "enabled_origin_commands",
+      host: "host",
+      jsonResponseEnabled: "json_response_enabled",
+      modifiedOn: "modified_on",
+      name: "name",
+      newUsersPerMinute: "new_users_per_minute",
+      nextEventPrequeueStartTime: "next_event_prequeue_start_time",
+      nextEventStartTime: "next_event_start_time",
+      path: "path",
+      queueAll: "queue_all",
+      queueingMethod: "queueing_method",
+      queueingStatusCode: "queueing_status_code",
+      sessionDuration: "session_duration",
+      suspended: "suspended",
+      totalActiveUsers: "total_active_users",
+      turnstileAction: "turnstile_action",
+      turnstileMode: "turnstile_mode",
+    }),
+  )
+  .pipe(
+    T.ResponsePath("result"),
+  ) as unknown as Schema.Schema<GetWaitingRoomResponse>;
 
 export type GetWaitingRoomError = DefaultErrors;
 
@@ -2031,263 +2294,395 @@ export const ListWaitingRoomsRequest =
     }),
   ) as unknown as Schema.Schema<ListWaitingRoomsRequest>;
 
-export type ListWaitingRoomsResponse = {
-  id?: string | null;
-  additionalRoutes?: { host?: string | null; path?: string | null }[] | null;
-  cookieAttributes?: {
-    samesite?: "auto" | "lax" | "none" | "strict" | null;
-    secure?: "auto" | "always" | "never" | null;
-  } | null;
-  cookieSuffix?: string | null;
-  createdOn?: string | null;
-  customPageHtml?: string | null;
-  defaultTemplateLanguage?:
-    | "en-US"
-    | "es-ES"
-    | "de-DE"
-    | "fr-FR"
-    | "it-IT"
-    | "ja-JP"
-    | "ko-KR"
-    | "pt-BR"
-    | "zh-CN"
-    | "zh-TW"
-    | "nl-NL"
-    | "pl-PL"
-    | "id-ID"
-    | "tr-TR"
-    | "ar-EG"
-    | "ru-RU"
-    | "fa-IR"
-    | "bg-BG"
-    | "hr-HR"
-    | "cs-CZ"
-    | "da-DK"
-    | "fi-FI"
-    | "lt-LT"
-    | "ms-MY"
-    | "nb-NO"
-    | "ro-RO"
-    | "el-GR"
-    | "he-IL"
-    | "hi-IN"
-    | "hu-HU"
-    | "sr-BA"
-    | "sk-SK"
-    | "sl-SI"
-    | "sv-SE"
-    | "tl-PH"
-    | "th-TH"
-    | "uk-UA"
-    | "vi-VN"
-    | null;
-  description?: string | null;
-  disableSessionRenewal?: boolean | null;
-  enabledOriginCommands?: "revoke"[] | null;
-  host?: string | null;
-  jsonResponseEnabled?: boolean | null;
-  modifiedOn?: string | null;
-  name?: string | null;
-  newUsersPerMinute?: number | null;
-  nextEventPrequeueStartTime?: string | null;
-  nextEventStartTime?: string | null;
-  path?: string | null;
-  queueAll?: boolean | null;
-  queueingMethod?: "fifo" | "random" | "passthrough" | "reject" | null;
-  queueingStatusCode?: "200" | "202" | "429" | null;
-  sessionDuration?: number | null;
-  suspended?: boolean | null;
-  totalActiveUsers?: number | null;
-  turnstileAction?: "log" | "infinite_queue" | null;
-  turnstileMode?:
-    | "off"
-    | "invisible"
-    | "visible_non_interactive"
-    | "visible_managed"
-    | null;
-}[];
+export interface ListWaitingRoomsResponse {
+  result: {
+    id?: string | null;
+    additionalRoutes?: { host?: string | null; path?: string | null }[] | null;
+    cookieAttributes?: {
+      samesite?: "auto" | "lax" | "none" | "strict" | null;
+      secure?: "auto" | "always" | "never" | null;
+    } | null;
+    cookieSuffix?: string | null;
+    createdOn?: string | null;
+    customPageHtml?: string | null;
+    defaultTemplateLanguage?:
+      | "en-US"
+      | "es-ES"
+      | "de-DE"
+      | "fr-FR"
+      | "it-IT"
+      | "ja-JP"
+      | "ko-KR"
+      | "pt-BR"
+      | "zh-CN"
+      | "zh-TW"
+      | "nl-NL"
+      | "pl-PL"
+      | "id-ID"
+      | "tr-TR"
+      | "ar-EG"
+      | "ru-RU"
+      | "fa-IR"
+      | "bg-BG"
+      | "hr-HR"
+      | "cs-CZ"
+      | "da-DK"
+      | "fi-FI"
+      | "lt-LT"
+      | "ms-MY"
+      | "nb-NO"
+      | "ro-RO"
+      | "el-GR"
+      | "he-IL"
+      | "hi-IN"
+      | "hu-HU"
+      | "sr-BA"
+      | "sk-SK"
+      | "sl-SI"
+      | "sv-SE"
+      | "tl-PH"
+      | "th-TH"
+      | "uk-UA"
+      | "vi-VN"
+      | null;
+    description?: string | null;
+    disableSessionRenewal?: boolean | null;
+    enabledOriginCommands?: "revoke"[] | null;
+    host?: string | null;
+    jsonResponseEnabled?: boolean | null;
+    modifiedOn?: string | null;
+    name?: string | null;
+    newUsersPerMinute?: number | null;
+    nextEventPrequeueStartTime?: string | null;
+    nextEventStartTime?: string | null;
+    path?: string | null;
+    queueAll?: boolean | null;
+    queueingMethod?: "fifo" | "random" | "passthrough" | "reject" | null;
+    queueingStatusCode?: "200" | "202" | "429" | null;
+    sessionDuration?: number | null;
+    suspended?: boolean | null;
+    totalActiveUsers?: number | null;
+    turnstileAction?: "log" | "infinite_queue" | null;
+    turnstileMode?:
+      | "off"
+      | "invisible"
+      | "visible_non_interactive"
+      | "visible_managed"
+      | null;
+  }[];
+  resultInfo: {
+    count?: number | null;
+    page?: number | null;
+    perPage?: number | null;
+    totalCount?: number | null;
+  };
+}
 
 export const ListWaitingRoomsResponse =
-  /*@__PURE__*/ /*#__PURE__*/ Schema.Array(
-    Schema.Struct({
-      id: Schema.optional(Schema.Union([Schema.String, Schema.Null])),
-      additionalRoutes: Schema.optional(
-        Schema.Union([
-          Schema.Array(
+  /*@__PURE__*/ /*#__PURE__*/ Schema.Struct({
+    result: Schema.Array(
+      Schema.Struct({
+        id: Schema.optional(Schema.Union([Schema.String, Schema.Null])),
+        additionalRoutes: Schema.optional(
+          Schema.Union([
+            Schema.Array(
+              Schema.Struct({
+                host: Schema.optional(
+                  Schema.Union([Schema.String, Schema.Null]),
+                ),
+                path: Schema.optional(
+                  Schema.Union([Schema.String, Schema.Null]),
+                ),
+              }),
+            ),
+            Schema.Null,
+          ]),
+        ),
+        cookieAttributes: Schema.optional(
+          Schema.Union([
             Schema.Struct({
-              host: Schema.optional(Schema.Union([Schema.String, Schema.Null])),
-              path: Schema.optional(Schema.Union([Schema.String, Schema.Null])),
+              samesite: Schema.optional(
+                Schema.Union([
+                  Schema.Literals(["auto", "lax", "none", "strict"]),
+                  Schema.Null,
+                ]),
+              ),
+              secure: Schema.optional(
+                Schema.Union([
+                  Schema.Literals(["auto", "always", "never"]),
+                  Schema.Null,
+                ]),
+              ),
             }),
-          ),
-          Schema.Null,
-        ]),
-      ),
-      cookieAttributes: Schema.optional(
-        Schema.Union([
-          Schema.Struct({
-            samesite: Schema.optional(
-              Schema.Union([
-                Schema.Literals(["auto", "lax", "none", "strict"]),
-                Schema.Null,
-              ]),
-            ),
-            secure: Schema.optional(
-              Schema.Union([
-                Schema.Literals(["auto", "always", "never"]),
-                Schema.Null,
-              ]),
-            ),
-          }),
-          Schema.Null,
-        ]),
-      ),
-      cookieSuffix: Schema.optional(Schema.Union([Schema.String, Schema.Null])),
-      createdOn: Schema.optional(Schema.Union([Schema.String, Schema.Null])),
-      customPageHtml: Schema.optional(
-        Schema.Union([Schema.String, Schema.Null]),
-      ),
-      defaultTemplateLanguage: Schema.optional(
-        Schema.Union([
-          Schema.Literals([
-            "en-US",
-            "es-ES",
-            "de-DE",
-            "fr-FR",
-            "it-IT",
-            "ja-JP",
-            "ko-KR",
-            "pt-BR",
-            "zh-CN",
-            "zh-TW",
-            "nl-NL",
-            "pl-PL",
-            "id-ID",
-            "tr-TR",
-            "ar-EG",
-            "ru-RU",
-            "fa-IR",
-            "bg-BG",
-            "hr-HR",
-            "cs-CZ",
-            "da-DK",
-            "fi-FI",
-            "lt-LT",
-            "ms-MY",
-            "nb-NO",
-            "ro-RO",
-            "el-GR",
-            "he-IL",
-            "hi-IN",
-            "hu-HU",
-            "sr-BA",
-            "sk-SK",
-            "sl-SI",
-            "sv-SE",
-            "tl-PH",
-            "th-TH",
-            "uk-UA",
-            "vi-VN",
+            Schema.Null,
+          ]),
+        ),
+        cookieSuffix: Schema.optional(
+          Schema.Union([Schema.String, Schema.Null]),
+        ),
+        createdOn: Schema.optional(Schema.Union([Schema.String, Schema.Null])),
+        customPageHtml: Schema.optional(
+          Schema.Union([Schema.String, Schema.Null]),
+        ),
+        defaultTemplateLanguage: Schema.optional(
+          Schema.Union([
+            Schema.Literals([
+              "en-US",
+              "es-ES",
+              "de-DE",
+              "fr-FR",
+              "it-IT",
+              "ja-JP",
+              "ko-KR",
+              "pt-BR",
+              "zh-CN",
+              "zh-TW",
+              "nl-NL",
+              "pl-PL",
+              "id-ID",
+              "tr-TR",
+              "ar-EG",
+              "ru-RU",
+              "fa-IR",
+              "bg-BG",
+              "hr-HR",
+              "cs-CZ",
+              "da-DK",
+              "fi-FI",
+              "lt-LT",
+              "ms-MY",
+              "nb-NO",
+              "ro-RO",
+              "el-GR",
+              "he-IL",
+              "hi-IN",
+              "hu-HU",
+              "sr-BA",
+              "sk-SK",
+              "sl-SI",
+              "sv-SE",
+              "tl-PH",
+              "th-TH",
+              "uk-UA",
+              "vi-VN",
+            ]),
+            Schema.Null,
+          ]),
+        ),
+        description: Schema.optional(
+          Schema.Union([Schema.String, Schema.Null]),
+        ),
+        disableSessionRenewal: Schema.optional(
+          Schema.Union([Schema.Boolean, Schema.Null]),
+        ),
+        enabledOriginCommands: Schema.optional(
+          Schema.Union([Schema.Array(Schema.Literal("revoke")), Schema.Null]),
+        ),
+        host: Schema.optional(Schema.Union([Schema.String, Schema.Null])),
+        jsonResponseEnabled: Schema.optional(
+          Schema.Union([Schema.Boolean, Schema.Null]),
+        ),
+        modifiedOn: Schema.optional(Schema.Union([Schema.String, Schema.Null])),
+        name: Schema.optional(Schema.Union([Schema.String, Schema.Null])),
+        newUsersPerMinute: Schema.optional(
+          Schema.Union([Schema.Number, Schema.Null]),
+        ),
+        nextEventPrequeueStartTime: Schema.optional(
+          Schema.Union([Schema.String, Schema.Null]),
+        ),
+        nextEventStartTime: Schema.optional(
+          Schema.Union([Schema.String, Schema.Null]),
+        ),
+        path: Schema.optional(Schema.Union([Schema.String, Schema.Null])),
+        queueAll: Schema.optional(Schema.Union([Schema.Boolean, Schema.Null])),
+        queueingMethod: Schema.optional(
+          Schema.Union([
+            Schema.Literals(["fifo", "random", "passthrough", "reject"]),
+            Schema.Null,
           ]),
-          Schema.Null,
-        ]),
-      ),
-      description: Schema.optional(Schema.Union([Schema.String, Schema.Null])),
-      disableSessionRenewal: Schema.optional(
-        Schema.Union([Schema.Boolean, Schema.Null]),
-      ),
-      enabledOriginCommands: Schema.optional(
-        Schema.Union([Schema.Array(Schema.Literal("revoke")), Schema.Null]),
-      ),
-      host: Schema.optional(Schema.Union([Schema.String, Schema.Null])),
-      jsonResponseEnabled: Schema.optional(
-        Schema.Union([Schema.Boolean, Schema.Null]),
-      ),
-      modifiedOn: Schema.optional(Schema.Union([Schema.String, Schema.Null])),
-      name: Schema.optional(Schema.Union([Schema.String, Schema.Null])),
-      newUsersPerMinute: Schema.optional(
-        Schema.Union([Schema.Number, Schema.Null]),
-      ),
-      nextEventPrequeueStartTime: Schema.optional(
-        Schema.Union([Schema.String, Schema.Null]),
-      ),
-      nextEventStartTime: Schema.optional(
-        Schema.Union([Schema.String, Schema.Null]),
-      ),
-      path: Schema.optional(Schema.Union([Schema.String, Schema.Null])),
-      queueAll: Schema.optional(Schema.Union([Schema.Boolean, Schema.Null])),
-      queueingMethod: Schema.optional(
-        Schema.Union([
-          Schema.Literals(["fifo", "random", "passthrough", "reject"]),
-          Schema.Null,
-        ]),
-      ),
-      queueingStatusCode: Schema.optional(
-        Schema.Union([Schema.Literals(["200", "202", "429"]), Schema.Null]),
-      ),
-      sessionDuration: Schema.optional(
-        Schema.Union([Schema.Number, Schema.Null]),
-      ),
-      suspended: Schema.optional(Schema.Union([Schema.Boolean, Schema.Null])),
-      totalActiveUsers: Schema.optional(
-        Schema.Union([Schema.Number, Schema.Null]),
-      ),
-      turnstileAction: Schema.optional(
-        Schema.Union([Schema.Literals(["log", "infinite_queue"]), Schema.Null]),
-      ),
-      turnstileMode: Schema.optional(
-        Schema.Union([
-          Schema.Literals([
-            "off",
-            "invisible",
-            "visible_non_interactive",
-            "visible_managed",
+        ),
+        queueingStatusCode: Schema.optional(
+          Schema.Union([Schema.Literals(["200", "202", "429"]), Schema.Null]),
+        ),
+        sessionDuration: Schema.optional(
+          Schema.Union([Schema.Number, Schema.Null]),
+        ),
+        suspended: Schema.optional(Schema.Union([Schema.Boolean, Schema.Null])),
+        totalActiveUsers: Schema.optional(
+          Schema.Union([Schema.Number, Schema.Null]),
+        ),
+        turnstileAction: Schema.optional(
+          Schema.Union([
+            Schema.Literals(["log", "infinite_queue"]),
+            Schema.Null,
           ]),
-          Schema.Null,
-        ]),
+        ),
+        turnstileMode: Schema.optional(
+          Schema.Union([
+            Schema.Literals([
+              "off",
+              "invisible",
+              "visible_non_interactive",
+              "visible_managed",
+            ]),
+            Schema.Null,
+          ]),
+        ),
+      }).pipe(
+        Schema.encodeKeys({
+          id: "id",
+          additionalRoutes: "additional_routes",
+          cookieAttributes: "cookie_attributes",
+          cookieSuffix: "cookie_suffix",
+          createdOn: "created_on",
+          customPageHtml: "custom_page_html",
+          defaultTemplateLanguage: "default_template_language",
+          description: "description",
+          disableSessionRenewal: "disable_session_renewal",
+          enabledOriginCommands: "enabled_origin_commands",
+          host: "host",
+          jsonResponseEnabled: "json_response_enabled",
+          modifiedOn: "modified_on",
+          name: "name",
+          newUsersPerMinute: "new_users_per_minute",
+          nextEventPrequeueStartTime: "next_event_prequeue_start_time",
+          nextEventStartTime: "next_event_start_time",
+          path: "path",
+          queueAll: "queue_all",
+          queueingMethod: "queueing_method",
+          queueingStatusCode: "queueing_status_code",
+          sessionDuration: "session_duration",
+          suspended: "suspended",
+          totalActiveUsers: "total_active_users",
+          turnstileAction: "turnstile_action",
+          turnstileMode: "turnstile_mode",
+        }),
       ),
+    ),
+    resultInfo: Schema.Struct({
+      count: Schema.optional(Schema.Union([Schema.Number, Schema.Null])),
+      page: Schema.optional(Schema.Union([Schema.Number, Schema.Null])),
+      perPage: Schema.optional(Schema.Union([Schema.Number, Schema.Null])),
+      totalCount: Schema.optional(Schema.Union([Schema.Number, Schema.Null])),
     }).pipe(
       Schema.encodeKeys({
-        id: "id",
-        additionalRoutes: "additional_routes",
-        cookieAttributes: "cookie_attributes",
-        cookieSuffix: "cookie_suffix",
-        createdOn: "created_on",
-        customPageHtml: "custom_page_html",
-        defaultTemplateLanguage: "default_template_language",
-        description: "description",
-        disableSessionRenewal: "disable_session_renewal",
-        enabledOriginCommands: "enabled_origin_commands",
-        host: "host",
-        jsonResponseEnabled: "json_response_enabled",
-        modifiedOn: "modified_on",
-        name: "name",
-        newUsersPerMinute: "new_users_per_minute",
-        nextEventPrequeueStartTime: "next_event_prequeue_start_time",
-        nextEventStartTime: "next_event_start_time",
-        path: "path",
-        queueAll: "queue_all",
-        queueingMethod: "queueing_method",
-        queueingStatusCode: "queueing_status_code",
-        sessionDuration: "session_duration",
-        suspended: "suspended",
-        totalActiveUsers: "total_active_users",
-        turnstileAction: "turnstile_action",
-        turnstileMode: "turnstile_mode",
+        count: "count",
+        page: "page",
+        perPage: "per_page",
+        totalCount: "total_count",
       }),
     ),
+  }).pipe(
+    Schema.encodeKeys({ result: "result", resultInfo: "result_info" }),
   ) as unknown as Schema.Schema<ListWaitingRoomsResponse>;
 
 export type ListWaitingRoomsError = DefaultErrors;
 
-export const listWaitingRooms: API.OperationMethod<
+export const listWaitingRooms: API.PaginatedOperationMethod<
   ListWaitingRoomsRequest,
   ListWaitingRoomsResponse,
   ListWaitingRoomsError,
   Credentials | HttpClient.HttpClient
-> = /*@__PURE__*/ /*#__PURE__*/ API.make(() => ({
+> & {
+  pages: (
+    input: ListWaitingRoomsRequest,
+  ) => stream.Stream<
+    ListWaitingRoomsResponse,
+    ListWaitingRoomsError,
+    Credentials | HttpClient.HttpClient
+  >;
+  items: (input: ListWaitingRoomsRequest) => stream.Stream<
+    {
+      id?: string | null;
+      additionalRoutes?:
+        | { host?: string | null; path?: string | null }[]
+        | null;
+      cookieAttributes?: {
+        samesite?: "auto" | "lax" | "none" | "strict" | null;
+        secure?: "auto" | "always" | "never" | null;
+      } | null;
+      cookieSuffix?: string | null;
+      createdOn?: string | null;
+      customPageHtml?: string | null;
+      defaultTemplateLanguage?:
+        | "en-US"
+        | "es-ES"
+        | "de-DE"
+        | "fr-FR"
+        | "it-IT"
+        | "ja-JP"
+        | "ko-KR"
+        | "pt-BR"
+        | "zh-CN"
+        | "zh-TW"
+        | "nl-NL"
+        | "pl-PL"
+        | "id-ID"
+        | "tr-TR"
+        | "ar-EG"
+        | "ru-RU"
+        | "fa-IR"
+        | "bg-BG"
+        | "hr-HR"
+        | "cs-CZ"
+        | "da-DK"
+        | "fi-FI"
+        | "lt-LT"
+        | "ms-MY"
+        | "nb-NO"
+        | "ro-RO"
+        | "el-GR"
+        | "he-IL"
+        | "hi-IN"
+        | "hu-HU"
+        | "sr-BA"
+        | "sk-SK"
+        | "sl-SI"
+        | "sv-SE"
+        | "tl-PH"
+        | "th-TH"
+        | "uk-UA"
+        | "vi-VN"
+        | null;
+      description?: string | null;
+      disableSessionRenewal?: boolean | null;
+      enabledOriginCommands?: "revoke"[] | null;
+      host?: string | null;
+      jsonResponseEnabled?: boolean | null;
+      modifiedOn?: string | null;
+      name?: string | null;
+      newUsersPerMinute?: number | null;
+      nextEventPrequeueStartTime?: string | null;
+      nextEventStartTime?: string | null;
+      path?: string | null;
+      queueAll?: boolean | null;
+      queueingMethod?: "fifo" | "random" | "passthrough" | "reject" | null;
+      queueingStatusCode?: "200" | "202" | "429" | null;
+      sessionDuration?: number | null;
+      suspended?: boolean | null;
+      totalActiveUsers?: number | null;
+      turnstileAction?: "log" | "infinite_queue" | null;
+      turnstileMode?:
+        | "off"
+        | "invisible"
+        | "visible_non_interactive"
+        | "visible_managed"
+        | null;
+    },
+    ListWaitingRoomsError,
+    Credentials | HttpClient.HttpClient
+  >;
+} = /*@__PURE__*/ /*#__PURE__*/ API.makePaginated(() => ({
   input: ListWaitingRoomsRequest,
   output: ListWaitingRoomsResponse,
   errors: [],
+  pagination: {
+    mode: "page",
+    inputToken: "page",
+    outputToken: "resultInfo.page",
+    items: "result",
+    pageSize: "perPage",
+  } as const,
 }));
 
 export interface CreateWaitingRoomRequest {
@@ -2735,36 +3130,40 @@ export const CreateWaitingRoomResponse =
         Schema.Null,
       ]),
     ),
-  }).pipe(
-    Schema.encodeKeys({
-      id: "id",
-      additionalRoutes: "additional_routes",
-      cookieAttributes: "cookie_attributes",
-      cookieSuffix: "cookie_suffix",
-      createdOn: "created_on",
-      customPageHtml: "custom_page_html",
-      defaultTemplateLanguage: "default_template_language",
-      description: "description",
-      disableSessionRenewal: "disable_session_renewal",
-      enabledOriginCommands: "enabled_origin_commands",
-      host: "host",
-      jsonResponseEnabled: "json_response_enabled",
-      modifiedOn: "modified_on",
-      name: "name",
-      newUsersPerMinute: "new_users_per_minute",
-      nextEventPrequeueStartTime: "next_event_prequeue_start_time",
-      nextEventStartTime: "next_event_start_time",
-      path: "path",
-      queueAll: "queue_all",
-      queueingMethod: "queueing_method",
-      queueingStatusCode: "queueing_status_code",
-      sessionDuration: "session_duration",
-      suspended: "suspended",
-      totalActiveUsers: "total_active_users",
-      turnstileAction: "turnstile_action",
-      turnstileMode: "turnstile_mode",
-    }),
-  ) as unknown as Schema.Schema<CreateWaitingRoomResponse>;
+  })
+    .pipe(
+      Schema.encodeKeys({
+        id: "id",
+        additionalRoutes: "additional_routes",
+        cookieAttributes: "cookie_attributes",
+        cookieSuffix: "cookie_suffix",
+        createdOn: "created_on",
+        customPageHtml: "custom_page_html",
+        defaultTemplateLanguage: "default_template_language",
+        description: "description",
+        disableSessionRenewal: "disable_session_renewal",
+        enabledOriginCommands: "enabled_origin_commands",
+        host: "host",
+        jsonResponseEnabled: "json_response_enabled",
+        modifiedOn: "modified_on",
+        name: "name",
+        newUsersPerMinute: "new_users_per_minute",
+        nextEventPrequeueStartTime: "next_event_prequeue_start_time",
+        nextEventStartTime: "next_event_start_time",
+        path: "path",
+        queueAll: "queue_all",
+        queueingMethod: "queueing_method",
+        queueingStatusCode: "queueing_status_code",
+        sessionDuration: "session_duration",
+        suspended: "suspended",
+        totalActiveUsers: "total_active_users",
+        turnstileAction: "turnstile_action",
+        turnstileMode: "turnstile_mode",
+      }),
+    )
+    .pipe(
+      T.ResponsePath("result"),
+    ) as unknown as Schema.Schema<CreateWaitingRoomResponse>;
 
 export type CreateWaitingRoomError = DefaultErrors;
 
@@ -3229,36 +3628,40 @@ export const UpdateWaitingRoomResponse =
         Schema.Null,
       ]),
     ),
-  }).pipe(
-    Schema.encodeKeys({
-      id: "id",
-      additionalRoutes: "additional_routes",
-      cookieAttributes: "cookie_attributes",
-      cookieSuffix: "cookie_suffix",
-      createdOn: "created_on",
-      customPageHtml: "custom_page_html",
-      defaultTemplateLanguage: "default_template_language",
-      description: "description",
-      disableSessionRenewal: "disable_session_renewal",
-      enabledOriginCommands: "enabled_origin_commands",
-      host: "host",
-      jsonResponseEnabled: "json_response_enabled",
-      modifiedOn: "modified_on",
-      name: "name",
-      newUsersPerMinute: "new_users_per_minute",
-      nextEventPrequeueStartTime: "next_event_prequeue_start_time",
-      nextEventStartTime: "next_event_start_time",
-      path: "path",
-      queueAll: "queue_all",
-      queueingMethod: "queueing_method",
-      queueingStatusCode: "queueing_status_code",
-      sessionDuration: "session_duration",
-      suspended: "suspended",
-      totalActiveUsers: "total_active_users",
-      turnstileAction: "turnstile_action",
-      turnstileMode: "turnstile_mode",
-    }),
-  ) as unknown as Schema.Schema<UpdateWaitingRoomResponse>;
+  })
+    .pipe(
+      Schema.encodeKeys({
+        id: "id",
+        additionalRoutes: "additional_routes",
+        cookieAttributes: "cookie_attributes",
+        cookieSuffix: "cookie_suffix",
+        createdOn: "created_on",
+        customPageHtml: "custom_page_html",
+        defaultTemplateLanguage: "default_template_language",
+        description: "description",
+        disableSessionRenewal: "disable_session_renewal",
+        enabledOriginCommands: "enabled_origin_commands",
+        host: "host",
+        jsonResponseEnabled: "json_response_enabled",
+        modifiedOn: "modified_on",
+        name: "name",
+        newUsersPerMinute: "new_users_per_minute",
+        nextEventPrequeueStartTime: "next_event_prequeue_start_time",
+        nextEventStartTime: "next_event_start_time",
+        path: "path",
+        queueAll: "queue_all",
+        queueingMethod: "queueing_method",
+        queueingStatusCode: "queueing_status_code",
+        sessionDuration: "session_duration",
+        suspended: "suspended",
+        totalActiveUsers: "total_active_users",
+        turnstileAction: "turnstile_action",
+        turnstileMode: "turnstile_mode",
+      }),
+    )
+    .pipe(
+      T.ResponsePath("result"),
+    ) as unknown as Schema.Schema<UpdateWaitingRoomResponse>;
 
 export type UpdateWaitingRoomError = DefaultErrors;
 
@@ -3723,36 +4126,40 @@ export const PatchWaitingRoomResponse =
         Schema.Null,
       ]),
     ),
-  }).pipe(
-    Schema.encodeKeys({
-      id: "id",
-      additionalRoutes: "additional_routes",
-      cookieAttributes: "cookie_attributes",
-      cookieSuffix: "cookie_suffix",
-      createdOn: "created_on",
-      customPageHtml: "custom_page_html",
-      defaultTemplateLanguage: "default_template_language",
-      description: "description",
-      disableSessionRenewal: "disable_session_renewal",
-      enabledOriginCommands: "enabled_origin_commands",
-      host: "host",
-      jsonResponseEnabled: "json_response_enabled",
-      modifiedOn: "modified_on",
-      name: "name",
-      newUsersPerMinute: "new_users_per_minute",
-      nextEventPrequeueStartTime: "next_event_prequeue_start_time",
-      nextEventStartTime: "next_event_start_time",
-      path: "path",
-      queueAll: "queue_all",
-      queueingMethod: "queueing_method",
-      queueingStatusCode: "queueing_status_code",
-      sessionDuration: "session_duration",
-      suspended: "suspended",
-      totalActiveUsers: "total_active_users",
-      turnstileAction: "turnstile_action",
-      turnstileMode: "turnstile_mode",
-    }),
-  ) as unknown as Schema.Schema<PatchWaitingRoomResponse>;
+  })
+    .pipe(
+      Schema.encodeKeys({
+        id: "id",
+        additionalRoutes: "additional_routes",
+        cookieAttributes: "cookie_attributes",
+        cookieSuffix: "cookie_suffix",
+        createdOn: "created_on",
+        customPageHtml: "custom_page_html",
+        defaultTemplateLanguage: "default_template_language",
+        description: "description",
+        disableSessionRenewal: "disable_session_renewal",
+        enabledOriginCommands: "enabled_origin_commands",
+        host: "host",
+        jsonResponseEnabled: "json_response_enabled",
+        modifiedOn: "modified_on",
+        name: "name",
+        newUsersPerMinute: "new_users_per_minute",
+        nextEventPrequeueStartTime: "next_event_prequeue_start_time",
+        nextEventStartTime: "next_event_start_time",
+        path: "path",
+        queueAll: "queue_all",
+        queueingMethod: "queueing_method",
+        queueingStatusCode: "queueing_status_code",
+        sessionDuration: "session_duration",
+        suspended: "suspended",
+        totalActiveUsers: "total_active_users",
+        turnstileAction: "turnstile_action",
+        turnstileMode: "turnstile_mode",
+      }),
+    )
+    .pipe(
+      T.ResponsePath("result"),
+    ) as unknown as Schema.Schema<PatchWaitingRoomResponse>;
 
 export type PatchWaitingRoomError = DefaultErrors;
 
@@ -3791,7 +4198,9 @@ export interface DeleteWaitingRoomResponse {
 export const DeleteWaitingRoomResponse =
   /*@__PURE__*/ /*#__PURE__*/ Schema.Struct({
     id: Schema.optional(Schema.Union([Schema.String, Schema.Null])),
-  }) as unknown as Schema.Schema<DeleteWaitingRoomResponse>;
+  }).pipe(
+    T.ResponsePath("result"),
+  ) as unknown as Schema.Schema<DeleteWaitingRoomResponse>;
 
 export type DeleteWaitingRoomError = DefaultErrors;