@gtmi/ramp-site-client 0.0.1 → 0.0.2

package/src/generated/types.gen.ts

@@ -4,6 +4,84 @@ export type ClientOptions = {
   baseUrl: `${string}://${string}` | (string & {});
 };
 
+export type ErrorResponse = {
+  error?: string;
+  details?: string;
+};
+
+export type CalledByData = {
+  phoneNumber?: string;
+  timestamp?: number;
+  direction?: string;
+  objectId?: string;
+};
+
+export type Campaign = {
+  email?: string;
+  companyName?: string;
+  objectID?: string;
+  encryptedObjectId?: string;
+  agentNumber?: string;
+  tag?: string;
+  createdAt?: string;
+  numCalls?: string;
+  shortLink?: string;
+};
+
+export type ConversationMemoryRecallResponse = {
+  communications?: string;
+  observations?: string;
+  summaries?: string;
+  meta?: string;
+  queryTime?: string;
+};
+
+export type Operator = {
+  id?: string;
+  displayName?: string;
+  description?: string;
+  version?: string;
+  availability?: string;
+  author?: string;
+  prompt?: string;
+  outputFormat?: string;
+  outputSchema?: string;
+  trainingExamples?: string;
+  context?: string;
+  parameters?: string;
+};
+
+export type IntelligenceConfiguration = {
+  accountId?: string;
+  dateCreated?: string;
+  dateUpdated?: string;
+  description?: string;
+  displayName?: string;
+  id?: string;
+  rules?: string;
+  version?: string;
+};
+
+export type LockedTemplateData = {
+  agentNumber?: string;
+  countryCode?: string;
+  dateShared?: string;
+  dateExpires?: string;
+  objectID?: string;
+  templateName?: string;
+  userEmail?: string;
+  webrtcUrl?: string;
+};
+
+export type SupportedRegion = {
+  isoCountry?: string;
+  numberType?: string;
+  bundleSid?: string;
+  label?: string;
+  flag?: string;
+  capabilities?: string;
+};
+
 export type PostApiAlgoliaSecuredKeyData = {
   body?: never;
   path?: never;
@@ -13,18 +91,41 @@ export type PostApiAlgoliaSecuredKeyData = {
 
 export type PostApiAlgoliaSecuredKeyErrors = {
   /**
-   * Internal server error
+   * Not authenticated
    */
-  500: unknown;
+  401: ErrorResponse;
+  /**
+   * Algolia configuration missing, or key generation failed
+   */
+  500: ErrorResponse;
 };
 
+export type PostApiAlgoliaSecuredKeyError =
+  PostApiAlgoliaSecuredKeyErrors[keyof PostApiAlgoliaSecuredKeyErrors];
+
 export type PostApiAlgoliaSecuredKeyResponses = {
   /**
    * Success
    */
-  200: unknown;
+  200: {
+    /**
+     * Unix timestamp (ms) when the secured key expires
+     */
+    expiresAt: number;
+    /**
+     * Base64-encoded Algolia secured API key
+     */
+    securedKey: string;
+    /**
+     * Email of the authenticated user the key was scoped to
+     */
+    userEmail: string;
+  };
 };
 
+export type PostApiAlgoliaSecuredKeyResponse =
+  PostApiAlgoliaSecuredKeyResponses[keyof PostApiAlgoliaSecuredKeyResponses];
+
 export type GetApiCampaignData = {
   body?: never;
   path?: never;
@@ -34,22 +135,39 @@ export type GetApiCampaignData = {
 
 export type GetApiCampaignErrors = {
   /**
-   * Unauthorized
+   * Unauthorized — requires an authenticated session
    */
   401: unknown;
   /**
-   * Internal server error
+   * Error fetching campaigns
    */
-  500: unknown;
+  500: ErrorResponse;
 };
 
+export type GetApiCampaignError = GetApiCampaignErrors[keyof GetApiCampaignErrors];
+
 export type GetApiCampaignResponses = {
   /**
    * Success
    */
-  200: unknown;
+  200: {
+    /**
+     * Call history data, present when includeCalledBy is set
+     */
+    calledByData: Array<CalledByData>;
+    /**
+     * Matching campaign templates
+     */
+    campaigns: Array<Campaign>;
+    /**
+     * Total number of matching campaigns
+     */
+    total: number;
+  };
 };
 
+export type GetApiCampaignResponse = GetApiCampaignResponses[keyof GetApiCampaignResponses];
+
 export type DeleteApiConversationMemoryConversationSummariesData = {
   body?: never;
   path?: never;
@@ -62,22 +180,40 @@ export type DeleteApiConversationMemoryConversationSummariesData = {
 
 export type DeleteApiConversationMemoryConversationSummariesErrors = {
   /**
-   * Unauthorized
+   * Missing required profileId or summaryId
+   */
+  400: ErrorResponse;
+  /**
+   * Unauthorized — requires an authenticated session
    */
   401: unknown;
   /**
-   * Internal server error
+   * Conversation Memory store not configured, or internal server error
    */
-  500: unknown;
+  500: ErrorResponse;
 };
 
+export type DeleteApiConversationMemoryConversationSummariesError =
+  DeleteApiConversationMemoryConversationSummariesErrors[keyof DeleteApiConversationMemoryConversationSummariesErrors];
+
 export type DeleteApiConversationMemoryConversationSummariesResponses = {
   /**
-   * Success
+   * Upstream summary data (single summary or paginated list) from the Conversation Memory API
    */
-  200: unknown;
+  200: {
+    [key: string]: unknown;
+  };
+  /**
+   * Upstream confirmation payload from the Conversation Memory API
+   */
+  202: {
+    [key: string]: unknown;
+  };
 };
 
+export type DeleteApiConversationMemoryConversationSummariesResponse =
+  DeleteApiConversationMemoryConversationSummariesResponses[keyof DeleteApiConversationMemoryConversationSummariesResponses];
+
 export type GetApiConversationMemoryConversationSummariesData = {
   body?: never;
   path?: never;
@@ -92,22 +228,34 @@ export type GetApiConversationMemoryConversationSummariesData = {
 
 export type GetApiConversationMemoryConversationSummariesErrors = {
   /**
-   * Unauthorized
+   * Missing required profileId
+   */
+  400: ErrorResponse;
+  /**
+   * Unauthorized — requires an authenticated session
    */
   401: unknown;
   /**
-   * Internal server error
+   * Conversation Memory store not configured, or internal server error
    */
-  500: unknown;
+  500: ErrorResponse;
 };
 
+export type GetApiConversationMemoryConversationSummariesError =
+  GetApiConversationMemoryConversationSummariesErrors[keyof GetApiConversationMemoryConversationSummariesErrors];
+
 export type GetApiConversationMemoryConversationSummariesResponses = {
   /**
-   * Success
+   * Upstream summary data (single summary or paginated list) from the Conversation Memory API
    */
-  200: unknown;
+  200: {
+    [key: string]: unknown;
+  };
 };
 
+export type GetApiConversationMemoryConversationSummariesResponse =
+  GetApiConversationMemoryConversationSummariesResponses[keyof GetApiConversationMemoryConversationSummariesResponses];
+
 export type PatchApiConversationMemoryConversationSummariesData = {
   body: {
     [key: string]: unknown;
@@ -122,22 +270,40 @@ export type PatchApiConversationMemoryConversationSummariesData = {
 
 export type PatchApiConversationMemoryConversationSummariesErrors = {
   /**
-   * Unauthorized
+   * Missing required profileId/summaryId, or no update fields provided
+   */
+  400: ErrorResponse;
+  /**
+   * Unauthorized — requires an authenticated session
    */
   401: unknown;
   /**
-   * Internal server error
+   * Conversation Memory store not configured, or internal server error
    */
-  500: unknown;
+  500: ErrorResponse;
 };
 
+export type PatchApiConversationMemoryConversationSummariesError =
+  PatchApiConversationMemoryConversationSummariesErrors[keyof PatchApiConversationMemoryConversationSummariesErrors];
+
 export type PatchApiConversationMemoryConversationSummariesResponses = {
   /**
-   * Success
+   * Upstream summary data (single summary or paginated list) from the Conversation Memory API
    */
-  200: unknown;
+  200: {
+    [key: string]: unknown;
+  };
+  /**
+   * Upstream confirmation payload from the Conversation Memory API
+   */
+  202: {
+    [key: string]: unknown;
+  };
 };
 
+export type PatchApiConversationMemoryConversationSummariesResponse =
+  PatchApiConversationMemoryConversationSummariesResponses[keyof PatchApiConversationMemoryConversationSummariesResponses];
+
 export type PostApiConversationMemoryConversationSummariesData = {
   body: {
     [key: string]: unknown;
@@ -149,22 +315,40 @@ export type PostApiConversationMemoryConversationSummariesData = {
 
 export type PostApiConversationMemoryConversationSummariesErrors = {
   /**
-   * Unauthorized
+   * Missing required profileId or summaries
+   */
+  400: ErrorResponse;
+  /**
+   * Unauthorized — requires an authenticated session
    */
   401: unknown;
   /**
-   * Internal server error
+   * Conversation Memory store not configured, or internal server error
    */
-  500: unknown;
+  500: ErrorResponse;
 };
 
+export type PostApiConversationMemoryConversationSummariesError =
+  PostApiConversationMemoryConversationSummariesErrors[keyof PostApiConversationMemoryConversationSummariesErrors];
+
 export type PostApiConversationMemoryConversationSummariesResponses = {
   /**
-   * Success
+   * Upstream summary data (single summary or paginated list) from the Conversation Memory API
    */
-  200: unknown;
+  200: {
+    [key: string]: unknown;
+  };
+  /**
+   * Upstream confirmation payload from the Conversation Memory API
+   */
+  202: {
+    [key: string]: unknown;
+  };
 };
 
+export type PostApiConversationMemoryConversationSummariesResponse =
+  PostApiConversationMemoryConversationSummariesResponses[keyof PostApiConversationMemoryConversationSummariesResponses];
+
 export type DeleteApiConversationMemoryIdentifiersData = {
   body?: never;
   path?: never;
@@ -179,50 +363,80 @@ export type DeleteApiConversationMemoryIdentifiersData = {
 
 export type DeleteApiConversationMemoryIdentifiersErrors = {
   /**
-   * Unauthorized
+   * Missing required profileId or idType
+   */
+  400: ErrorResponse;
+  /**
+   * Unauthorized — requires an authenticated session
    */
   401: unknown;
   /**
-   * Internal server error
+   * Conversation Memory store not configured, or internal server error
    */
-  500: unknown;
+  500: ErrorResponse;
 };
 
+export type DeleteApiConversationMemoryIdentifiersError =
+  DeleteApiConversationMemoryIdentifiersErrors[keyof DeleteApiConversationMemoryIdentifiersErrors];
+
 export type DeleteApiConversationMemoryIdentifiersResponses = {
   /**
-   * Success
+   * Upstream identifier data (single value or list) from the Conversation Memory API
    */
-  200: unknown;
+  200: {
+    [key: string]: unknown;
+  };
+  /**
+   * Upstream confirmation payload from the Conversation Memory API
+   */
+  202: {
+    [key: string]: unknown;
+  };
 };
 
+export type DeleteApiConversationMemoryIdentifiersResponse =
+  DeleteApiConversationMemoryIdentifiersResponses[keyof DeleteApiConversationMemoryIdentifiersResponses];
+
 export type GetApiConversationMemoryIdentifiersData = {
   body?: never;
   path?: never;
   query: {
     profileId: string;
-    idType: string;
+    idType?: string;
   };
   url: '/api/conversation-memory/identifiers';
 };
 
 export type GetApiConversationMemoryIdentifiersErrors = {
   /**
-   * Unauthorized
+   * Missing required profileId
+   */
+  400: ErrorResponse;
+  /**
+   * Unauthorized — requires an authenticated session
    */
   401: unknown;
   /**
-   * Internal server error
+   * Conversation Memory store not configured, or internal server error
    */
-  500: unknown;
+  500: ErrorResponse;
 };
 
+export type GetApiConversationMemoryIdentifiersError =
+  GetApiConversationMemoryIdentifiersErrors[keyof GetApiConversationMemoryIdentifiersErrors];
+
 export type GetApiConversationMemoryIdentifiersResponses = {
   /**
-   * Success
+   * Upstream identifier data (single value or list) from the Conversation Memory API
    */
-  200: unknown;
+  200: {
+    [key: string]: unknown;
+  };
 };
 
+export type GetApiConversationMemoryIdentifiersResponse =
+  GetApiConversationMemoryIdentifiersResponses[keyof GetApiConversationMemoryIdentifiersResponses];
+
 export type PatchApiConversationMemoryIdentifiersData = {
   body: {
     [key: string]: unknown;
@@ -239,54 +453,85 @@ export type PatchApiConversationMemoryIdentifiersData = {
 
 export type PatchApiConversationMemoryIdentifiersErrors = {
   /**
-   * Unauthorized
+   * Missing required profileId, idType, oldValue, or newValue
+   */
+  400: ErrorResponse;
+  /**
+   * Unauthorized — requires an authenticated session
    */
   401: unknown;
   /**
-   * Internal server error
+   * Conversation Memory store not configured, or internal server error
    */
-  500: unknown;
+  500: ErrorResponse;
 };
 
+export type PatchApiConversationMemoryIdentifiersError =
+  PatchApiConversationMemoryIdentifiersErrors[keyof PatchApiConversationMemoryIdentifiersErrors];
+
 export type PatchApiConversationMemoryIdentifiersResponses = {
   /**
-   * Success
+   * Upstream identifier data (single value or list) from the Conversation Memory API
    */
-  200: unknown;
+  200: {
+    [key: string]: unknown;
+  };
+  /**
+   * Upstream confirmation payload from the Conversation Memory API
+   */
+  202: {
+    [key: string]: unknown;
+  };
 };
 
+export type PatchApiConversationMemoryIdentifiersResponse =
+  PatchApiConversationMemoryIdentifiersResponses[keyof PatchApiConversationMemoryIdentifiersResponses];
+
 export type PostApiConversationMemoryIdentifiersData = {
   body: {
     [key: string]: unknown;
   };
   path?: never;
-  query: {
-    profileId: string;
-    idType: string;
-    removeAll?: string;
-    value: string;
-  };
+  query?: never;
   url: '/api/conversation-memory/identifiers';
 };
 
 export type PostApiConversationMemoryIdentifiersErrors = {
   /**
-   * Unauthorized
+   * Missing required profileId, idType, or value
+   */
+  400: ErrorResponse;
+  /**
+   * Unauthorized — requires an authenticated session
    */
   401: unknown;
   /**
-   * Internal server error
+   * Conversation Memory store not configured, or internal server error
    */
-  500: unknown;
+  500: ErrorResponse;
 };
 
+export type PostApiConversationMemoryIdentifiersError =
+  PostApiConversationMemoryIdentifiersErrors[keyof PostApiConversationMemoryIdentifiersErrors];
+
 export type PostApiConversationMemoryIdentifiersResponses = {
   /**
-   * Success
+   * Upstream identifier data (single value or list) from the Conversation Memory API
    */
-  200: unknown;
+  200: {
+    [key: string]: unknown;
+  };
+  /**
+   * Upstream confirmation payload from the Conversation Memory API
+   */
+  202: {
+    [key: string]: unknown;
+  };
 };
 
+export type PostApiConversationMemoryIdentifiersResponse =
+  PostApiConversationMemoryIdentifiersResponses[keyof PostApiConversationMemoryIdentifiersResponses];
+
 export type DeleteApiConversationMemoryObservationsData = {
   body?: never;
   path?: never;
@@ -299,22 +544,40 @@ export type DeleteApiConversationMemoryObservationsData = {
 
 export type DeleteApiConversationMemoryObservationsErrors = {
   /**
-   * Unauthorized
+   * Missing required profileId or observationId
+   */
+  400: ErrorResponse;
+  /**
+   * Unauthorized — requires an authenticated session
    */
   401: unknown;
   /**
-   * Internal server error
+   * Conversation Memory store not configured, or internal server error
    */
-  500: unknown;
+  500: ErrorResponse;
 };
 
+export type DeleteApiConversationMemoryObservationsError =
+  DeleteApiConversationMemoryObservationsErrors[keyof DeleteApiConversationMemoryObservationsErrors];
+
 export type DeleteApiConversationMemoryObservationsResponses = {
   /**
-   * Success
+   * Upstream observation data (single observation or paginated list) from the Conversation Memory API
    */
-  200: unknown;
+  200: {
+    [key: string]: unknown;
+  };
+  /**
+   * Upstream confirmation payload from the Conversation Memory API
+   */
+  202: {
+    [key: string]: unknown;
+  };
 };
 
+export type DeleteApiConversationMemoryObservationsResponse =
+  DeleteApiConversationMemoryObservationsResponses[keyof DeleteApiConversationMemoryObservationsResponses];
+
 export type GetApiConversationMemoryObservationsData = {
   body?: never;
   path?: never;
@@ -333,22 +596,34 @@ export type GetApiConversationMemoryObservationsData = {
 
 export type GetApiConversationMemoryObservationsErrors = {
   /**
-   * Unauthorized
+   * Missing required profileId
+   */
+  400: ErrorResponse;
+  /**
+   * Unauthorized — requires an authenticated session
    */
   401: unknown;
   /**
-   * Internal server error
+   * Conversation Memory store not configured, or internal server error
    */
-  500: unknown;
+  500: ErrorResponse;
 };
 
+export type GetApiConversationMemoryObservationsError =
+  GetApiConversationMemoryObservationsErrors[keyof GetApiConversationMemoryObservationsErrors];
+
 export type GetApiConversationMemoryObservationsResponses = {
   /**
-   * Success
+   * Upstream observation data (single observation or paginated list) from the Conversation Memory API
    */
-  200: unknown;
+  200: {
+    [key: string]: unknown;
+  };
 };
 
+export type GetApiConversationMemoryObservationsResponse =
+  GetApiConversationMemoryObservationsResponses[keyof GetApiConversationMemoryObservationsResponses];
+
 export type PatchApiConversationMemoryObservationsData = {
   body: {
     [key: string]: unknown;
@@ -363,51 +638,85 @@ export type PatchApiConversationMemoryObservationsData = {
 
 export type PatchApiConversationMemoryObservationsErrors = {
   /**
-   * Unauthorized
+   * Missing required fields (profileId, observationId, content, source, occurredAt)
+   */
+  400: ErrorResponse;
+  /**
+   * Unauthorized — requires an authenticated session
    */
   401: unknown;
   /**
-   * Internal server error
+   * Conversation Memory store not configured, or internal server error
    */
-  500: unknown;
+  500: ErrorResponse;
 };
 
+export type PatchApiConversationMemoryObservationsError =
+  PatchApiConversationMemoryObservationsErrors[keyof PatchApiConversationMemoryObservationsErrors];
+
 export type PatchApiConversationMemoryObservationsResponses = {
   /**
-   * Success
+   * Upstream observation data (single observation or paginated list) from the Conversation Memory API
    */
-  200: unknown;
+  200: {
+    [key: string]: unknown;
+  };
+  /**
+   * Upstream confirmation payload from the Conversation Memory API
+   */
+  202: {
+    [key: string]: unknown;
+  };
 };
 
+export type PatchApiConversationMemoryObservationsResponse =
+  PatchApiConversationMemoryObservationsResponses[keyof PatchApiConversationMemoryObservationsResponses];
+
 export type PostApiConversationMemoryObservationsData = {
   body: {
     [key: string]: unknown;
   };
   path?: never;
-  query: {
-    profileId: string;
-  };
+  query?: never;
   url: '/api/conversation-memory/observations';
 };
 
 export type PostApiConversationMemoryObservationsErrors = {
   /**
-   * Unauthorized
+   * Missing required profileId or observations
+   */
+  400: ErrorResponse;
+  /**
+   * Unauthorized — requires an authenticated session
    */
   401: unknown;
   /**
-   * Internal server error
+   * Conversation Memory store not configured, or internal server error
    */
-  500: unknown;
+  500: ErrorResponse;
 };
 
+export type PostApiConversationMemoryObservationsError =
+  PostApiConversationMemoryObservationsErrors[keyof PostApiConversationMemoryObservationsErrors];
+
 export type PostApiConversationMemoryObservationsResponses = {
   /**
-   * Success
+   * Upstream observation data (single observation or paginated list) from the Conversation Memory API
    */
-  200: unknown;
+  200: {
+    [key: string]: unknown;
+  };
+  /**
+   * Upstream confirmation payload from the Conversation Memory API
+   */
+  202: {
+    [key: string]: unknown;
+  };
 };
 
+export type PostApiConversationMemoryObservationsResponse =
+  PostApiConversationMemoryObservationsResponses[keyof PostApiConversationMemoryObservationsResponses];
+
 export type DeleteApiConversationMemoryProfilesData = {
   body?: never;
   path?: never;
@@ -419,22 +728,40 @@ export type DeleteApiConversationMemoryProfilesData = {
 
 export type DeleteApiConversationMemoryProfilesErrors = {
   /**
-   * Unauthorized
+   * Missing required profileId
+   */
+  400: ErrorResponse;
+  /**
+   * Unauthorized — requires an authenticated session
    */
   401: unknown;
   /**
-   * Internal server error
+   * Conversation Memory store not configured, or internal server error
    */
-  500: unknown;
+  500: ErrorResponse;
 };
 
+export type DeleteApiConversationMemoryProfilesError =
+  DeleteApiConversationMemoryProfilesErrors[keyof DeleteApiConversationMemoryProfilesErrors];
+
 export type DeleteApiConversationMemoryProfilesResponses = {
   /**
-   * Success
+   * Upstream profile data (single profile or paginated list) from the Conversation Memory API
    */
-  200: unknown;
+  200: {
+    [key: string]: unknown;
+  };
+  /**
+   * Upstream confirmation payload from the Conversation Memory API
+   */
+  202: {
+    [key: string]: unknown;
+  };
 };
 
+export type DeleteApiConversationMemoryProfilesResponse =
+  DeleteApiConversationMemoryProfilesResponses[keyof DeleteApiConversationMemoryProfilesResponses];
+
 export type GetApiConversationMemoryProfilesData = {
   body?: never;
   path?: never;
@@ -450,22 +777,30 @@ export type GetApiConversationMemoryProfilesData = {
 
 export type GetApiConversationMemoryProfilesErrors = {
   /**
-   * Unauthorized
+   * Unauthorized — requires an authenticated session
    */
   401: unknown;
   /**
-   * Internal server error
+   * Conversation Memory store not configured, or internal server error
    */
-  500: unknown;
+  500: ErrorResponse;
 };
 
+export type GetApiConversationMemoryProfilesError =
+  GetApiConversationMemoryProfilesErrors[keyof GetApiConversationMemoryProfilesErrors];
+
 export type GetApiConversationMemoryProfilesResponses = {
   /**
-   * Success
+   * Upstream profile data (single profile or paginated list) from the Conversation Memory API
    */
-  200: unknown;
+  200: {
+    [key: string]: unknown;
+  };
 };
 
+export type GetApiConversationMemoryProfilesResponse =
+  GetApiConversationMemoryProfilesResponses[keyof GetApiConversationMemoryProfilesResponses];
+
 export type PatchApiConversationMemoryProfilesData = {
   body: {
     [key: string]: unknown;
@@ -479,51 +814,87 @@ export type PatchApiConversationMemoryProfilesData = {
 
 export type PatchApiConversationMemoryProfilesErrors = {
   /**
-   * Unauthorized
+   * Missing required profileId or traits
+   */
+  400: ErrorResponse;
+  /**
+   * Unauthorized — requires an authenticated session
    */
   401: unknown;
   /**
-   * Internal server error
+   * Conversation Memory store not configured, or internal server error
    */
-  500: unknown;
+  500: ErrorResponse;
 };
 
+export type PatchApiConversationMemoryProfilesError =
+  PatchApiConversationMemoryProfilesErrors[keyof PatchApiConversationMemoryProfilesErrors];
+
 export type PatchApiConversationMemoryProfilesResponses = {
   /**
-   * Success
+   * Upstream profile data (single profile or paginated list) from the Conversation Memory API
    */
-  200: unknown;
+  200: {
+    [key: string]: unknown;
+  };
+  /**
+   * Upstream confirmation payload from the Conversation Memory API
+   */
+  202: {
+    [key: string]: unknown;
+  };
 };
 
+export type PatchApiConversationMemoryProfilesResponse =
+  PatchApiConversationMemoryProfilesResponses[keyof PatchApiConversationMemoryProfilesResponses];
+
 export type PostApiConversationMemoryProfilesData = {
   body: {
     [key: string]: unknown;
   };
   path?: never;
-  query: {
-    profileId: string;
+  query?: {
+    profileId?: string;
   };
   url: '/api/conversation-memory/profiles';
 };
 
 export type PostApiConversationMemoryProfilesErrors = {
   /**
-   * Unauthorized
+   * Missing required traits
+   */
+  400: ErrorResponse;
+  /**
+   * Unauthorized — requires an authenticated session
    */
   401: unknown;
   /**
-   * Internal server error
+   * Conversation Memory store not configured, or internal server error
    */
-  500: unknown;
+  500: ErrorResponse;
 };
 
+export type PostApiConversationMemoryProfilesError =
+  PostApiConversationMemoryProfilesErrors[keyof PostApiConversationMemoryProfilesErrors];
+
 export type PostApiConversationMemoryProfilesResponses = {
   /**
-   * Success
+   * Upstream profile data (single profile or paginated list) from the Conversation Memory API
    */
-  200: unknown;
+  200: {
+    [key: string]: unknown;
+  };
+  /**
+   * Upstream confirmation payload from the Conversation Memory API
+   */
+  202: {
+    [key: string]: unknown;
+  };
 };
 
+export type PostApiConversationMemoryProfilesResponse =
+  PostApiConversationMemoryProfilesResponses[keyof PostApiConversationMemoryProfilesResponses];
+
 export type PostApiConversationMemoryProfilesLookupData = {
   body: {
     [key: string]: unknown;
@@ -535,22 +906,34 @@ export type PostApiConversationMemoryProfilesLookupData = {
 
 export type PostApiConversationMemoryProfilesLookupErrors = {
   /**
-   * Unauthorized
+   * Missing required idType or value
+   */
+  400: ErrorResponse;
+  /**
+   * Unauthorized — requires an authenticated session
    */
   401: unknown;
   /**
-   * Internal server error
+   * Conversation Memory store not configured, or internal server error
    */
-  500: unknown;
+  500: ErrorResponse;
 };
 
+export type PostApiConversationMemoryProfilesLookupError =
+  PostApiConversationMemoryProfilesLookupErrors[keyof PostApiConversationMemoryProfilesLookupErrors];
+
 export type PostApiConversationMemoryProfilesLookupResponses = {
   /**
-   * Success
+   * Upstream profile lookup result from the Conversation Memory API
    */
-  200: unknown;
+  200: {
+    [key: string]: unknown;
+  };
 };
 
+export type PostApiConversationMemoryProfilesLookupResponse =
+  PostApiConversationMemoryProfilesLookupResponses[keyof PostApiConversationMemoryProfilesLookupResponses];
+
 export type PostApiConversationMemoryRecallData = {
   body: {
     [key: string]: unknown;
@@ -562,22 +945,32 @@ export type PostApiConversationMemoryRecallData = {
 
 export type PostApiConversationMemoryRecallErrors = {
   /**
-   * Unauthorized
+   * Missing required profileId or query
+   */
+  400: ErrorResponse;
+  /**
+   * Unauthorized — requires an authenticated session
    */
   401: unknown;
   /**
-   * Internal server error
+   * Conversation Memory store not configured, or internal server error
    */
-  500: unknown;
+  500: ErrorResponse;
 };
 
+export type PostApiConversationMemoryRecallError =
+  PostApiConversationMemoryRecallErrors[keyof PostApiConversationMemoryRecallErrors];
+
 export type PostApiConversationMemoryRecallResponses = {
   /**
-   * Success
+   * Recalled communications, observations, and summaries matching the query
    */
-  200: unknown;
+  200: ConversationMemoryRecallResponse;
 };
 
+export type PostApiConversationMemoryRecallResponse =
+  PostApiConversationMemoryRecallResponses[keyof PostApiConversationMemoryRecallResponses];
+
 export type DeleteApiConversationMemoryResetData = {
   body?: never;
   path?: never;
@@ -589,22 +982,34 @@ export type DeleteApiConversationMemoryResetData = {
 
 export type DeleteApiConversationMemoryResetErrors = {
   /**
-   * Unauthorized
+   * Missing required profileId
    */
-  401: unknown;
+  400: ErrorResponse;
   /**
-   * Internal server error
+   * Unauthorized — requires an authenticated session
    */
-  500: unknown;
+  401: unknown;
+  /**
+   * Conversation Memory store not configured, or internal server error
+   */
+  500: ErrorResponse;
 };
 
+export type DeleteApiConversationMemoryResetError =
+  DeleteApiConversationMemoryResetErrors[keyof DeleteApiConversationMemoryResetErrors];
+
 export type DeleteApiConversationMemoryResetResponses = {
   /**
-   * Success
+   * Upstream confirmation payload from the Conversation Memory API
    */
-  200: unknown;
+  200: {
+    [key: string]: unknown;
+  };
 };
 
+export type DeleteApiConversationMemoryResetResponse =
+  DeleteApiConversationMemoryResetResponses[keyof DeleteApiConversationMemoryResetResponses];
+
 export type GetApiConversationMemoryTraitGroupsData = {
   body?: never;
   path?: never;
@@ -619,22 +1024,30 @@ export type GetApiConversationMemoryTraitGroupsData = {
 
 export type GetApiConversationMemoryTraitGroupsErrors = {
   /**
-   * Unauthorized
+   * Unauthorized — requires an authenticated session
    */
   401: unknown;
   /**
-   * Internal server error
+   * Conversation Memory store not configured, or internal server error
    */
-  500: unknown;
+  500: ErrorResponse;
 };
 
+export type GetApiConversationMemoryTraitGroupsError =
+  GetApiConversationMemoryTraitGroupsErrors[keyof GetApiConversationMemoryTraitGroupsErrors];
+
 export type GetApiConversationMemoryTraitGroupsResponses = {
   /**
-   * Success
+   * Upstream trait group data (single group or paginated list) from the Conversation Memory API
    */
-  200: unknown;
+  200: {
+    [key: string]: unknown;
+  };
 };
 
+export type GetApiConversationMemoryTraitGroupsResponse =
+  GetApiConversationMemoryTraitGroupsResponses[keyof GetApiConversationMemoryTraitGroupsResponses];
+
 export type PatchApiConversationMemoryTraitGroupsData = {
   body: {
     [key: string]: unknown;
@@ -646,22 +1059,40 @@ export type PatchApiConversationMemoryTraitGroupsData = {
 
 export type PatchApiConversationMemoryTraitGroupsErrors = {
   /**
-   * Unauthorized
+   * Missing required traitGroupName
+   */
+  400: ErrorResponse;
+  /**
+   * Unauthorized — requires an authenticated session
    */
   401: unknown;
   /**
-   * Internal server error
+   * Conversation Memory store not configured, or internal server error
    */
-  500: unknown;
+  500: ErrorResponse;
 };
 
+export type PatchApiConversationMemoryTraitGroupsError =
+  PatchApiConversationMemoryTraitGroupsErrors[keyof PatchApiConversationMemoryTraitGroupsErrors];
+
 export type PatchApiConversationMemoryTraitGroupsResponses = {
   /**
-   * Success
+   * Upstream trait group data (single group or paginated list) from the Conversation Memory API
    */
-  200: unknown;
+  200: {
+    [key: string]: unknown;
+  };
+  /**
+   * Upstream confirmation payload from the Conversation Memory API
+   */
+  202: {
+    [key: string]: unknown;
+  };
 };
 
+export type PatchApiConversationMemoryTraitGroupsResponse =
+  PatchApiConversationMemoryTraitGroupsResponses[keyof PatchApiConversationMemoryTraitGroupsResponses];
+
 export type PostApiConversationMemoryTraitGroupsData = {
   body: {
     [key: string]: unknown;
@@ -673,22 +1104,40 @@ export type PostApiConversationMemoryTraitGroupsData = {
 
 export type PostApiConversationMemoryTraitGroupsErrors = {
   /**
-   * Unauthorized
+   * Missing required displayName
+   */
+  400: ErrorResponse;
+  /**
+   * Unauthorized — requires an authenticated session
    */
   401: unknown;
   /**
-   * Internal server error
+   * Conversation Memory store not configured, or internal server error
    */
-  500: unknown;
+  500: ErrorResponse;
 };
 
+export type PostApiConversationMemoryTraitGroupsError =
+  PostApiConversationMemoryTraitGroupsErrors[keyof PostApiConversationMemoryTraitGroupsErrors];
+
 export type PostApiConversationMemoryTraitGroupsResponses = {
   /**
-   * Success
+   * Upstream trait group data (single group or paginated list) from the Conversation Memory API
    */
-  200: unknown;
+  200: {
+    [key: string]: unknown;
+  };
+  /**
+   * Upstream confirmation payload from the Conversation Memory API
+   */
+  202: {
+    [key: string]: unknown;
+  };
 };
 
+export type PostApiConversationMemoryTraitGroupsResponse =
+  PostApiConversationMemoryTraitGroupsResponses[keyof PostApiConversationMemoryTraitGroupsResponses];
+
 export type GetApiConversationMemoryTraitsData = {
   body?: never;
   path?: never;
@@ -704,22 +1153,34 @@ export type GetApiConversationMemoryTraitsData = {
 
 export type GetApiConversationMemoryTraitsErrors = {
   /**
-   * Unauthorized
+   * Missing required profileId
+   */
+  400: ErrorResponse;
+  /**
+   * Unauthorized — requires an authenticated session
    */
   401: unknown;
   /**
-   * Internal server error
+   * Conversation Memory store not configured, or internal server error
    */
-  500: unknown;
+  500: ErrorResponse;
 };
 
+export type GetApiConversationMemoryTraitsError =
+  GetApiConversationMemoryTraitsErrors[keyof GetApiConversationMemoryTraitsErrors];
+
 export type GetApiConversationMemoryTraitsResponses = {
   /**
-   * Success
+   * Upstream paginated trait data from the Conversation Memory API
    */
-  200: unknown;
+  200: {
+    [key: string]: unknown;
+  };
 };
 
+export type GetApiConversationMemoryTraitsResponse =
+  GetApiConversationMemoryTraitsResponses[keyof GetApiConversationMemoryTraitsResponses];
+
 export type DeleteApiConversationalIntelligenceOperatorData = {
   body?: never;
   path?: never;
@@ -731,22 +1192,34 @@ export type DeleteApiConversationalIntelligenceOperatorData = {
 
 export type DeleteApiConversationalIntelligenceOperatorErrors = {
   /**
-   * Unauthorized
+   * Missing intelligenceOperatorId
+   */
+  400: ErrorResponse;
+  /**
+   * Unauthorized — requires an authenticated session
    */
   401: unknown;
   /**
    * Internal server error
    */
-  500: unknown;
+  500: ErrorResponse;
 };
 
+export type DeleteApiConversationalIntelligenceOperatorError =
+  DeleteApiConversationalIntelligenceOperatorErrors[keyof DeleteApiConversationalIntelligenceOperatorErrors];
+
 export type DeleteApiConversationalIntelligenceOperatorResponses = {
   /**
-   * Success
+   * `{ success: true }` when the upstream returned no content, otherwise the deleted operator object as-is
    */
-  200: unknown;
+  200: {
+    [key: string]: unknown;
+  };
 };
 
+export type DeleteApiConversationalIntelligenceOperatorResponse =
+  DeleteApiConversationalIntelligenceOperatorResponses[keyof DeleteApiConversationalIntelligenceOperatorResponses];
+
 export type GetApiConversationalIntelligenceOperatorData = {
   body?: never;
   path?: never;
@@ -759,22 +1232,30 @@ export type GetApiConversationalIntelligenceOperatorData = {
 
 export type GetApiConversationalIntelligenceOperatorErrors = {
   /**
-   * Unauthorized
+   * Unauthorized — requires an authenticated session
    */
   401: unknown;
   /**
    * Internal server error
    */
-  500: unknown;
+  500: ErrorResponse;
 };
 
+export type GetApiConversationalIntelligenceOperatorError =
+  GetApiConversationalIntelligenceOperatorErrors[keyof GetApiConversationalIntelligenceOperatorErrors];
+
 export type GetApiConversationalIntelligenceOperatorResponses = {
   /**
-   * Success
+   * A single Operator (when intelligenceOperatorId is provided) or an OperatorList (paginated), proxied from the upstream API
    */
-  200: unknown;
+  200: {
+    [key: string]: unknown;
+  };
 };
 
+export type GetApiConversationalIntelligenceOperatorResponse =
+  GetApiConversationalIntelligenceOperatorResponses[keyof GetApiConversationalIntelligenceOperatorResponses];
+
 export type PostApiConversationalIntelligenceOperatorData = {
   body: {
     [key: string]: unknown;
@@ -788,22 +1269,28 @@ export type PostApiConversationalIntelligenceOperatorData = {
 
 export type PostApiConversationalIntelligenceOperatorErrors = {
   /**
-   * Unauthorized
+   * Unauthorized — requires an authenticated session
    */
   401: unknown;
   /**
    * Internal server error
    */
-  500: unknown;
+  500: ErrorResponse;
 };
 
+export type PostApiConversationalIntelligenceOperatorError =
+  PostApiConversationalIntelligenceOperatorErrors[keyof PostApiConversationalIntelligenceOperatorErrors];
+
 export type PostApiConversationalIntelligenceOperatorResponses = {
   /**
-   * Success
+   * The created operator object
    */
-  200: unknown;
+  200: Operator;
 };
 
+export type PostApiConversationalIntelligenceOperatorResponse =
+  PostApiConversationalIntelligenceOperatorResponses[keyof PostApiConversationalIntelligenceOperatorResponses];
+
 export type PutApiConversationalIntelligenceOperatorData = {
   body: {
     [key: string]: unknown;
@@ -817,22 +1304,28 @@ export type PutApiConversationalIntelligenceOperatorData = {
 
 export type PutApiConversationalIntelligenceOperatorErrors = {
   /**
-   * Unauthorized
+   * Unauthorized — requires an authenticated session
    */
   401: unknown;
   /**
    * Internal server error
    */
-  500: unknown;
+  500: ErrorResponse;
 };
 
+export type PutApiConversationalIntelligenceOperatorError =
+  PutApiConversationalIntelligenceOperatorErrors[keyof PutApiConversationalIntelligenceOperatorErrors];
+
 export type PutApiConversationalIntelligenceOperatorResponses = {
   /**
-   * Success
+   * The updated operator object
    */
-  200: unknown;
+  200: Operator;
 };
 
+export type PutApiConversationalIntelligenceOperatorResponse =
+  PutApiConversationalIntelligenceOperatorResponses[keyof PutApiConversationalIntelligenceOperatorResponses];
+
 export type DeleteApiConversationsDeleteData = {
   body?: never;
   path?: never;
@@ -842,22 +1335,45 @@ export type DeleteApiConversationsDeleteData = {
 
 export type DeleteApiConversationsDeleteErrors = {
   /**
-   * Unauthorized
+   * Missing required objectID
+   */
+  400: ErrorResponse;
+  /**
+   * Unauthorized — requires an authenticated session
    */
   401: unknown;
   /**
-   * Internal server error
+   * Failed to delete conversation
    */
-  500: unknown;
+  500: ErrorResponse;
 };
 
+export type DeleteApiConversationsDeleteError =
+  DeleteApiConversationsDeleteErrors[keyof DeleteApiConversationsDeleteErrors];
+
 export type DeleteApiConversationsDeleteResponses = {
   /**
    * Success
    */
-  200: unknown;
+  200: {
+    /**
+     * Always true on successful deletion
+     */
+    success: boolean;
+    /**
+     * Confirmation message
+     */
+    message: string;
+    /**
+     * The deleted template's objectID
+     */
+    objectID: string;
+  };
 };
 
+export type DeleteApiConversationsDeleteResponse =
+  DeleteApiConversationsDeleteResponses[keyof DeleteApiConversationsDeleteResponses];
+
 export type PostApiConversationsSaveData = {
   body: {
     [key: string]: unknown;
@@ -869,22 +1385,49 @@ export type PostApiConversationsSaveData = {
 
 export type PostApiConversationsSaveErrors = {
   /**
-   * Unauthorized
+   * Unauthorized — requires an authenticated session
    */
   401: unknown;
   /**
-   * Internal server error
+   * Failed to save conversation
    */
-  500: unknown;
+  500: ErrorResponse;
 };
 
+export type PostApiConversationsSaveError =
+  PostApiConversationsSaveErrors[keyof PostApiConversationsSaveErrors];
+
 export type PostApiConversationsSaveResponses = {
   /**
    * Success
    */
-  200: unknown;
+  200: {
+    /**
+     * Confirmation message
+     */
+    message: string;
+    /**
+     * The saved template's objectID
+     */
+    objectID: string;
+    /**
+     * Always true on successful save
+     */
+    success: boolean;
+    /**
+     * Present only when a new CINTEL configuration was created for this template
+     */
+    intelligenceConfigurationId: string;
+    /**
+     * Present only when the target worker was auto-resolved from the user's email
+     */
+    crTargetWorker: string;
+  };
 };
 
+export type PostApiConversationsSaveResponse =
+  PostApiConversationsSaveResponses[keyof PostApiConversationsSaveResponses];
+
 export type PostApiConversationsShareData = {
   body: {
     [key: string]: unknown;
@@ -896,22 +1439,49 @@ export type PostApiConversationsShareData = {
 
 export type PostApiConversationsShareErrors = {
   /**
-   * Unauthorized
+   * Missing required objectID/recipientEmail, or invalid email address
+   */
+  400: ErrorResponse;
+  /**
+   * Unauthorized — requires an authenticated session
    */
   401: unknown;
   /**
-   * Internal server error
+   * Source template not found
    */
-  500: unknown;
+  404: ErrorResponse;
+  /**
+   * Failed to share template
+   */
+  500: ErrorResponse;
 };
 
+export type PostApiConversationsShareError =
+  PostApiConversationsShareErrors[keyof PostApiConversationsShareErrors];
+
 export type PostApiConversationsShareResponses = {
   /**
    * Success
    */
-  200: unknown;
+  200: {
+    /**
+     * Confirmation message
+     */
+    message: string;
+    /**
+     * The objectID of the newly created shared copy
+     */
+    newObjectID: string;
+    /**
+     * Always true on successful share
+     */
+    success: boolean;
+  };
 };
 
+export type PostApiConversationsShareResponse =
+  PostApiConversationsShareResponses[keyof PostApiConversationsShareResponses];
+
 export type GetApiCountryConfigsData = {
   body?: never;
   path?: never;
@@ -921,22 +1491,35 @@ export type GetApiCountryConfigsData = {
 
 export type GetApiCountryConfigsErrors = {
   /**
-   * Unauthorized
+   * Unauthorized — requires an authenticated session
    */
   401: unknown;
   /**
-   * Internal server error
+   * Error fetching country configs
    */
-  500: unknown;
+  500: ErrorResponse;
 };
 
+export type GetApiCountryConfigsError =
+  GetApiCountryConfigsErrors[keyof GetApiCountryConfigsErrors];
+
 export type GetApiCountryConfigsResponses = {
   /**
    * Success
    */
-  200: unknown;
+  200: {
+    /**
+     * Array of country configurations
+     */
+    configs: Array<{
+      [key: string]: unknown;
+    }>;
+  };
 };
 
+export type GetApiCountryConfigsResponse =
+  GetApiCountryConfigsResponses[keyof GetApiCountryConfigsResponses];
+
 export type PostApiCreateExternalFlexConnectionData = {
   body: {
     [key: string]: unknown;
@@ -947,19 +1530,66 @@ export type PostApiCreateExternalFlexConnectionData = {
 };
 
 export type PostApiCreateExternalFlexConnectionErrors = {
+  /**
+   * Bad Request
+   */
+  400: {
+    /**
+     * Always false
+     */
+    success: boolean;
+    /**
+     * Always "Invalid JSON in request"
+     */
+    error: string;
+  };
+  /**
+   * Unauthorized — requires an authenticated session
+   */
+  401: unknown;
   /**
    * Internal server error
    */
-  500: unknown;
+  500: {
+    /**
+     * Always false
+     */
+    success: boolean;
+    /**
+     * Error message
+     */
+    error: string;
+  };
+  /**
+   * Response
+   */
+  502: {
+    /**
+     * Always false
+     */
+    success: boolean;
+    /**
+     * Always "Invalid JSON from upstream"
+     */
+    error: string;
+  };
 };
 
+export type PostApiCreateExternalFlexConnectionError =
+  PostApiCreateExternalFlexConnectionErrors[keyof PostApiCreateExternalFlexConnectionErrors];
+
 export type PostApiCreateExternalFlexConnectionResponses = {
   /**
-   * Success
+   * Proxied response from the upstream API (shape depends on upstream; non-2xx upstream statuses are also passed through as-is)
    */
-  200: unknown;
+  200: {
+    [key: string]: unknown;
+  };
 };
 
+export type PostApiCreateExternalFlexConnectionResponse =
+  PostApiCreateExternalFlexConnectionResponses[keyof PostApiCreateExternalFlexConnectionResponses];
+
 export type PostApiEnhancePromptData = {
   body: {
     [key: string]: unknown;
@@ -971,22 +1601,37 @@ export type PostApiEnhancePromptData = {
 
 export type PostApiEnhancePromptErrors = {
   /**
-   * Unauthorized
+   * Unauthorized — requires an authenticated session
    */
   401: unknown;
   /**
-   * Internal server error
+   * Failed to enhance prompt with AI
    */
-  500: unknown;
+  500: ErrorResponse;
 };
 
+export type PostApiEnhancePromptError =
+  PostApiEnhancePromptErrors[keyof PostApiEnhancePromptErrors];
+
 export type PostApiEnhancePromptResponses = {
   /**
    * Success
    */
-  200: unknown;
+  200: {
+    /**
+     * The AI-enhanced context/background text
+     */
+    enhancedContext: string;
+    /**
+     * The AI-enhanced instructions text
+     */
+    enhancedInstructions: string;
+  };
 };
 
+export type PostApiEnhancePromptResponse =
+  PostApiEnhancePromptResponses[keyof PostApiEnhancePromptResponses];
+
 export type PostApiGenerateTagsData = {
   body: {
     [key: string]: unknown;
@@ -998,7 +1643,7 @@ export type PostApiGenerateTagsData = {
 
 export type PostApiGenerateTagsErrors = {
   /**
-   * Unauthorized
+   * Unauthorized — requires an authenticated session
    */
   401: unknown;
   /**
@@ -1011,9 +1656,17 @@ export type PostApiGenerateTagsResponses = {
   /**
    * Success
    */
-  200: unknown;
+  200: {
+    /**
+     * Generated tags (empty array if no input fields, generation failed, or AI response was unparseable)
+     */
+    tags: Array<string>;
+  };
 };
 
+export type PostApiGenerateTagsResponse =
+  PostApiGenerateTagsResponses[keyof PostApiGenerateTagsResponses];
+
 export type PostApiIncrementViewCountData = {
   body: {
     [key: string]: unknown;
@@ -1025,22 +1678,49 @@ export type PostApiIncrementViewCountData = {
 
 export type PostApiIncrementViewCountErrors = {
   /**
-   * Unauthorized
+   * Missing or invalid objectID
+   */
+  400: ErrorResponse;
+  /**
+   * Unauthorized — requires an authenticated session
    */
   401: unknown;
   /**
-   * Internal server error
+   * Record not found
    */
-  500: unknown;
+  404: ErrorResponse;
+  /**
+   * Failed to increment view count
+   */
+  500: ErrorResponse;
 };
 
+export type PostApiIncrementViewCountError =
+  PostApiIncrementViewCountErrors[keyof PostApiIncrementViewCountErrors];
+
 export type PostApiIncrementViewCountResponses = {
   /**
    * Success
    */
-  200: unknown;
+  200: {
+    /**
+     * The template's objectID
+     */
+    objectID: string;
+    /**
+     * Always true on successful increment
+     */
+    success: boolean;
+    /**
+     * The new view count after incrementing
+     */
+    viewCount: number;
+  };
 };
 
+export type PostApiIncrementViewCountResponse =
+  PostApiIncrementViewCountResponses[keyof PostApiIncrementViewCountResponses];
+
 export type GetApiIntelligenceConfigurationData = {
   body?: never;
   path?: never;
@@ -1053,22 +1733,30 @@ export type GetApiIntelligenceConfigurationData = {
 
 export type GetApiIntelligenceConfigurationErrors = {
   /**
-   * Unauthorized
+   * Unauthorized — requires an authenticated session
    */
   401: unknown;
   /**
    * Internal server error
    */
-  500: unknown;
+  500: ErrorResponse;
 };
 
+export type GetApiIntelligenceConfigurationError =
+  GetApiIntelligenceConfigurationErrors[keyof GetApiIntelligenceConfigurationErrors];
+
 export type GetApiIntelligenceConfigurationResponses = {
   /**
-   * Success
+   * A single IntelligenceConfiguration (when intelligenceConfigurationId is provided) or a paginated list
    */
-  200: unknown;
+  200: {
+    [key: string]: unknown;
+  };
 };
 
+export type GetApiIntelligenceConfigurationResponse =
+  GetApiIntelligenceConfigurationResponses[keyof GetApiIntelligenceConfigurationResponses];
+
 export type PostApiIntelligenceConfigurationData = {
   body: {
     [key: string]: unknown;
@@ -1080,22 +1768,28 @@ export type PostApiIntelligenceConfigurationData = {
 
 export type PostApiIntelligenceConfigurationErrors = {
   /**
-   * Unauthorized
+   * Unauthorized — requires an authenticated session
    */
   401: unknown;
   /**
    * Internal server error
    */
-  500: unknown;
+  500: ErrorResponse;
 };
 
+export type PostApiIntelligenceConfigurationError =
+  PostApiIntelligenceConfigurationErrors[keyof PostApiIntelligenceConfigurationErrors];
+
 export type PostApiIntelligenceConfigurationResponses = {
   /**
-   * Success
+   * The created configuration
    */
-  200: unknown;
+  200: IntelligenceConfiguration;
 };
 
+export type PostApiIntelligenceConfigurationResponse =
+  PostApiIntelligenceConfigurationResponses[keyof PostApiIntelligenceConfigurationResponses];
+
 export type PutApiIntelligenceConfigurationData = {
   body: {
     [key: string]: unknown;
@@ -1107,42 +1801,27 @@ export type PutApiIntelligenceConfigurationData = {
 
 export type PutApiIntelligenceConfigurationErrors = {
   /**
-   * Unauthorized
+   * Unauthorized — requires an authenticated session
    */
   401: unknown;
   /**
    * Internal server error
    */
-  500: unknown;
-};
-
-export type PutApiIntelligenceConfigurationResponses = {
-  /**
-   * Success
-   */
-  200: unknown;
+  500: ErrorResponse;
 };
 
-export type GetApiInternalNavData = {
-  body?: never;
-  path?: never;
-  query?: never;
-  url: '/api/internal-nav';
-};
+export type PutApiIntelligenceConfigurationError =
+  PutApiIntelligenceConfigurationErrors[keyof PutApiIntelligenceConfigurationErrors];
 
-export type GetApiInternalNavErrors = {
+export type PutApiIntelligenceConfigurationResponses = {
   /**
-   * Internal server error
+   * The updated configuration
    */
-  500: unknown;
+  200: IntelligenceConfiguration;
 };
 
-export type GetApiInternalNavResponses = {
-  /**
-   * Success
-   */
-  200: unknown;
-};
+export type PutApiIntelligenceConfigurationResponse =
+  PutApiIntelligenceConfigurationResponses[keyof PutApiIntelligenceConfigurationResponses];
 
 export type GetApiIsvLogoData = {
   body?: never;
@@ -1155,18 +1834,47 @@ export type GetApiIsvLogoData = {
 
 export type GetApiIsvLogoErrors = {
   /**
-   * Internal server error
+   * Missing or empty "company" query parameter
    */
-  500: unknown;
+  400: ErrorResponse;
+  /**
+   * Logo not found for company
+   */
+  404: ErrorResponse;
+  /**
+   * Failed to lookup ISV logo
+   */
+  500: ErrorResponse;
+  /**
+   * Logo URL missing in mapping record
+   */
+  502: ErrorResponse;
 };
 
+export type GetApiIsvLogoError = GetApiIsvLogoErrors[keyof GetApiIsvLogoErrors];
+
 export type GetApiIsvLogoResponses = {
   /**
    * Success
    */
-  200: unknown;
+  200: {
+    /**
+     * Matched company name
+     */
+    company: string;
+    /**
+     * URL of the company's logo
+     */
+    logoUrl: string;
+    /**
+     * Algolia objectID of the matched mapping record
+     */
+    objectID: string;
+  };
 };
 
+export type GetApiIsvLogoResponse = GetApiIsvLogoResponses[keyof GetApiIsvLogoResponses];
+
 export type DeleteApiLeadGenData = {
   body?: never;
   path?: never;
@@ -1176,22 +1884,32 @@ export type DeleteApiLeadGenData = {
 
 export type DeleteApiLeadGenErrors = {
   /**
-   * Unauthorized
+   * Missing required objectID or agentNumber
+   */
+  400: ErrorResponse;
+  /**
+   * Unauthorized — requires an authenticated session
    */
   401: unknown;
   /**
-   * Internal server error
+   * Failed to delete lead gen, or internal server error
    */
-  500: unknown;
+  500: ErrorResponse;
 };
 
+export type DeleteApiLeadGenError = DeleteApiLeadGenErrors[keyof DeleteApiLeadGenErrors];
+
 export type DeleteApiLeadGenResponses = {
   /**
-   * Success
+   * Proxied response from the upstream lead-gen API (shape depends on upstream)
    */
-  200: unknown;
+  200: {
+    [key: string]: unknown;
+  };
 };
 
+export type DeleteApiLeadGenResponse = DeleteApiLeadGenResponses[keyof DeleteApiLeadGenResponses];
+
 export type GetApiLeadGenData = {
   body?: never;
   path?: never;
@@ -1204,22 +1922,35 @@ export type GetApiLeadGenData = {
 
 export type GetApiLeadGenErrors = {
   /**
-   * Unauthorized
+   * Missing required objectID or agentNumber
+   */
+  400: ErrorResponse;
+  /**
+   * Unauthorized — requires an authenticated session
    */
   401: unknown;
   /**
    * Internal server error
    */
-  500: unknown;
+  500: ErrorResponse;
 };
 
+export type GetApiLeadGenError = GetApiLeadGenErrors[keyof GetApiLeadGenErrors];
+
 export type GetApiLeadGenResponses = {
   /**
    * Success
    */
-  200: unknown;
+  200: {
+    /**
+     * Locked templates matching the lookup key
+     */
+    templates: Array<LockedTemplateData>;
+  };
 };
 
+export type GetApiLeadGenResponse = GetApiLeadGenResponses[keyof GetApiLeadGenResponses];
+
 export type PatchApiLeadGenData = {
   body: {
     [key: string]: unknown;
@@ -1231,22 +1962,32 @@ export type PatchApiLeadGenData = {
 
 export type PatchApiLeadGenErrors = {
   /**
-   * Unauthorized
+   * Missing required objectID or agentNumber
+   */
+  400: ErrorResponse;
+  /**
+   * Unauthorized — requires an authenticated session
    */
   401: unknown;
   /**
-   * Internal server error
+   * Failed to update lead gen, or internal server error
    */
-  500: unknown;
+  500: ErrorResponse;
 };
 
+export type PatchApiLeadGenError = PatchApiLeadGenErrors[keyof PatchApiLeadGenErrors];
+
 export type PatchApiLeadGenResponses = {
   /**
-   * Success
+   * Proxied response from the upstream lead-gen API (shape depends on upstream)
    */
-  200: unknown;
+  200: {
+    [key: string]: unknown;
+  };
 };
 
+export type PatchApiLeadGenResponse = PatchApiLeadGenResponses[keyof PatchApiLeadGenResponses];
+
 export type PostApiLeadGenData = {
   body: {
     [key: string]: unknown;
@@ -1258,22 +1999,32 @@ export type PostApiLeadGenData = {
 
 export type PostApiLeadGenErrors = {
   /**
-   * Unauthorized
+   * Missing required objectID or agentNumber
+   */
+  400: ErrorResponse;
+  /**
+   * Unauthorized — requires an authenticated session
    */
   401: unknown;
   /**
-   * Internal server error
+   * Failed to create lead gen, or internal server error
    */
-  500: unknown;
+  500: ErrorResponse;
 };
 
+export type PostApiLeadGenError = PostApiLeadGenErrors[keyof PostApiLeadGenErrors];
+
 export type PostApiLeadGenResponses = {
   /**
-   * Success
+   * Proxied response from the upstream lead-gen API (shape depends on upstream)
    */
-  200: unknown;
+  200: {
+    [key: string]: unknown;
+  };
 };
 
+export type PostApiLeadGenResponse = PostApiLeadGenResponses[keyof PostApiLeadGenResponses];
+
 export type DeleteApiLinkShortenerData = {
   body?: never;
   path?: never;
@@ -1285,22 +2036,34 @@ export type DeleteApiLinkShortenerData = {
 
 export type DeleteApiLinkShortenerErrors = {
   /**
-   * Unauthorized
+   * Missing required code query param
+   */
+  400: ErrorResponse;
+  /**
+   * Unauthorized — requires an authenticated session
    */
   401: unknown;
   /**
-   * Internal server error
+   * Failed to delete link, or internal server error
    */
-  500: unknown;
+  500: ErrorResponse;
 };
 
+export type DeleteApiLinkShortenerError =
+  DeleteApiLinkShortenerErrors[keyof DeleteApiLinkShortenerErrors];
+
 export type DeleteApiLinkShortenerResponses = {
   /**
-   * Success
+   * Proxied response from the upstream link-shortener API (shape depends on upstream)
    */
-  200: unknown;
+  200: {
+    [key: string]: unknown;
+  };
 };
 
+export type DeleteApiLinkShortenerResponse =
+  DeleteApiLinkShortenerResponses[keyof DeleteApiLinkShortenerResponses];
+
 export type GetApiLinkShortenerData = {
   body?: never;
   path?: never;
@@ -1312,22 +2075,29 @@ export type GetApiLinkShortenerData = {
 
 export type GetApiLinkShortenerErrors = {
   /**
-   * Unauthorized
+   * Unauthorized — requires an authenticated session
    */
   401: unknown;
   /**
-   * Internal server error
+   * Failed to fetch links, or internal server error
    */
-  500: unknown;
+  500: ErrorResponse;
 };
 
+export type GetApiLinkShortenerError = GetApiLinkShortenerErrors[keyof GetApiLinkShortenerErrors];
+
 export type GetApiLinkShortenerResponses = {
   /**
-   * Success
+   * Proxied response from the upstream link-shortener API (shape depends on upstream)
    */
-  200: unknown;
+  200: {
+    [key: string]: unknown;
+  };
 };
 
+export type GetApiLinkShortenerResponse =
+  GetApiLinkShortenerResponses[keyof GetApiLinkShortenerResponses];
+
 export type PatchApiLinkShortenerData = {
   body: {
     [key: string]: unknown;
@@ -1341,22 +2111,30 @@ export type PatchApiLinkShortenerData = {
 
 export type PatchApiLinkShortenerErrors = {
   /**
-   * Unauthorized
+   * Unauthorized — requires an authenticated session
    */
   401: unknown;
   /**
-   * Internal server error
+   * Failed to persist short link, or internal server error
    */
-  500: unknown;
+  500: ErrorResponse;
 };
 
+export type PatchApiLinkShortenerError =
+  PatchApiLinkShortenerErrors[keyof PatchApiLinkShortenerErrors];
+
 export type PatchApiLinkShortenerResponses = {
   /**
-   * Success
+   * Proxied response from the upstream link-shortener API (shape depends on upstream)
    */
-  200: unknown;
+  200: {
+    [key: string]: unknown;
+  };
 };
 
+export type PatchApiLinkShortenerResponse =
+  PatchApiLinkShortenerResponses[keyof PatchApiLinkShortenerResponses];
+
 export type PostApiLinkShortenerData = {
   body: {
     [key: string]: unknown;
@@ -1370,22 +2148,30 @@ export type PostApiLinkShortenerData = {
 
 export type PostApiLinkShortenerErrors = {
   /**
-   * Unauthorized
+   * Unauthorized — requires an authenticated session
    */
   401: unknown;
   /**
-   * Internal server error
+   * Failed to shorten URLs, or internal server error
    */
-  500: unknown;
+  500: ErrorResponse;
 };
 
+export type PostApiLinkShortenerError =
+  PostApiLinkShortenerErrors[keyof PostApiLinkShortenerErrors];
+
 export type PostApiLinkShortenerResponses = {
   /**
-   * Success
+   * Proxied response from the upstream link-shortener API (shape depends on upstream)
    */
-  200: unknown;
+  200: {
+    [key: string]: unknown;
+  };
 };
 
+export type PostApiLinkShortenerResponse =
+  PostApiLinkShortenerResponses[keyof PostApiLinkShortenerResponses];
+
 export type DeleteApiLiveNumbersData = {
   body?: never;
   path?: never;
@@ -1395,22 +2181,51 @@ export type DeleteApiLiveNumbersData = {
 
 export type DeleteApiLiveNumbersErrors = {
   /**
-   * Unauthorized
+   * Missing required phoneNumber
+   */
+  400: ErrorResponse;
+  /**
+   * Unauthorized — requires an authenticated session
    */
   401: unknown;
   /**
-   * Internal server error
+   * Upstream server error, or internal server error
    */
-  500: unknown;
+  500: ErrorResponse;
 };
 
+export type DeleteApiLiveNumbersError =
+  DeleteApiLiveNumbersErrors[keyof DeleteApiLiveNumbersErrors];
+
 export type DeleteApiLiveNumbersResponses = {
   /**
    * Success
    */
-  200: unknown;
+  200: {
+    /**
+     * Always true on success; additional upstream confirmation fields are merged in (shape depends on upstream)
+     */
+    success: boolean;
+    /**
+     * Live phone numbers for the requested country
+     */
+    liveNumbers: Array<{
+      [key: string]: unknown;
+    }>;
+    /**
+     * Count of liveNumbers
+     */
+    totalCount: number;
+    /**
+     * ISO timestamp the response was generated
+     */
+    timestamp: string;
+  };
 };
 
+export type DeleteApiLiveNumbersResponse =
+  DeleteApiLiveNumbersResponses[keyof DeleteApiLiveNumbersResponses];
+
 export type GetApiLiveNumbersData = {
   body?: never;
   path?: never;
@@ -1422,22 +2237,46 @@ export type GetApiLiveNumbersData = {
 
 export type GetApiLiveNumbersErrors = {
   /**
-   * Unauthorized
+   * Unauthorized — requires an authenticated session
    */
   401: unknown;
   /**
-   * Internal server error
+   * Upstream server error, or internal server error
    */
-  500: unknown;
+  500: ErrorResponse;
 };
 
+export type GetApiLiveNumbersError = GetApiLiveNumbersErrors[keyof GetApiLiveNumbersErrors];
+
 export type GetApiLiveNumbersResponses = {
   /**
    * Success
    */
-  200: unknown;
+  200: {
+    /**
+     * Always true on success
+     */
+    success: boolean;
+    /**
+     * Live phone numbers for the requested country
+     */
+    liveNumbers: Array<{
+      [key: string]: unknown;
+    }>;
+    /**
+     * Count of liveNumbers
+     */
+    totalCount: number;
+    /**
+     * ISO timestamp the response was generated
+     */
+    timestamp: string;
+  };
 };
 
+export type GetApiLiveNumbersResponse =
+  GetApiLiveNumbersResponses[keyof GetApiLiveNumbersResponses];
+
 export type PostApiOutboundCallData = {
   body: {
     [key: string]: unknown;
@@ -1449,22 +2288,33 @@ export type PostApiOutboundCallData = {
 
 export type PostApiOutboundCallErrors = {
   /**
-   * Unauthorized
+   * Missing required to or from fields
+   */
+  400: ErrorResponse;
+  /**
+   * Unauthorized — requires an authenticated session
    */
   401: unknown;
   /**
-   * Internal server error
+   * Failed to initiate call, or internal server error
    */
-  500: unknown;
+  500: ErrorResponse;
 };
 
+export type PostApiOutboundCallError = PostApiOutboundCallErrors[keyof PostApiOutboundCallErrors];
+
 export type PostApiOutboundCallResponses = {
   /**
-   * Success
+   * Proxied response from the upstream agent outbound-call API (shape depends on upstream)
    */
-  200: unknown;
+  200: {
+    [key: string]: unknown;
+  };
 };
 
+export type PostApiOutboundCallResponse =
+  PostApiOutboundCallResponses[keyof PostApiOutboundCallResponses];
+
 export type PostApiOutboundCommunicationTextData = {
   body: {
     [key: string]: unknown;
@@ -1476,22 +2326,34 @@ export type PostApiOutboundCommunicationTextData = {
 
 export type PostApiOutboundCommunicationTextErrors = {
   /**
-   * Unauthorized
+   * Missing required to field
+   */
+  400: ErrorResponse;
+  /**
+   * Unauthorized — requires an authenticated session
    */
   401: unknown;
   /**
-   * Internal server error
+   * Failed to send message, or internal server error
    */
-  500: unknown;
+  500: ErrorResponse;
 };
 
+export type PostApiOutboundCommunicationTextError =
+  PostApiOutboundCommunicationTextErrors[keyof PostApiOutboundCommunicationTextErrors];
+
 export type PostApiOutboundCommunicationTextResponses = {
   /**
-   * Success
+   * Proxied response from the upstream agent outbound-communication-text API (shape depends on upstream)
    */
-  200: unknown;
+  200: {
+    [key: string]: unknown;
+  };
 };
 
+export type PostApiOutboundCommunicationTextResponse =
+  PostApiOutboundCommunicationTextResponses[keyof PostApiOutboundCommunicationTextResponses];
+
 export type GetApiPhoneLogsByPhoneNumberData = {
   body?: never;
   path: {
@@ -1504,19 +2366,35 @@ export type GetApiPhoneLogsByPhoneNumberData = {
 };
 
 export type GetApiPhoneLogsByPhoneNumberErrors = {
+  /**
+   * No call logs found for this phone number
+   */
+  404: ErrorResponse;
+  /**
+   * Too many requests for this phone number
+   */
+  429: ErrorResponse;
   /**
    * Internal server error
    */
-  500: unknown;
+  500: ErrorResponse;
 };
 
+export type GetApiPhoneLogsByPhoneNumberError =
+  GetApiPhoneLogsByPhoneNumberErrors[keyof GetApiPhoneLogsByPhoneNumberErrors];
+
 export type GetApiPhoneLogsByPhoneNumberResponses = {
   /**
-   * Success
+   * Phone call logs for the requested number, proxied from the upstream agent API
    */
-  200: unknown;
+  200: {
+    [key: string]: unknown;
+  };
 };
 
+export type GetApiPhoneLogsByPhoneNumberResponse =
+  GetApiPhoneLogsByPhoneNumberResponses[keyof GetApiPhoneLogsByPhoneNumberResponses];
+
 export type GetApiRecentlyActiveNumbersData = {
   body?: never;
   path?: never;
@@ -1528,22 +2406,47 @@ export type GetApiRecentlyActiveNumbersData = {
 
 export type GetApiRecentlyActiveNumbersErrors = {
   /**
-   * Unauthorized
+   * Unauthorized — requires an authenticated session
    */
   401: unknown;
   /**
    * Internal server error
    */
-  500: unknown;
+  500: ErrorResponse;
 };
 
+export type GetApiRecentlyActiveNumbersError =
+  GetApiRecentlyActiveNumbersErrors[keyof GetApiRecentlyActiveNumbersErrors];
+
 export type GetApiRecentlyActiveNumbersResponses = {
   /**
    * Success
    */
-  200: unknown;
+  200: {
+    /**
+     * Always true on success
+     */
+    success: boolean;
+    /**
+     * Recently active phone numbers
+     */
+    activeNumbers: Array<{
+      [key: string]: unknown;
+    }>;
+    /**
+     * Count of activeNumbers
+     */
+    totalCount: number;
+    /**
+     * ISO timestamp the response was generated
+     */
+    timestamp: string;
+  };
 };
 
+export type GetApiRecentlyActiveNumbersResponse =
+  GetApiRecentlyActiveNumbersResponses[keyof GetApiRecentlyActiveNumbersResponses];
+
 export type PostApiSegmentIdentifyData = {
   body: {
     [key: string]: unknown;
@@ -1555,22 +2458,37 @@ export type PostApiSegmentIdentifyData = {
 
 export type PostApiSegmentIdentifyErrors = {
   /**
-   * Unauthorized
+   * Missing required identifier, missing Segment write key, or invalid JSON body
+   */
+  400: ErrorResponse;
+  /**
+   * Unauthorized — requires an authenticated session
    */
   401: unknown;
   /**
-   * Internal server error
+   * Segment API error, or internal server error
    */
-  500: unknown;
+  500: ErrorResponse;
 };
 
+export type PostApiSegmentIdentifyError =
+  PostApiSegmentIdentifyErrors[keyof PostApiSegmentIdentifyErrors];
+
 export type PostApiSegmentIdentifyResponses = {
   /**
    * Success
    */
-  200: unknown;
+  200: {
+    /**
+     * Always "Event tracked successfully"
+     */
+    message: string;
+  };
 };
 
+export type PostApiSegmentIdentifyResponse =
+  PostApiSegmentIdentifyResponses[keyof PostApiSegmentIdentifyResponses];
+
 export type PostApiSegmentProfileData = {
   body: {
     [key: string]: unknown;
@@ -1582,21 +2500,64 @@ export type PostApiSegmentProfileData = {
 
 export type PostApiSegmentProfileErrors = {
   /**
-   * Unauthorized
+   * Missing required identifier/token/space, or invalid JSON body
+   */
+  400: ErrorResponse;
+  /**
+   * Unauthorized — requires an authenticated session
    */
   401: unknown;
   /**
-   * Internal server error
+   * Profile not found
    */
-  500: unknown;
+  404: ErrorResponse;
+  /**
+   * Segment profile error, or internal server error
+   */
+  500: ErrorResponse;
 };
 
+export type PostApiSegmentProfileError =
+  PostApiSegmentProfileErrors[keyof PostApiSegmentProfileErrors];
+
 export type PostApiSegmentProfileResponses = {
   /**
    * Success
    */
-  200: unknown;
-};
+  200: {
+    /**
+     * Resolved user_id, when one was found via external IDs
+     */
+    canonicalUserId: string;
+    /**
+     * The customer's Segment traits
+     */
+    data: {
+      [key: string]: unknown;
+    };
+    /**
+     * The identifier value originally supplied
+     */
+    identifier: string;
+    /**
+     * External identifiers associated with the profile
+     */
+    identifiers: Array<{
+      [key: string]: unknown;
+    }>;
+    /**
+     * Which identifier type ("user_id" or "phone") successfully matched
+     */
+    matchedKey: string;
+    /**
+     * Always "Profile retrieved successfully"
+     */
+    message: string;
+  };
+};
+
+export type PostApiSegmentProfileResponse =
+  PostApiSegmentProfileResponses[keyof PostApiSegmentProfileResponses];
 
 export type GetApiSessionData = {
   body?: never;
@@ -1609,16 +2570,35 @@ export type GetApiSessionErrors = {
   /**
    * Internal server error
    */
-  500: unknown;
+  500: ErrorResponse;
 };
 
+export type GetApiSessionError = GetApiSessionErrors[keyof GetApiSessionErrors];
+
 export type GetApiSessionResponses = {
   /**
    * Success
    */
-  200: unknown;
+  200: {
+    /**
+     * Whether the request has an active session
+     */
+    authenticated: boolean;
+    /**
+     * The session user, or null if not authenticated
+     */
+    user: {
+      [key: string]: unknown;
+    };
+    /**
+     * ISO timestamp the response was generated
+     */
+    timestamp: string;
+  };
 };
 
+export type GetApiSessionResponse = GetApiSessionResponses[keyof GetApiSessionResponses];
+
 export type GetApiSupportedRegionsData = {
   body?: never;
   path?: never;
@@ -1628,22 +2608,33 @@ export type GetApiSupportedRegionsData = {
 
 export type GetApiSupportedRegionsErrors = {
   /**
-   * Unauthorized
+   * Unauthorized — requires an authenticated session
    */
   401: unknown;
   /**
    * Internal server error
    */
-  500: unknown;
+  500: ErrorResponse;
 };
 
+export type GetApiSupportedRegionsError =
+  GetApiSupportedRegionsErrors[keyof GetApiSupportedRegionsErrors];
+
 export type GetApiSupportedRegionsResponses = {
   /**
    * Success
    */
-  200: unknown;
+  200: {
+    /**
+     * Regions a phone number can be purchased in
+     */
+    regions: Array<SupportedRegion>;
+  };
 };
 
+export type GetApiSupportedRegionsResponse =
+  GetApiSupportedRegionsResponses[keyof GetApiSupportedRegionsResponses];
+
 export type PostApiTagsData = {
   body: {
     [key: string]: unknown;
@@ -1655,18 +2646,37 @@ export type PostApiTagsData = {
 
 export type PostApiTagsErrors = {
   /**
-   * Internal server error
+   * Missing/invalid tag, or tag shorter than 2 characters
    */
-  500: unknown;
+  400: ErrorResponse;
+  /**
+   * Failed to save tag
+   */
+  500: ErrorResponse;
 };
 
+export type PostApiTagsError = PostApiTagsErrors[keyof PostApiTagsErrors];
+
 export type PostApiTagsResponses = {
   /**
    * Success
    */
-  200: unknown;
+  200: {
+    /**
+     * Always true on successful save
+     */
+    success: boolean;
+    /**
+     * The saved tag record (`{ isTag, objectID, value }`)
+     */
+    tag: {
+      [key: string]: unknown;
+    };
+  };
 };
 
+export type PostApiTagsResponse = PostApiTagsResponses[keyof PostApiTagsResponses];
+
 export type PostApiTelemetryData = {
   body?: never;
   path?: never;
@@ -1677,19 +2687,33 @@ export type PostApiTelemetryData = {
 };
 
 export type PostApiTelemetryErrors = {
+  /**
+   * Invalid or missing ddforward parameter
+   */
+  400: ErrorResponse;
   /**
    * Internal server error
    */
   500: unknown;
 };
 
+export type PostApiTelemetryError = PostApiTelemetryErrors[keyof PostApiTelemetryErrors];
+
 export type PostApiTelemetryResponses = {
   /**
    * Success
    */
   200: unknown;
+  /**
+   * Empty body; status mirrors the upstream Datadog intake response (202 on success, or on proxy fetch failure since telemetry is best-effort)
+   */
+  202: {
+    [key: string]: unknown;
+  };
 };
 
+export type PostApiTelemetryResponse = PostApiTelemetryResponses[keyof PostApiTelemetryResponses];
+
 export type DeleteApiTemplateData = {
   body?: never;
   path?: never;
@@ -1701,22 +2725,29 @@ export type DeleteApiTemplateData = {
 
 export type DeleteApiTemplateErrors = {
   /**
-   * Unauthorized
+   * Unauthorized — requires an authenticated session
    */
   401: unknown;
   /**
    * Internal server error
    */
-  500: unknown;
+  500: ErrorResponse;
 };
 
+export type DeleteApiTemplateError = DeleteApiTemplateErrors[keyof DeleteApiTemplateErrors];
+
 export type DeleteApiTemplateResponses = {
   /**
-   * Success
+   * Proxied response from the upstream template API (shape depends on upstream)
    */
-  200: unknown;
+  200: {
+    [key: string]: unknown;
+  };
 };
 
+export type DeleteApiTemplateResponse =
+  DeleteApiTemplateResponses[keyof DeleteApiTemplateResponses];
+
 export type PostApiTemplateAutogenData = {
   body: {
     [key: string]: unknown;
@@ -1728,22 +2759,30 @@ export type PostApiTemplateAutogenData = {
 
 export type PostApiTemplateAutogenErrors = {
   /**
-   * Unauthorized
+   * Unauthorized — requires an authenticated session
    */
   401: unknown;
   /**
    * Internal server error
    */
-  500: unknown;
+  500: ErrorResponse;
 };
 
+export type PostApiTemplateAutogenError =
+  PostApiTemplateAutogenErrors[keyof PostApiTemplateAutogenErrors];
+
 export type PostApiTemplateAutogenResponses = {
   /**
-   * Success
+   * Proxied response from the upstream template-autogen API (shape depends on upstream)
    */
-  200: unknown;
+  200: {
+    [key: string]: unknown;
+  };
 };
 
+export type PostApiTemplateAutogenResponse =
+  PostApiTemplateAutogenResponses[keyof PostApiTemplateAutogenResponses];
+
 export type PostApiVerifyCheckData = {
   body: {
     [key: string]: unknown;
@@ -1755,18 +2794,36 @@ export type PostApiVerifyCheckData = {
 
 export type PostApiVerifyCheckErrors = {
   /**
-   * Internal server error
+   * Missing required to or code
    */
-  500: unknown;
+  400: ErrorResponse;
+  /**
+   * Unable to verify code
+   */
+  500: ErrorResponse;
 };
 
+export type PostApiVerifyCheckError = PostApiVerifyCheckErrors[keyof PostApiVerifyCheckErrors];
+
 export type PostApiVerifyCheckResponses = {
   /**
    * Success
    */
-  200: unknown;
+  200: {
+    /**
+     * Whether the code was approved
+     */
+    verified: boolean;
+    /**
+     * Present alongside `verified: false` when the code is invalid
+     */
+    error: string;
+  };
 };
 
+export type PostApiVerifyCheckResponse =
+  PostApiVerifyCheckResponses[keyof PostApiVerifyCheckResponses];
+
 export type PostApiVerifySendData = {
   body: {
     [key: string]: unknown;
@@ -1778,14 +2835,419 @@ export type PostApiVerifySendData = {
 
 export type PostApiVerifySendErrors = {
   /**
-   * Internal server error
+   * Missing required phone or email
    */
-  500: unknown;
+  400: ErrorResponse;
+  /**
+   * Failed to send verification code
+   */
+  500: ErrorResponse;
 };
 
+export type PostApiVerifySendError = PostApiVerifySendErrors[keyof PostApiVerifySendErrors];
+
 export type PostApiVerifySendResponses = {
   /**
    * Success
    */
-  200: unknown;
+  200: {
+    /**
+     * The channel the verification was sent over ("sms" or "email")
+     */
+    channel: string;
+    /**
+     * The Twilio Verify verification SID
+     */
+    sid: string;
+  };
+};
+
+export type PostApiVerifySendResponse =
+  PostApiVerifySendResponses[keyof PostApiVerifySendResponses];
+
+export type PostApiWebchatChatData = {
+  body: {
+    [key: string]: unknown;
+  };
+  path?: never;
+  query?: never;
+  url: '/api/webchat/chat';
+};
+
+export type PostApiWebchatChatErrors = {
+  /**
+   * "proxy_error" if the upstream call fails
+   */
+  500: ErrorResponse;
+};
+
+export type PostApiWebchatChatError = PostApiWebchatChatErrors[keyof PostApiWebchatChatErrors];
+
+export type PostApiWebchatChatResponses = {
+  /**
+   * Proxied response from the agent chat service
+   */
+  200: {
+    [key: string]: unknown;
+  };
 };
+
+export type PostApiWebchatChatResponse =
+  PostApiWebchatChatResponses[keyof PostApiWebchatChatResponses];
+
+export type PostApiWebchatConversationData = {
+  body: {
+    [key: string]: unknown;
+  };
+  path?: never;
+  query?: never;
+  url: '/api/webchat/conversation';
+};
+
+export type PostApiWebchatConversationErrors = {
+  /**
+   * "proxy_error" if the upstream call fails
+   */
+  500: ErrorResponse;
+};
+
+export type PostApiWebchatConversationError =
+  PostApiWebchatConversationErrors[keyof PostApiWebchatConversationErrors];
+
+export type PostApiWebchatConversationResponses = {
+  /**
+   * Proxied response from the agent conversation service
+   */
+  200: {
+    [key: string]: unknown;
+  };
+};
+
+export type PostApiWebchatConversationResponse =
+  PostApiWebchatConversationResponses[keyof PostApiWebchatConversationResponses];
+
+export type GetApiWebchatConversationsTokenData = {
+  body?: never;
+  path?: never;
+  query?: {
+    /**
+     * Conversation participant identity (required)
+     */
+    identity?: string;
+  };
+  url: '/api/webchat/conversations/token';
+};
+
+export type GetApiWebchatConversationsTokenErrors = {
+  /**
+   * Missing identity query param
+   */
+  400: ErrorResponse;
+  /**
+   * "proxy_error" if the upstream call fails
+   */
+  500: ErrorResponse;
+};
+
+export type GetApiWebchatConversationsTokenError =
+  GetApiWebchatConversationsTokenErrors[keyof GetApiWebchatConversationsTokenErrors];
+
+export type GetApiWebchatConversationsTokenResponses = {
+  /**
+   * Proxied response from the API conversations-token service
+   */
+  200: {
+    [key: string]: unknown;
+  };
+};
+
+export type GetApiWebchatConversationsTokenResponse =
+  GetApiWebchatConversationsTokenResponses[keyof GetApiWebchatConversationsTokenResponses];
+
+export type PostApiWebchatConversationsTokenData = {
+  body: {
+    [key: string]: unknown;
+  };
+  path?: never;
+  query?: {
+    /**
+     * Conversation participant identity (required)
+     */
+    identity?: string;
+  };
+  url: '/api/webchat/conversations/token';
+};
+
+export type PostApiWebchatConversationsTokenErrors = {
+  /**
+   * Missing identity in request body
+   */
+  400: ErrorResponse;
+  /**
+   * "proxy_error" if the upstream call fails
+   */
+  500: ErrorResponse;
+};
+
+export type PostApiWebchatConversationsTokenError =
+  PostApiWebchatConversationsTokenErrors[keyof PostApiWebchatConversationsTokenErrors];
+
+export type PostApiWebchatConversationsTokenResponses = {
+  /**
+   * Proxied response from the API conversations-token service
+   */
+  200: {
+    [key: string]: unknown;
+  };
+};
+
+export type PostApiWebchatConversationsTokenResponse =
+  PostApiWebchatConversationsTokenResponses[keyof PostApiWebchatConversationsTokenResponses];
+
+export type PostApiWebchatEndChatData = {
+  body: {
+    [key: string]: unknown;
+  };
+  path?: never;
+  query?: never;
+  url: '/api/webchat/end-chat';
+};
+
+export type PostApiWebchatEndChatErrors = {
+  /**
+   * Missing customerNumber in request body
+   */
+  400: ErrorResponse;
+  /**
+   * "proxy_error" if the upstream call fails
+   */
+  500: ErrorResponse;
+};
+
+export type PostApiWebchatEndChatError =
+  PostApiWebchatEndChatErrors[keyof PostApiWebchatEndChatErrors];
+
+export type PostApiWebchatEndChatResponses = {
+  /**
+   * Proxied response from the agent live-numbers delete service
+   */
+  200: {
+    [key: string]: unknown;
+  };
+};
+
+export type PostApiWebchatEndChatResponse =
+  PostApiWebchatEndChatResponses[keyof PostApiWebchatEndChatResponses];
+
+export type PostApiWebchatLiveAgentWebchatConnectData = {
+  body: {
+    [key: string]: unknown;
+  };
+  path?: never;
+  query?: never;
+  url: '/api/webchat/live-agent-webchat-connect';
+};
+
+export type PostApiWebchatLiveAgentWebchatConnectErrors = {
+  /**
+   * "proxy_error" if the upstream call fails
+   */
+  500: ErrorResponse;
+};
+
+export type PostApiWebchatLiveAgentWebchatConnectError =
+  PostApiWebchatLiveAgentWebchatConnectErrors[keyof PostApiWebchatLiveAgentWebchatConnectErrors];
+
+export type PostApiWebchatLiveAgentWebchatConnectResponses = {
+  /**
+   * Proxied response from the API live-agent-webchat-connect service
+   */
+  200: {
+    [key: string]: unknown;
+  };
+};
+
+export type PostApiWebchatLiveAgentWebchatConnectResponse =
+  PostApiWebchatLiveAgentWebchatConnectResponses[keyof PostApiWebchatLiveAgentWebchatConnectResponses];
+
+export type PostApiWebchatLiveAgentWebchatEndData = {
+  body: {
+    [key: string]: unknown;
+  };
+  path?: never;
+  query?: never;
+  url: '/api/webchat/live-agent-webchat-end';
+};
+
+export type PostApiWebchatLiveAgentWebchatEndErrors = {
+  /**
+   * "proxy_error" if the upstream call fails
+   */
+  500: ErrorResponse;
+};
+
+export type PostApiWebchatLiveAgentWebchatEndError =
+  PostApiWebchatLiveAgentWebchatEndErrors[keyof PostApiWebchatLiveAgentWebchatEndErrors];
+
+export type PostApiWebchatLiveAgentWebchatEndResponses = {
+  /**
+   * Proxied response from the API live-agent-webchat-end service
+   */
+  200: {
+    [key: string]: unknown;
+  };
+};
+
+export type PostApiWebchatLiveAgentWebchatEndResponse =
+  PostApiWebchatLiveAgentWebchatEndResponses[keyof PostApiWebchatLiveAgentWebchatEndResponses];
+
+export type PostApiWebchatUiConfigData = {
+  body: {
+    [key: string]: unknown;
+  };
+  path?: never;
+  query?: never;
+  url: '/api/webchat/ui-config';
+};
+
+export type PostApiWebchatUiConfigErrors = {
+  /**
+   * Both or neither of customerNumber/objectID were provided
+   */
+  400: ErrorResponse;
+  /**
+   * "ui_config_error" if template lookup fails
+   */
+  500: ErrorResponse;
+};
+
+export type PostApiWebchatUiConfigError =
+  PostApiWebchatUiConfigErrors[keyof PostApiWebchatUiConfigErrors];
+
+export type PostApiWebchatUiConfigResponses = {
+  /**
+   * Success
+   */
+  200: {
+    /**
+     * Dialog UI customization config from the template (or null)
+     */
+    ui: {
+      [key: string]: unknown;
+    };
+    /**
+     * Dialog link map from the template (or null)
+     */
+    linkMap: {
+      [key: string]: unknown;
+    };
+    /**
+     * Whether the chat link should be hidden (or null)
+     */
+    hideChatLink: boolean;
+    /**
+     * Resolved Algolia objectID for the template (or null)
+     */
+    templateObjectId: string;
+    /**
+     * Default language code for the template, e.g. 'es-ES' (or null)
+     */
+    templateLanguage: string;
+    /**
+     * Representative customer number resolved from objectID lookups (or null)
+     */
+    resolvedCustomerNumber: string;
+    /**
+     * Agent phone number resolved from objectID lookups (or null)
+     */
+    resolvedAgentNumber: string;
+    /**
+     * Template title (or null)
+     */
+    templateTitle: string;
+    /**
+     * Dialog UI customization config from the template (or null)
+     */
+    dialogConfig: {
+      [key: string]: unknown;
+    };
+    /**
+     * Dialog runtime settings (trait mappings, feature flags) (or null)
+     */
+    dialogSettings: {
+      [key: string]: unknown;
+    };
+  };
+};
+
+export type PostApiWebchatUiConfigResponse =
+  PostApiWebchatUiConfigResponses[keyof PostApiWebchatUiConfigResponses];
+
+export type GetApiWebchatVoiceTokenData = {
+  body?: never;
+  path?: never;
+  query?: {
+    /**
+     * Voice grant identity (required)
+     */
+    identity?: string;
+  };
+  url: '/api/webchat/voice-token';
+};
+
+export type GetApiWebchatVoiceTokenErrors = {
+  /**
+   * Missing identity query param
+   */
+  400: ErrorResponse;
+  /**
+   * "proxy_error" if the upstream call fails
+   */
+  500: ErrorResponse;
+};
+
+export type GetApiWebchatVoiceTokenError =
+  GetApiWebchatVoiceTokenErrors[keyof GetApiWebchatVoiceTokenErrors];
+
+export type GetApiWebchatVoiceTokenResponses = {
+  /**
+   * Proxied response from the API voice-token service
+   */
+  200: {
+    [key: string]: unknown;
+  };
+};
+
+export type GetApiWebchatVoiceTokenResponse =
+  GetApiWebchatVoiceTokenResponses[keyof GetApiWebchatVoiceTokenResponses];
+
+export type PostApiWebchatWebchatSendData = {
+  body: {
+    [key: string]: unknown;
+  };
+  path?: never;
+  query?: never;
+  url: '/api/webchat/webchat-send';
+};
+
+export type PostApiWebchatWebchatSendErrors = {
+  /**
+   * "proxy_error" if the upstream call fails
+   */
+  500: ErrorResponse;
+};
+
+export type PostApiWebchatWebchatSendError =
+  PostApiWebchatWebchatSendErrors[keyof PostApiWebchatWebchatSendErrors];
+
+export type PostApiWebchatWebchatSendResponses = {
+  /**
+   * Proxied response from the agent chat service
+   */
+  200: {
+    [key: string]: unknown;
+  };
+};
+
+export type PostApiWebchatWebchatSendResponse =
+  PostApiWebchatWebchatSendResponses[keyof PostApiWebchatWebchatSendResponses];