@gpt-platform/admin 0.3.4 → 0.4.0

package/dist/index.js

@@ -853,7 +853,7 @@ var createClient = (config = {}) => {
 };
 
 // src/version.ts
-var SDK_VERSION = "0.3.4";
+var SDK_VERSION = "0.4.0";
 var DEFAULT_API_VERSION = "2026-02-27";
 
 // src/base-client.ts
@@ -1172,6 +1172,7 @@ var RequestBuilder = class {
       const { data } = await this.requestWithRetry(
         () => fn({
           client: this.clientInstance,
+          throwOnError: true,
           headers,
           ...params,
           ...options?.signal && { signal: options.signal }
@@ -1191,6 +1192,7 @@ var RequestBuilder = class {
       await this.requestWithRetry(
         () => fn({
           client: this.clientInstance,
+          throwOnError: true,
           headers,
           ...params,
           ...options?.signal && { signal: options.signal }
@@ -1368,6 +1370,35 @@ var client = createClient(
 );
 
 // src/_internal/sdk.gen.ts
+var getAdminFieldTemplates = (options) => (options.client ?? client).get({
+  security: [{ scheme: "bearer", type: "http" }],
+  url: "/admin/field-templates",
+  ...options
+});
+var postAdminFieldTemplates = (options) => (options.client ?? client).post({
+  security: [{ scheme: "bearer", type: "http" }],
+  url: "/admin/field-templates",
+  ...options,
+  headers: {
+    "Content-Type": "application/vnd.api+json",
+    ...options.headers
+  }
+});
+var getAdminAgents = (options) => (options.client ?? client).get({
+  security: [{ scheme: "bearer", type: "http" }],
+  url: "/admin/agents",
+  ...options
+});
+var deleteAdminAgentVersionsById = (options) => (options.client ?? client).delete({
+  security: [{ scheme: "bearer", type: "http" }],
+  url: "/admin/agent-versions/{id}",
+  ...options
+});
+var getAdminAgentVersionsById = (options) => (options.client ?? client).get({
+  security: [{ scheme: "bearer", type: "http" }],
+  url: "/admin/agent-versions/{id}",
+  ...options
+});
 var patchAdminAccountsByIdCredit = (options) => (options.client ?? client).patch({
   security: [{ scheme: "bearer", type: "http" }],
   url: "/admin/accounts/{id}/credit",
@@ -1377,16 +1408,206 @@ var patchAdminAccountsByIdCredit = (options) => (options.client ?? client).patch
     ...options.headers
   }
 });
+var getAdminTrainingSessionsAgentsByAgentIdSessions = (options) => (options.client ?? client).get({
+  security: [{ scheme: "bearer", type: "http" }],
+  url: "/admin/training-sessions/agents/{agent_id}/sessions",
+  ...options
+});
+var patchAdminApiKeysByIdSetBudget = (options) => (options.client ?? client).patch({
+  security: [{ scheme: "bearer", type: "http" }],
+  url: "/admin/api-keys/{id}/set-budget",
+  ...options,
+  headers: {
+    "Content-Type": "application/vnd.api+json",
+    ...options.headers
+  }
+});
+var getAdminAgentVersionsByIdRevisions = (options) => (options.client ?? client).get({
+  security: [{ scheme: "bearer", type: "http" }],
+  url: "/admin/agent-versions/{id}/revisions",
+  ...options
+});
+var postAdminAgentsCloneForWorkspace = (options) => (options.client ?? client).post({
+  security: [{ scheme: "bearer", type: "http" }],
+  url: "/admin/agents/clone-for-workspace",
+  ...options,
+  headers: {
+    "Content-Type": "application/vnd.api+json",
+    ...options.headers
+  }
+});
+var getAdminAgentsById = (options) => (options.client ?? client).get({
+  security: [{ scheme: "bearer", type: "http" }],
+  url: "/admin/agents/{id}",
+  ...options
+});
+var postAdminAgentsByIdExport = (options) => (options.client ?? client).post({
+  security: [{ scheme: "bearer", type: "http" }],
+  url: "/admin/agents/{id}/export",
+  ...options
+});
+var postAdminAgentsByIdRestoreVersion = (options) => (options.client ?? client).post({
+  security: [{ scheme: "bearer", type: "http" }],
+  url: "/admin/agents/{id}/restore-version",
+  ...options,
+  headers: {
+    "Content-Type": "application/vnd.api+json",
+    ...options.headers
+  }
+});
+var getAdminAgentsByIdTrainingExamples = (options) => (options.client ?? client).get({
+  security: [{ scheme: "bearer", type: "http" }],
+  url: "/admin/agents/{id}/training-examples",
+  ...options
+});
+var deleteAdminEmailMarketingCampaignsById = (options) => (options.client ?? client).delete({
+  security: [{ scheme: "bearer", type: "http" }],
+  url: "/admin/email-marketing/campaigns/{id}",
+  ...options
+});
+var getAdminEmailMarketingCampaignsById = (options) => (options.client ?? client).get({
+  security: [{ scheme: "bearer", type: "http" }],
+  url: "/admin/email-marketing/campaigns/{id}",
+  ...options
+});
 var getAdminWebhookDeliveriesById = (options) => (options.client ?? client).get({
   security: [{ scheme: "bearer", type: "http" }],
   url: "/admin/webhook-deliveries/{id}",
   ...options
 });
+var postAdminAgentsByIdSchemaVersionsByVersionIdActivate = (options) => (options.client ?? client).post({
+  security: [{ scheme: "bearer", type: "http" }],
+  url: "/admin/agents/{id}/schema-versions/{version_id}/activate",
+  ...options
+});
+var postAdminAgentsPredict = (options) => (options.client ?? client).post({
+  security: [{ scheme: "bearer", type: "http" }],
+  url: "/admin/agents/predict",
+  ...options,
+  headers: {
+    "Content-Type": "application/vnd.api+json",
+    ...options.headers
+  }
+});
+var deleteAdminApiKeysById = (options) => (options.client ?? client).delete({
+  security: [{ scheme: "bearer", type: "http" }],
+  url: "/admin/api-keys/{id}",
+  ...options
+});
 var getAdminApiKeysById = (options) => (options.client ?? client).get({
   security: [{ scheme: "bearer", type: "http" }],
   url: "/admin/api-keys/{id}",
   ...options
 });
+var patchAdminApiKeysById = (options) => (options.client ?? client).patch({
+  security: [{ scheme: "bearer", type: "http" }],
+  url: "/admin/api-keys/{id}",
+  ...options,
+  headers: {
+    "Content-Type": "application/vnd.api+json",
+    ...options.headers
+  }
+});
+var getAdminVoiceRecordingsSessionBySessionId = (options) => (options.client ?? client).get({
+  security: [{ scheme: "bearer", type: "http" }],
+  url: "/admin/voice/recordings/session/{session_id}",
+  ...options
+});
+var getAdminEmailTrackingEventsWorkspaceByWorkspaceId = (options) => (options.client ?? client).get({
+  security: [{ scheme: "bearer", type: "http" }],
+  url: "/admin/email/tracking-events/workspace/{workspace_id}",
+  ...options
+});
+var deleteAdminTrainingExamplesById = (options) => (options.client ?? client).delete({
+  security: [{ scheme: "bearer", type: "http" }],
+  url: "/admin/training-examples/{id}",
+  ...options
+});
+var getAdminTrainingExamplesById = (options) => (options.client ?? client).get({
+  security: [{ scheme: "bearer", type: "http" }],
+  url: "/admin/training-examples/{id}",
+  ...options
+});
+var patchAdminTrainingExamplesById = (options) => (options.client ?? client).patch({
+  security: [{ scheme: "bearer", type: "http" }],
+  url: "/admin/training-examples/{id}",
+  ...options,
+  headers: {
+    "Content-Type": "application/vnd.api+json",
+    ...options.headers
+  }
+});
+var postAdminTrainingExamplesBulkDelete = (options) => (options.client ?? client).post({
+  security: [{ scheme: "bearer", type: "http" }],
+  url: "/admin/training-examples/bulk-delete",
+  ...options,
+  headers: {
+    "Content-Type": "application/vnd.api+json",
+    ...options.headers
+  }
+});
+var getAdminVoiceSessions = (options) => (options.client ?? client).get({
+  security: [{ scheme: "bearer", type: "http" }],
+  url: "/admin/voice/sessions",
+  ...options
+});
+var getAdminVoiceTranscriptionResultsSessionBySessionId = (options) => (options.client ?? client).get({
+  security: [{ scheme: "bearer", type: "http" }],
+  url: "/admin/voice/transcription-results/session/{session_id}",
+  ...options
+});
+var getAdminUsers = (options) => (options.client ?? client).get({
+  security: [{ scheme: "bearer", type: "http" }],
+  url: "/admin/users",
+  ...options
+});
+var getAdminAgentVersionsByIdMetrics = (options) => (options.client ?? client).get({
+  security: [{ scheme: "bearer", type: "http" }],
+  url: "/admin/agent-versions/{id}/metrics",
+  ...options
+});
+var postAdminAgentVersionsByIdSetSystemFields = (options) => (options.client ?? client).post({
+  security: [{ scheme: "bearer", type: "http" }],
+  url: "/admin/agent-versions/{id}/set-system-fields",
+  ...options,
+  headers: {
+    "Content-Type": "application/vnd.api+json",
+    ...options.headers
+  }
+});
+var postAdminEmailMarketingCampaigns = (options) => (options.client ?? client).post({
+  security: [{ scheme: "bearer", type: "http" }],
+  url: "/admin/email-marketing/campaigns",
+  ...options,
+  headers: {
+    "Content-Type": "application/vnd.api+json",
+    ...options.headers
+  }
+});
+var postAdminAgentVersionsByIdAddSystemField = (options) => (options.client ?? client).post({
+  security: [{ scheme: "bearer", type: "http" }],
+  url: "/admin/agent-versions/{id}/add-system-field",
+  ...options,
+  headers: {
+    "Content-Type": "application/vnd.api+json",
+    ...options.headers
+  }
+});
+var deleteAdminFieldTemplatesById = (options) => (options.client ?? client).delete({
+  security: [{ scheme: "bearer", type: "http" }],
+  url: "/admin/field-templates/{id}",
+  ...options
+});
+var getAdminFieldTemplatesById = (options) => (options.client ?? client).get({
+  security: [{ scheme: "bearer", type: "http" }],
+  url: "/admin/field-templates/{id}",
+  ...options
+});
+var getAdminVoiceSessionsById = (options) => (options.client ?? client).get({
+  security: [{ scheme: "bearer", type: "http" }],
+  url: "/admin/voice/sessions/{id}",
+  ...options
+});
 var deleteAdminWebhookConfigsById = (options) => (options.client ?? client).delete({
   security: [{ scheme: "bearer", type: "http" }],
   url: "/admin/webhook-configs/{id}",
@@ -1406,6 +1627,24 @@ var patchAdminWebhookConfigsById = (options) => (options.client ?? client).patch
     ...options.headers
   }
 });
+var patchAdminUsersByIdAdminEmail = (options) => (options.client ?? client).patch({
+  security: [{ scheme: "bearer", type: "http" }],
+  url: "/admin/users/{id}/admin/email",
+  ...options,
+  headers: {
+    "Content-Type": "application/vnd.api+json",
+    ...options.headers
+  }
+});
+var postAdminTrainingExamplesSearch = (options) => (options.client ?? client).post({
+  security: [{ scheme: "bearer", type: "http" }],
+  url: "/admin/training-examples/search",
+  ...options,
+  headers: {
+    "Content-Type": "application/vnd.api+json",
+    ...options.headers
+  }
+});
 var patchAdminAccountsByIdDebit = (options) => (options.client ?? client).patch({
   security: [{ scheme: "bearer", type: "http" }],
   url: "/admin/accounts/{id}/debit",
@@ -1415,11 +1654,25 @@ var patchAdminAccountsByIdDebit = (options) => (options.client ?? client).patch(
     ...options.headers
   }
 });
+var getAdminVoiceTranscriptionResultsById = (options) => (options.client ?? client).get({
+  security: [{ scheme: "bearer", type: "http" }],
+  url: "/admin/voice/transcription-results/{id}",
+  ...options
+});
 var getAdminApiKeys = (options) => (options.client ?? client).get({
   security: [{ scheme: "bearer", type: "http" }],
   url: "/admin/api-keys",
   ...options
 });
+var postAdminApiKeys = (options) => (options.client ?? client).post({
+  security: [{ scheme: "bearer", type: "http" }],
+  url: "/admin/api-keys",
+  ...options,
+  headers: {
+    "Content-Type": "application/vnd.api+json",
+    ...options.headers
+  }
+});
 var getAdminExtractionDocumentsById = (options) => (options.client ?? client).get({
   security: [{ scheme: "bearer", type: "http" }],
   url: "/admin/extraction/documents/{id}",
@@ -1435,124 +1688,1442 @@ var getAdminStorageStats = (options) => (options.client ?? client).get({
   url: "/admin/storage/stats",
   ...options
 });
+var getAdminAgentsByIdStats = (options) => (options.client ?? client).get({
+  security: [{ scheme: "bearer", type: "http" }],
+  url: "/admin/agents/{id}/stats",
+  ...options
+});
+var patchAdminUsersByIdConfirmEmail = (options) => (options.client ?? client).patch({
+  security: [{ scheme: "bearer", type: "http" }],
+  url: "/admin/users/{id}/confirm-email",
+  ...options,
+  headers: {
+    "Content-Type": "application/vnd.api+json",
+    ...options.headers
+  }
+});
+var getAdminEmailMarketingSenderProfilesWorkspaceByWorkspaceId = (options) => (options.client ?? client).get({
+  security: [{ scheme: "bearer", type: "http" }],
+  url: "/admin/email-marketing/sender-profiles/workspace/{workspace_id}",
+  ...options
+});
+var getAdminEmailMarketingCampaignsWorkspaceByWorkspaceId = (options) => (options.client ?? client).get({
+  security: [{ scheme: "bearer", type: "http" }],
+  url: "/admin/email-marketing/campaigns/workspace/{workspace_id}",
+  ...options
+});
 var getAdminAccountsById = (options) => (options.client ?? client).get({
   security: [{ scheme: "bearer", type: "http" }],
   url: "/admin/accounts/{id}",
   ...options
 });
-var getAdminBucketsByIdStats = (options) => (options.client ?? client).get({
+var deleteAdminUsersById = (options) => (options.client ?? client).delete({
   security: [{ scheme: "bearer", type: "http" }],
-  url: "/admin/buckets/{id}/stats",
+  url: "/admin/users/{id}",
   ...options
 });
-var getAdminDocumentsStats = (options) => (options.client ?? client).get({
+var getAdminUsersById = (options) => (options.client ?? client).get({
   security: [{ scheme: "bearer", type: "http" }],
-  url: "/admin/documents/stats",
+  url: "/admin/users/{id}",
   ...options
 });
-var getAdminWebhookDeliveries = (options) => (options.client ?? client).get({
+var getAdminAgentsByIdUsage = (options) => (options.client ?? client).get({
   security: [{ scheme: "bearer", type: "http" }],
-  url: "/admin/webhook-deliveries",
+  url: "/admin/agents/{id}/usage",
   ...options
 });
-var getAdminExtractionDocuments = (options) => (options.client ?? client).get({
+var getAdminEmailTrackingEventsById = (options) => (options.client ?? client).get({
   security: [{ scheme: "bearer", type: "http" }],
-  url: "/admin/extraction/documents",
+  url: "/admin/email/tracking-events/{id}",
   ...options
 });
-var postAdminDocumentsBulkDelete = (options) => (options.client ?? client).post({
+var deleteAdminEmailMarketingSenderProfilesById = (options) => (options.client ?? client).delete({
   security: [{ scheme: "bearer", type: "http" }],
-  url: "/admin/documents/bulk-delete",
-  ...options,
-  headers: {
-    "Content-Type": "application/vnd.api+json",
-    ...options.headers
-  }
+  url: "/admin/email-marketing/sender-profiles/{id}",
+  ...options
 });
-var getAdminWebhookConfigs = (options) => (options.client ?? client).get({
+var getAdminEmailMarketingSenderProfilesById = (options) => (options.client ?? client).get({
   security: [{ scheme: "bearer", type: "http" }],
-  url: "/admin/webhook-configs",
+  url: "/admin/email-marketing/sender-profiles/{id}",
   ...options
 });
-var postAdminWebhookConfigs = (options) => (options.client ?? client).post({
+var patchAdminEmailMarketingSenderProfilesById = (options) => (options.client ?? client).patch({
   security: [{ scheme: "bearer", type: "http" }],
-  url: "/admin/webhook-configs",
+  url: "/admin/email-marketing/sender-profiles/{id}",
   ...options,
   headers: {
     "Content-Type": "application/vnd.api+json",
     ...options.headers
   }
 });
-var patchAdminApiKeysByIdAllocate = (options) => (options.client ?? client).patch({
+var getAdminAgentVersions = (options) => (options.client ?? client).get({
   security: [{ scheme: "bearer", type: "http" }],
-  url: "/admin/api-keys/{id}/allocate",
-  ...options,
-  headers: {
-    "Content-Type": "application/vnd.api+json",
-    ...options.headers
-  }
+  url: "/admin/agent-versions",
+  ...options
 });
-var patchAdminApiKeysByIdRevoke = (options) => (options.client ?? client).patch({
+var postAdminAgentVersions = (options) => (options.client ?? client).post({
   security: [{ scheme: "bearer", type: "http" }],
-  url: "/admin/api-keys/{id}/revoke",
+  url: "/admin/agent-versions",
   ...options,
   headers: {
     "Content-Type": "application/vnd.api+json",
     ...options.headers
   }
 });
-var getAdminBuckets = (options) => (options.client ?? client).get({
+var getAdminVoiceSessionsWorkspaceByWorkspaceId = (options) => (options.client ?? client).get({
   security: [{ scheme: "bearer", type: "http" }],
-  url: "/admin/buckets",
+  url: "/admin/voice/sessions/workspace/{workspace_id}",
   ...options
 });
-var patchAdminApiKeysByIdRotate = (options) => (options.client ?? client).patch({
+var postAdminEmailOutboundEmails = (options) => (options.client ?? client).post({
   security: [{ scheme: "bearer", type: "http" }],
-  url: "/admin/api-keys/{id}/rotate",
+  url: "/admin/email/outbound-emails",
   ...options,
   headers: {
     "Content-Type": "application/vnd.api+json",
     ...options.headers
   }
 });
-var getAdminBucketsById = (options) => (options.client ?? client).get({
+var getAdminEmailOutboundEmailsWorkspaceByWorkspaceId = (options) => (options.client ?? client).get({
   security: [{ scheme: "bearer", type: "http" }],
-  url: "/admin/buckets/{id}",
+  url: "/admin/email/outbound-emails/workspace/{workspace_id}",
   ...options
 });
-var postAdminWebhookConfigsByIdTest = (options) => (options.client ?? client).post({
+var getAdminBucketsByIdStats = (options) => (options.client ?? client).get({
   security: [{ scheme: "bearer", type: "http" }],
-  url: "/admin/webhook-configs/{id}/test",
+  url: "/admin/buckets/{id}/stats",
+  ...options
+});
+var getAdminUsersByEmail = (options) => (options.client ?? client).get({
+  security: [{ scheme: "bearer", type: "http" }],
+  url: "/admin/users/by-email",
+  ...options
+});
+var deleteAdminAgentsByIdTrainingExamplesByExampleId = (options) => (options.client ?? client).delete({
+  security: [{ scheme: "bearer", type: "http" }],
+  url: "/admin/agents/{id}/training-examples/{example_id}",
+  ...options
+});
+var postAdminAgentsImport = (options) => (options.client ?? client).post({
+  security: [{ scheme: "bearer", type: "http" }],
+  url: "/admin/agents/import",
   ...options,
   headers: {
     "Content-Type": "application/vnd.api+json",
     ...options.headers
   }
 });
-var postAdminWebhookDeliveriesByIdRetry = (options) => (options.client ?? client).post({
+var postAdminAgentsByIdPublishVersion = (options) => (options.client ?? client).post({
   security: [{ scheme: "bearer", type: "http" }],
-  url: "/admin/webhook-deliveries/{id}/retry",
+  url: "/admin/agents/{id}/publish-version",
   ...options,
   headers: {
     "Content-Type": "application/vnd.api+json",
     ...options.headers
   }
 });
-
-// src/namespaces/accounts.ts
-function createAccountsNamespace(rb) {
-  return {
-    list: async (options) => {
-      return rb.execute(getAdminAccounts, {}, options);
-    },
-    get: async (id, options) => {
-      return rb.execute(
-        getAdminAccountsById,
-        { path: { id } },
-        options
-      );
-    },
-    credit: async (id, amount, description, options) => {
+var getAdminDocumentsStats = (options) => (options.client ?? client).get({
+  security: [{ scheme: "bearer", type: "http" }],
+  url: "/admin/documents/stats",
+  ...options
+});
+var getAdminWebhookDeliveries = (options) => (options.client ?? client).get({
+  security: [{ scheme: "bearer", type: "http" }],
+  url: "/admin/webhook-deliveries",
+  ...options
+});
+var getAdminExtractionDocuments = (options) => (options.client ?? client).get({
+  security: [{ scheme: "bearer", type: "http" }],
+  url: "/admin/extraction/documents",
+  ...options
+});
+var getAdminAgentVersionRevisionsById = (options) => (options.client ?? client).get({
+  security: [{ scheme: "bearer", type: "http" }],
+  url: "/admin/agent-version-revisions/{id}",
+  ...options
+});
+var getAdminAgentVersionRevisions = (options) => (options.client ?? client).get({
+  security: [{ scheme: "bearer", type: "http" }],
+  url: "/admin/agent-version-revisions",
+  ...options
+});
+var postAdminDocumentsBulkDelete = (options) => (options.client ?? client).post({
+  security: [{ scheme: "bearer", type: "http" }],
+  url: "/admin/documents/bulk-delete",
+  ...options,
+  headers: {
+    "Content-Type": "application/vnd.api+json",
+    ...options.headers
+  }
+});
+var getAdminWebhookConfigs = (options) => (options.client ?? client).get({
+  security: [{ scheme: "bearer", type: "http" }],
+  url: "/admin/webhook-configs",
+  ...options
+});
+var postAdminWebhookConfigs = (options) => (options.client ?? client).post({
+  security: [{ scheme: "bearer", type: "http" }],
+  url: "/admin/webhook-configs",
+  ...options,
+  headers: {
+    "Content-Type": "application/vnd.api+json",
+    ...options.headers
+  }
+});
+var deleteAdminTrainingSessionsById = (options) => (options.client ?? client).delete({
+  security: [{ scheme: "bearer", type: "http" }],
+  url: "/admin/training-sessions/{id}",
+  ...options
+});
+var getAdminTrainingSessionsById = (options) => (options.client ?? client).get({
+  security: [{ scheme: "bearer", type: "http" }],
+  url: "/admin/training-sessions/{id}",
+  ...options
+});
+var patchAdminUsersByIdAdmin = (options) => (options.client ?? client).patch({
+  security: [{ scheme: "bearer", type: "http" }],
+  url: "/admin/users/{id}/admin",
+  ...options,
+  headers: {
+    "Content-Type": "application/vnd.api+json",
+    ...options.headers
+  }
+});
+var getAdminAgentsByIdTrainingStats = (options) => (options.client ?? client).get({
+  security: [{ scheme: "bearer", type: "http" }],
+  url: "/admin/agents/{id}/training-stats",
+  ...options
+});
+var postAdminAgentsByIdTest = (options) => (options.client ?? client).post({
+  security: [{ scheme: "bearer", type: "http" }],
+  url: "/admin/agents/{id}/test",
+  ...options,
+  headers: {
+    "Content-Type": "application/vnd.api+json",
+    ...options.headers
+  }
+});
+var patchAdminApiKeysByIdResetPeriod = (options) => (options.client ?? client).patch({
+  security: [{ scheme: "bearer", type: "http" }],
+  url: "/admin/api-keys/{id}/reset-period",
+  ...options,
+  headers: {
+    "Content-Type": "application/vnd.api+json",
+    ...options.headers
+  }
+});
+var getAdminVoiceTranscriptionResults = (options) => (options.client ?? client).get({
+  security: [{ scheme: "bearer", type: "http" }],
+  url: "/admin/voice/transcription-results",
+  ...options
+});
+var postAdminAgentVersionsByIdRemoveSystemField = (options) => (options.client ?? client).post({
+  security: [{ scheme: "bearer", type: "http" }],
+  url: "/admin/agent-versions/{id}/remove-system-field",
+  ...options,
+  headers: {
+    "Content-Type": "application/vnd.api+json",
+    ...options.headers
+  }
+});
+var getAdminApiKeysStats = (options) => (options.client ?? client).get({
+  security: [{ scheme: "bearer", type: "http" }],
+  url: "/admin/api-keys/stats",
+  ...options
+});
+var postAdminAgentsByIdTeach = (options) => (options.client ?? client).post({
+  security: [{ scheme: "bearer", type: "http" }],
+  url: "/admin/agents/{id}/teach",
+  ...options,
+  headers: {
+    "Content-Type": "application/vnd.api+json",
+    ...options.headers
+  }
+});
+var patchAdminAgentsByIdSchemaVersionsByVersionId = (options) => (options.client ?? client).patch({
+  security: [{ scheme: "bearer", type: "http" }],
+  url: "/admin/agents/{id}/schema-versions/{version_id}",
+  ...options,
+  headers: {
+    "Content-Type": "application/vnd.api+json",
+    ...options.headers
+  }
+});
+var getAdminVoiceRecordingsById = (options) => (options.client ?? client).get({
+  security: [{ scheme: "bearer", type: "http" }],
+  url: "/admin/voice/recordings/{id}",
+  ...options
+});
+var patchAdminApiKeysByIdRevoke = (options) => (options.client ?? client).patch({
+  security: [{ scheme: "bearer", type: "http" }],
+  url: "/admin/api-keys/{id}/revoke",
+  ...options,
+  headers: {
+    "Content-Type": "application/vnd.api+json",
+    ...options.headers
+  }
+});
+var getAdminBuckets = (options) => (options.client ?? client).get({
+  security: [{ scheme: "bearer", type: "http" }],
+  url: "/admin/buckets",
+  ...options
+});
+var getAdminAgentsByIdSchemaVersions = (options) => (options.client ?? client).get({
+  security: [{ scheme: "bearer", type: "http" }],
+  url: "/admin/agents/{id}/schema-versions",
+  ...options
+});
+var postAdminAgentsByIdSchemaVersions = (options) => (options.client ?? client).post({
+  security: [{ scheme: "bearer", type: "http" }],
+  url: "/admin/agents/{id}/schema-versions",
+  ...options,
+  headers: {
+    "Content-Type": "application/vnd.api+json",
+    ...options.headers
+  }
+});
+var patchAdminApiKeysByIdRotate = (options) => (options.client ?? client).patch({
+  security: [{ scheme: "bearer", type: "http" }],
+  url: "/admin/api-keys/{id}/rotate",
+  ...options,
+  headers: {
+    "Content-Type": "application/vnd.api+json",
+    ...options.headers
+  }
+});
+var getAdminBucketsById = (options) => (options.client ?? client).get({
+  security: [{ scheme: "bearer", type: "http" }],
+  url: "/admin/buckets/{id}",
+  ...options
+});
+var patchAdminUsersByIdResetPassword = (options) => (options.client ?? client).patch({
+  security: [{ scheme: "bearer", type: "http" }],
+  url: "/admin/users/{id}/reset-password",
+  ...options,
+  headers: {
+    "Content-Type": "application/vnd.api+json",
+    ...options.headers
+  }
+});
+var deleteAdminEmailOutboundEmailsById = (options) => (options.client ?? client).delete({
+  security: [{ scheme: "bearer", type: "http" }],
+  url: "/admin/email/outbound-emails/{id}",
+  ...options
+});
+var getAdminEmailOutboundEmailsById = (options) => (options.client ?? client).get({
+  security: [{ scheme: "bearer", type: "http" }],
+  url: "/admin/email/outbound-emails/{id}",
+  ...options
+});
+var getAdminTrainingExamples = (options) => (options.client ?? client).get({
+  security: [{ scheme: "bearer", type: "http" }],
+  url: "/admin/training-examples",
+  ...options
+});
+var postAdminTrainingExamples = (options) => (options.client ?? client).post({
+  security: [{ scheme: "bearer", type: "http" }],
+  url: "/admin/training-examples",
+  ...options,
+  headers: {
+    "Content-Type": "application/vnd.api+json",
+    ...options.headers
+  }
+});
+var getAdminApiKeysActive = (options) => (options.client ?? client).get({
+  security: [{ scheme: "bearer", type: "http" }],
+  url: "/admin/api-keys/active",
+  ...options
+});
+var postAdminAgentsByIdAnalyzeTraining = (options) => (options.client ?? client).post({
+  security: [{ scheme: "bearer", type: "http" }],
+  url: "/admin/agents/{id}/analyze-training",
+  ...options
+});
+var postAdminTrainingExamplesBulk = (options) => (options.client ?? client).post({
+  security: [{ scheme: "bearer", type: "http" }],
+  url: "/admin/training-examples/bulk",
+  ...options,
+  headers: {
+    "Content-Type": "application/vnd.api+json",
+    ...options.headers
+  }
+});
+var postAdminAgentsByIdClone = (options) => (options.client ?? client).post({
+  security: [{ scheme: "bearer", type: "http" }],
+  url: "/admin/agents/{id}/clone",
+  ...options,
+  headers: {
+    "Content-Type": "application/vnd.api+json",
+    ...options.headers
+  }
+});
+var postAdminWebhookConfigsByIdTest = (options) => (options.client ?? client).post({
+  security: [{ scheme: "bearer", type: "http" }],
+  url: "/admin/webhook-configs/{id}/test",
+  ...options,
+  headers: {
+    "Content-Type": "application/vnd.api+json",
+    ...options.headers
+  }
+});
+var postAdminAgentVersionComparisons = (options) => (options.client ?? client).post({
+  security: [{ scheme: "bearer", type: "http" }],
+  url: "/admin/agent-version-comparisons",
+  ...options,
+  headers: {
+    "Content-Type": "application/vnd.api+json",
+    ...options.headers
+  }
+});
+var postAdminWebhookDeliveriesByIdRetry = (options) => (options.client ?? client).post({
+  security: [{ scheme: "bearer", type: "http" }],
+  url: "/admin/webhook-deliveries/{id}/retry",
+  ...options,
+  headers: {
+    "Content-Type": "application/vnd.api+json",
+    ...options.headers
+  }
+});
+var patchAdminEmailMarketingSenderProfilesByIdValidateDns = (options) => (options.client ?? client).patch({
+  security: [{ scheme: "bearer", type: "http" }],
+  url: "/admin/email-marketing/sender-profiles/{id}/validate-dns",
+  ...options,
+  headers: {
+    "Content-Type": "application/vnd.api+json",
+    ...options.headers
+  }
+});
+var getAdminAgentsUsage = (options) => (options.client ?? client).get({
+  security: [{ scheme: "bearer", type: "http" }],
+  url: "/admin/agents/usage",
+  ...options
+});
+var postAdminAgentsByIdValidate = (options) => (options.client ?? client).post({
+  security: [{ scheme: "bearer", type: "http" }],
+  url: "/admin/agents/{id}/validate",
+  ...options,
+  headers: {
+    "Content-Type": "application/vnd.api+json",
+    ...options.headers
+  }
+});
+var postAdminEmailMarketingCampaignsByIdSend = (options) => (options.client ?? client).post({
+  security: [{ scheme: "bearer", type: "http" }],
+  url: "/admin/email-marketing/campaigns/{id}/send",
+  ...options,
+  headers: {
+    "Content-Type": "application/vnd.api+json",
+    ...options.headers
+  }
+});
+var postAdminEmailMarketingSenderProfiles = (options) => (options.client ?? client).post({
+  security: [{ scheme: "bearer", type: "http" }],
+  url: "/admin/email-marketing/sender-profiles",
+  ...options,
+  headers: {
+    "Content-Type": "application/vnd.api+json",
+    ...options.headers
+  }
+});
+var getAdminVoiceRecordings = (options) => (options.client ?? client).get({
+  security: [{ scheme: "bearer", type: "http" }],
+  url: "/admin/voice/recordings",
+  ...options
+});
+
+// src/namespaces/agents.ts
+function createAgentsNamespace(rb) {
+  return {
+    /**
+     * Lists all agents (platform-wide, no workspace filter).
+     *
+     * @param options - Optional request options.
+     * @returns Array of Agent objects.
+     *
+     * @example
+     * const agents = await admin.agents.list();
+     */
+    list: async (options) => {
+      return rb.execute(getAdminAgents, {}, options);
+    },
+    /**
+     * Fetches a single agent by ID.
+     *
+     * @param id - The UUID of the agent.
+     * @param options - Optional request options.
+     * @returns The Agent record.
+     *
+     * @example
+     * const agent = await admin.agents.get('agt_01...');
+     */
+    get: async (id, options) => {
+      return rb.execute(getAdminAgentsById, { path: { id } }, options);
+    },
+    /**
+     * Clones an agent within the same workspace.
+     *
+     * @param id - The UUID of the agent to clone.
+     * @param attributes - Optional attributes for the clone (name, description).
+     * @param options - Optional request options.
+     * @returns The cloned Agent.
+     *
+     * @example
+     * const clone = await admin.agents.clone('agt_01...', { name: 'Clone of Bot' });
+     */
+    clone: async (id, attributes = {}, options) => {
+      return rb.execute(
+        postAdminAgentsByIdClone,
+        { path: { id }, body: { data: { type: "agent", attributes } } },
+        options
+      );
+    },
+    /**
+     * Clones an agent into a different workspace.
+     *
+     * @param agentId - The UUID of the agent to clone.
+     * @param targetWorkspaceId - The UUID of the destination workspace.
+     * @param options - Optional request options.
+     * @returns The cloned Agent in the target workspace.
+     *
+     * @example
+     * const cloned = await admin.agents.cloneForWorkspace('agt_01...', 'ws_02...');
+     */
+    cloneForWorkspace: async (agentId, targetWorkspaceId, options) => {
+      return rb.execute(
+        postAdminAgentsCloneForWorkspace,
+        {
+          body: {
+            data: {
+              type: "agent",
+              attributes: {
+                agent_id: agentId,
+                target_workspace_id: targetWorkspaceId
+              }
+            }
+          }
+        },
+        options
+      );
+    },
+    /**
+     * Exports an agent to a portable JSON bundle.
+     *
+     * @param id - The UUID of the agent to export.
+     * @param options - Optional request options.
+     * @returns The export bundle payload.
+     *
+     * @example
+     * const bundle = await admin.agents.export('agt_01...');
+     */
+    export: async (id, options) => {
+      return rb.execute(
+        postAdminAgentsByIdExport,
+        { path: { id }, body: {} },
+        options
+      );
+    },
+    /**
+     * Imports an agent from a portable export bundle.
+     *
+     * @param data - The export bundle object.
+     * @param options - Optional request options.
+     * @returns The newly created Agent.
+     *
+     * @example
+     * const imported = await admin.agents.import(exportBundle);
+     */
+    import: async (data, options) => {
+      return rb.execute(
+        postAdminAgentsImport,
+        { body: { data: { type: "agent", attributes: { data } } } },
+        options
+      );
+    },
+    /**
+     * Runs prediction/inference on an agent.
+     *
+     * @param agentId - The UUID of the agent.
+     * @param input - Input data for prediction.
+     * @param options - Optional request options.
+     * @returns Prediction result.
+     *
+     * @example
+     * const result = await admin.agents.predict('agt_01...', { text: 'Classify this' });
+     */
+    predict: async (agentId, input, options) => {
+      return rb.execute(
+        postAdminAgentsPredict,
+        {
+          body: {
+            data: {
+              type: "agent",
+              attributes: { agent_id: agentId, ...input }
+            }
+          }
+        },
+        options
+      );
+    },
+    /**
+     * Runs an agent against a test input and returns the result.
+     *
+     * @param id - The UUID of the agent.
+     * @param attributes - Test attributes (input, expected_output, etc.).
+     * @param options - Optional request options.
+     * @returns Test result payload.
+     *
+     * @example
+     * const result = await admin.agents.test('agt_01...', { input: { text: '...' } });
+     */
+    test: async (id, attributes, options) => {
+      return rb.execute(
+        postAdminAgentsByIdTest,
+        { path: { id }, body: { data: { type: "agent", attributes } } },
+        options
+      );
+    },
+    /**
+     * Validates an agent's configuration without publishing.
+     *
+     * @param id - The UUID of the agent.
+     * @param options - Optional request options.
+     * @returns Validation result with any errors or warnings.
+     *
+     * @example
+     * const result = await admin.agents.validate('agt_01...');
+     */
+    validate: async (id, options) => {
+      return rb.execute(
+        postAdminAgentsByIdValidate,
+        { path: { id }, body: {} },
+        options
+      );
+    },
+    /**
+     * Runs a training job (fine-tuning) on the agent using its examples.
+     *
+     * @param id - The UUID of the agent.
+     * @param attributes - Training configuration attributes.
+     * @param options - Optional request options.
+     * @returns Training job status payload.
+     *
+     * @example
+     * await admin.agents.teach('agt_01...', { epochs: 3 });
+     */
+    teach: async (id, attributes = {}, options) => {
+      return rb.execute(
+        postAdminAgentsByIdTeach,
+        { path: { id }, body: { data: { type: "agent", attributes } } },
+        options
+      );
+    },
+    /**
+     * Publishes a new immutable version from the agent's current state.
+     *
+     * @param id - The UUID of the agent.
+     * @param options - Optional request options.
+     * @returns The newly created AgentVersion.
+     *
+     * @example
+     * const version = await admin.agents.publishVersion('agt_01...');
+     */
+    publishVersion: async (id, options) => {
+      return rb.execute(
+        postAdminAgentsByIdPublishVersion,
+        { path: { id }, body: {} },
+        options
+      );
+    },
+    /**
+     * Restores a previously published version as the active version.
+     *
+     * @param id - The UUID of the agent.
+     * @param attributes - Must include `version_id` of the version to restore.
+     * @param options - Optional request options.
+     * @returns The restored AgentVersion.
+     *
+     * @example
+     * const version = await admin.agents.restoreVersion('agt_01...', { version_id: 'ver_01...' });
+     */
+    restoreVersion: async (id, attributes, options) => {
+      return rb.execute(
+        postAdminAgentsByIdRestoreVersion,
+        { path: { id }, body: { data: { type: "agent", attributes } } },
+        options
+      );
+    },
+    /**
+     * Analyzes training examples and returns insights.
+     *
+     * @param id - The UUID of the agent.
+     * @param options - Optional request options.
+     * @returns Training analysis result.
+     *
+     * @example
+     * const analysis = await admin.agents.analyzeTraining('agt_01...');
+     */
+    analyzeTraining: async (id, options) => {
+      return rb.execute(
+        postAdminAgentsByIdAnalyzeTraining,
+        { path: { id }, body: {} },
+        options
+      );
+    },
+    /**
+     * Retrieves usage statistics for a single agent.
+     *
+     * @param id - The UUID of the agent.
+     * @param options - Optional request options.
+     * @returns Usage data for the agent.
+     *
+     * @example
+     * const usage = await admin.agents.usage('agt_01...');
+     */
+    usage: async (id, options) => {
+      return rb.execute(
+        getAdminAgentsByIdUsage,
+        { path: { id } },
+        options
+      );
+    },
+    /**
+     * Retrieves usage information for all agents.
+     *
+     * @param options - Optional request options.
+     * @returns Array of usage data for all agents.
+     *
+     * @example
+     * const allUsage = await admin.agents.usageAll();
+     */
+    usageAll: async (options) => {
+      return rb.execute(
+        getAdminAgentsUsage,
+        {},
+        options
+      );
+    },
+    /**
+     * Retrieves execution and performance statistics for an agent.
+     *
+     * @param id - The UUID of the agent.
+     * @param options - Optional request options.
+     * @returns Statistics payload.
+     *
+     * @example
+     * const stats = await admin.agents.stats('agt_01...');
+     */
+    stats: async (id, options) => {
+      return rb.execute(
+        getAdminAgentsByIdStats,
+        { path: { id } },
+        options
+      );
+    },
+    /**
+     * Retrieves training statistics for a single agent.
+     *
+     * @param id - The UUID of the agent.
+     * @param options - Optional request options.
+     * @returns Training statistics data.
+     *
+     * @example
+     * const stats = await admin.agents.trainingStats('agt_01...');
+     */
+    trainingStats: async (id, options) => {
+      return rb.execute(
+        getAdminAgentsByIdTrainingStats,
+        { path: { id } },
+        options
+      );
+    },
+    /**
+     * Sub-namespace for managing immutable agent versions.
+     */
+    versions: {
+      /**
+       * Lists all agent versions.
+       *
+       * @param options - Optional request options.
+       * @returns Array of AgentVersion objects.
+       *
+       * @example
+       * const versions = await admin.agents.versions.list();
+       */
+      list: async (options) => {
+        return rb.execute(getAdminAgentVersions, {}, options);
+      },
+      /**
+       * Fetches a single agent version by ID.
+       *
+       * @param id - The UUID of the agent version.
+       * @param options - Optional request options.
+       * @returns The AgentVersion record.
+       *
+       * @example
+       * const version = await admin.agents.versions.get('ver_01...');
+       */
+      get: async (id, options) => {
+        return rb.execute(
+          getAdminAgentVersionsById,
+          { path: { id } },
+          options
+        );
+      },
+      /**
+       * Permanently deletes an agent version.
+       *
+       * @param id - The UUID of the version to delete.
+       * @param options - Optional request options.
+       * @returns True on successful deletion.
+       *
+       * @example
+       * await admin.agents.versions.delete('ver_01...');
+       */
+      delete: async (id, options) => {
+        return rb.executeDelete(
+          deleteAdminAgentVersionsById,
+          { path: { id } },
+          options
+        );
+      },
+      /**
+       * Creates a new agent version snapshot.
+       *
+       * @param attributes - Version attributes (agent_id, prompt_template, fields, etc.).
+       * @param options - Optional request options.
+       * @returns The newly created AgentVersion.
+       *
+       * @example
+       * const version = await admin.agents.versions.create({ agent_id: 'agt_01...', ... });
+       */
+      create: async (attributes, options) => {
+        return rb.execute(
+          postAdminAgentVersions,
+          { body: { data: { type: "agent_version", attributes } } },
+          options
+        );
+      },
+      /**
+       * Marks a system field as selected for this version.
+       *
+       * @param id - The UUID of the agent version.
+       * @param fieldName - The name of the system field to add (e.g. `_filename`).
+       * @param options - Optional request options.
+       * @returns The updated AgentVersion.
+       *
+       * @example
+       * await admin.agents.versions.addSystemField('ver_01...', '_filename');
+       */
+      addSystemField: async (id, fieldName, options) => {
+        return rb.execute(
+          postAdminAgentVersionsByIdAddSystemField,
+          {
+            path: { id },
+            body: {
+              data: {
+                type: "agent_version",
+                attributes: { system_field_name: fieldName }
+              }
+            }
+          },
+          options
+        );
+      },
+      /**
+       * Removes a system field from the selected set for this version.
+       *
+       * @param id - The UUID of the agent version.
+       * @param fieldName - The name of the system field to remove (e.g. `_filename`).
+       * @param options - Optional request options.
+       * @returns The updated AgentVersion.
+       *
+       * @example
+       * await admin.agents.versions.removeSystemField('ver_01...', '_filename');
+       */
+      removeSystemField: async (id, fieldName, options) => {
+        return rb.execute(
+          postAdminAgentVersionsByIdRemoveSystemField,
+          {
+            path: { id },
+            body: {
+              data: {
+                type: "agent_version",
+                attributes: { system_field_name: fieldName }
+              }
+            }
+          },
+          options
+        );
+      },
+      /**
+       * Sets the full list of selected system fields for this version.
+       *
+       * @param id - The UUID of the agent version.
+       * @param fieldNames - Array of system field names to set (e.g. `['_filename', '_pages']`).
+       * @param options - Optional request options.
+       * @returns The updated AgentVersion.
+       *
+       * @example
+       * await admin.agents.versions.setSystemFields('ver_01...', ['_filename', '_pages']);
+       */
+      setSystemFields: async (id, fieldNames, options) => {
+        return rb.execute(
+          postAdminAgentVersionsByIdSetSystemFields,
+          {
+            path: { id },
+            body: {
+              data: {
+                type: "agent_version",
+                attributes: { system_field_names: fieldNames }
+              }
+            }
+          },
+          options
+        );
+      },
+      /**
+       * Retrieves performance metrics for an agent version.
+       *
+       * @param id - The UUID of the agent version.
+       * @param options - Optional request options.
+       * @returns Metrics data for the version.
+       *
+       * @example
+       * const metrics = await admin.agents.versions.metrics('ver_01...');
+       */
+      metrics: async (id, options) => {
+        return rb.execute(
+          getAdminAgentVersionsByIdMetrics,
+          { path: { id } },
+          options
+        );
+      },
+      /**
+       * Lists revision history for an agent version.
+       *
+       * @param id - The UUID of the agent version.
+       * @param options - Optional request options.
+       * @returns Array of revision records.
+       *
+       * @example
+       * const revisions = await admin.agents.versions.revisions('ver_01...');
+       */
+      revisions: async (id, options) => {
+        return rb.execute(
+          getAdminAgentVersionsByIdRevisions,
+          { path: { id } },
+          options
+        );
+      },
+      /**
+       * Fetches a single revision record by ID.
+       *
+       * @param id - The UUID of the revision.
+       * @param options - Optional request options.
+       * @returns The revision record.
+       *
+       * @example
+       * const revision = await admin.agents.versions.getRevision('rev_01...');
+       */
+      getRevision: async (id, options) => {
+        return rb.execute(
+          getAdminAgentVersionRevisionsById,
+          { path: { id } },
+          options
+        );
+      },
+      /**
+       * Lists all revisions across all agent versions.
+       *
+       * @param options - Optional request options.
+       * @returns Array of revision records.
+       *
+       * @example
+       * const revisions = await admin.agents.versions.listAllRevisions();
+       */
+      listAllRevisions: async (options) => {
+        return rb.execute(
+          getAdminAgentVersionRevisions,
+          {},
+          options
+        );
+      },
+      /**
+       * Compares two agent versions side-by-side.
+       *
+       * @param versionAId - UUID of the first version.
+       * @param versionBId - UUID of the second version.
+       * @param options - Optional request options.
+       * @returns Comparison result with schema_diff and prompt_diff.
+       *
+       * @example
+       * const diff = await admin.agents.versions.compare('ver_A...', 'ver_B...');
+       */
+      compare: async (versionAId, versionBId, options) => {
+        return rb.execute(
+          postAdminAgentVersionComparisons,
+          {
+            body: {
+              data: {
+                type: "agent_version_comparison",
+                attributes: {
+                  version_a_id: versionAId,
+                  version_b_id: versionBId
+                }
+              }
+            }
+          },
+          options
+        );
+      },
+      /**
+       * Sub-namespace for managing schema versions within an agent.
+       */
+      schemaVersions: {
+        /**
+         * Lists all schema versions for an agent.
+         *
+         * @param agentId - The UUID of the agent.
+         * @param options - Optional request options.
+         * @returns Array of schema version records.
+         *
+         * @example
+         * const versions = await admin.agents.versions.schemaVersions.list('agt_01...');
+         */
+        list: async (agentId, options) => {
+          return rb.execute(
+            getAdminAgentsByIdSchemaVersions,
+            { path: { id: agentId } },
+            options
+          );
+        },
+        /**
+         * Creates a new schema version for an agent.
+         *
+         * @param agentId - The UUID of the agent.
+         * @param attributes - Schema version attributes.
+         * @param options - Optional request options.
+         * @returns The newly created schema version.
+         *
+         * @example
+         * const sv = await admin.agents.versions.schemaVersions.create('agt_01...', { fields: [...] });
+         */
+        create: async (agentId, attributes, options) => {
+          return rb.execute(
+            postAdminAgentsByIdSchemaVersions,
+            {
+              path: { id: agentId },
+              body: { data: { type: "agent_version", attributes } }
+            },
+            options
+          );
+        },
+        /**
+         * Activates a schema version, making it the live version.
+         *
+         * @param agentId - The UUID of the agent.
+         * @param versionId - The UUID of the schema version to activate.
+         * @param options - Optional request options.
+         * @returns The activated schema version.
+         *
+         * @example
+         * await admin.agents.versions.schemaVersions.activate('agt_01...', 'ver_01...');
+         */
+        activate: async (agentId, versionId, options) => {
+          return rb.execute(
+            postAdminAgentsByIdSchemaVersionsByVersionIdActivate,
+            { path: { id: agentId, version_id: versionId }, body: {} },
+            options
+          );
+        },
+        /**
+         * Updates an existing schema version.
+         *
+         * @param agentId - The UUID of the agent.
+         * @param versionId - The UUID of the schema version to update.
+         * @param attributes - Attributes to update.
+         * @param options - Optional request options.
+         * @returns The updated schema version.
+         *
+         * @example
+         * await admin.agents.versions.schemaVersions.update('agt_01...', 'ver_01...', { fields: [...] });
+         */
+        update: async (agentId, versionId, attributes, options) => {
+          return rb.execute(
+            patchAdminAgentsByIdSchemaVersionsByVersionId,
+            {
+              path: { id: agentId, version_id: versionId },
+              body: { data: { type: "agent_version", attributes } }
+            },
+            options
+          );
+        }
+      }
+    },
+    /**
+     * Sub-namespace for managing training examples attached to agents.
+     */
+    training: {
+      /**
+       * Lists all training examples.
+       *
+       * @param options - Optional request options.
+       * @returns Array of TrainingExample objects.
+       *
+       * @example
+       * const examples = await admin.agents.training.list();
+       */
+      list: async (options) => {
+        return rb.execute(
+          getAdminTrainingExamples,
+          {},
+          options
+        );
+      },
+      /**
+       * Fetches a single training example by ID.
+       *
+       * @param id - The UUID of the training example.
+       * @param options - Optional request options.
+       * @returns The TrainingExample record.
+       *
+       * @example
+       * const example = await admin.agents.training.get('tex_01...');
+       */
+      get: async (id, options) => {
+        return rb.execute(
+          getAdminTrainingExamplesById,
+          { path: { id } },
+          options
+        );
+      },
+      /**
+       * Creates a new training example.
+       *
+       * @param attributes - Training example attributes (agent_id, input_text, output_json, etc.).
+       * @param options - Optional request options.
+       * @returns The created TrainingExample.
+       *
+       * @example
+       * const example = await admin.agents.training.create({ agent_id: 'agt_01...', input_text: '...', output_json: {} });
+       */
+      create: async (attributes, options) => {
+        return rb.execute(
+          postAdminTrainingExamples,
+          { body: { data: { type: "training_example", attributes } } },
+          options
+        );
+      },
+      /**
+       * Updates a training example's attributes.
+       *
+       * @param id - The UUID of the training example.
+       * @param attributes - Attributes to update.
+       * @param options - Optional request options.
+       * @returns The updated TrainingExample.
+       *
+       * @example
+       * const updated = await admin.agents.training.update('tex_01...', { label: 'reviewed' });
+       */
+      update: async (id, attributes, options) => {
+        return rb.execute(
+          patchAdminTrainingExamplesById,
+          {
+            path: { id },
+            body: { data: { id, type: "training_example", attributes } }
+          },
+          options
+        );
+      },
+      /**
+       * Deletes a training example.
+       *
+       * @param id - The UUID of the training example to delete.
+       * @param options - Optional request options.
+       * @returns True on successful deletion.
+       *
+       * @example
+       * await admin.agents.training.delete('tex_01...');
+       */
+      delete: async (id, options) => {
+        return rb.executeDelete(
+          deleteAdminTrainingExamplesById,
+          { path: { id } },
+          options
+        );
+      },
+      /**
+       * Creates multiple training examples in a single batch operation.
+       *
+       * @param examples - Array of training example attribute objects.
+       * @param options - Optional request options.
+       * @returns Array of created TrainingExample objects.
+       *
+       * @example
+       * const created = await admin.agents.training.bulkCreate([
+       *   { agent_id: 'agt_01...', input_text: '...', output_json: {} },
+       * ]);
+       */
+      bulkCreate: async (examples, options) => {
+        return rb.execute(
+          postAdminTrainingExamplesBulk,
+          {
+            body: {
+              data: examples.map((attrs) => ({
+                type: "training_example",
+                attributes: attrs
+              }))
+            }
+          },
+          options
+        );
+      },
+      /**
+       * Deletes multiple training examples in a single batch operation.
+       *
+       * @param ids - Array of training example UUIDs to delete.
+       * @param options - Optional request options.
+       * @returns Deletion result payload.
+       *
+       * @example
+       * await admin.agents.training.bulkDelete(['tex_01...', 'tex_02...']);
+       */
+      bulkDelete: async (ids, options) => {
+        return rb.execute(
+          postAdminTrainingExamplesBulkDelete,
+          {
+            body: { data: ids.map((id) => ({ type: "training_example", id })) }
+          },
+          options
+        );
+      },
+      /**
+       * Searches training examples by semantic similarity.
+       *
+       * @param query - The search query text.
+       * @param options - Optional request options.
+       * @returns Array of matching TrainingExample objects.
+       *
+       * @example
+       * const results = await admin.agents.training.search('invoice total');
+       */
+      search: async (query, options) => {
+        return rb.execute(
+          postAdminTrainingExamplesSearch,
+          {
+            body: {
+              data: { type: "training_example", attributes: { query } }
+            }
+          },
+          options
+        );
+      },
+      /**
+       * Lists training examples for a specific agent.
+       *
+       * @param agentId - The UUID of the agent.
+       * @param options - Optional request options.
+       * @returns Array of training examples for the agent.
+       *
+       * @example
+       * const examples = await admin.agents.training.listForAgent('agt_01...');
+       */
+      listForAgent: async (agentId, options) => {
+        return rb.execute(
+          getAdminAgentsByIdTrainingExamples,
+          { path: { id: agentId } },
+          options
+        );
+      },
+      /**
+       * Deletes a training example for a specific agent.
+       *
+       * @param agentId - The UUID of the agent.
+       * @param exampleId - The UUID of the training example.
+       * @param options - Optional request options.
+       * @returns True on successful deletion.
+       *
+       * @example
+       * await admin.agents.training.deleteForAgent('agt_01...', 'tex_01...');
+       */
+      deleteForAgent: async (agentId, exampleId, options) => {
+        return rb.executeDelete(
+          deleteAdminAgentsByIdTrainingExamplesByExampleId,
+          { path: { id: agentId, example_id: exampleId } },
+          options
+        );
+      },
+      /**
+       * Sub-namespace for managing training sessions.
+       */
+      sessions: {
+        /**
+         * Lists training sessions for a specific agent.
+         *
+         * @param agentId - The UUID of the agent.
+         * @param options - Optional request options.
+         * @returns Array of training session records.
+         *
+         * @example
+         * const sessions = await admin.agents.training.sessions.list('agt_01...');
+         */
+        list: async (agentId, options) => {
+          return rb.execute(
+            getAdminTrainingSessionsAgentsByAgentIdSessions,
+            { path: { agent_id: agentId } },
+            options
+          );
+        },
+        /**
+         * Fetches a single training session by ID.
+         *
+         * @param id - The UUID of the training session.
+         * @param options - Optional request options.
+         * @returns The training session record.
+         *
+         * @example
+         * const session = await admin.agents.training.sessions.get('ts_01...');
+         */
+        get: async (id, options) => {
+          return rb.execute(
+            getAdminTrainingSessionsById,
+            { path: { id } },
+            options
+          );
+        },
+        /**
+         * Deletes a training session.
+         *
+         * @param id - The UUID of the training session.
+         * @param options - Optional request options.
+         * @returns True on successful deletion.
+         *
+         * @example
+         * await admin.agents.training.sessions.delete('ts_01...');
+         */
+        delete: async (id, options) => {
+          return rb.executeDelete(
+            deleteAdminTrainingSessionsById,
+            { path: { id } },
+            options
+          );
+        }
+      }
+    },
+    /**
+     * Sub-namespace for field templates — reusable field definitions.
+     */
+    fieldTemplates: {
+      /**
+       * Lists all available field templates.
+       *
+       * @param options - Optional request options.
+       * @returns Array of field template objects.
+       *
+       * @example
+       * const templates = await admin.agents.fieldTemplates.list();
+       */
+      list: async (options) => {
+        return rb.execute(
+          getAdminFieldTemplates,
+          {},
+          options
+        );
+      },
+      /**
+       * Fetches a single field template by ID.
+       *
+       * @param id - The UUID of the field template.
+       * @param options - Optional request options.
+       * @returns The field template object.
+       *
+       * @example
+       * const template = await admin.agents.fieldTemplates.get('ftpl_01...');
+       */
+      get: async (id, options) => {
+        return rb.execute(
+          getAdminFieldTemplatesById,
+          { path: { id } },
+          options
+        );
+      },
+      /**
+       * Creates a new field template.
+       *
+       * @param attributes - Field template attributes (name, category, field_type, etc.).
+       * @param options - Optional request options.
+       * @returns The created field template object.
+       *
+       * @example
+       * const template = await admin.agents.fieldTemplates.create({ name: 'Invoice Total', category: 'finance', field_type: 'currency' });
+       */
+      create: async (attributes, options) => {
+        return rb.execute(
+          postAdminFieldTemplates,
+          { body: { data: { type: "field_template", attributes } } },
+          options
+        );
+      },
+      /**
+       * Permanently deletes a field template by ID.
+       *
+       * @param id - The UUID of the field template to delete.
+       * @param options - Optional request options.
+       * @returns True on successful deletion.
+       *
+       * @example
+       * await admin.agents.fieldTemplates.delete('ftpl_01...');
+       */
+      delete: async (id, options) => {
+        return rb.executeDelete(
+          deleteAdminFieldTemplatesById,
+          { path: { id } },
+          options
+        );
+      }
+    }
+  };
+}
+
+// src/namespaces/accounts.ts
+function createAccountsNamespace(rb) {
+  return {
+    /**
+     * Lists all billing accounts across the platform.
+     *
+     * @param options - Optional request options (headers, abort signal).
+     * @returns Array of Account objects with current balances.
+     */
+    list: async (options) => {
+      return rb.execute(getAdminAccounts, {}, options);
+    },
+    /**
+     * Fetches a single billing account by ID.
+     *
+     * @param id - Account ID.
+     * @param options - Optional request options.
+     * @returns The Account record.
+     */
+    get: async (id, options) => {
+      return rb.execute(
+        getAdminAccountsById,
+        { path: { id } },
+        options
+      );
+    },
+    /**
+     * Adds credits to an account balance.
+     *
+     * Use for manual top-ups, promotional credits, or correction adjustments.
+     * The amount must be a positive number greater than zero.
+     *
+     * @param id - Account ID.
+     * @param amount - Number of credits to add (must be > 0).
+     * @param description - Optional human-readable reason for the credit.
+     * @param options - Optional request options.
+     * @returns Updated Account with the new balance.
+     */
+    credit: async (id, amount, description, options) => {
       if (amount <= 0) {
         throw new Error("Credit amount must be positive");
       }
@@ -1567,6 +3138,18 @@ function createAccountsNamespace(rb) {
         options
       );
     },
+    /**
+     * Deducts credits from an account balance.
+     *
+     * Use for charge-backs, manual usage adjustments, or corrections.
+     * The amount must be a positive number greater than zero.
+     *
+     * @param id - Account ID.
+     * @param amount - Number of credits to deduct (must be > 0).
+     * @param description - Optional human-readable reason for the debit.
+     * @param options - Optional request options.
+     * @returns Updated Account with the new balance.
+     */
     debit: async (id, amount, description, options) => {
       if (amount <= 0) {
         throw new Error("Debit amount must be positive");
@@ -1585,129 +3168,1142 @@ function createAccountsNamespace(rb) {
   };
 }
 
-// src/namespaces/apiKeys.ts
-function createApiKeysNamespace(rb) {
+// src/namespaces/capabilities.ts
+function createCapabilitiesNamespace(rb) {
+  return {
+    /**
+     * List the full capability catalog (platform admin view — no app annotations).
+     *
+     * Returns all capabilities with their tier, dependency, and metadata
+     * information. No per-application annotations (`enabled`, `can_enable`,
+     * etc.) — this view shows the raw platform catalog.
+     *
+     * Requires a platform admin key (`sk_sys_`).
+     *
+     * @param options - Optional request options (signal for cancellation, etc.).
+     * @returns Array of `AdminCapabilityEntry` objects.
+     *
+     * @example
+     * ```typescript
+     * const admin = new GptAdmin({ apiKey: 'sk_sys_...' });
+     * const catalog = await admin.capabilities.list();
+     * const premium = catalog.filter(c => c.tier === "premium");
+     * ```
+     */
+    list: async (options) => {
+      return rb.rawGet("/sys/capabilities", options);
+    },
+    /**
+     * List the capability catalog annotated for the authenticated application
+     * (ISV view).
+     *
+     * Returns the full catalog with per-application state:
+     * - `enabled` — whether the app currently has this capability active
+     * - `can_enable` — whether the plan tier allows enabling it
+     * - `missing_requires` — required capabilities not yet enabled
+     * - `missing_requires_any` — `requires_any` alternatives not yet enabled
+     *
+     * Requires an ISV application key (`sk_app_`, `sk_srv_`). Use this method
+     * to build plan upgrade flows and capability management UIs.
+     *
+     * @param options - Optional request options (signal for cancellation, etc.).
+     * @returns Array of `AnnotatedCapabilityEntry` objects.
+     *
+     * @example
+     * ```typescript
+     * const admin = new GptAdmin({ apiKey: 'sk_srv_...' });
+     * const catalog = await admin.capabilities.listForApplication();
+     * const upgradeable = catalog.filter(c => !c.enabled && c.can_enable);
+     * ```
+     */
+    listForApplication: async (options) => {
+      return rb.rawGet(
+        "/isv/capabilities",
+        options
+      );
+    },
+    /**
+     * Get a single capability by key from the platform admin catalog.
+     *
+     * Convenience method that fetches the full catalog and returns the entry
+     * matching `key`, or `null` if not found.
+     *
+     * Requires a platform admin key (`sk_sys_`).
+     *
+     * @param key - The capability atom key as a string (e.g., `"salesforce_bulk"`).
+     * @param options - Optional request options.
+     * @returns The matching `AdminCapabilityEntry`, or `null`.
+     *
+     * @example
+     * ```typescript
+     * const entry = await admin.capabilities.get("salesforce_bulk");
+     * if (entry) console.log(entry.tier); // "premium"
+     * ```
+     */
+    get: async (key, options) => {
+      const all = await rb.rawGet(
+        "/sys/capabilities",
+        options
+      );
+      return all.find((c) => c.key === key) ?? null;
+    }
+  };
+}
+
+// src/namespaces/apiKeys.ts
+function createApiKeysNamespace(rb) {
+  return {
+    /**
+     * Lists API keys. Supports keyset and offset pagination.
+     *
+     * Returns keys scoped to the actor — users see only their own keys,
+     * ISV owners see keys for their application.
+     *
+     * @param options - Optional request options.
+     * @returns Array of ApiKey objects.
+     */
+    list: async (options) => {
+      return rb.execute(getAdminApiKeys, {}, options);
+    },
+    /**
+     * Fetches a single API key by ID.
+     *
+     * @param id - API key ID.
+     * @param options - Optional request options.
+     * @returns The ApiKey record.
+     */
+    get: async (id, options) => {
+      return rb.execute(getAdminApiKeysById, { path: { id } }, options);
+    },
+    /**
+     * Revokes an API key, setting its status to `revoked` and recording the
+     * revocation timestamp.
+     *
+     * Triggers smart credit reclaim: any unspent credits allocated to this key
+     * are returned to the App Treasury or Tenant Wallet. Prefer this over
+     * hard deletion to preserve the audit trail.
+     *
+     * @param id - API key ID.
+     * @param options - Optional request options.
+     * @returns Updated ApiKey with status `revoked`.
+     */
+    revoke: async (id, options) => {
+      return rb.execute(
+        patchAdminApiKeysByIdRevoke,
+        { path: { id }, body: {} },
+        options
+      );
+    },
+    /**
+     * Rotates an API key by generating a new token while preserving the key's
+     * ID, metadata, and configuration.
+     *
+     * The new raw token is returned once in the `generated_api_key` field and
+     * cannot be retrieved again. All active sessions using the old token are
+     * immediately invalidated.
+     *
+     * @param id - API key ID.
+     * @param options - Optional request options.
+     * @returns Updated ApiKey with the new token in `generated_api_key`.
+     */
+    rotate: async (id, options) => {
+      return rb.execute(
+        patchAdminApiKeysByIdRotate,
+        { path: { id }, body: {} },
+        options
+      );
+    },
+    /**
+     * Create a new API key.
+     * @param attributes - Key attributes (name, key_type, scopes, etc.)
+     * @returns Created API key with generated token
+     */
+    create: async (attributes, options) => {
+      return rb.execute(
+        postAdminApiKeys,
+        { body: { data: { type: "api_key", attributes } } },
+        options
+      );
+    },
+    /**
+     * Update an API key's configuration.
+     * @param id - API key ID
+     * @param attributes - Attributes to update (name, scopes, rate limits)
+     * @returns Updated API key
+     */
+    update: async (id, attributes, options) => {
+      return rb.execute(
+        patchAdminApiKeysById,
+        { path: { id }, body: { data: { id, type: "api_key", attributes } } },
+        options
+      );
+    },
+    /**
+     * Delete an API key permanently.
+     * @param id - API key ID
+     */
+    delete: async (id, options) => {
+      return rb.executeDelete(
+        deleteAdminApiKeysById,
+        { path: { id } },
+        options
+      );
+    },
+    /**
+     * Set or remove a credit budget for an API key.
+     * @param id - API key ID
+     * @param creditLimit - Max credits per period (null to remove)
+     * @param creditLimitPeriod - Budget period (null to remove)
+     * @returns Updated API key
+     */
+    setBudget: async (id, creditLimit, creditLimitPeriod, options) => {
+      return rb.execute(
+        patchAdminApiKeysByIdSetBudget,
+        {
+          path: { id },
+          body: {
+            data: {
+              id,
+              type: "api_key",
+              attributes: {
+                credit_limit: creditLimit,
+                credit_limit_period: creditLimitPeriod
+              }
+            }
+          }
+        },
+        options
+      );
+    },
+    /**
+     * Get API key usage statistics grouped by key type.
+     * @returns Array of usage stat records
+     */
+    usageStats: async (options) => {
+      return rb.execute(
+        getAdminApiKeysStats,
+        {},
+        options
+      );
+    },
+    /**
+     * List only active (non-revoked) API keys.
+     * @returns Array of active API keys
+     */
+    active: async (options) => {
+      return rb.execute(getAdminApiKeysActive, {}, options);
+    },
+    /**
+     * Reset the budget period for an API key (resets period_credits_used to 0).
+     * @param id - API key ID
+     * @returns Updated API key
+     */
+    resetBudgetPeriod: async (id, options) => {
+      return rb.execute(
+        patchAdminApiKeysByIdResetPeriod,
+        {
+          path: { id },
+          body: { data: { id, type: "api_key", attributes: {} } }
+        },
+        options
+      );
+    }
+  };
+}
+
+// src/namespaces/documents.ts
+function createDocumentsNamespace(rb) {
+  return {
+    /**
+     * Lists active (non-deleted) documents across the platform.
+     *
+     * Excludes soft-deleted documents. To list deleted documents, call the
+     * API directly with the `read_trashed` action.
+     *
+     * @param options - Optional request options.
+     * @returns Array of ExtractionDocument objects.
+     */
+    list: async (options) => {
+      return rb.execute(
+        getAdminExtractionDocuments,
+        {},
+        options
+      );
+    },
+    /**
+     * Fetches a single active document by ID.
+     *
+     * Returns a 404 error for soft-deleted documents.
+     *
+     * @param id - Document ID.
+     * @param options - Optional request options.
+     * @returns The ExtractionDocument.
+     */
+    get: async (id, options) => {
+      return rb.execute(
+        getAdminExtractionDocumentsById,
+        { path: { id } },
+        options
+      );
+    },
+    /**
+     * Soft-deletes up to 100 documents in a single operation.
+     *
+     * Sets `deleted_at` on each document without removing the database rows,
+     * preserving the audit trail. Throws synchronously if the array is empty
+     * or exceeds 100 items.
+     *
+     * @param ids - Array of document IDs to delete (1–100 items).
+     * @param options - Optional request options.
+     * @returns Result metadata for the bulk operation.
+     */
+    bulkDelete: async (ids, options) => {
+      if (ids.length === 0) {
+        throw new Error("At least one document ID is required");
+      }
+      if (ids.length > 100) {
+        throw new Error("Maximum 100 documents per bulk operation");
+      }
+      return rb.execute(
+        postAdminDocumentsBulkDelete,
+        { body: { data: { type: "bulk_delete", attributes: { ids } } } },
+        options
+      );
+    },
+    /**
+     * Returns platform-wide document statistics.
+     *
+     * Includes total counts by status (uploaded, processing, complete, failed)
+     * and aggregate storage usage.
+     *
+     * @param options - Optional request options.
+     * @returns Statistics record.
+     */
+    stats: async (options) => {
+      return rb.execute(
+        getAdminDocumentsStats,
+        {},
+        options
+      );
+    }
+  };
+}
+
+// src/namespaces/executions.ts
+function createExecutionsNamespace(rb) {
+  return {
+    /**
+     * Start a new agent execution.
+     *
+     * @param agentId - The UUID of the agent to execute.
+     * @param input - Input data for the agent (task description, documents, etc.).
+     * @param options - Optional request options. Use `idempotencyKey` to prevent duplicate executions.
+     * @returns The created execution record with status `pending`.
+     *
+     * @example
+     * const exec = await admin.executions.start('agt_01...', {
+     *   task: 'Process invoice batch',
+     * });
+     * console.log(`Execution ${exec.id} started, status: ${exec.status}`);
+     */
+    async start(agentId, input, options) {
+      return rb.rawPost(
+        `/isv/agents/${agentId}/execute`,
+        { input },
+        options
+      );
+    },
+    /**
+     * Estimate credits required for an execution without running it.
+     *
+     * @param agentId - The UUID of the agent.
+     * @param input - The input the agent would process.
+     * @param options - Optional request options.
+     * @returns Cost estimate with min/max credit ranges.
+     *
+     * @example
+     * const estimate = await admin.executions.estimate('agt_01...', {
+     *   task: 'Process batch',
+     * });
+     * console.log(`Estimated: ${estimate.min_credits} - ${estimate.max_credits}`);
+     */
+    async estimate(agentId, input, options) {
+      return rb.rawPost(
+        `/isv/agents/${agentId}/estimate`,
+        { input },
+        options
+      );
+    },
+    /**
+     * List agent executions.
+     *
+     * @param options - Optional request options.
+     * @returns Array of execution records.
+     *
+     * @example
+     * const executions = await admin.executions.list();
+     */
+    async list(options) {
+      return rb.rawGet("/isv/agent-executions", options);
+    },
+    /**
+     * Get a single execution by ID.
+     *
+     * @param id - Execution UUID.
+     * @param options - Optional request options.
+     * @returns The execution record.
+     *
+     * @example
+     * const exec = await admin.executions.get('exec_01...');
+     * console.log(exec.status, exec.total_tokens);
+     */
+    async get(id, options) {
+      return rb.rawGet(`/isv/agent-executions/${id}`, options);
+    },
+    /**
+     * Stream execution events via Server-Sent Events.
+     * Returns an async iterator of typed execution events.
+     *
+     * @param id - Execution UUID to stream.
+     * @param options - Optional request and stream options.
+     * @returns Async iterator of ExecutionEvent objects.
+     *
+     * @example
+     * const stream = await admin.executions.stream(exec.id);
+     * for await (const event of stream) {
+     *   if (event.type === 'token_delta') process.stdout.write(event.data.content);
+     *   if (event.type === 'done') console.log('Complete');
+     * }
+     */
+    async stream(id, options) {
+      return rb.streamGetRequest(
+        `/isv/agent-executions/${id}/stream`,
+        options
+      );
+    },
+    /**
+     * Approve a pending human-in-the-loop tool call.
+     *
+     * @param id - Execution UUID awaiting approval.
+     * @param options - Optional request options.
+     * @returns The updated execution record.
+     *
+     * @example
+     * await admin.executions.approve('exec_01...');
+     */
+    async approve(id, options) {
+      return rb.rawPost(
+        `/isv/agent-executions/${id}/approve`,
+        void 0,
+        options
+      );
+    },
+    /**
+     * Deny a pending human-in-the-loop tool call.
+     *
+     * @param id - Execution UUID awaiting approval.
+     * @param reason - Human-readable reason for rejection.
+     * @param options - Optional request options.
+     * @returns The updated execution record.
+     *
+     * @example
+     * await admin.executions.deny('exec_01...', 'Not authorized to send emails');
+     */
+    async deny(id, reason, options) {
+      return rb.rawPost(
+        `/isv/agent-executions/${id}/deny`,
+        { reason },
+        options
+      );
+    },
+    /**
+     * Cancel an in-progress execution.
+     *
+     * @param id - Execution UUID to cancel.
+     * @param options - Optional request options.
+     * @returns The updated execution record with `cancelled` status.
+     *
+     * @example
+     * await admin.executions.cancel('exec_01...');
+     */
+    async cancel(id, options) {
+      return rb.rawPost(
+        `/isv/agent-executions/${id}/cancel`,
+        void 0,
+        options
+      );
+    },
+    /**
+     * List child executions spawned by a parent execution (multi-agent delegation).
+     *
+     * @param id - Parent execution UUID.
+     * @param options - Optional request options.
+     * @returns Array of child execution records.
+     *
+     * @example
+     * const children = await admin.executions.children('exec_01...');
+     */
+    async children(id, options) {
+      return rb.rawGet(
+        `/isv/agent-executions/${id}/children`,
+        options
+      );
+    },
+    /**
+     * Get the full execution tree for a root execution.
+     * Includes all nested child executions and their statuses.
+     *
+     * @param id - Root execution UUID.
+     * @param options - Optional request options.
+     * @returns Hierarchical execution tree structure.
+     *
+     * @example
+     * const tree = await admin.executions.tree('exec_01...');
+     */
+    async tree(id, options) {
+      return rb.rawGet(
+        `/isv/agent-executions/${id}/tree`,
+        options
+      );
+    }
+  };
+}
+
+// src/namespaces/storage.ts
+function createStorageNamespace(rb) {
+  return {
+    /**
+     * Retrieves platform-wide storage statistics.
+     *
+     * Pass a `workspaceId` to scope results to a single workspace.
+     *
+     * @param workspaceId - Optional workspace ID to filter statistics.
+     * @param options - Optional request options.
+     * @returns Storage statistics record with byte counts and file totals.
+     */
+    stats: async (workspaceId, options) => {
+      const params = workspaceId ? { query: { "filter[workspace_id]": workspaceId } } : {};
+      return rb.execute(
+        getAdminStorageStats,
+        params,
+        options
+      );
+    },
+    buckets: {
+      /**
+       * Lists all storage buckets, excluding processing-type buckets by default.
+       *
+       * @param options - Optional request options.
+       * @returns Array of Bucket objects.
+       */
+      list: async (options) => {
+        return rb.execute(getAdminBuckets, {}, options);
+      },
+      /**
+       * Fetches a single bucket by ID.
+       *
+       * @param id - Bucket ID.
+       * @param options - Optional request options.
+       * @returns The Bucket record.
+       */
+      get: async (id, options) => {
+        return rb.execute(
+          getAdminBucketsById,
+          { path: { id } },
+          options
+        );
+      },
+      /**
+       * Fetches a bucket with the `storage_used` calculation.
+       *
+       * Returns total bytes across all workspace files stored in this bucket.
+       *
+       * @param id - Bucket ID.
+       * @param options - Optional request options.
+       * @returns Bucket record including computed `storage_used` field.
+       */
+      stats: async (id, options) => {
+        return rb.execute(
+          getAdminBucketsByIdStats,
+          { path: { id } },
+          options
+        );
+      }
+    }
+  };
+}
+
+// src/pagination.ts
+var DEFAULT_MAX_PAGES = 500;
+async function* paginateAll(fetcher, options = {}) {
+  const pageSize = options.pageSize || 20;
+  const limit = options.limit;
+  const maxPages = options.maxPages ?? DEFAULT_MAX_PAGES;
+  const logger = options.logger ?? (typeof console !== "undefined" ? console : void 0);
+  let page = 1;
+  let totalYielded = 0;
+  while (true) {
+    if (page > maxPages) {
+      logger?.warn(
+        `[GPT Core SDK] Pagination stopped: reached maximum page limit (${maxPages}). Use options.maxPages to increase or options.limit to cap total items.`
+      );
+      return;
+    }
+    const response = await fetcher(page, pageSize);
+    for (const item of response.data) {
+      yield item;
+      totalYielded++;
+      if (limit && totalYielded >= limit) {
+        return;
+      }
+    }
+    if (!response.links?.next || response.data.length === 0) {
+      break;
+    }
+    page++;
+  }
+}
+var DEFAULT_LIMIT = 1e4;
+async function paginateToArray(fetcher, options = {}) {
+  const safeOptions = {
+    pageSize: options.pageSize || 20,
+    // Security: Apply default limit to prevent unbounded memory usage
+    limit: options.limit ?? DEFAULT_LIMIT,
+    logger: options.logger
+  };
+  const results = [];
+  for await (const item of paginateAll(fetcher, safeOptions)) {
+    results.push(item);
+  }
+  return results;
+}
+
+// src/namespace-types.ts
+function buildPageQuery(page, pageSize) {
+  return {
+    query: {
+      page: {
+        ...page && { number: page },
+        ...pageSize && { size: pageSize }
+      }
+    }
+  };
+}
+
+// src/namespaces/users.ts
+function createUsersNamespace(rb) {
   return {
+    /**
+     * List all users (paginated).
+     * @param options - Optional page and pageSize along with request options
+     * @returns Array of users
+     */
     list: async (options) => {
-      return rb.execute(getAdminApiKeys, {}, options);
-    },
-    get: async (id, options) => {
-      return rb.execute(getAdminApiKeysById, { path: { id } }, options);
-    },
-    allocate: async (id, amount, description, options) => {
       return rb.execute(
-        patchAdminApiKeysByIdAllocate,
-        {
-          path: { id },
-          body: {
-            data: { type: "api_key", attributes: { amount, description } }
-          }
-        },
+        getAdminUsers,
+        buildPageQuery(options?.page, options?.pageSize),
         options
       );
     },
-    revoke: async (id, options) => {
-      return rb.execute(
-        patchAdminApiKeysByIdRevoke,
-        { path: { id }, body: {} },
-        options
+    /**
+     * List all users (fetches all pages automatically).
+     * @returns Complete array of all users
+     */
+    listAll: async (options) => {
+      return paginateToArray(
+        rb.createPaginatedFetcher(
+          getAdminUsers,
+          (page, pageSize) => ({
+            query: { page: { number: page, size: pageSize } }
+          }),
+          options
+        )
       );
     },
-    rotate: async (id, options) => {
+    /**
+     * Get a user by ID.
+     * @param id - User ID
+     * @returns User object
+     */
+    get: async (id, options) => {
+      return rb.execute(getAdminUsersById, { path: { id } }, options);
+    },
+    /**
+     * Look up a user by email address.
+     * @param email - Email address to search
+     * @returns User object
+     */
+    getByEmail: async (email, options) => {
       return rb.execute(
-        patchAdminApiKeysByIdRotate,
-        { path: { id }, body: {} },
+        getAdminUsersByEmail,
+        { query: { email } },
         options
       );
-    }
-  };
-}
-
-// src/namespaces/documents.ts
-function createDocumentsNamespace(rb) {
-  return {
-    list: async (options) => {
+    },
+    /**
+     * Update a user's admin-level attributes (is_platform_admin, is_app_admin).
+     * @param id - User ID
+     * @param attributes - Admin attributes to update
+     * @returns Updated user
+     */
+    adminUpdate: async (id, attributes, options) => {
       return rb.execute(
-        getAdminExtractionDocuments,
-        {},
+        patchAdminUsersByIdAdmin,
+        { path: { id }, body: { data: { id, type: "user", attributes } } },
         options
       );
     },
-    get: async (id, options) => {
+    /**
+     * Change a user's email address (admin action).
+     * @param id - User ID
+     * @param email - New email address
+     * @returns Updated user
+     */
+    adminUpdateEmail: async (id, email, options) => {
       return rb.execute(
-        getAdminExtractionDocumentsById,
-        { path: { id } },
+        patchAdminUsersByIdAdminEmail,
+        {
+          path: { id },
+          body: { data: { id, type: "user", attributes: { email } } }
+        },
         options
       );
     },
-    bulkDelete: async (ids, options) => {
-      if (ids.length === 0) {
-        throw new Error("At least one document ID is required");
-      }
-      if (ids.length > 100) {
-        throw new Error("Maximum 100 documents per bulk operation");
-      }
+    /**
+     * Confirm a user's email address (admin bypass).
+     * @param id - User ID
+     * @returns Updated user
+     */
+    confirmEmail: async (id, options) => {
       return rb.execute(
-        postAdminDocumentsBulkDelete,
-        { body: { data: { type: "bulk_delete", attributes: { ids } } } },
+        patchAdminUsersByIdConfirmEmail,
+        { path: { id }, body: { data: { id, type: "user", attributes: {} } } },
         options
       );
     },
-    stats: async (options) => {
+    /**
+     * Trigger a password reset email for a user (admin action).
+     * @param id - User ID
+     * @returns Updated user
+     */
+    triggerPasswordReset: async (id, options) => {
       return rb.execute(
-        getAdminDocumentsStats,
-        {},
+        patchAdminUsersByIdResetPassword,
+        { path: { id }, body: { data: { id, type: "user", attributes: {} } } },
         options
       );
+    },
+    /**
+     * Delete a user and all associated data.
+     * @param id - User ID
+     */
+    delete: async (id, options) => {
+      return rb.executeDelete(deleteAdminUsersById, { path: { id } }, options);
     }
   };
 }
 
-// src/namespaces/executions.ts
-function createExecutionsNamespace(_rb) {
-  return {};
-}
-
-// src/namespaces/storage.ts
-function createStorageNamespace(rb) {
+// src/namespaces/voice.ts
+function createVoiceNamespace(rb) {
   return {
-    stats: async (workspaceId, options) => {
-      const params = workspaceId ? { query: { "filter[workspace_id]": workspaceId } } : {};
-      return rb.execute(
-        getAdminStorageStats,
-        params,
-        options
-      );
+    /**
+     * Voice session management — admin view across all workspaces.
+     */
+    sessions: {
+      /**
+       * List voice sessions across all workspaces.
+       *
+       * @param options - Optional pagination, filter, and request options.
+       * @returns Array of VoiceSession objects.
+       *
+       * @example
+       * ```typescript
+       * const admin = new GptAdmin({ apiKey: 'sk_srv_...' });
+       * // List all active sessions
+       * const activeSessions = await admin.voice.sessions.list({ status: "active" });
+       * // List sessions from the last 24 hours
+       * const recentSessions = await admin.voice.sessions.list({
+       *   insertedAfter: new Date(Date.now() - 86400000).toISOString()
+       * });
+       * ```
+       */
+      list: async (options) => {
+        const filters = {};
+        if (options?.status) filters["filter[status]"] = options.status;
+        if (options?.insertedAfter)
+          filters["filter[inserted_after]"] = options.insertedAfter;
+        if (options?.insertedBefore)
+          filters["filter[inserted_before]"] = options.insertedBefore;
+        return rb.execute(
+          getAdminVoiceSessions,
+          {
+            ...buildPageQuery(options?.page, options?.pageSize),
+            query: filters
+          },
+          options
+        );
+      },
+      /**
+       * Retrieve a single voice session by ID.
+       *
+       * @param id - The UUID of the voice session.
+       * @param options - Optional request options.
+       * @returns The VoiceSession.
+       *
+       * @example
+       * ```typescript
+       * const session = await admin.voice.sessions.get('session-uuid');
+       * ```
+       */
+      get: async (id, options) => {
+        return rb.execute(
+          getAdminVoiceSessionsById,
+          { path: { id } },
+          options
+        );
+      },
+      /**
+       * List voice sessions in a specific workspace.
+       *
+       * @param workspaceId - The UUID of the workspace.
+       * @param options - Optional pagination and request options.
+       * @returns Array of VoiceSession objects in the workspace.
+       *
+       * @example
+       * ```typescript
+       * const sessions = await admin.voice.sessions.listByWorkspace('ws-uuid');
+       * ```
+       */
+      listByWorkspace: async (workspaceId, options) => {
+        return rb.execute(
+          getAdminVoiceSessionsWorkspaceByWorkspaceId,
+          {
+            path: { workspace_id: workspaceId },
+            ...buildPageQuery(options?.page, options?.pageSize)
+          },
+          options
+        );
+      }
     },
-    buckets: {
+    /**
+     * Voice recording management — admin view.
+     */
+    recordings: {
+      /**
+       * List voice recordings.
+       *
+       * @param options - Optional pagination and request options.
+       * @returns Array of VoiceRecording objects.
+       *
+       * @example
+       * ```typescript
+       * const recordings = await admin.voice.recordings.list();
+       * ```
+       */
       list: async (options) => {
-        return rb.execute(getAdminBuckets, {}, options);
+        return rb.execute(
+          getAdminVoiceRecordings,
+          buildPageQuery(options?.page, options?.pageSize),
+          options
+        );
       },
+      /**
+       * Retrieve a single recording by ID.
+       *
+       * @param id - The UUID of the recording.
+       * @param options - Optional request options.
+       * @returns The VoiceRecording.
+       *
+       * @example
+       * ```typescript
+       * const recording = await admin.voice.recordings.get('recording-uuid');
+       * ```
+       */
       get: async (id, options) => {
         return rb.execute(
-          getAdminBucketsById,
+          getAdminVoiceRecordingsById,
           { path: { id } },
           options
         );
       },
-      stats: async (id, options) => {
+      /**
+       * List all recordings for a specific voice session.
+       *
+       * @param sessionId - The UUID of the voice session.
+       * @param options - Optional request options.
+       * @returns Array of VoiceRecording objects for the session.
+       *
+       * @example
+       * ```typescript
+       * const recordings = await admin.voice.recordings.bySession('session-uuid');
+       * ```
+       */
+      bySession: async (sessionId, options) => {
         return rb.execute(
-          getAdminBucketsByIdStats,
+          getAdminVoiceRecordingsSessionBySessionId,
+          { path: { session_id: sessionId } },
+          options
+        );
+      }
+    },
+    /**
+     * Transcription result management — admin view.
+     */
+    transcriptionResults: {
+      /**
+       * List transcription results.
+       *
+       * @param options - Optional pagination and request options.
+       * @returns Array of VoiceTranscriptionResult objects.
+       *
+       * @example
+       * ```typescript
+       * const results = await admin.voice.transcriptionResults.list();
+       * ```
+       */
+      list: async (options) => {
+        return rb.execute(
+          getAdminVoiceTranscriptionResults,
+          buildPageQuery(options?.page, options?.pageSize),
+          options
+        );
+      },
+      /**
+       * Retrieve a single transcription result by ID.
+       *
+       * @param id - The UUID of the transcription result.
+       * @param options - Optional request options.
+       * @returns The VoiceTranscriptionResult.
+       *
+       * @example
+       * ```typescript
+       * const result = await admin.voice.transcriptionResults.get('result-uuid');
+       * ```
+       */
+      get: async (id, options) => {
+        return rb.execute(
+          getAdminVoiceTranscriptionResultsById,
           { path: { id } },
           options
         );
+      },
+      /**
+       * List transcription results for a specific voice session.
+       *
+       * @param sessionId - The UUID of the voice session.
+       * @param options - Optional pagination and request options.
+       * @returns Array of VoiceTranscriptionResult objects for the session.
+       *
+       * @example
+       * ```typescript
+       * const results = await admin.voice.transcriptionResults.bySession('session-uuid');
+       * ```
+       */
+      bySession: async (sessionId, options) => {
+        return rb.execute(
+          getAdminVoiceTranscriptionResultsSessionBySessionId,
+          {
+            path: { session_id: sessionId },
+            ...buildPageQuery(options?.page, options?.pageSize)
+          },
+          options
+        );
       }
     }
   };
 }
 
+// src/namespaces/audit.ts
+function createAuditNamespace(rb) {
+  return {
+    /**
+     * List audit log entries with keyset or offset pagination.
+     *
+     * Returns up to `limit` (default 50) entries sorted by `inserted_at` descending.
+     * The `actor_display_name` calculation is included automatically.
+     *
+     * @param params - Optional pagination and sort parameters.
+     * @param options - Optional request options.
+     * @returns Array of AuditLog entries.
+     *
+     * @example
+     * ```typescript
+     * const admin = new GptAdmin({ apiKey: 'sk_srv_...' });
+     *
+     * // First page (default limit 50)
+     * const page1 = await admin.audit.list();
+     *
+     * // Next page using keyset cursor
+     * const page2 = await admin.audit.list({ after: page1.at(-1)?.id, limit: 25 });
+     * ```
+     */
+    async list(params = {}, options) {
+      const parts = [];
+      if (params.limit !== void 0) parts.push(`page[limit]=${params.limit}`);
+      if (params.offset !== void 0)
+        parts.push(`page[offset]=${params.offset}`);
+      if (params.after)
+        parts.push(`page[after]=${encodeURIComponent(params.after)}`);
+      if (params.before)
+        parts.push(`page[before]=${encodeURIComponent(params.before)}`);
+      if (params.sort) parts.push(`sort=${encodeURIComponent(params.sort)}`);
+      const qs = parts.length ? `?${parts.join("&")}` : "";
+      return rb.rawGet(`/admin/audit-logs${qs}`, options);
+    },
+    /**
+     * Fetch a paginated, time-sorted activity feed scoped to a tenant.
+     *
+     * Optionally filter by workspace, action type, actor, or date range.
+     * Results are sorted by `inserted_at` descending (most recent first).
+     *
+     * @param params - Feed parameters. `tenantId` is required.
+     * @param options - Optional request options.
+     * @returns Array of AuditLog entries matching the filters.
+     *
+     * @example
+     * ```typescript
+     * const admin = new GptAdmin({ apiKey: 'sk_srv_...' });
+     *
+     * // All activity for a tenant in the last 24h
+     * const feed = await admin.audit.activityFeed({
+     *   tenantId: 'tenant-uuid',
+     *   fromDate: new Date(Date.now() - 86400000).toISOString(),
+     * });
+     *
+     * // Narrow to a specific workspace and actor
+     * const focused = await admin.audit.activityFeed({
+     *   tenantId: 'tenant-uuid',
+     *   workspaceId: 'ws-uuid',
+     *   actorId: 'user-uuid',
+     *   limit: 20,
+     * });
+     * ```
+     */
+    async activityFeed(params, options) {
+      if (!params.tenantId) throw new Error("tenantId is required");
+      const parts = [
+        `tenant_id=${encodeURIComponent(params.tenantId)}`
+      ];
+      if (params.workspaceId)
+        parts.push(`workspace_id=${encodeURIComponent(params.workspaceId)}`);
+      if (params.activityType)
+        parts.push(`activity_type=${encodeURIComponent(params.activityType)}`);
+      if (params.actorId)
+        parts.push(`actor_id=${encodeURIComponent(params.actorId)}`);
+      if (params.fromDate)
+        parts.push(`from_date=${encodeURIComponent(params.fromDate)}`);
+      if (params.toDate)
+        parts.push(`to_date=${encodeURIComponent(params.toDate)}`);
+      if (params.limit !== void 0) parts.push(`limit=${params.limit}`);
+      if (params.offset !== void 0) parts.push(`offset=${params.offset}`);
+      return rb.rawGet(
+        `/admin/audit-logs/activity?${parts.join("&")}`,
+        options
+      );
+    },
+    /**
+     * Return per-action counts for a tenant, sorted by frequency descending.
+     *
+     * Useful for anomaly dashboards and compliance reporting.
+     *
+     * @param params - `tenantId` is required. `workspaceId` narrows to one workspace.
+     * @param options - Optional request options.
+     * @returns Array of `{ action, count }` objects sorted by count descending.
+     *
+     * @example
+     * ```typescript
+     * const admin = new GptAdmin({ apiKey: 'sk_srv_...' });
+     *
+     * const counts = await admin.audit.countByAction({ tenantId: 'tenant-uuid' });
+     * // [{ action: "document.analyzed", count: 1240 }, { action: "user.login", count: 98 }, ...]
+     * ```
+     */
+    async countByAction(params, options) {
+      if (!params.tenantId) throw new Error("tenantId is required");
+      const parts = [
+        `tenant_id=${encodeURIComponent(params.tenantId)}`
+      ];
+      if (params.workspaceId)
+        parts.push(`workspace_id=${encodeURIComponent(params.workspaceId)}`);
+      return rb.rawGet(
+        `/admin/audit-logs/count-by-action?${parts.join("&")}`,
+        options
+      );
+    },
+    /**
+     * Enqueue a bulk compliance export of audit logs for a tenant.
+     *
+     * The export is processed asynchronously by the `ExportAuditLogsWorker` Oban job.
+     * The caller receives a job ID and status immediately; the file URL is published
+     * to `audit:export:{tenant_id}` via PubSub when ready (see `AuditExportCompleted`).
+     *
+     * @param params - Export parameters. `tenantId` and `format` are required.
+     * @param options - Optional request options.
+     * @returns `{ jobId, status }` — the Oban job ID and initial status (`"enqueued"`).
+     *
+     * @example
+     * ```typescript
+     * const admin = new GptAdmin({ apiKey: 'sk_srv_...' });
+     *
+     * // Request a CSV export of the last 30 days
+     * const thirty = new Date();
+     * thirty.setDate(thirty.getDate() - 30);
+     * const result = await admin.audit.requestExport({
+     *   format: 'csv',
+     *   tenantId: 'tenant-uuid',
+     *   fromDate: thirty.toISOString(),
+     * });
+     * console.log(`Export job ${result.jobId} enqueued`);
+     * ```
+     */
+    async requestExport(params, options) {
+      if (!params.tenantId) throw new Error("tenantId is required");
+      return rb.rawPost(
+        `/admin/audit-logs/export`,
+        {
+          data: {
+            type: "audit_log",
+            attributes: {
+              format: params.format,
+              tenant_id: params.tenantId,
+              ...params.fromDate && { from_date: params.fromDate },
+              ...params.toDate && { to_date: params.toDate }
+            }
+          }
+        },
+        options
+      );
+    }
+  };
+}
+
 // src/namespaces/webhooks-ns.ts
 function createWebhooksNamespace(rb) {
   return {
     configs: {
+      /**
+       * Lists all webhook configurations.
+       *
+       * @param options - Optional request options.
+       * @returns Array of WebhookConfig objects.
+       */
       list: async (options) => {
         return rb.execute(getAdminWebhookConfigs, {}, options);
       },
+      /**
+       * Registers a new webhook endpoint to receive platform events.
+       *
+       * The `application_id` is inferred from the API key used to make the
+       * request. Supply it explicitly to scope the webhook to a specific application.
+       *
+       * @param name - Display name for the webhook configuration.
+       * @param url - HTTPS URL that will receive event POST requests.
+       * @param events - Event types to subscribe to (e.g. `"document.analyzed"`).
+       * @param applicationId - Optional application ID to scope this webhook.
+       * @param secret - Optional HMAC signing secret for payload verification.
+       * @param options - Optional request options.
+       * @returns The created WebhookConfig.
+       */
       create: async (name, url, events, applicationId, secret, options) => {
         return rb.execute(
           postAdminWebhookConfigs,
@@ -1728,6 +4324,13 @@ function createWebhooksNamespace(rb) {
           options
         );
       },
+      /**
+       * Fetches a single webhook configuration by ID.
+       *
+       * @param id - WebhookConfig ID.
+       * @param options - Optional request options.
+       * @returns The WebhookConfig.
+       */
       get: async (id, options) => {
         return rb.execute(
           getAdminWebhookConfigsById,
@@ -1735,6 +4338,18 @@ function createWebhooksNamespace(rb) {
           options
         );
       },
+      /**
+       * Updates webhook endpoint settings.
+       *
+       * Updates URL, subscribed event types, enabled state, and other mutable
+       * fields. To change the HMAC signing secret, use the `rotate_secret`
+       * action via the API directly instead.
+       *
+       * @param id - WebhookConfig ID.
+       * @param attributes - Partial attributes to update.
+       * @param options - Optional request options.
+       * @returns Updated WebhookConfig.
+       */
       update: async (id, attributes, options) => {
         return rb.execute(
           patchAdminWebhookConfigsById,
@@ -1745,6 +4360,15 @@ function createWebhooksNamespace(rb) {
           options
         );
       },
+      /**
+       * Permanently deletes a webhook configuration.
+       *
+       * This action cannot be undone. Associated delivery records are preserved.
+       *
+       * @param id - WebhookConfig ID.
+       * @param options - Optional request options.
+       * @returns `true` on success.
+       */
       delete: async (id, options) => {
         return rb.executeDelete(
           deleteAdminWebhookConfigsById,
@@ -1752,6 +4376,18 @@ function createWebhooksNamespace(rb) {
           options
         );
       },
+      /**
+       * Sends a realistic sample payload to the webhook URL.
+       *
+       * Verifies connectivity and signature verification by enqueuing a
+       * WebhookSender Oban job tagged with `test: true`. Use this to confirm
+       * the endpoint is reachable and parsing HMAC signatures correctly before
+       * subscribing to live events.
+       *
+       * @param id - WebhookConfig ID.
+       * @param options - Optional request options.
+       * @returns The WebhookConfig on success.
+       */
       test: async (id, options) => {
         return rb.execute(
           postAdminWebhookConfigsByIdTest,
@@ -1761,6 +4397,15 @@ function createWebhooksNamespace(rb) {
       }
     },
     deliveries: {
+      /**
+       * Lists all webhook delivery records across all configurations.
+       *
+       * Each delivery record tracks the attempt count, status, payload, and
+       * response for a single event dispatch.
+       *
+       * @param options - Optional request options.
+       * @returns Array of WebhookDelivery objects.
+       */
       list: async (options) => {
         return rb.execute(
           getAdminWebhookDeliveries,
@@ -1768,6 +4413,13 @@ function createWebhooksNamespace(rb) {
           options
         );
       },
+      /**
+       * Fetches a single delivery record by ID.
+       *
+       * @param id - WebhookDelivery ID.
+       * @param options - Optional request options.
+       * @returns The WebhookDelivery.
+       */
       get: async (id, options) => {
         return rb.execute(
           getAdminWebhookDeliveriesById,
@@ -1775,6 +4427,17 @@ function createWebhooksNamespace(rb) {
           options
         );
       },
+      /**
+       * Re-enqueues a failed or pending delivery for immediate re-dispatch.
+       *
+       * Sets the delivery status to `retrying` and inserts a new WebhookSender
+       * Oban job. Use this to recover from transient endpoint failures without
+       * waiting for the automatic retry schedule.
+       *
+       * @param id - WebhookDelivery ID.
+       * @param options - Optional request options.
+       * @returns Updated WebhookDelivery with status `retrying`.
+       */
       retry: async (id, options) => {
         return rb.execute(
           postAdminWebhookDeliveriesByIdRetry,
@@ -1786,6 +4449,405 @@ function createWebhooksNamespace(rb) {
   };
 }
 
+// src/namespaces/campaigns.ts
+function createCampaignsNamespace(rb) {
+  return {
+    /**
+     * Get a campaign by ID.
+     *
+     * @param id - The unique identifier of the campaign.
+     * @param options - Optional request-level overrides.
+     * @returns A promise resolving to the {@link Campaign}.
+     *
+     * @example
+     * ```typescript
+     * const admin = new GptAdmin({ apiKey: 'sk_srv_...' });
+     * const campaign = await admin.campaigns.get('camp_abc123');
+     * ```
+     */
+    get: async (id, options) => {
+      return rb.execute(
+        getAdminEmailMarketingCampaignsById,
+        { path: { id } },
+        options
+      );
+    },
+    /**
+     * List all campaigns for a workspace.
+     *
+     * @param workspaceId - The ID of the workspace to query.
+     * @param options - Optional pagination and request options.
+     * @returns A promise resolving to an array of {@link Campaign} records.
+     *
+     * @example
+     * ```typescript
+     * const admin = new GptAdmin({ apiKey: 'sk_srv_...' });
+     * const campaigns = await admin.campaigns.listByWorkspace('ws_abc123');
+     * ```
+     */
+    listByWorkspace: async (workspaceId, options) => {
+      return rb.execute(
+        getAdminEmailMarketingCampaignsWorkspaceByWorkspaceId,
+        {
+          path: { workspace_id: workspaceId },
+          ...buildPageQuery(options?.page, options?.pageSize)
+        },
+        options
+      );
+    },
+    /**
+     * Create a new campaign.
+     *
+     * @param attributes - Campaign attributes including `workspace_id`, `name`, `template_id`.
+     * @param options - Optional request-level overrides.
+     * @returns A promise resolving to the newly created {@link Campaign}.
+     *
+     * @example
+     * ```typescript
+     * const admin = new GptAdmin({ apiKey: 'sk_srv_...' });
+     * const campaign = await admin.campaigns.create({
+     *   workspace_id: 'ws_abc123',
+     *   name: 'Q1 Outreach',
+     *   template_id: 'tmpl_xyz',
+     * });
+     * ```
+     */
+    create: async (attributes, options) => {
+      return rb.execute(
+        postAdminEmailMarketingCampaigns,
+        { body: { data: { type: "campaign", attributes } } },
+        options
+      );
+    },
+    /**
+     * Trigger sending for an approved campaign.
+     *
+     * @param id - The ID of the campaign to send.
+     * @param options - Optional request-level overrides.
+     * @returns A promise resolving to the updated {@link Campaign}.
+     *
+     * @example
+     * ```typescript
+     * const admin = new GptAdmin({ apiKey: 'sk_srv_...' });
+     * await admin.campaigns.send('camp_abc123');
+     * ```
+     */
+    send: async (id, options) => {
+      return rb.execute(
+        postAdminEmailMarketingCampaignsByIdSend,
+        { path: { id }, body: {} },
+        options
+      );
+    },
+    /**
+     * Delete a campaign.
+     *
+     * @param id - The unique identifier of the campaign to delete.
+     * @param options - Optional request-level overrides.
+     * @returns A promise that resolves to `true` on successful deletion.
+     *
+     * @example
+     * ```typescript
+     * const admin = new GptAdmin({ apiKey: 'sk_srv_...' });
+     * await admin.campaigns.delete('camp_abc123');
+     * ```
+     */
+    delete: async (id, options) => {
+      return rb.executeDelete(
+        deleteAdminEmailMarketingCampaignsById,
+        { path: { id } },
+        options
+      );
+    }
+  };
+}
+
+// src/namespaces/email.ts
+function createEmailNamespace(rb) {
+  return {
+    /**
+     * Outbound email management — admin view across all workspaces.
+     */
+    outboundEmails: {
+      /**
+       * Get an outbound email by ID.
+       *
+       * @param id - The unique identifier of the outbound email.
+       * @param options - Optional request-level overrides.
+       * @returns A promise resolving to the {@link EmailOutboundEmail}.
+       *
+       * @example
+       * ```typescript
+       * const admin = new GptAdmin({ apiKey: 'sk_srv_...' });
+       * const email = await admin.email.outboundEmails.get('oe_abc123');
+       * ```
+       */
+      get: async (id, options) => {
+        return rb.execute(
+          getAdminEmailOutboundEmailsById,
+          { path: { id } },
+          options
+        );
+      },
+      /**
+       * List outbound emails for a workspace.
+       *
+       * @param workspaceId - The ID of the workspace to query.
+       * @param options - Optional pagination and request options.
+       * @returns A promise resolving to an array of {@link EmailOutboundEmail}.
+       *
+       * @example
+       * ```typescript
+       * const admin = new GptAdmin({ apiKey: 'sk_srv_...' });
+       * const emails = await admin.email.outboundEmails.listByWorkspace('ws_abc123');
+       * ```
+       */
+      listByWorkspace: async (workspaceId, options) => {
+        return rb.execute(
+          getAdminEmailOutboundEmailsWorkspaceByWorkspaceId,
+          {
+            path: { workspace_id: workspaceId },
+            ...buildPageQuery(options?.page, options?.pageSize)
+          },
+          options
+        );
+      },
+      /**
+       * Create an outbound email draft.
+       *
+       * @param attributes - Email attributes including `workspace_id`, `subject`, `body_html`, `sender_profile_id`.
+       * @param options - Optional request-level overrides.
+       * @returns A promise resolving to the created {@link EmailOutboundEmail}.
+       *
+       * @example
+       * ```typescript
+       * const admin = new GptAdmin({ apiKey: 'sk_srv_...' });
+       * const email = await admin.email.outboundEmails.create({
+       *   workspace_id: 'ws_abc123',
+       *   subject: 'Admin notification',
+       *   body_html: '<p>Hello</p>',
+       *   sender_profile_id: 'sp_noreply',
+       * });
+       * ```
+       */
+      create: async (attributes, options) => {
+        return rb.execute(
+          postAdminEmailOutboundEmails,
+          { body: { data: { type: "email_outbound_email", attributes } } },
+          options
+        );
+      },
+      /**
+       * Delete an outbound email draft.
+       *
+       * @param id - The unique identifier of the outbound email to delete.
+       * @param options - Optional request-level overrides.
+       * @returns A promise that resolves to `true` on successful deletion.
+       *
+       * @example
+       * ```typescript
+       * const admin = new GptAdmin({ apiKey: 'sk_srv_...' });
+       * await admin.email.outboundEmails.delete('oe_abc123');
+       * ```
+       */
+      delete: async (id, options) => {
+        return rb.executeDelete(
+          deleteAdminEmailOutboundEmailsById,
+          { path: { id } },
+          options
+        );
+      }
+    },
+    /**
+     * Sender profile management — admin view across all workspaces.
+     */
+    senderProfiles: {
+      /**
+       * Get a sender profile by ID.
+       *
+       * @param id - The unique identifier of the sender profile.
+       * @param options - Optional request-level overrides.
+       * @returns A promise resolving to the {@link EmailMarketingSenderProfile}.
+       *
+       * @example
+       * ```typescript
+       * const admin = new GptAdmin({ apiKey: 'sk_srv_...' });
+       * const profile = await admin.email.senderProfiles.get('sp_abc123');
+       * ```
+       */
+      get: async (id, options) => {
+        return rb.execute(
+          getAdminEmailMarketingSenderProfilesById,
+          { path: { id } },
+          options
+        );
+      },
+      /**
+       * List sender profiles for a workspace.
+       *
+       * @param workspaceId - The ID of the workspace to query.
+       * @param options - Optional pagination and request options.
+       * @returns A promise resolving to an array of {@link EmailMarketingSenderProfile}.
+       *
+       * @example
+       * ```typescript
+       * const admin = new GptAdmin({ apiKey: 'sk_srv_...' });
+       * const profiles = await admin.email.senderProfiles.listByWorkspace('ws_abc123');
+       * ```
+       */
+      listByWorkspace: async (workspaceId, options) => {
+        return rb.execute(
+          getAdminEmailMarketingSenderProfilesWorkspaceByWorkspaceId,
+          {
+            path: { workspace_id: workspaceId },
+            ...buildPageQuery(options?.page, options?.pageSize)
+          },
+          options
+        );
+      },
+      /**
+       * Create a new sender profile.
+       *
+       * @param attributes - Profile attributes including `workspace_id`, `from_email`, `from_name`.
+       * @param options - Optional request-level overrides.
+       * @returns A promise resolving to the created {@link EmailMarketingSenderProfile}.
+       *
+       * @example
+       * ```typescript
+       * const admin = new GptAdmin({ apiKey: 'sk_srv_...' });
+       * const profile = await admin.email.senderProfiles.create({
+       *   workspace_id: 'ws_abc123',
+       *   from_email: 'noreply@acme.com',
+       *   from_name: 'Acme Team',
+       * });
+       * ```
+       */
+      create: async (attributes, options) => {
+        return rb.execute(
+          postAdminEmailMarketingSenderProfiles,
+          { body: { data: { type: "email_sender_profile", attributes } } },
+          options
+        );
+      },
+      /**
+       * Update a sender profile.
+       *
+       * @param id - The unique identifier of the sender profile to update.
+       * @param attributes - Attributes to update.
+       * @param options - Optional request-level overrides.
+       * @returns A promise resolving to the updated {@link EmailMarketingSenderProfile}.
+       *
+       * @example
+       * ```typescript
+       * const admin = new GptAdmin({ apiKey: 'sk_srv_...' });
+       * const profile = await admin.email.senderProfiles.update('sp_abc123', {
+       *   from_name: 'Acme Support',
+       * });
+       * ```
+       */
+      update: async (id, attributes, options) => {
+        return rb.execute(
+          patchAdminEmailMarketingSenderProfilesById,
+          {
+            path: { id },
+            body: { data: { id, type: "email_sender_profile", attributes } }
+          },
+          options
+        );
+      },
+      /**
+       * Delete a sender profile.
+       *
+       * @param id - The unique identifier of the sender profile to delete.
+       * @param options - Optional request-level overrides.
+       * @returns A promise that resolves to `true` on successful deletion.
+       *
+       * @example
+       * ```typescript
+       * const admin = new GptAdmin({ apiKey: 'sk_srv_...' });
+       * await admin.email.senderProfiles.delete('sp_abc123');
+       * ```
+       */
+      delete: async (id, options) => {
+        return rb.executeDelete(
+          deleteAdminEmailMarketingSenderProfilesById,
+          { path: { id } },
+          options
+        );
+      },
+      /**
+       * Trigger DNS validation for a sender profile (verifies SPF/DKIM/DMARC).
+       *
+       * @param id - The unique identifier of the sender profile.
+       * @param options - Optional request-level overrides.
+       * @returns A promise resolving to the updated {@link EmailMarketingSenderProfile} with DNS status.
+       *
+       * @example
+       * ```typescript
+       * const admin = new GptAdmin({ apiKey: 'sk_srv_...' });
+       * const result = await admin.email.senderProfiles.validateDns('sp_abc123');
+       * console.log(result.attributes.spf_valid, result.attributes.dkim_valid);
+       * ```
+       */
+      validateDns: async (id, options) => {
+        return rb.execute(
+          patchAdminEmailMarketingSenderProfilesByIdValidateDns,
+          { path: { id }, body: {} },
+          options
+        );
+      }
+    },
+    /**
+     * Tracking event management — admin view across all workspaces.
+     */
+    trackingEvents: {
+      /**
+       * Get a tracking event by ID.
+       *
+       * @param id - The unique identifier of the tracking event.
+       * @param options - Optional request-level overrides.
+       * @returns A promise resolving to the tracking event record.
+       *
+       * @example
+       * ```typescript
+       * const admin = new GptAdmin({ apiKey: 'sk_srv_...' });
+       * const event = await admin.email.trackingEvents.get('te_abc123');
+       * ```
+       */
+      get: async (id, options) => {
+        return rb.execute(
+          getAdminEmailTrackingEventsById,
+          { path: { id } },
+          options
+        );
+      },
+      /**
+       * List tracking events for a workspace.
+       *
+       * @param workspaceId - The ID of the workspace to query.
+       * @param options - Optional pagination and request options.
+       * @returns A promise resolving to an array of {@link EmailTrackingEvent} records.
+       *
+       * @example
+       * ```typescript
+       * const admin = new GptAdmin({ apiKey: 'sk_srv_...' });
+       * const events = await admin.email.trackingEvents.listByWorkspace('ws_abc123');
+       * ```
+       */
+      listByWorkspace: async (workspaceId, options) => {
+        return rb.execute(
+          getAdminEmailTrackingEventsWorkspaceByWorkspaceId,
+          {
+            path: { workspace_id: workspaceId },
+            ...buildPageQuery(options?.page, options?.pageSize)
+          },
+          options
+        );
+      }
+    }
+  };
+}
+
 // src/gpt-admin.ts
 var GptAdmin = class extends BaseClient {
   constructor(config) {
@@ -1796,12 +4858,19 @@ var GptAdmin = class extends BaseClient {
       (d) => this.unwrap(d),
       (fn) => this.requestWithRetry(fn)
     );
+    this.agents = createAgentsNamespace(rb);
     this.accounts = createAccountsNamespace(rb);
+    this.capabilities = createCapabilitiesNamespace(rb);
     this.apiKeys = createApiKeysNamespace(rb);
     this.documents = createDocumentsNamespace(rb);
     this.executions = createExecutionsNamespace(rb);
     this.storage = createStorageNamespace(rb);
+    this.users = createUsersNamespace(rb);
+    this.voice = createVoiceNamespace(rb);
+    this.audit = createAuditNamespace(rb);
     this.webhooks = createWebhooksNamespace(rb);
+    this.campaigns = createCampaignsNamespace(rb);
+    this.email = createEmailNamespace(rb);
   }
 };