@alienplatform/platform-api 1.4.2 → 1.7.0

package/src/models/deploymentlistitemresponse.ts

@@ -25,6 +25,7 @@ import { SDKValidationError } from "./errors/sdkvalidationerror.js";
  */
 export const DeploymentListItemResponseStatus = {
   Pending: "pending",
+  PreflightsFailed: "preflights-failed",
   InitialSetup: "initial-setup",
   InitialSetupFailed: "initial-setup-failed",
   Provisioning: "provisioning",
@@ -37,6 +38,8 @@ export const DeploymentListItemResponseStatus = {
   DeletePending: "delete-pending",
   Deleting: "deleting",
   DeleteFailed: "delete-failed",
+  TeardownRequired: "teardown-required",
+  TeardownFailed: "teardown-failed",
   Deleted: "deleted",
   Error: "error",
 } as const;
@@ -209,6 +212,24 @@ export type DeploymentListItemResponseImportSource = ClosedEnum<
   typeof DeploymentListItemResponseImportSource
 >;
 
+/**
+ * Setup method that created the deployment record.
+ */
+export const DeploymentListItemResponseSetupMethod = {
+  Cloudformation: "cloudformation",
+  GoogleOauth: "google-oauth",
+  Terraform: "terraform",
+  Helm: "helm",
+  Cli: "cli",
+  Manual: "manual",
+} as const;
+/**
+ * Setup method that created the deployment record.
+ */
+export type DeploymentListItemResponseSetupMethod = ClosedEnum<
+  typeof DeploymentListItemResponseSetupMethod
+>;
+
 /**
  * Latest error information if in a failed state
  */
@@ -341,6 +362,14 @@ export type DeploymentListItemResponse = {
    * Setup source that imported this deployment
    */
   importSource?: DeploymentListItemResponseImportSource | null | undefined;
+  /**
+   * Setup method that created the deployment record.
+   */
+  setupMethod?: DeploymentListItemResponseSetupMethod | null | undefined;
+  /**
+   * Setup method metadata needed to guide privileged teardown.
+   */
+  setupMetadata?: { [k: string]: any | null } | null | undefined;
   /**
    * Imported setup target for compatibility checks
    */
@@ -573,6 +602,11 @@ export const DeploymentListItemResponseImportSource$inboundSchema: z.ZodEnum<
   typeof DeploymentListItemResponseImportSource
 > = z.enum(DeploymentListItemResponseImportSource);
 
+/** @internal */
+export const DeploymentListItemResponseSetupMethod$inboundSchema: z.ZodEnum<
+  typeof DeploymentListItemResponseSetupMethod
+> = z.enum(DeploymentListItemResponseSetupMethod);
+
 /** @internal */
 export const DeploymentListItemResponseError$inboundSchema: z.ZodType<
   DeploymentListItemResponseError,
@@ -631,6 +665,10 @@ export const DeploymentListItemResponse$inboundSchema: z.ZodType<
   pinnedReleaseId: z.nullable(z.string()).optional(),
   importSource: z.nullable(DeploymentListItemResponseImportSource$inboundSchema)
     .optional(),
+  setupMethod: z.nullable(DeploymentListItemResponseSetupMethod$inboundSchema)
+    .optional(),
+  setupMetadata: z.nullable(z.record(z.string(), z.nullable(z.any())))
+    .optional(),
   setupTarget: z.nullable(z.string()).optional(),
   setupFingerprint: z.nullable(z.string()).optional(),
   setupFingerprintVersion: z.nullable(z.int()).optional(),

package/src/models/deploymentportaldomainresponse.ts

@@ -6,13 +6,14 @@ import * as z from "zod/v4";
 import { safeParse } from "../lib/schemas.js";
 import { Result as SafeParseResult } from "../types/fp.js";
 import {
-  DeploymentPortalDomain,
-  DeploymentPortalDomain$inboundSchema,
-} from "./deploymentportaldomain.js";
+  DomainEndpoint,
+  DomainEndpoint$inboundSchema,
+} from "./domainendpoint.js";
 import { SDKValidationError } from "./errors/sdkvalidationerror.js";
 
 export type DeploymentPortalDomainResponse = {
-  deploymentPortalDomain: DeploymentPortalDomain | null;
+  deploymentPortalEndpoint: DomainEndpoint | null;
+  packageEndpoint: DomainEndpoint | null;
 };
 
 /** @internal */
@@ -20,7 +21,8 @@ export const DeploymentPortalDomainResponse$inboundSchema: z.ZodType<
   DeploymentPortalDomainResponse,
   unknown
 > = z.object({
-  deploymentPortalDomain: z.nullable(DeploymentPortalDomain$inboundSchema),
+  deploymentPortalEndpoint: z.nullable(DomainEndpoint$inboundSchema),
+  packageEndpoint: z.nullable(DomainEndpoint$inboundSchema),
 });
 
 export function deploymentPortalDomainResponseFromJSON(

package/src/models/deploymentrole.ts

@@ -11,6 +11,7 @@ import { ClosedEnum } from "../types/enums.js";
 export const DeploymentRole = {
   DeploymentViewer: "deployment.viewer",
   DeploymentManager: "deployment.manager",
+  DeploymentTelemetryWriter: "deployment.telemetry-writer",
 } as const;
 /**
  * Role for deployment-scoped service accounts

package/src/models/deploymentsetupstacksettingspolicy.ts

@@ -33,6 +33,7 @@ export type DeploymentSetupStackSettingsPolicyAwsUnion =
 
 export type DeploymentSetupStackSettingsPolicyAzure = {
   keyVaultCertificateId: string;
+  keyVaultResourceId?: string | null | undefined;
 };
 
 export type DeploymentSetupStackSettingsPolicyAzureUnion =
@@ -859,6 +860,10 @@ export type DeploymentSetupStackSettingsPolicyTypeByoVnetAzure = ClosedEnum<
 >;
 
 export type DeploymentSetupStackSettingsPolicyNetworkByoVnetAzure = {
+  /**
+   * Name of the dedicated classic Application Gateway subnet within the VNet.
+   */
+  applicationGatewaySubnetName?: string | null | undefined;
   /**
    * Name of the private subnet within the VNet
    */
@@ -1214,10 +1219,12 @@ export const DeploymentSetupStackSettingsPolicyAzure$inboundSchema: z.ZodType<
   unknown
 > = z.object({
   keyVaultCertificateId: z.string(),
+  keyVaultResourceId: z.nullable(z.string()).optional(),
 });
 /** @internal */
 export type DeploymentSetupStackSettingsPolicyAzure$Outbound = {
   keyVaultCertificateId: string;
+  keyVaultResourceId?: string | null | undefined;
 };
 
 /** @internal */
@@ -1226,6 +1233,7 @@ export const DeploymentSetupStackSettingsPolicyAzure$outboundSchema: z.ZodType<
   DeploymentSetupStackSettingsPolicyAzure
 > = z.object({
   keyVaultCertificateId: z.string(),
+  keyVaultResourceId: z.nullable(z.string()).optional(),
 });
 
 export function deploymentSetupStackSettingsPolicyAzureToJSON(
@@ -4814,12 +4822,14 @@ export const DeploymentSetupStackSettingsPolicyTypeByoVnetAzure$outboundSchema:
 export const DeploymentSetupStackSettingsPolicyNetworkByoVnetAzure$inboundSchema:
   z.ZodType<DeploymentSetupStackSettingsPolicyNetworkByoVnetAzure, unknown> = z
     .object({
+      application_gateway_subnet_name: z.nullable(z.string()).optional(),
       private_subnet_name: z.string(),
       public_subnet_name: z.string(),
       type: DeploymentSetupStackSettingsPolicyTypeByoVnetAzure$inboundSchema,
       vnet_resource_id: z.string(),
     }).transform((v) => {
       return remap$(v, {
+        "application_gateway_subnet_name": "applicationGatewaySubnetName",
         "private_subnet_name": "privateSubnetName",
         "public_subnet_name": "publicSubnetName",
         "vnet_resource_id": "vnetResourceId",
@@ -4827,6 +4837,7 @@ export const DeploymentSetupStackSettingsPolicyNetworkByoVnetAzure$inboundSchema
     });
 /** @internal */
 export type DeploymentSetupStackSettingsPolicyNetworkByoVnetAzure$Outbound = {
+  application_gateway_subnet_name?: string | null | undefined;
   private_subnet_name: string;
   public_subnet_name: string;
   type: string;
@@ -4839,12 +4850,14 @@ export const DeploymentSetupStackSettingsPolicyNetworkByoVnetAzure$outboundSchem
     DeploymentSetupStackSettingsPolicyNetworkByoVnetAzure$Outbound,
     DeploymentSetupStackSettingsPolicyNetworkByoVnetAzure
   > = z.object({
+    applicationGatewaySubnetName: z.nullable(z.string()).optional(),
     privateSubnetName: z.string(),
     publicSubnetName: z.string(),
     type: DeploymentSetupStackSettingsPolicyTypeByoVnetAzure$outboundSchema,
     vnetResourceId: z.string(),
   }).transform((v) => {
     return remap$(v, {
+      applicationGatewaySubnetName: "application_gateway_subnet_name",
       privateSubnetName: "private_subnet_name",
       publicSubnetName: "public_subnet_name",
       vnetResourceId: "vnet_resource_id",

package/src/models/{deploymentportaldomain.ts → domainendpoint.ts}

@@ -4,26 +4,25 @@
 
 import * as z from "zod/v4";
 import { safeParse } from "../lib/schemas.js";
-import { ClosedEnum } from "../types/enums.js";
 import { Result as SafeParseResult } from "../types/fp.js";
 import {
   DeploymentPortalManagedDnsRecord,
   DeploymentPortalManagedDnsRecord$inboundSchema,
 } from "./deploymentportalmanageddnsrecord.js";
+import {
+  DomainEndpointKind,
+  DomainEndpointKind$inboundSchema,
+} from "./domainendpointkind.js";
+import {
+  DomainEndpointOwner,
+  DomainEndpointOwner$inboundSchema,
+} from "./domainendpointowner.js";
+import {
+  DomainEndpointStatus,
+  DomainEndpointStatus$inboundSchema,
+} from "./domainendpointstatus.js";
 import { SDKValidationError } from "./errors/sdkvalidationerror.js";
 
-export const DeploymentPortalDomainStatus = {
-  WaitingForDomain: "waiting-for-domain",
-  PendingVercel: "pending-vercel",
-  PendingDns: "pending-dns",
-  Active: "active",
-  Failed: "failed",
-  Deleting: "deleting",
-} as const;
-export type DeploymentPortalDomainStatus = ClosedEnum<
-  typeof DeploymentPortalDomainStatus
->;
-
 /**
  * Canonical error container that provides a structured way to represent errors
  *
@@ -35,7 +34,7 @@ export type DeploymentPortalDomainStatus = ClosedEnum<
  * supporting serialization for API responses and detailed error reporting
  * in distributed systems.
  */
-export type DeploymentPortalDomainError = {
+export type DomainEndpointError = {
   /**
    * A unique identifier for the type of error.
    *
@@ -110,28 +109,25 @@ export type DeploymentPortalDomainError = {
   source?: any | null | undefined;
 };
 
-export type DeploymentPortalDomain = {
+export type DomainEndpoint = {
   /**
-   * Unique identifier for the deployment portal domain.
+   * Unique identifier for the domain endpoint.
    */
   id: string;
   /**
    * Unique identifier for the workspace.
    */
   workspaceId: string;
-  /**
-   * Unique identifier for the project.
-   */
-  projectId: string;
   /**
    * Unique identifier for the domain.
    */
   domainId: string;
+  kind: DomainEndpointKind;
+  owner: DomainEndpointOwner;
   hostname: string;
-  status: DeploymentPortalDomainStatus;
-  vercelProjectDomain?: { [k: string]: any | null } | null | undefined;
-  vercelVerification?: { [k: string]: any | null } | null | undefined;
-  vercelDomainConfig?: { [k: string]: any | null } | null | undefined;
+  status: DomainEndpointStatus;
+  provider?: string | null | undefined;
+  providerState?: { [k: string]: any | null } | null | undefined;
   managedDnsRecords: Array<DeploymentPortalManagedDnsRecord>;
   /**
    * Canonical error container that provides a structured way to represent errors
@@ -144,7 +140,7 @@ export type DeploymentPortalDomain = {
    * supporting serialization for API responses and detailed error reporting
    * in distributed systems.
    */
-  error?: DeploymentPortalDomainError | null | undefined;
+  error?: DomainEndpointError | null | undefined;
   lockedAt?: Date | null | undefined;
   lockedBy?: string | null | undefined;
   retryAttempts: number;
@@ -154,13 +150,8 @@ export type DeploymentPortalDomain = {
 };
 
 /** @internal */
-export const DeploymentPortalDomainStatus$inboundSchema: z.ZodEnum<
-  typeof DeploymentPortalDomainStatus
-> = z.enum(DeploymentPortalDomainStatus);
-
-/** @internal */
-export const DeploymentPortalDomainError$inboundSchema: z.ZodType<
-  DeploymentPortalDomainError,
+export const DomainEndpointError$inboundSchema: z.ZodType<
+  DomainEndpointError,
   unknown
 > = z.object({
   code: z.string(),
@@ -173,54 +164,50 @@ export const DeploymentPortalDomainError$inboundSchema: z.ZodType<
   source: z.nullable(z.any()).optional(),
 });
 
-export function deploymentPortalDomainErrorFromJSON(
+export function domainEndpointErrorFromJSON(
   jsonString: string,
-): SafeParseResult<DeploymentPortalDomainError, SDKValidationError> {
+): SafeParseResult<DomainEndpointError, SDKValidationError> {
   return safeParse(
     jsonString,
-    (x) => DeploymentPortalDomainError$inboundSchema.parse(JSON.parse(x)),
-    `Failed to parse 'DeploymentPortalDomainError' from JSON`,
+    (x) => DomainEndpointError$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'DomainEndpointError' from JSON`,
   );
 }
 
 /** @internal */
-export const DeploymentPortalDomain$inboundSchema: z.ZodType<
-  DeploymentPortalDomain,
-  unknown
-> = z.object({
-  id: z.string(),
-  workspaceId: z.string(),
-  projectId: z.string(),
-  domainId: z.string(),
-  hostname: z.string(),
-  status: DeploymentPortalDomainStatus$inboundSchema,
-  vercelProjectDomain: z.nullable(z.record(z.string(), z.nullable(z.any())))
-    .optional(),
-  vercelVerification: z.nullable(z.record(z.string(), z.nullable(z.any())))
-    .optional(),
-  vercelDomainConfig: z.nullable(z.record(z.string(), z.nullable(z.any())))
-    .optional(),
-  managedDnsRecords: z.array(DeploymentPortalManagedDnsRecord$inboundSchema),
-  error: z.nullable(z.lazy(() => DeploymentPortalDomainError$inboundSchema))
-    .optional(),
-  lockedAt: z.nullable(
-    z.iso.datetime({ offset: true }).transform(v => new Date(v)),
-  ).optional(),
-  lockedBy: z.nullable(z.string()).optional(),
-  retryAttempts: z.int(),
-  nextStepAfter: z.nullable(
-    z.iso.datetime({ offset: true }).transform(v => new Date(v)),
-  ).optional(),
-  createdAt: z.iso.datetime({ offset: true }).transform(v => new Date(v)),
-  updatedAt: z.iso.datetime({ offset: true }).transform(v => new Date(v)),
-});
+export const DomainEndpoint$inboundSchema: z.ZodType<DomainEndpoint, unknown> =
+  z.object({
+    id: z.string(),
+    workspaceId: z.string(),
+    domainId: z.string(),
+    kind: DomainEndpointKind$inboundSchema,
+    owner: DomainEndpointOwner$inboundSchema,
+    hostname: z.string(),
+    status: DomainEndpointStatus$inboundSchema,
+    provider: z.nullable(z.string()).optional(),
+    providerState: z.nullable(z.record(z.string(), z.nullable(z.any())))
+      .optional(),
+    managedDnsRecords: z.array(DeploymentPortalManagedDnsRecord$inboundSchema),
+    error: z.nullable(z.lazy(() => DomainEndpointError$inboundSchema))
+      .optional(),
+    lockedAt: z.nullable(
+      z.iso.datetime({ offset: true }).transform(v => new Date(v)),
+    ).optional(),
+    lockedBy: z.nullable(z.string()).optional(),
+    retryAttempts: z.int(),
+    nextStepAfter: z.nullable(
+      z.iso.datetime({ offset: true }).transform(v => new Date(v)),
+    ).optional(),
+    createdAt: z.iso.datetime({ offset: true }).transform(v => new Date(v)),
+    updatedAt: z.iso.datetime({ offset: true }).transform(v => new Date(v)),
+  });
 
-export function deploymentPortalDomainFromJSON(
+export function domainEndpointFromJSON(
   jsonString: string,
-): SafeParseResult<DeploymentPortalDomain, SDKValidationError> {
+): SafeParseResult<DomainEndpoint, SDKValidationError> {
   return safeParse(
     jsonString,
-    (x) => DeploymentPortalDomain$inboundSchema.parse(JSON.parse(x)),
-    `Failed to parse 'DeploymentPortalDomain' from JSON`,
+    (x) => DomainEndpoint$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'DomainEndpoint' from JSON`,
   );
 }

package/src/models/domainendpointkind.ts

@@ -0,0 +1,19 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ */
+
+import * as z from "zod/v4";
+import { ClosedEnum } from "../types/enums.js";
+
+export const DomainEndpointKind = {
+  DeploymentPortal: "deployment_portal",
+  WorkspacePackages: "workspace_packages",
+  ManagerApi: "manager_api",
+  DeploymentUrlBase: "deployment_url_base",
+} as const;
+export type DomainEndpointKind = ClosedEnum<typeof DomainEndpointKind>;
+
+/** @internal */
+export const DomainEndpointKind$inboundSchema: z.ZodEnum<
+  typeof DomainEndpointKind
+> = z.enum(DomainEndpointKind);

package/src/models/domainendpointowner.ts

@@ -0,0 +1,36 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ */
+
+import * as z from "zod/v4";
+import { safeParse } from "../lib/schemas.js";
+import { Result as SafeParseResult } from "../types/fp.js";
+import {
+  DomainEndpointOwnerType,
+  DomainEndpointOwnerType$inboundSchema,
+} from "./domainendpointownertype.js";
+import { SDKValidationError } from "./errors/sdkvalidationerror.js";
+
+export type DomainEndpointOwner = {
+  type: DomainEndpointOwnerType;
+  id: string;
+};
+
+/** @internal */
+export const DomainEndpointOwner$inboundSchema: z.ZodType<
+  DomainEndpointOwner,
+  unknown
+> = z.object({
+  type: DomainEndpointOwnerType$inboundSchema,
+  id: z.string(),
+});
+
+export function domainEndpointOwnerFromJSON(
+  jsonString: string,
+): SafeParseResult<DomainEndpointOwner, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => DomainEndpointOwner$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'DomainEndpointOwner' from JSON`,
+  );
+}

package/src/models/domainendpointownertype.ts

@@ -0,0 +1,20 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ */
+
+import * as z from "zod/v4";
+import { ClosedEnum } from "../types/enums.js";
+
+export const DomainEndpointOwnerType = {
+  Workspace: "workspace",
+  Project: "project",
+  Manager: "manager",
+} as const;
+export type DomainEndpointOwnerType = ClosedEnum<
+  typeof DomainEndpointOwnerType
+>;
+
+/** @internal */
+export const DomainEndpointOwnerType$inboundSchema: z.ZodEnum<
+  typeof DomainEndpointOwnerType
+> = z.enum(DomainEndpointOwnerType);

package/src/models/domainendpointstatus.ts

@@ -0,0 +1,22 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ */
+
+import * as z from "zod/v4";
+import { ClosedEnum } from "../types/enums.js";
+
+export const DomainEndpointStatus = {
+  WaitingForDomain: "waiting_for_domain",
+  Provisioning: "provisioning",
+  WaitingForDns: "waiting_for_dns",
+  WaitingForHealth: "waiting_for_health",
+  Active: "active",
+  Failed: "failed",
+  Deleting: "deleting",
+} as const;
+export type DomainEndpointStatus = ClosedEnum<typeof DomainEndpointStatus>;
+
+/** @internal */
+export const DomainEndpointStatus$inboundSchema: z.ZodEnum<
+  typeof DomainEndpointStatus
+> = z.enum(DomainEndpointStatus);

package/src/models/domainwithusage.ts

@@ -6,6 +6,10 @@ import * as z from "zod/v4";
 import { safeParse } from "../lib/schemas.js";
 import { ClosedEnum } from "../types/enums.js";
 import { Result as SafeParseResult } from "../types/fp.js";
+import {
+  DomainEndpoint,
+  DomainEndpoint$inboundSchema,
+} from "./domainendpoint.js";
 import { SDKValidationError } from "./errors/sdkvalidationerror.js";
 
 export const DomainWithUsageStatus = {
@@ -25,14 +29,28 @@ export type DeploymentUrlProject = {
 
 export type PortalBinding = {
   id: string;
-  projectId: string;
-  projectName: string;
+  projectId: string | null;
+  projectName: string | null;
+  hostname: string;
+};
+
+export type PackageDomain = {
+  id: string;
+  hostname: string;
+};
+
+export type ManagerBinding = {
+  id: string;
+  managerId: string;
+  managerName: string;
   hostname: string;
 };
 
 export type DomainWithUsageUsage = {
   deploymentUrlProjects: Array<DeploymentUrlProject>;
   portalBindings: Array<PortalBinding>;
+  packageDomains: Array<PackageDomain>;
+  managerBindings: Array<ManagerBinding>;
 };
 
 export type DomainWithUsage = {
@@ -54,6 +72,7 @@ export type DomainWithUsage = {
   createdAt: Date;
   updatedAt: Date;
   verifiedAt?: Date | null | undefined;
+  endpoints: Array<DomainEndpoint | null>;
   usage: DomainWithUsageUsage;
 };
 
@@ -85,8 +104,8 @@ export function deploymentUrlProjectFromJSON(
 export const PortalBinding$inboundSchema: z.ZodType<PortalBinding, unknown> = z
   .object({
     id: z.string(),
-    projectId: z.string(),
-    projectName: z.string(),
+    projectId: z.nullable(z.string()),
+    projectName: z.nullable(z.string()),
     hostname: z.string(),
   });
 
@@ -100,6 +119,42 @@ export function portalBindingFromJSON(
   );
 }
 
+/** @internal */
+export const PackageDomain$inboundSchema: z.ZodType<PackageDomain, unknown> = z
+  .object({
+    id: z.string(),
+    hostname: z.string(),
+  });
+
+export function packageDomainFromJSON(
+  jsonString: string,
+): SafeParseResult<PackageDomain, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => PackageDomain$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'PackageDomain' from JSON`,
+  );
+}
+
+/** @internal */
+export const ManagerBinding$inboundSchema: z.ZodType<ManagerBinding, unknown> =
+  z.object({
+    id: z.string(),
+    managerId: z.string(),
+    managerName: z.string(),
+    hostname: z.string(),
+  });
+
+export function managerBindingFromJSON(
+  jsonString: string,
+): SafeParseResult<ManagerBinding, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => ManagerBinding$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'ManagerBinding' from JSON`,
+  );
+}
+
 /** @internal */
 export const DomainWithUsageUsage$inboundSchema: z.ZodType<
   DomainWithUsageUsage,
@@ -109,6 +164,8 @@ export const DomainWithUsageUsage$inboundSchema: z.ZodType<
     z.lazy(() => DeploymentUrlProject$inboundSchema),
   ),
   portalBindings: z.array(z.lazy(() => PortalBinding$inboundSchema)),
+  packageDomains: z.array(z.lazy(() => PackageDomain$inboundSchema)),
+  managerBindings: z.array(z.lazy(() => ManagerBinding$inboundSchema)),
 });
 
 export function domainWithUsageUsageFromJSON(
@@ -140,6 +197,7 @@ export const DomainWithUsage$inboundSchema: z.ZodType<
   verifiedAt: z.nullable(
     z.iso.datetime({ offset: true }).transform(v => new Date(v)),
   ).optional(),
+  endpoints: z.array(z.nullable(DomainEndpoint$inboundSchema)),
   usage: z.lazy(() => DomainWithUsageUsage$inboundSchema),
 });
 

package/src/models/event.ts

@@ -390,11 +390,13 @@ export type DataError1 = {
  *
  * @remarks
  *
- * Derived from the source deployment status: `provisioning-failed` →
- * `Provisioning`, `update-failed` → `Updating`, `delete-failed` → `Deleting`.
+ * Derived from the source deployment status: `preflights-failed` →
+ * `Preflights`, `provisioning-failed` → `Provisioning`, `update-failed` →
+ * `Updating`, `delete-failed` → `Deleting`.
  * `refresh-failed` is modelled separately via `DeploymentDegraded`.
  */
 export const Phase = {
+  Preflights: "preflights",
   Provisioning: "provisioning",
   Updating: "updating",
   Deleting: "deleting",
@@ -404,8 +406,9 @@ export const Phase = {
  *
  * @remarks
  *
- * Derived from the source deployment status: `provisioning-failed` →
- * `Provisioning`, `update-failed` → `Updating`, `delete-failed` → `Deleting`.
+ * Derived from the source deployment status: `preflights-failed` →
+ * `Preflights`, `provisioning-failed` → `Provisioning`, `update-failed` →
+ * `Updating`, `delete-failed` → `Deleting`.
  * `refresh-failed` is modelled separately via `DeploymentDegraded`.
  */
 export type Phase = ClosedEnum<typeof Phase>;
@@ -436,8 +439,9 @@ export type DataDeploymentFailed = {
    *
    * @remarks
    *
-   * Derived from the source deployment status: `provisioning-failed` →
-   * `Provisioning`, `update-failed` → `Updating`, `delete-failed` → `Deleting`.
+   * Derived from the source deployment status: `preflights-failed` →
+   * `Preflights`, `provisioning-failed` → `Provisioning`, `update-failed` →
+   * `Updating`, `delete-failed` → `Deleting`.
    * `refresh-failed` is modelled separately via `DeploymentDegraded`.
    */
   phase: Phase;
@@ -857,6 +861,7 @@ export const EventStatus = {
   UpdateFailed: "update-failed",
   Deleting: "deleting",
   DeleteFailed: "delete-failed",
+  TeardownRequired: "teardown-required",
   Deleted: "deleted",
   RefreshFailed: "refresh-failed",
 } as const;