@zyphr-dev/node-sdk 0.1.31 → 0.1.33

package/src/src/apis/AuthUserProfileApi.ts

@@ -31,6 +31,10 @@ import {
     UpdateEndUserRequestToJSON,
 } from '../models/index';
 
+export interface AuthUserProfileApiDeleteEndUserByApplicationRequest {
+    userId: string;
+}
+
 export interface AuthUserProfileApiUpdateEndUserOperationRequest {
     updateEndUserRequest: UpdateEndUserRequest;
 }
@@ -57,6 +61,22 @@ export interface AuthUserProfileApiInterface {
      */
     deleteEndUser(initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<EndUserDeleteResponse>;
 
+    /**
+     * App-credentialed soft-delete for an end user, scoped to the test environment only. Live-mode credentials receive 403 — this is the intentional safety guard against a misconfigured CI runner nuking production users.  Mirrors the self-service `DELETE /auth/users/me` flow: revokes all sessions, soft-deletes the row (status=\'deleted\'), and emits a `user.deleted` webhook with `method=\'application_admin\'`. The audit log row survives (no FK to end_users), so org-history queries still resolve.  Intended for smoke / test-fixture cleanup. Production deletes should continue to use `DELETE /auth/users/me` from the end-user\'s own session or the dashboard. 
+     * @summary Delete an end user (test environment only)
+     * @param {string} userId 
+     * @param {*} [options] Override http request option.
+     * @throws {RequiredError}
+     * @memberof AuthUserProfileApiInterface
+     */
+    deleteEndUserByApplicationRaw(requestParameters: AuthUserProfileApiDeleteEndUserByApplicationRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<void>>;
+
+    /**
+     * App-credentialed soft-delete for an end user, scoped to the test environment only. Live-mode credentials receive 403 — this is the intentional safety guard against a misconfigured CI runner nuking production users.  Mirrors the self-service `DELETE /auth/users/me` flow: revokes all sessions, soft-deletes the row (status=\'deleted\'), and emits a `user.deleted` webhook with `method=\'application_admin\'`. The audit log row survives (no FK to end_users), so org-history queries still resolve.  Intended for smoke / test-fixture cleanup. Production deletes should continue to use `DELETE /auth/users/me` from the end-user\'s own session or the dashboard. 
+     * Delete an end user (test environment only)
+     */
+    deleteEndUserByApplication(userId: string, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<void>;
+
     /**
      * Retrieve the profile of the currently authenticated end user.
      * @summary Get current end user profile
@@ -135,6 +155,48 @@ export class AuthUserProfileApi extends runtime.BaseAPI implements AuthUserProfi
         return await response.value();
     }
 
+    /**
+     * App-credentialed soft-delete for an end user, scoped to the test environment only. Live-mode credentials receive 403 — this is the intentional safety guard against a misconfigured CI runner nuking production users.  Mirrors the self-service `DELETE /auth/users/me` flow: revokes all sessions, soft-deletes the row (status=\'deleted\'), and emits a `user.deleted` webhook with `method=\'application_admin\'`. The audit log row survives (no FK to end_users), so org-history queries still resolve.  Intended for smoke / test-fixture cleanup. Production deletes should continue to use `DELETE /auth/users/me` from the end-user\'s own session or the dashboard. 
+     * Delete an end user (test environment only)
+     */
+    async deleteEndUserByApplicationRaw(requestParameters: AuthUserProfileApiDeleteEndUserByApplicationRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<void>> {
+        if (requestParameters['userId'] == null) {
+            throw new runtime.RequiredError(
+                'userId',
+                'Required parameter "userId" was null or undefined when calling deleteEndUserByApplication().'
+            );
+        }
+
+        const queryParameters: any = {};
+
+        const headerParameters: runtime.HTTPHeaders = {};
+
+        if (this.configuration && this.configuration.apiKey) {
+            headerParameters["X-Application-Secret"] = await this.configuration.apiKey("X-Application-Secret"); // ApplicationSecret authentication
+        }
+
+        if (this.configuration && this.configuration.apiKey) {
+            headerParameters["X-Application-Key"] = await this.configuration.apiKey("X-Application-Key"); // ApplicationPublicKey authentication
+        }
+
+        const response = await this.request({
+            path: `/auth/users/{user_id}`.replace(`{${"user_id"}}`, encodeURIComponent(String(requestParameters['userId']))),
+            method: 'DELETE',
+            headers: headerParameters,
+            query: queryParameters,
+        }, initOverrides);
+
+        return new runtime.VoidApiResponse(response);
+    }
+
+    /**
+     * App-credentialed soft-delete for an end user, scoped to the test environment only. Live-mode credentials receive 403 — this is the intentional safety guard against a misconfigured CI runner nuking production users.  Mirrors the self-service `DELETE /auth/users/me` flow: revokes all sessions, soft-deletes the row (status=\'deleted\'), and emits a `user.deleted` webhook with `method=\'application_admin\'`. The audit log row survives (no FK to end_users), so org-history queries still resolve.  Intended for smoke / test-fixture cleanup. Production deletes should continue to use `DELETE /auth/users/me` from the end-user\'s own session or the dashboard. 
+     * Delete an end user (test environment only)
+     */
+    async deleteEndUserByApplication(userId: string, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<void> {
+        await this.deleteEndUserByApplicationRaw({ userId: userId }, initOverrides);
+    }
+
     /**
      * Retrieve the profile of the currently authenticated end user.
      * Get current end user profile

package/src/src/apis/DomainsApi.ts

@@ -18,7 +18,11 @@ import type {
   AddDomain200Response,
   AddDomainRequest,
   ApiError,
+  DeleteDomainResponse,
   DomainListResponse,
+  GetDomain200Response,
+  VerificationStatusResponse,
+  VerifyDomainResponse,
 } from '../models/index';
 import {
     AddDomain200ResponseFromJSON,
@@ -27,14 +31,38 @@ import {
     AddDomainRequestToJSON,
     ApiErrorFromJSON,
     ApiErrorToJSON,
+    DeleteDomainResponseFromJSON,
+    DeleteDomainResponseToJSON,
     DomainListResponseFromJSON,
     DomainListResponseToJSON,
+    GetDomain200ResponseFromJSON,
+    GetDomain200ResponseToJSON,
+    VerificationStatusResponseFromJSON,
+    VerificationStatusResponseToJSON,
+    VerifyDomainResponseFromJSON,
+    VerifyDomainResponseToJSON,
 } from '../models/index';
 
 export interface DomainsApiAddDomainOperationRequest {
     addDomainRequest: AddDomainRequest;
 }
 
+export interface DomainsApiDeleteDomainRequest {
+    id: string;
+}
+
+export interface DomainsApiGetDomainRequest {
+    id: string;
+}
+
+export interface DomainsApiGetDomainVerificationStatusRequest {
+    id: string;
+}
+
+export interface DomainsApiVerifyDomainRequest {
+    id: string;
+}
+
 /**
  * DomainsApi - interface
  * 
@@ -58,6 +86,54 @@ export interface DomainsApiInterface {
      */
     addDomain(addDomainRequest: AddDomainRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<AddDomain200Response>;
 
+    /**
+     * Remove a sending domain from the project. The domain is also detached from any SES identity that was provisioned for it. Returns 409 if the domain is still referenced by other resources (templates, scheduled sends, etc.) — those must be removed first. 
+     * @summary Remove a sending domain
+     * @param {string} id 
+     * @param {*} [options] Override http request option.
+     * @throws {RequiredError}
+     * @memberof DomainsApiInterface
+     */
+    deleteDomainRaw(requestParameters: DomainsApiDeleteDomainRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<DeleteDomainResponse>>;
+
+    /**
+     * Remove a sending domain from the project. The domain is also detached from any SES identity that was provisioned for it. Returns 409 if the domain is still referenced by other resources (templates, scheduled sends, etc.) — those must be removed first. 
+     * Remove a sending domain
+     */
+    deleteDomain(id: string, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<DeleteDomainResponse>;
+
+    /**
+     * Retrieve a single sending domain by ID, including DNS records and verification counters.
+     * @summary Get a sending domain
+     * @param {string} id 
+     * @param {*} [options] Override http request option.
+     * @throws {RequiredError}
+     * @memberof DomainsApiInterface
+     */
+    getDomainRaw(requestParameters: DomainsApiGetDomainRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<GetDomain200Response>>;
+
+    /**
+     * Retrieve a single sending domain by ID, including DNS records and verification counters.
+     * Get a sending domain
+     */
+    getDomain(id: string, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<GetDomain200Response>;
+
+    /**
+     * Returns the current verification status with per-record `verified` flags and aggregate counters. Useful when polling for terminal status from an AI agent (the recommended pattern is to subscribe to the `domain.verified` webhook event instead — see sc-5444). 
+     * @summary Get domain verification status
+     * @param {string} id Domain ID
+     * @param {*} [options] Override http request option.
+     * @throws {RequiredError}
+     * @memberof DomainsApiInterface
+     */
+    getDomainVerificationStatusRaw(requestParameters: DomainsApiGetDomainVerificationStatusRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<VerificationStatusResponse>>;
+
+    /**
+     * Returns the current verification status with per-record `verified` flags and aggregate counters. Useful when polling for terminal status from an AI agent (the recommended pattern is to subscribe to the `domain.verified` webhook event instead — see sc-5444). 
+     * Get domain verification status
+     */
+    getDomainVerificationStatus(id: string, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<VerificationStatusResponse>;
+
     /**
      * List sending domains on the current project, with verification status and DNS records.
      * @summary List sending domains
@@ -73,6 +149,22 @@ export interface DomainsApiInterface {
      */
     listDomains(initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<DomainListResponse>;
 
+    /**
+     * Queue an asynchronous DNS verification check. Returns immediately with a `job_id`. Poll `GET /v1/domains/{id}/verification-status` (or the higher-level `GET /v1/domains/{id}`) for the result, or subscribe to the `domain.verified` webhook event when sc-5444 ships.  Returns 409 if a verification is already in progress for this domain (within the last 2 minutes). 
+     * @summary Trigger domain verification
+     * @param {string} id 
+     * @param {*} [options] Override http request option.
+     * @throws {RequiredError}
+     * @memberof DomainsApiInterface
+     */
+    verifyDomainRaw(requestParameters: DomainsApiVerifyDomainRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<VerifyDomainResponse>>;
+
+    /**
+     * Queue an asynchronous DNS verification check. Returns immediately with a `job_id`. Poll `GET /v1/domains/{id}/verification-status` (or the higher-level `GET /v1/domains/{id}`) for the result, or subscribe to the `domain.verified` webhook event when sc-5444 ships.  Returns 409 if a verification is already in progress for this domain (within the last 2 minutes). 
+     * Trigger domain verification
+     */
+    verifyDomain(id: string, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<VerifyDomainResponse>;
+
 }
 
 /**
@@ -122,6 +214,123 @@ export class DomainsApi extends runtime.BaseAPI implements DomainsApiInterface {
         return await response.value();
     }
 
+    /**
+     * Remove a sending domain from the project. The domain is also detached from any SES identity that was provisioned for it. Returns 409 if the domain is still referenced by other resources (templates, scheduled sends, etc.) — those must be removed first. 
+     * Remove a sending domain
+     */
+    async deleteDomainRaw(requestParameters: DomainsApiDeleteDomainRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<DeleteDomainResponse>> {
+        if (requestParameters['id'] == null) {
+            throw new runtime.RequiredError(
+                'id',
+                'Required parameter "id" was null or undefined when calling deleteDomain().'
+            );
+        }
+
+        const queryParameters: any = {};
+
+        const headerParameters: runtime.HTTPHeaders = {};
+
+        if (this.configuration && this.configuration.apiKey) {
+            headerParameters["X-API-Key"] = await this.configuration.apiKey("X-API-Key"); // ApiKeyAuth authentication
+        }
+
+        const response = await this.request({
+            path: `/domains/{id}`.replace(`{${"id"}}`, encodeURIComponent(String(requestParameters['id']))),
+            method: 'DELETE',
+            headers: headerParameters,
+            query: queryParameters,
+        }, initOverrides);
+
+        return new runtime.JSONApiResponse(response, (jsonValue) => DeleteDomainResponseFromJSON(jsonValue));
+    }
+
+    /**
+     * Remove a sending domain from the project. The domain is also detached from any SES identity that was provisioned for it. Returns 409 if the domain is still referenced by other resources (templates, scheduled sends, etc.) — those must be removed first. 
+     * Remove a sending domain
+     */
+    async deleteDomain(id: string, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<DeleteDomainResponse> {
+        const response = await this.deleteDomainRaw({ id: id }, initOverrides);
+        return await response.value();
+    }
+
+    /**
+     * Retrieve a single sending domain by ID, including DNS records and verification counters.
+     * Get a sending domain
+     */
+    async getDomainRaw(requestParameters: DomainsApiGetDomainRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<GetDomain200Response>> {
+        if (requestParameters['id'] == null) {
+            throw new runtime.RequiredError(
+                'id',
+                'Required parameter "id" was null or undefined when calling getDomain().'
+            );
+        }
+
+        const queryParameters: any = {};
+
+        const headerParameters: runtime.HTTPHeaders = {};
+
+        if (this.configuration && this.configuration.apiKey) {
+            headerParameters["X-API-Key"] = await this.configuration.apiKey("X-API-Key"); // ApiKeyAuth authentication
+        }
+
+        const response = await this.request({
+            path: `/domains/{id}`.replace(`{${"id"}}`, encodeURIComponent(String(requestParameters['id']))),
+            method: 'GET',
+            headers: headerParameters,
+            query: queryParameters,
+        }, initOverrides);
+
+        return new runtime.JSONApiResponse(response, (jsonValue) => GetDomain200ResponseFromJSON(jsonValue));
+    }
+
+    /**
+     * Retrieve a single sending domain by ID, including DNS records and verification counters.
+     * Get a sending domain
+     */
+    async getDomain(id: string, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<GetDomain200Response> {
+        const response = await this.getDomainRaw({ id: id }, initOverrides);
+        return await response.value();
+    }
+
+    /**
+     * Returns the current verification status with per-record `verified` flags and aggregate counters. Useful when polling for terminal status from an AI agent (the recommended pattern is to subscribe to the `domain.verified` webhook event instead — see sc-5444). 
+     * Get domain verification status
+     */
+    async getDomainVerificationStatusRaw(requestParameters: DomainsApiGetDomainVerificationStatusRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<VerificationStatusResponse>> {
+        if (requestParameters['id'] == null) {
+            throw new runtime.RequiredError(
+                'id',
+                'Required parameter "id" was null or undefined when calling getDomainVerificationStatus().'
+            );
+        }
+
+        const queryParameters: any = {};
+
+        const headerParameters: runtime.HTTPHeaders = {};
+
+        if (this.configuration && this.configuration.apiKey) {
+            headerParameters["X-API-Key"] = await this.configuration.apiKey("X-API-Key"); // ApiKeyAuth authentication
+        }
+
+        const response = await this.request({
+            path: `/domains/{id}/verification-status`.replace(`{${"id"}}`, encodeURIComponent(String(requestParameters['id']))),
+            method: 'GET',
+            headers: headerParameters,
+            query: queryParameters,
+        }, initOverrides);
+
+        return new runtime.JSONApiResponse(response, (jsonValue) => VerificationStatusResponseFromJSON(jsonValue));
+    }
+
+    /**
+     * Returns the current verification status with per-record `verified` flags and aggregate counters. Useful when polling for terminal status from an AI agent (the recommended pattern is to subscribe to the `domain.verified` webhook event instead — see sc-5444). 
+     * Get domain verification status
+     */
+    async getDomainVerificationStatus(id: string, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<VerificationStatusResponse> {
+        const response = await this.getDomainVerificationStatusRaw({ id: id }, initOverrides);
+        return await response.value();
+    }
+
     /**
      * List sending domains on the current project, with verification status and DNS records.
      * List sending domains
@@ -154,4 +363,43 @@ export class DomainsApi extends runtime.BaseAPI implements DomainsApiInterface {
         return await response.value();
     }
 
+    /**
+     * Queue an asynchronous DNS verification check. Returns immediately with a `job_id`. Poll `GET /v1/domains/{id}/verification-status` (or the higher-level `GET /v1/domains/{id}`) for the result, or subscribe to the `domain.verified` webhook event when sc-5444 ships.  Returns 409 if a verification is already in progress for this domain (within the last 2 minutes). 
+     * Trigger domain verification
+     */
+    async verifyDomainRaw(requestParameters: DomainsApiVerifyDomainRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<VerifyDomainResponse>> {
+        if (requestParameters['id'] == null) {
+            throw new runtime.RequiredError(
+                'id',
+                'Required parameter "id" was null or undefined when calling verifyDomain().'
+            );
+        }
+
+        const queryParameters: any = {};
+
+        const headerParameters: runtime.HTTPHeaders = {};
+
+        if (this.configuration && this.configuration.apiKey) {
+            headerParameters["X-API-Key"] = await this.configuration.apiKey("X-API-Key"); // ApiKeyAuth authentication
+        }
+
+        const response = await this.request({
+            path: `/domains/{id}/verify`.replace(`{${"id"}}`, encodeURIComponent(String(requestParameters['id']))),
+            method: 'POST',
+            headers: headerParameters,
+            query: queryParameters,
+        }, initOverrides);
+
+        return new runtime.JSONApiResponse(response, (jsonValue) => VerifyDomainResponseFromJSON(jsonValue));
+    }
+
+    /**
+     * Queue an asynchronous DNS verification check. Returns immediately with a `job_id`. Poll `GET /v1/domains/{id}/verification-status` (or the higher-level `GET /v1/domains/{id}`) for the result, or subscribe to the `domain.verified` webhook event when sc-5444 ships.  Returns 409 if a verification is already in progress for this domain (within the last 2 minutes). 
+     * Trigger domain verification
+     */
+    async verifyDomain(id: string, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<VerifyDomainResponse> {
+        const response = await this.verifyDomainRaw({ id: id }, initOverrides);
+        return await response.value();
+    }
+
 }