@gpt-platform/client 0.1.4 → 0.2.0

package/dist/index.js

@@ -1284,9 +1284,11 @@ function buildUserAgent(sdkVersion, appInfo) {
   return ua;
 }
 
+// src/version.ts
+var SDK_VERSION = "0.2.0";
+var DEFAULT_API_VERSION = "2026-02-25";
+
 // src/base-client.ts
-var DEFAULT_API_VERSION = "2025-12-03";
-var SDK_VERSION = "0.1.4";
 function generateUUID() {
   if (typeof crypto !== "undefined" && typeof crypto.randomUUID === "function") {
     return crypto.randomUUID();
@@ -1392,7 +1394,9 @@ var BaseClient = class {
         "Accept",
         `application/vnd.api+json; version=${this.apiVersion}`
       );
-      req.headers.set("Content-Type", "application/vnd.api+json");
+      if (!req.headers.get("Content-Type")?.startsWith("multipart/")) {
+        req.headers.set("Content-Type", "application/vnd.api+json");
+      }
       if (typeof process !== "undefined") {
         req.headers.set("User-Agent", userAgent);
       }
@@ -1598,6 +1602,11 @@ var postThreads = (options) => (options.client ?? client).post({
     ...options.headers
   }
 });
+var getVoiceSessionsWorkspaceByWorkspaceId = (options) => (options.client ?? client).get({
+  security: [{ scheme: "bearer", type: "http" }],
+  url: "/voice/sessions/workspace/{workspace_id}",
+  ...options
+});
 var patchExtractionDocumentsByIdCancel = (options) => (options.client ?? client).patch({
   security: [{ scheme: "bearer", type: "http" }],
   url: "/extraction/documents/{id}/cancel",
@@ -1617,6 +1626,11 @@ var getAgentVersionsById = (options) => (options.client ?? client).get({
   url: "/agent-versions/{id}",
   ...options
 });
+var getWatcherEventsById = (options) => (options.client ?? client).get({
+  security: [{ scheme: "bearer", type: "http" }],
+  url: "/watcher/events/{id}",
+  ...options
+});
 var patchApiKeysByIdRevoke = (options) => (options.client ?? client).patch({
   security: [{ scheme: "bearer", type: "http" }],
   url: "/api-keys/{id}/revoke",
@@ -1682,11 +1696,30 @@ var patchExtractionDocumentsByIdDismiss = (options) => (options.client ?? client
     ...options.headers
   }
 });
+var postUsersAuthResetPasswordRequest = (options) => (options.client ?? client).post({
+  security: [{ scheme: "bearer", type: "http" }],
+  url: "/users/auth/reset-password/request",
+  ...options,
+  headers: {
+    "Content-Type": "application/vnd.api+json",
+    ...options.headers
+  }
+});
 var getSearchIndexes = (options) => (options.client ?? client).get({
   security: [{ scheme: "bearer", type: "http" }],
   url: "/search/indexes",
   ...options
 });
+var deleteTrainingSessionsById = (options) => (options.client ?? client).delete({
+  security: [{ scheme: "bearer", type: "http" }],
+  url: "/training-sessions/{id}",
+  ...options
+});
+var getTrainingSessionsById = (options) => (options.client ?? client).get({
+  security: [{ scheme: "bearer", type: "http" }],
+  url: "/training-sessions/{id}",
+  ...options
+});
 var postAgentsByIdAnalyzeTraining = (options) => (options.client ?? client).post({
   security: [{ scheme: "bearer", type: "http" }],
   url: "/agents/{id}/analyze-training",
@@ -1701,9 +1734,9 @@ var postWebhookConfigsByIdTest = (options) => (options.client ?? client).post({
     ...options.headers
   }
 });
-var postStorageSignDownload = (options) => (options.client ?? client).post({
+var patchUsersAuthPasswordChange = (options) => (options.client ?? client).patch({
   security: [{ scheme: "bearer", type: "http" }],
-  url: "/storage/sign-download",
+  url: "/users/auth/password/change",
   ...options,
   headers: {
     "Content-Type": "application/vnd.api+json",
@@ -1793,6 +1826,20 @@ var postAgentsByIdPublishVersion = (options) => (options.client ?? client).post(
     ...options.headers
   }
 });
+var getVoiceSessionsMine = (options) => (options.client ?? client).get({
+  security: [{ scheme: "bearer", type: "http" }],
+  url: "/voice/sessions/mine",
+  ...options
+});
+var postUsersAuthMagicLinkLogin = (options) => (options.client ?? client).post({
+  security: [{ scheme: "bearer", type: "http" }],
+  url: "/users/auth/magic-link/login",
+  ...options,
+  headers: {
+    "Content-Type": "application/vnd.api+json",
+    ...options.headers
+  }
+});
 var deleteApiKeysById = (options) => (options.client ?? client).delete({
   security: [{ scheme: "bearer", type: "http" }],
   url: "/api-keys/{id}",
@@ -1812,6 +1859,15 @@ var patchApiKeysById = (options) => (options.client ?? client).patch({
     ...options.headers
   }
 });
+var patchUsersAuthResetPassword = (options) => (options.client ?? client).patch({
+  security: [{ scheme: "bearer", type: "http" }],
+  url: "/users/auth/reset-password",
+  ...options,
+  headers: {
+    "Content-Type": "application/vnd.api+json",
+    ...options.headers
+  }
+});
 var getSchedulingCalendarSyncsById = (options) => (options.client ?? client).get({
   security: [{ scheme: "bearer", type: "http" }],
   url: "/scheduling/calendar-syncs/{id}",
@@ -2043,6 +2099,15 @@ var getWebhookDeliveriesById = (options) => (options.client ?? client).get({
   url: "/webhook-deliveries/{id}",
   ...options
 });
+var patchVoiceSessionsByIdStop = (options) => (options.client ?? client).patch({
+  security: [{ scheme: "bearer", type: "http" }],
+  url: "/voice/sessions/{id}/stop",
+  ...options,
+  headers: {
+    "Content-Type": "application/vnd.api+json",
+    ...options.headers
+  }
+});
 var getSchedulingParticipants = (options) => (options.client ?? client).get({
   security: [{ scheme: "bearer", type: "http" }],
   url: "/scheduling/participants",
@@ -2071,11 +2136,35 @@ var patchExtractionDocumentsByIdFinishUpload = (options) => (options.client ?? c
     ...options.headers
   }
 });
+var getTrainingSessionsAgentsByAgentIdSessions = (options) => (options.client ?? client).get({
+  security: [{ scheme: "bearer", type: "http" }],
+  url: "/training-sessions/agents/{agent_id}/sessions",
+  ...options
+});
 var getSearch = (options) => (options.client ?? client).get({
   security: [{ scheme: "bearer", type: "http" }],
   url: "/search",
   ...options
 });
+var getVoiceSessionsById = (options) => (options.client ?? client).get({
+  security: [{ scheme: "bearer", type: "http" }],
+  url: "/voice/sessions/{id}",
+  ...options
+});
+var getVoiceSessions = (options) => (options.client ?? client).get({
+  security: [{ scheme: "bearer", type: "http" }],
+  url: "/voice/sessions",
+  ...options
+});
+var postVoiceSessions = (options) => (options.client ?? client).post({
+  security: [{ scheme: "bearer", type: "http" }],
+  url: "/voice/sessions",
+  ...options,
+  headers: {
+    "Content-Type": "application/vnd.api+json",
+    ...options.headers
+  }
+});
 var postInvitations = (options) => (options.client ?? client).post({
   security: [{ scheme: "bearer", type: "http" }],
   url: "/invitations",
@@ -2183,6 +2272,20 @@ var patchNotificationPreferencesById = (options) => (options.client ?? client).p
     ...options.headers
   }
 });
+var getWatcherClaims = (options) => (options.client ?? client).get({
+  security: [{ scheme: "bearer", type: "http" }],
+  url: "/watcher/claims",
+  ...options
+});
+var postWatcherClaims = (options) => (options.client ?? client).post({
+  security: [{ scheme: "bearer", type: "http" }],
+  url: "/watcher/claims",
+  ...options,
+  headers: {
+    "Content-Type": "application/vnd.api+json",
+    ...options.headers
+  }
+});
 var patchSchedulingBookingsSchedulingBookingsByIdReschedule = (options) => (options.client ?? client).patch({
   security: [{ scheme: "bearer", type: "http" }],
   url: "/scheduling/bookings/scheduling/bookings/{id}/reschedule",
@@ -2192,6 +2295,15 @@ var patchSchedulingBookingsSchedulingBookingsByIdReschedule = (options) => (opti
     ...options.headers
   }
 });
+var patchVoiceSessionsByIdFinalize = (options) => (options.client ?? client).patch({
+  security: [{ scheme: "bearer", type: "http" }],
+  url: "/voice/sessions/{id}/finalize",
+  ...options,
+  headers: {
+    "Content-Type": "application/vnd.api+json",
+    ...options.headers
+  }
+});
 var postThreadsByIdExport = (options) => (options.client ?? client).post({
   security: [{ scheme: "bearer", type: "http" }],
   url: "/threads/{id}/export",
@@ -2479,15 +2591,6 @@ var patchThreadsByIdUnarchive = (options) => (options.client ?? client).patch({
     ...options.headers
   }
 });
-var postStorageSignUpload = (options) => (options.client ?? client).post({
-  security: [{ scheme: "bearer", type: "http" }],
-  url: "/storage/sign-upload",
-  ...options,
-  headers: {
-    "Content-Type": "application/vnd.api+json",
-    ...options.headers
-  }
-});
 var getAiConversations = (options) => (options.client ?? client).get({
   security: [{ scheme: "bearer", type: "http" }],
   url: "/ai/conversations",
@@ -2594,6 +2697,20 @@ var postWebhookDeliveriesBulkRetry = (options) => (options.client ?? client).pos
     ...options.headers
   }
 });
+var getWatcherClaimsById = (options) => (options.client ?? client).get({
+  security: [{ scheme: "bearer", type: "http" }],
+  url: "/watcher/claims/{id}",
+  ...options
+});
+var patchWatcherClaimsById = (options) => (options.client ?? client).patch({
+  security: [{ scheme: "bearer", type: "http" }],
+  url: "/watcher/claims/{id}",
+  ...options,
+  headers: {
+    "Content-Type": "application/vnd.api+json",
+    ...options.headers
+  }
+});
 var postUsersAuthLogin = (options) => (options.client ?? client).post({
   security: [{ scheme: "bearer", type: "http" }],
   url: "/users/auth/login",
@@ -2663,6 +2780,15 @@ var patchExtractionResultsByIdRegenerate = (options) => (options.client ?? clien
     ...options.headers
   }
 });
+var postUsersAuthConfirm = (options) => (options.client ?? client).post({
+  security: [{ scheme: "bearer", type: "http" }],
+  url: "/users/auth/confirm",
+  ...options,
+  headers: {
+    "Content-Type": "application/vnd.api+json",
+    ...options.headers
+  }
+});
 var getSchedulingEventsById = (options) => (options.client ?? client).get({
   security: [{ scheme: "bearer", type: "http" }],
   url: "/scheduling/events/{id}",
@@ -2677,6 +2803,20 @@ var patchSchedulingEventsById = (options) => (options.client ?? client).patch({
     ...options.headers
   }
 });
+var getWorkspaceMemberships = (options) => (options.client ?? client).get({
+  security: [{ scheme: "bearer", type: "http" }],
+  url: "/workspace-memberships",
+  ...options
+});
+var postWorkspaceMemberships = (options) => (options.client ?? client).post({
+  security: [{ scheme: "bearer", type: "http" }],
+  url: "/workspace-memberships",
+  ...options,
+  headers: {
+    "Content-Type": "application/vnd.api+json",
+    ...options.headers
+  }
+});
 var getTenantsByTenantIdDocumentStats = (options) => (options.client ?? client).get({
   security: [{ scheme: "bearer", type: "http" }],
   url: "/tenants/{tenant_id}/document_stats",
@@ -2767,6 +2907,15 @@ var patchApplicationsByIdAllocateCredits = (options) => (options.client ?? clien
     ...options.headers
   }
 });
+var postUsersAuthMagicLinkRequest = (options) => (options.client ?? client).post({
+  security: [{ scheme: "bearer", type: "http" }],
+  url: "/users/auth/magic-link/request",
+  ...options,
+  headers: {
+    "Content-Type": "application/vnd.api+json",
+    ...options.headers
+  }
+});
 var getExtractionResultsWorkspaceByWorkspaceId = (options) => (options.client ?? client).get({
   security: [{ scheme: "bearer", type: "http" }],
   url: "/extraction/results/workspace/{workspace_id}",
@@ -2870,6 +3019,20 @@ var postAiMessages = (options) => (options.client ?? client).post({
     ...options.headers
   }
 });
+var getWatcherEvents = (options) => (options.client ?? client).get({
+  security: [{ scheme: "bearer", type: "http" }],
+  url: "/watcher/events",
+  ...options
+});
+var postWatcherEvents = (options) => (options.client ?? client).post({
+  security: [{ scheme: "bearer", type: "http" }],
+  url: "/watcher/events",
+  ...options,
+  headers: {
+    "Content-Type": "application/vnd.api+json",
+    ...options.headers
+  }
+});
 var postAgentVersionsByIdSetSystemFields = (options) => (options.client ?? client).post({
   security: [{ scheme: "bearer", type: "http" }],
   url: "/agent-versions/{id}/set-system-fields",
@@ -2997,6 +3160,29 @@ var postWorkspacesByWorkspaceIdExtractionExports = (options) => (options.client
     ...options.headers
   }
 });
+var deleteWorkspaceMembershipsByWorkspaceIdByUserId = (options) => (options.client ?? client).delete({
+  security: [{ scheme: "bearer", type: "http" }],
+  url: "/workspace-memberships/{workspace_id}/{user_id}",
+  ...options
+});
+var patchWorkspaceMembershipsByWorkspaceIdByUserId = (options) => (options.client ?? client).patch({
+  security: [{ scheme: "bearer", type: "http" }],
+  url: "/workspace-memberships/{workspace_id}/{user_id}",
+  ...options,
+  headers: {
+    "Content-Type": "application/vnd.api+json",
+    ...options.headers
+  }
+});
+var postTrainingExamplesBulkDelete = (options) => (options.client ?? client).post({
+  security: [{ scheme: "bearer", type: "http" }],
+  url: "/training-examples/bulk-delete",
+  ...options,
+  headers: {
+    "Content-Type": "application/vnd.api+json",
+    ...options.headers
+  }
+});
 var getCreditPackages = (options) => (options.client ?? client).get({
   security: [{ scheme: "bearer", type: "http" }],
   url: "/credit-packages",
@@ -3007,11 +3193,6 @@ var getUsers = (options) => (options.client ?? client).get({
   url: "/users",
   ...options
 });
-var getObjects = (options) => (options.client ?? client).get({
-  security: [{ scheme: "bearer", type: "http" }],
-  url: "/objects",
-  ...options
-});
 
 // src/pagination.ts
 var DEFAULT_MAX_PAGES = 500;
@@ -3957,6 +4138,35 @@ function createExtractionNamespace(rb) {
           },
           options
         );
+      },
+      /**
+       * Query rows in an ExtractionResult server-side.
+       *
+       * Applies AttributeFilter predicates against the `rows` JSONB array
+       * using a PostgreSQL lateral join. Suitable for datasets with 10K+ rows.
+       * Empty `filters` array returns all rows (paginated by `limit`/`offset`).
+       *
+       * @example
+       * const result = await client.extraction.results.query(resultId, {
+       *   filters: [
+       *     { field: 'wellness_score', op: 'gt', value: 75 },
+       *     { field: 'enrolled', op: 'eq', value: 'true' },
+       *   ],
+       *   limit: 100,
+       *   offset: 0,
+       * });
+       * console.log(`${result.filtered} of ${result.total} rows match`);
+       */
+      query: async (resultId, params, options) => {
+        return rb.rawPost(
+          `/extraction/results/${resultId}/query`,
+          {
+            filters: params.filters,
+            limit: params.limit,
+            offset: params.offset
+          },
+          options
+        );
       }
     },
     batches: {
@@ -4108,6 +4318,35 @@ var ApiKeyAllocateSchema = import_zod2.z.object({
   amount: import_zod2.z.number().positive(),
   description: import_zod2.z.string().min(1)
 });
+var MagicLinkRequestSchema = import_zod2.z.object({
+  email: import_zod2.z.string().email()
+});
+var RequestPasswordResetSchema = import_zod2.z.object({
+  email: import_zod2.z.string().email()
+});
+var MagicLinkLoginSchema = import_zod2.z.object({
+  token: import_zod2.z.string().min(1)
+});
+var ConfirmEmailSchema = import_zod2.z.object({
+  email: import_zod2.z.string().email(),
+  confirmation_token: import_zod2.z.string().min(1)
+});
+var ResetPasswordWithTokenSchema = import_zod2.z.object({
+  token: import_zod2.z.string().min(1),
+  password: import_zod2.z.string().min(8),
+  password_confirmation: import_zod2.z.string().min(8)
+}).refine((data) => data.password === data.password_confirmation, {
+  message: "Passwords do not match",
+  path: ["password_confirmation"]
+});
+var ChangePasswordSchema = import_zod2.z.object({
+  current_password: import_zod2.z.string().min(1),
+  password: import_zod2.z.string().min(8),
+  password_confirmation: import_zod2.z.string().min(8)
+}).refine((data) => data.password === data.password_confirmation, {
+  message: "Passwords do not match",
+  path: ["password_confirmation"]
+});
 function createIdentityNamespace(rb) {
   return {
     /** Login with email and password — returns a token object */
@@ -4187,6 +4426,117 @@ function createIdentityNamespace(rb) {
     resendConfirmation: async (options) => {
       return rb.execute(postUsersAuthResendConfirmation, {}, options);
     },
+    /** Confirm an email address using the token from the confirmation email */
+    confirmEmail: async (email, confirmationToken, options) => {
+      ConfirmEmailSchema.parse({
+        email,
+        confirmation_token: confirmationToken
+      });
+      return rb.execute(
+        postUsersAuthConfirm,
+        {
+          body: {
+            data: {
+              type: "user",
+              attributes: { email, confirmation_token: confirmationToken }
+            }
+          }
+        },
+        options
+      );
+    },
+    /** Request a magic link sign-in email */
+    requestMagicLink: async (email, options) => {
+      MagicLinkRequestSchema.parse({ email });
+      return rb.execute(
+        postUsersAuthMagicLinkRequest,
+        {
+          body: {
+            data: { type: "user", attributes: { email } }
+          }
+        },
+        options
+      );
+    },
+    /**
+     * Request a password reset email — always returns success to prevent email enumeration.
+     * The user will receive an email with a reset token if the account exists.
+     */
+    requestPasswordReset: async (email, options) => {
+      RequestPasswordResetSchema.parse({ email });
+      return rb.execute(
+        postUsersAuthResetPasswordRequest,
+        {
+          body: {
+            data: { type: "user", attributes: { email } }
+          }
+        },
+        options
+      );
+    },
+    /** Sign in using a token from a magic link email */
+    signInWithMagicLink: async (token, options) => {
+      MagicLinkLoginSchema.parse({ token });
+      return rb.execute(
+        postUsersAuthMagicLinkLogin,
+        {
+          body: {
+            data: { type: "user", attributes: { token } }
+          }
+        },
+        options
+      );
+    },
+    /** Reset a password using the token from a password reset email */
+    resetPasswordWithToken: async (token, password, passwordConfirmation, options) => {
+      ResetPasswordWithTokenSchema.parse({
+        token,
+        password,
+        password_confirmation: passwordConfirmation
+      });
+      return rb.execute(
+        patchUsersAuthResetPassword,
+        {
+          body: {
+            data: {
+              id: "",
+              type: "user",
+              attributes: {
+                token,
+                password,
+                password_confirmation: passwordConfirmation
+              }
+            }
+          }
+        },
+        options
+      );
+    },
+    /** Change password for the currently authenticated user */
+    changePassword: async (currentPassword, password, passwordConfirmation, options) => {
+      ChangePasswordSchema.parse({
+        current_password: currentPassword,
+        password,
+        password_confirmation: passwordConfirmation
+      });
+      return rb.execute(
+        patchUsersAuthPasswordChange,
+        {
+          body: {
+            data: {
+              id: "",
+              type: "user",
+              attributes: {
+                current_password: currentPassword,
+                password,
+                password_confirmation: passwordConfirmation
+              }
+            }
+          }
+        },
+        options
+      );
+    },
     delete: async (id, options) => {
       return rb.executeDelete(deleteUsersById, { path: { id } }, options);
     },
@@ -4579,12 +4929,440 @@ function createPlatformNamespace(rb) {
           options
         );
       }
-    }
-  };
-}
-
-// src/namespaces/search.ts
-function createSearchNamespace(rb) {
+    },
+    workspaceMembers: {
+      /** List members of a workspace */
+      list: async (workspaceId, options) => {
+        return rb.execute(
+          getWorkspaceMemberships,
+          {
+            query: {
+              filter: { workspace_id: workspaceId },
+              ...buildPageQuery(options?.page, options?.pageSize)?.query
+            }
+          },
+          options
+        );
+      },
+      /** Get a specific workspace member by workspace and user ID */
+      get: async (workspaceId, memberId, options) => {
+        return rb.rawGet(
+          `/workspace-memberships/${workspaceId}/${memberId}`,
+          options
+        );
+      },
+      /** Add a user to a workspace */
+      create: async (workspaceId, attrs, options) => {
+        return rb.execute(
+          postWorkspaceMemberships,
+          {
+            body: {
+              data: {
+                type: "workspace-membership",
+                attributes: { workspace_id: workspaceId, ...attrs }
+              }
+            }
+          },
+          options
+        );
+      },
+      /** Update workspace member permissions or role */
+      update: async (workspaceId, memberId, attrs, options) => {
+        return rb.execute(
+          patchWorkspaceMembershipsByWorkspaceIdByUserId,
+          {
+            path: { workspace_id: workspaceId, user_id: memberId },
+            body: {
+              data: {
+                id: memberId,
+                type: "workspace-membership",
+                attributes: attrs
+              }
+            }
+          },
+          options
+        );
+      },
+      /** Update workspace member profile attributes (G9) */
+      updateProfile: async (workspaceId, memberId, profileAttrs, options) => {
+        return rb.rawPost(
+          `/workspace-memberships/${workspaceId}/${memberId}/profile`,
+          { data: { attributes: { profile_attributes: profileAttrs } } },
+          options
+        );
+      },
+      /** Remove a user from a workspace */
+      remove: async (workspaceId, memberId, options) => {
+        return rb.executeDelete(
+          deleteWorkspaceMembershipsByWorkspaceIdByUserId,
+          { path: { workspace_id: workspaceId, user_id: memberId } },
+          options
+        );
+      }
+    }
+  };
+}
+
+// src/namespaces/scheduling.ts
+function createSchedulingNamespace(rb) {
+  return {
+    /**
+     * Event Types — templates for bookable events
+     */
+    eventTypes: {
+      /** List event types with optional pagination */
+      list: async (options) => {
+        return rb.execute(
+          getSchedulingEventTypes,
+          buildPageQuery(options?.page, options?.pageSize),
+          options
+        );
+      },
+      /** List all event types with automatic pagination */
+      listAll: async (options) => {
+        return paginateToArray(
+          rb.createPaginatedFetcher(
+            getSchedulingEventTypes,
+            (page, pageSize) => ({
+              query: { page: { number: page, size: pageSize } }
+            }),
+            options
+          )
+        );
+      },
+      /** Get an event type by ID */
+      get: async (id, options) => {
+        return rb.execute(
+          getSchedulingEventTypesById,
+          { path: { id } },
+          options
+        );
+      },
+      /**
+       * Create a new event type.
+       * @example
+       * ```typescript
+       * const client = new GptClient({ apiKey: 'sk_tenant_...' });
+       * const eventType = await client.scheduling.eventTypes.create({
+       *   name: '30-Minute Consultation',
+       *   slug: '30min-consult',
+       *   duration_minutes: 30,
+       *   location_type: 'video',
+       * });
+       * ```
+       */
+      create: async (attributes, options) => {
+        return rb.execute(
+          postSchedulingEventTypes,
+          {
+            body: { data: { type: "scheduling_event_type", attributes } }
+          },
+          options
+        );
+      },
+      /** Update an event type */
+      update: async (id, attributes, options) => {
+        return rb.execute(
+          patchSchedulingEventTypesById,
+          {
+            path: { id },
+            body: { data: { id, type: "scheduling_event_type", attributes } }
+          },
+          options
+        );
+      }
+    },
+    /**
+     * Events — scheduled occurrences
+     */
+    events: {
+      /** List events with optional pagination */
+      list: async (options) => {
+        return rb.execute(
+          getSchedulingEvents,
+          buildPageQuery(options?.page, options?.pageSize),
+          options
+        );
+      },
+      /** List all events with automatic pagination */
+      listAll: async (options) => {
+        return paginateToArray(
+          rb.createPaginatedFetcher(
+            getSchedulingEvents,
+            (page, pageSize) => ({
+              query: { page: { number: page, size: pageSize } }
+            }),
+            options
+          )
+        );
+      },
+      /** Get an event by ID */
+      get: async (id, options) => {
+        return rb.execute(
+          getSchedulingEventsById,
+          { path: { id } },
+          options
+        );
+      },
+      /**
+       * Create an internal event directly.
+       * Use for meetings between known users in the workspace.
+       */
+      create: async (attributes, options) => {
+        return rb.execute(
+          postSchedulingEvents,
+          {
+            body: { data: { type: "scheduling_event", attributes } }
+          },
+          options
+        );
+      },
+      /** Update an event */
+      update: async (id, attributes, options) => {
+        return rb.execute(
+          patchSchedulingEventsById,
+          {
+            path: { id },
+            body: { data: { id, type: "scheduling_event", attributes } }
+          },
+          options
+        );
+      }
+    },
+    /**
+     * Participants — people attending events
+     */
+    participants: {
+      /** List participants with optional pagination */
+      list: async (options) => {
+        return rb.execute(
+          getSchedulingParticipants,
+          buildPageQuery(options?.page, options?.pageSize),
+          options
+        );
+      },
+      /** List all participants with automatic pagination */
+      listAll: async (options) => {
+        return paginateToArray(
+          rb.createPaginatedFetcher(
+            getSchedulingParticipants,
+            (page, pageSize) => ({
+              query: { page: { number: page, size: pageSize } }
+            }),
+            options
+          )
+        );
+      },
+      /** Get a participant by ID */
+      get: async (id, options) => {
+        return rb.execute(
+          getSchedulingParticipantsById,
+          { path: { id } },
+          options
+        );
+      },
+      /** Add a participant to an event */
+      create: async (attributes, options) => {
+        return rb.execute(
+          postSchedulingParticipants,
+          {
+            body: { data: { type: "scheduling_participant", attributes } }
+          },
+          options
+        );
+      },
+      /** Update a participant (e.g., confirm attendance, respond to invite) */
+      update: async (id, attributes, options) => {
+        return rb.execute(
+          patchSchedulingParticipantsById,
+          {
+            path: { id },
+            body: { data: { id, type: "scheduling_participant", attributes } }
+          },
+          options
+        );
+      }
+    },
+    /**
+     * Bookings — external party requests for appointments
+     */
+    bookings: {
+      /** List bookings with optional pagination */
+      list: async (options) => {
+        return rb.execute(
+          getSchedulingBookings,
+          buildPageQuery(options?.page, options?.pageSize),
+          options
+        );
+      },
+      /** List all bookings with automatic pagination */
+      listAll: async (options) => {
+        return paginateToArray(
+          rb.createPaginatedFetcher(
+            getSchedulingBookings,
+            (page, pageSize) => ({
+              query: { page: { number: page, size: pageSize } }
+            }),
+            options
+          )
+        );
+      },
+      /** Get a booking by ID */
+      get: async (id, options) => {
+        return rb.execute(
+          getSchedulingBookingsById,
+          { path: { id } },
+          options
+        );
+      },
+      /**
+       * Create a booking request.
+       * Use when someone outside the platform requests an appointment.
+       * @example
+       * ```typescript
+       * const booking = await client.scheduling.bookings.create({
+       *   event_type_id: 'event_123',
+       *   start_time: '2025-03-01T10:00:00Z',
+       *   booker_name: 'John Doe',
+       *   booker_email: 'john@example.com',
+       * });
+       * ```
+       */
+      create: async (attributes, options) => {
+        return rb.execute(
+          postSchedulingBookings,
+          {
+            body: { data: { type: "scheduling_booking", attributes } }
+          },
+          options
+        );
+      },
+      /**
+       * Confirm a pending booking.
+       * For EventTypes with requires_approval=true.
+       */
+      confirm: async (id, options) => {
+        return rb.execute(
+          patchSchedulingBookingsSchedulingBookingsByIdConfirm,
+          { path: { id }, body: {} },
+          options
+        );
+      },
+      /**
+       * Cancel or reject a booking.
+       */
+      cancel: async (id, attributes, options) => {
+        return rb.execute(
+          patchSchedulingBookingsSchedulingBookingsByIdCancel,
+          {
+            path: { id },
+            body: attributes ? { data: { type: "scheduling_booking", attributes } } : {}
+          },
+          options
+        );
+      },
+      /**
+       * Reschedule a booking to a new time.
+       */
+      reschedule: async (id, attributes, options) => {
+        return rb.execute(
+          patchSchedulingBookingsSchedulingBookingsByIdReschedule,
+          {
+            path: { id },
+            body: { data: { type: "scheduling_booking", attributes } }
+          },
+          options
+        );
+      }
+    },
+    /**
+     * Calendar Syncs — external calendar integrations
+     */
+    calendarSyncs: {
+      /** List calendar syncs with optional pagination */
+      list: async (options) => {
+        return rb.execute(
+          getSchedulingCalendarSyncs,
+          buildPageQuery(options?.page, options?.pageSize),
+          options
+        );
+      },
+      /** List all calendar syncs with automatic pagination */
+      listAll: async (options) => {
+        return paginateToArray(
+          rb.createPaginatedFetcher(
+            getSchedulingCalendarSyncs,
+            (page, pageSize) => ({
+              query: { page: { number: page, size: pageSize } }
+            }),
+            options
+          )
+        );
+      },
+      /** Get a calendar sync by ID */
+      get: async (id, options) => {
+        return rb.execute(
+          getSchedulingCalendarSyncsById,
+          { path: { id } },
+          options
+        );
+      },
+      /**
+       * Create a calendar sync.
+       * For bi-directional sync with external calendars (Google, Outlook).
+       */
+      create: async (attributes, options) => {
+        return rb.execute(
+          postSchedulingCalendarSyncs,
+          {
+            body: { data: { type: "scheduling_calendar_sync", attributes } }
+          },
+          options
+        );
+      },
+      /** Update a calendar sync */
+      update: async (id, attributes, options) => {
+        return rb.execute(
+          patchSchedulingCalendarSyncsSchedulingCalendarSyncsById,
+          {
+            path: { id },
+            body: {
+              data: { id, type: "scheduling_calendar_sync", attributes }
+            }
+          },
+          options
+        );
+      },
+      /** Delete a calendar sync */
+      delete: async (id, options) => {
+        return rb.executeDelete(
+          deleteSchedulingCalendarSyncsSchedulingCalendarSyncsById,
+          { path: { id } },
+          options
+        );
+      },
+      /** Pause a calendar sync (stops pushing/pulling) */
+      pause: async (id, options) => {
+        return rb.execute(
+          patchSchedulingCalendarSyncsSchedulingCalendarSyncsByIdPause,
+          { path: { id }, body: {} },
+          options
+        );
+      },
+      /** Resume a paused calendar sync */
+      resume: async (id, options) => {
+        return rb.execute(
+          patchSchedulingCalendarSyncsSchedulingCalendarSyncsByIdResume,
+          { path: { id }, body: {} },
+          options
+        );
+      }
+    }
+  };
+}
+
+// src/namespaces/search.ts
+function createSearchNamespace(rb) {
   return {
     /** Full-text search query */
     query: async (query, options) => {
@@ -4649,29 +5427,15 @@ function createStorageNamespace(rb) {
     /** Generate a presigned upload URL for direct-to-storage uploads */
     signUpload: async (attributes, options) => {
       return rb.execute(
-        postStorageSignUpload,
-        {
-          body: { data: { type: "signed_url", attributes: attributes ?? {} } }
-        },
-        options
-      );
-    },
-    /** Generate a presigned download URL for accessing stored objects */
-    signDownload: async (attributes, options) => {
-      return rb.execute(
-        postStorageSignDownload,
+        postDocumentsPresignedUpload,
         {
-          body: { data: { type: "signed_url", attributes: attributes ?? {} } }
+          body: {
+            data: { type: "presigned_upload", attributes: attributes ?? {} }
+          }
         },
         options
       );
     },
-    objects: {
-      /** List storage objects */
-      list: async (options) => {
-        return rb.execute(getObjects, {}, options);
-      }
-    },
     buckets: {
       list: async (options) => {
         return rb.execute(
@@ -4833,20 +5597,20 @@ function createThreadsNamespace(rb) {
   };
 }
 
-// src/namespaces/webhooks-ns.ts
-function createWebhooksNamespace(rb) {
+// src/namespaces/training.ts
+function createTrainingNamespace(rb) {
   return {
-    configs: {
+    examples: {
       delete: async (id, options) => {
         return rb.executeDelete(
-          deleteWebhookConfigsById,
+          deleteTrainingExamplesById,
           { path: { id } },
           options
         );
       },
       list: async (options) => {
         return rb.execute(
-          getWebhookConfigs,
+          getTrainingExamples,
           buildPageQuery(options?.page, options?.pageSize),
           options
         );
@@ -4854,7 +5618,7 @@ function createWebhooksNamespace(rb) {
       listAll: async (options) => {
         return paginateToArray(
           rb.createPaginatedFetcher(
-            getWebhookConfigs,
+            getTrainingExamples,
             (page, pageSize) => ({
               query: { page: { number: page, size: pageSize } }
             }),
@@ -4862,112 +5626,257 @@ function createWebhooksNamespace(rb) {
           )
         );
       },
+      get: async (id, options) => {
+        return rb.execute(
+          getTrainingExamplesById,
+          { path: { id } },
+          options
+        );
+      },
       create: async (attributes, options) => {
         return rb.execute(
-          postWebhookConfigs,
-          { body: { data: { type: "webhook_config", attributes } } },
+          postTrainingExamplesBulkDelete,
+          { body: { data: { type: "training_example", attributes } } },
           options
         );
       },
       update: async (id, attributes, options) => {
         return rb.execute(
-          patchWebhookConfigsById,
+          patchTrainingExamplesById,
           {
             path: { id },
-            body: { data: { id, type: "webhook_config", attributes } }
+            body: { data: { id, type: "training_example", attributes } }
           },
           options
         );
       },
-      test: async (id, options) => {
+      bulkCreate: async (options) => {
         return rb.execute(
-          postWebhookConfigsByIdTest,
-          { path: { id }, body: {} },
+          postTrainingExamplesBulkDelete,
+          {},
           options
         );
       },
-      bulkEnable: async (options) => {
+      bulkDestroy: async (options) => {
         return rb.execute(
-          postWebhookConfigsBulkEnable,
+          postTrainingExamplesBulkDelete,
           {},
           options
         );
       },
-      bulkDisable: async (options) => {
+      searchByVector: async (options) => {
         return rb.execute(
-          postWebhookConfigsBulkDisable,
+          postTrainingExamplesBulkDelete,
           {},
           options
         );
-      },
-      /** Replay historical events to this webhook */
-      replay: async (id, options) => {
+      }
+    },
+    sessions: {
+      listAgentsSessions: async (options) => {
         return rb.execute(
-          postWebhookConfigsByIdReplay,
-          { path: { id }, body: {} },
+          getTrainingSessionsAgentsByAgentIdSessions,
+          buildPageQuery(options?.page, options?.pageSize),
           options
         );
       },
+      listAllAgentsSessions: async (options) => {
+        return paginateToArray(
+          rb.createPaginatedFetcher(
+            getTrainingSessionsAgentsByAgentIdSessions,
+            (page, pageSize) => ({
+              query: { page: { number: page, size: pageSize } }
+            }),
+            options
+          )
+        );
+      },
       get: async (id, options) => {
         return rb.execute(
-          getWebhookConfigsById,
+          getTrainingSessionsById,
           { path: { id } },
           options
         );
       },
-      /** Rotate the signing secret for a webhook config */
-      rotateSecret: async (id, options) => {
+      create: async (attributes, options) => {
         return rb.execute(
-          patchWebhookConfigsByIdRotateSecret,
-          { path: { id }, body: {} },
+          getTrainingSessionsAgentsByAgentIdSessions,
+          { body: { data: { type: "training_session", attributes } } },
+          options
+        );
+      },
+      delete: async (id, options) => {
+        return rb.executeDelete(
+          deleteTrainingSessionsById,
+          { path: { id } },
+          options
+        );
+      },
+      update: async (agentId, attributes, options) => {
+        return rb.execute(
+          getTrainingSessionsAgentsByAgentIdSessions,
+          {
+            path: { agent_id: agentId },
+            body: { data: { type: "training_session", attributes } }
+          },
           options
         );
       }
+    }
+  };
+}
+
+// src/namespaces/voice.ts
+function createVoiceNamespace(rb) {
+  return {
+    /**
+     * Transcribe an audio file via the voice transcription endpoint.
+     * Accepts File or Blob. Supported formats: mp3, ogg, wav, m4a, webm, flac, aac.
+     *
+     * @param audio - Audio file to transcribe (max 200 MB)
+     * @param params - Optional transcription parameters
+     * @param options - Request options (signal, headers, etc.)
+     */
+    transcribe: async (audio, params, options) => {
+      const form = new FormData();
+      form.append("audio", audio);
+      if (params?.language) form.append("language", params.language);
+      if (params?.modelSize) form.append("model_size", params.modelSize);
+      if (params?.phiMode) form.append("phi_mode", params.phiMode);
+      if (params?.phiKey) form.append("phi_key", params.phiKey);
+      return rb.rawPostMultipart(
+        "/voice/transcribe",
+        form,
+        options
+      );
     },
-    deliveries: {
+    /**
+     * Sessions — voice session management
+     */
+    sessions: {
+      /** List voice sessions with pagination */
       list: async (options) => {
         return rb.execute(
-          getWebhookDeliveries,
+          getVoiceSessions,
           buildPageQuery(options?.page, options?.pageSize),
           options
         );
       },
-      listAll: async (options) => {
-        return paginateToArray(
-          rb.createPaginatedFetcher(
-            getWebhookDeliveries,
-            (page, pageSize) => ({
-              query: { page: { number: page, size: pageSize } }
-            }),
-            options
-          )
+      /** Get a session by ID */
+      get: async (id, options) => {
+        return rb.execute(
+          getVoiceSessionsById,
+          { path: { id } },
+          options
         );
       },
-      create: async (attributes, options) => {
+      /** List my voice sessions */
+      listMine: async (options) => {
         return rb.execute(
-          postWebhookDeliveriesBulkRetry,
-          { body: { data: { type: "webhook_delivery", attributes } } },
+          getVoiceSessionsMine,
+          buildPageQuery(options?.page, options?.pageSize),
           options
         );
       },
-      retry: async (options) => {
+      /** List sessions by workspace */
+      listByWorkspace: async (workspaceId, options) => {
         return rb.execute(
-          postWebhookDeliveriesBulkRetry,
-          {},
+          getVoiceSessionsWorkspaceByWorkspaceId,
+          {
+            path: { workspace_id: workspaceId },
+            ...buildPageQuery(options?.page, options?.pageSize)
+          },
           options
         );
       },
-      bulkRetry: async (options) => {
+      /**
+       * Start a new voice session with LiveKit room provisioning.
+       *
+       * @param params - Session parameters
+       * @param params.phiKey - AES-256 encryption key for PHI (Protected Health
+       *   Information), encoded as Base64 (32 raw bytes). Required when
+       *   `phiMode` is `"tokenize_encrypt"`.
+       * @param options - Request options
+       *
+       * @remarks
+       * **Security — `phiKey`:** This value is a sensitive encryption key.
+       * - Transmitted over HTTPS only — never send over plain HTTP.
+       * - Do not log, store in `localStorage`, or include in error reports.
+       * - Treat it with the same care as a password or private key.
+       * - The server never persists this key; it is used only within the
+       *   lifetime of the request.
+       */
+      start: async (params, options) => {
         return rb.execute(
-          postWebhookDeliveriesBulkRetry,
-          {},
+          postVoiceSessions,
+          {
+            body: {
+              data: {
+                type: "voice_session",
+                attributes: {
+                  thread_id: params?.threadId,
+                  blueprint_id: params?.blueprintId,
+                  blueprint_mode: params?.blueprintMode,
+                  phi_mode: params?.phiMode,
+                  phi_key: params?.phiKey,
+                  patient_id: params?.patientId
+                }
+              }
+            }
+          },
           options
         );
       },
-      get: async (id, options) => {
+      /** End a voice session and release the LiveKit room */
+      stop: async (id, options) => {
         return rb.execute(
-          getWebhookDeliveriesById,
-          { path: { id } },
+          patchVoiceSessionsByIdStop,
+          { path: { id }, body: { data: { id, type: "voice_session" } } },
+          options
+        );
+      },
+      /**
+       * Dispatch the accumulated session transcript to the blueprint or chat
+       * pipeline. The transcript may contain PHI (Protected Health Information)
+       * depending on the session's `phiMode`.
+       *
+       * @param id - Voice session ID
+       * @param params - Finalization parameters
+       * @param params.phiKey - AES-256 encryption key for PHI, encoded as
+       *   Base64 (32 raw bytes). Overrides the key supplied at session start.
+       *   Required when `phiMode` is `"tokenize_encrypt"`.
+       * @param options - Request options
+       *
+       * @remarks
+       * **Security — transcript PHI:** The finalized transcript submitted to
+       * this endpoint may contain Protected Health Information. Ensure the
+       * request is made over HTTPS only.
+       *
+       * **Security — `phiKey`:** This value is a sensitive encryption key.
+       * - Transmitted over HTTPS only — never send over plain HTTP.
+       * - Do not log, store in `localStorage`, or include in error reports.
+       * - Treat it with the same care as a password or private key.
+       * - The server never persists this key; it is used only within the
+       *   lifetime of the request.
+       */
+      finalize: async (id, params, options) => {
+        return rb.execute(
+          patchVoiceSessionsByIdFinalize,
+          {
+            path: { id },
+            body: {
+              data: {
+                id,
+                type: "voice_session",
+                attributes: {
+                  blueprint_id: params?.blueprintId,
+                  phi_mode: params?.phiMode,
+                  phi_key: params?.phiKey,
+                  patient_id: params?.patientId
+                }
+              }
+            }
+          },
           options
         );
       }
@@ -4975,26 +5884,21 @@ function createWebhooksNamespace(rb) {
   };
 }
 
-// src/namespaces/scheduling.ts
-function createSchedulingNamespace(rb) {
+// src/namespaces/watcher.ts
+function createWatcherNamespace(rb) {
   return {
-    /**
-     * Event Types — templates for bookable events
-     */
-    eventTypes: {
-      /** List event types with optional pagination */
+    claims: {
       list: async (options) => {
         return rb.execute(
-          getSchedulingEventTypes,
+          getWatcherClaims,
           buildPageQuery(options?.page, options?.pageSize),
           options
         );
       },
-      /** List all event types with automatic pagination */
       listAll: async (options) => {
         return paginateToArray(
           rb.createPaginatedFetcher(
-            getSchedulingEventTypes,
+            getWatcherClaims,
             (page, pageSize) => ({
               query: { page: { number: page, size: pageSize } }
             }),
@@ -5002,65 +5906,68 @@ function createSchedulingNamespace(rb) {
           )
         );
       },
-      /** Get an event type by ID */
-      get: async (id, options) => {
-        return rb.execute(
-          getSchedulingEventTypesById,
-          { path: { id } },
-          options
-        );
+      claim: async (options) => {
+        return rb.execute(postWatcherClaims, {}, options);
       },
-      /**
-       * Create a new event type.
-       * @example
-       * ```typescript
-       * const client = new GptClient({ apiKey: 'sk_tenant_...' });
-       * const eventType = await client.scheduling.eventTypes.create({
-       *   name: '30-Minute Consultation',
-       *   slug: '30min-consult',
-       *   duration_minutes: 30,
-       *   location_type: 'video',
-       * });
-       * ```
-       */
       create: async (attributes, options) => {
         return rb.execute(
-          postSchedulingEventTypes,
-          {
-            body: { data: { type: "scheduling_event_type", attributes } }
-          },
+          postWatcherClaims,
+          { body: { data: { type: "watcher_claim", attributes } } },
           options
         );
       },
-      /** Update an event type */
       update: async (id, attributes, options) => {
         return rb.execute(
-          patchSchedulingEventTypesById,
+          patchWatcherClaimsById,
           {
             path: { id },
-            body: { data: { id, type: "scheduling_event_type", attributes } }
+            body: { data: { id, type: "watcher_claim", attributes } }
           },
           options
         );
+      },
+      delete: async (id, options) => {
+        return rb.executeDelete(
+          getWatcherClaimsById,
+          { path: { id } },
+          options
+        );
+      },
+      /** Register a completed claim for a document (used by ProcessDocument worker) */
+      registerCompleted: async (options) => {
+        return rb.execute(postWatcherClaims, {}, options);
+      },
+      /** Get ingestion status for a workspace */
+      readStatus: async (options) => {
+        return rb.execute(postWatcherClaims, {}, options);
+      },
+      get: async (id, options) => {
+        return rb.execute(
+          getWatcherClaimsById,
+          { path: { id } },
+          options
+        );
       }
     },
-    /**
-     * Events — scheduled occurrences
-     */
     events: {
-      /** List events with optional pagination */
+      create: async (attributes, options) => {
+        return rb.execute(
+          postWatcherEvents,
+          { body: { data: { type: "watcher_event", attributes } } },
+          options
+        );
+      },
       list: async (options) => {
         return rb.execute(
-          getSchedulingEvents,
+          getWatcherEvents,
           buildPageQuery(options?.page, options?.pageSize),
           options
         );
       },
-      /** List all events with automatic pagination */
       listAll: async (options) => {
         return paginateToArray(
           rb.createPaginatedFetcher(
-            getSchedulingEvents,
+            getWatcherEvents,
             (page, pageSize) => ({
               query: { page: { number: page, size: pageSize } }
             }),
@@ -5068,56 +5975,46 @@ function createSchedulingNamespace(rb) {
           )
         );
       },
-      /** Get an event by ID */
+      delete: async (options) => {
+        return rb.executeDelete(getWatcherEvents, { path: {} }, options);
+      },
+      /** Create multiple events in batch */
+      batchCreate: async (options) => {
+        return rb.execute(postWatcherEvents, {}, options);
+      },
       get: async (id, options) => {
         return rb.execute(
-          getSchedulingEventsById,
+          getWatcherEventsById,
           { path: { id } },
           options
         );
-      },
-      /**
-       * Create an internal event directly.
-       * Use for meetings between known users in the workspace.
-       */
-      create: async (attributes, options) => {
-        return rb.execute(
-          postSchedulingEvents,
-          {
-            body: { data: { type: "scheduling_event", attributes } }
-          },
+      }
+    }
+  };
+}
+
+// src/namespaces/webhooks-ns.ts
+function createWebhooksNamespace(rb) {
+  return {
+    configs: {
+      delete: async (id, options) => {
+        return rb.executeDelete(
+          deleteWebhookConfigsById,
+          { path: { id } },
           options
         );
       },
-      /** Update an event */
-      update: async (id, attributes, options) => {
-        return rb.execute(
-          patchSchedulingEventsById,
-          {
-            path: { id },
-            body: { data: { id, type: "scheduling_event", attributes } }
-          },
-          options
-        );
-      }
-    },
-    /**
-     * Participants — people attending events
-     */
-    participants: {
-      /** List participants with optional pagination */
       list: async (options) => {
         return rb.execute(
-          getSchedulingParticipants,
+          getWebhookConfigs,
           buildPageQuery(options?.page, options?.pageSize),
           options
         );
       },
-      /** List all participants with automatic pagination */
       listAll: async (options) => {
         return paginateToArray(
           rb.createPaginatedFetcher(
-            getSchedulingParticipants,
+            getWebhookConfigs,
             (page, pageSize) => ({
               query: { page: { number: page, size: pageSize } }
             }),
@@ -5125,145 +6022,80 @@ function createSchedulingNamespace(rb) {
           )
         );
       },
-      /** Get a participant by ID */
-      get: async (id, options) => {
-        return rb.execute(
-          getSchedulingParticipantsById,
-          { path: { id } },
-          options
-        );
-      },
-      /** Add a participant to an event */
       create: async (attributes, options) => {
         return rb.execute(
-          postSchedulingParticipants,
-          {
-            body: { data: { type: "scheduling_participant", attributes } }
-          },
+          postWebhookConfigs,
+          { body: { data: { type: "webhook_config", attributes } } },
           options
         );
       },
-      /** Update a participant (e.g., confirm attendance, respond to invite) */
       update: async (id, attributes, options) => {
         return rb.execute(
-          patchSchedulingParticipantsById,
+          patchWebhookConfigsById,
           {
             path: { id },
-            body: { data: { id, type: "scheduling_participant", attributes } }
+            body: { data: { id, type: "webhook_config", attributes } }
           },
           options
         );
-      }
-    },
-    /**
-     * Bookings — external party requests for appointments
-     */
-    bookings: {
-      /** List bookings with optional pagination */
-      list: async (options) => {
+      },
+      test: async (id, options) => {
         return rb.execute(
-          getSchedulingBookings,
-          buildPageQuery(options?.page, options?.pageSize),
+          postWebhookConfigsByIdTest,
+          { path: { id }, body: {} },
           options
         );
       },
-      /** List all bookings with automatic pagination */
-      listAll: async (options) => {
-        return paginateToArray(
-          rb.createPaginatedFetcher(
-            getSchedulingBookings,
-            (page, pageSize) => ({
-              query: { page: { number: page, size: pageSize } }
-            }),
-            options
-          )
-        );
-      },
-      /** Get a booking by ID */
-      get: async (id, options) => {
+      bulkEnable: async (options) => {
         return rb.execute(
-          getSchedulingBookingsById,
-          { path: { id } },
+          postWebhookConfigsBulkEnable,
+          {},
           options
         );
       },
-      /**
-       * Create a booking request.
-       * Use when someone outside the platform requests an appointment.
-       * @example
-       * ```typescript
-       * const booking = await client.scheduling.bookings.create({
-       *   event_type_id: 'event_123',
-       *   start_time: '2025-03-01T10:00:00Z',
-       *   booker_name: 'John Doe',
-       *   booker_email: 'john@example.com',
-       * });
-       * ```
-       */
-      create: async (attributes, options) => {
+      bulkDisable: async (options) => {
         return rb.execute(
-          postSchedulingBookings,
-          {
-            body: { data: { type: "scheduling_booking", attributes } }
-          },
+          postWebhookConfigsBulkDisable,
+          {},
           options
         );
       },
-      /**
-       * Confirm a pending booking.
-       * For EventTypes with requires_approval=true.
-       */
-      confirm: async (id, options) => {
+      /** Replay historical events to this webhook */
+      replay: async (id, options) => {
         return rb.execute(
-          patchSchedulingBookingsSchedulingBookingsByIdConfirm,
+          postWebhookConfigsByIdReplay,
           { path: { id }, body: {} },
           options
         );
       },
-      /**
-       * Cancel or reject a booking.
-       */
-      cancel: async (id, attributes, options) => {
+      get: async (id, options) => {
         return rb.execute(
-          patchSchedulingBookingsSchedulingBookingsByIdCancel,
-          {
-            path: { id },
-            body: attributes ? { data: { type: "scheduling_booking", attributes } } : {}
-          },
+          getWebhookConfigsById,
+          { path: { id } },
           options
         );
       },
-      /**
-       * Reschedule a booking to a new time.
-       */
-      reschedule: async (id, attributes, options) => {
+      /** Rotate the signing secret for a webhook config */
+      rotateSecret: async (id, options) => {
         return rb.execute(
-          patchSchedulingBookingsSchedulingBookingsByIdReschedule,
-          {
-            path: { id },
-            body: { data: { type: "scheduling_booking", attributes } }
-          },
+          patchWebhookConfigsByIdRotateSecret,
+          { path: { id }, body: {} },
           options
         );
       }
     },
-    /**
-     * Calendar Syncs — external calendar integrations
-     */
-    calendarSyncs: {
-      /** List calendar syncs with optional pagination */
+    deliveries: {
       list: async (options) => {
         return rb.execute(
-          getSchedulingCalendarSyncs,
+          getWebhookDeliveries,
           buildPageQuery(options?.page, options?.pageSize),
           options
         );
       },
-      /** List all calendar syncs with automatic pagination */
       listAll: async (options) => {
         return paginateToArray(
           rb.createPaginatedFetcher(
-            getSchedulingCalendarSyncs,
+            getWebhookDeliveries,
             (page, pageSize) => ({
               query: { page: { number: page, size: pageSize } }
             }),
@@ -5271,61 +6103,31 @@ function createSchedulingNamespace(rb) {
           )
         );
       },
-      /** Get a calendar sync by ID */
-      get: async (id, options) => {
-        return rb.execute(
-          getSchedulingCalendarSyncsById,
-          { path: { id } },
-          options
-        );
-      },
-      /**
-       * Create a calendar sync.
-       * For bi-directional sync with external calendars (Google, Outlook).
-       */
       create: async (attributes, options) => {
         return rb.execute(
-          postSchedulingCalendarSyncs,
-          {
-            body: { data: { type: "scheduling_calendar_sync", attributes } }
-          },
+          postWebhookDeliveriesBulkRetry,
+          { body: { data: { type: "webhook_delivery", attributes } } },
           options
         );
       },
-      /** Update a calendar sync */
-      update: async (id, attributes, options) => {
+      retry: async (options) => {
         return rb.execute(
-          patchSchedulingCalendarSyncsSchedulingCalendarSyncsById,
-          {
-            path: { id },
-            body: {
-              data: { id, type: "scheduling_calendar_sync", attributes }
-            }
-          },
-          options
-        );
-      },
-      /** Delete a calendar sync */
-      delete: async (id, options) => {
-        return rb.executeDelete(
-          deleteSchedulingCalendarSyncsSchedulingCalendarSyncsById,
-          { path: { id } },
+          postWebhookDeliveriesBulkRetry,
+          {},
           options
         );
       },
-      /** Pause a calendar sync (stops pushing/pulling) */
-      pause: async (id, options) => {
+      bulkRetry: async (options) => {
         return rb.execute(
-          patchSchedulingCalendarSyncsSchedulingCalendarSyncsByIdPause,
-          { path: { id }, body: {} },
+          postWebhookDeliveriesBulkRetry,
+          {},
           options
         );
       },
-      /** Resume a paused calendar sync */
-      resume: async (id, options) => {
+      get: async (id, options) => {
         return rb.execute(
-          patchSchedulingCalendarSyncsSchedulingCalendarSyncsByIdResume,
-          { path: { id }, body: {} },
+          getWebhookDeliveriesById,
+          { path: { id } },
           options
         );
       }
@@ -5513,6 +6315,30 @@ var RequestBuilder = class {
       throw handleApiError(error);
     }
   }
+  /**
+   * Execute a raw multipart/form-data POST request.
+   * Used for file upload endpoints (custom Phoenix controllers).
+   * Content-Type is omitted from headers so the browser sets the correct
+   * multipart boundary automatically from the FormData body.
+   */
+  async rawPostMultipart(url, body, options) {
+    const headers = buildHeaders(this.getHeaders, options);
+    delete headers["Content-Type"];
+    delete headers["content-type"];
+    try {
+      const { data } = await this.requestWithRetry(
+        () => this.clientInstance.post({
+          url,
+          headers,
+          body,
+          ...options?.signal && { signal: options.signal }
+        })
+      );
+      return this.unwrap(data?.data);
+    } catch (error) {
+      throw handleApiError(error);
+    }
+  }
   /**
    * Execute a raw POST request to a custom (non-generated) endpoint.
    * Used for endpoints implemented as custom Phoenix controllers.
@@ -5672,11 +6498,14 @@ var GptClient = class extends BaseClient {
     this.extraction = createExtractionNamespace(rb);
     this.identity = createIdentityNamespace(rb);
     this.platform = createPlatformNamespace(rb);
+    this.scheduling = createSchedulingNamespace(rb);
     this.search = createSearchNamespace(rb);
     this.storage = createStorageNamespace(rb);
     this.threads = createThreadsNamespace(rb);
+    this.training = createTrainingNamespace(rb);
+    this.voice = createVoiceNamespace(rb);
+    this.watcher = createWatcherNamespace(rb);
     this.webhooks = createWebhooksNamespace(rb);
-    this.scheduling = createSchedulingNamespace(rb);
   }
   /**
    * Subscribe to SDK lifecycle events.