@alienplatform/platform-api 3.3.11 → 3.3.13

package/src/models/projectlistitemresponse.ts

@@ -274,6 +274,90 @@ export type ProjectListItemResponseDefaultManagers = {
   local?: string | null | undefined;
 };
 
+export type ProjectListItemResponseDeployments = {
+  enabled: boolean;
+};
+
+export type ProjectListItemResponseKeys = {
+  enabled: boolean;
+  applicationEncryption: boolean;
+};
+
+export const ProjectListItemResponseAllowedProvider = {
+  AwsBedrock: "aws-bedrock",
+  GcpVertex: "gcp-vertex",
+  AzureFoundry: "azure-foundry",
+  Anthropic: "anthropic",
+  Databricks: "databricks",
+  Openai: "openai",
+} as const;
+export type ProjectListItemResponseAllowedProvider = ClosedEnum<
+  typeof ProjectListItemResponseAllowedProvider
+>;
+
+export const ProjectListItemResponseClientApi = {
+  OpenaiChat: "openai-chat",
+  OpenaiResponses: "openai-responses",
+  AnthropicMessages: "anthropic-messages",
+} as const;
+export type ProjectListItemResponseClientApi = ClosedEnum<
+  typeof ProjectListItemResponseClientApi
+>;
+
+export type ProjectListItemResponseRequirement = {
+  publicModelId: string;
+  clientApis: Array<ProjectListItemResponseClientApi>;
+  required: boolean;
+};
+
+export type ProjectListItemResponseModels = {
+  enabled: boolean;
+  allowedProviders: Array<ProjectListItemResponseAllowedProvider>;
+  requirements: Array<ProjectListItemResponseRequirement>;
+};
+
+export const ProjectListItemResponseAccess = {
+  ReadWrite: "read-write",
+} as const;
+export type ProjectListItemResponseAccess = ClosedEnum<
+  typeof ProjectListItemResponseAccess
+>;
+
+export type ProjectListItemResponseBuckets = {
+  enabled: boolean;
+  access: ProjectListItemResponseAccess;
+};
+
+export const ProjectListItemResponseCredentialPolicy = {
+  PullOnly: "pull-only",
+  PushAndPull: "push-and-pull",
+} as const;
+export type ProjectListItemResponseCredentialPolicy = ClosedEnum<
+  typeof ProjectListItemResponseCredentialPolicy
+>;
+
+export type ProjectListItemResponseRegistry = {
+  enabled: boolean;
+  repositories: Array<string>;
+  credentialPolicy: ProjectListItemResponseCredentialPolicy;
+};
+
+export type ProjectListItemResponseCapabilities = {
+  deployments?: ProjectListItemResponseDeployments | undefined;
+  keys?: ProjectListItemResponseKeys | undefined;
+  models?: ProjectListItemResponseModels | undefined;
+  buckets?: ProjectListItemResponseBuckets | undefined;
+  registry?: ProjectListItemResponseRegistry | undefined;
+};
+
+/**
+ * Capabilities this Project may offer through setup links.
+ */
+export type ProjectListItemResponseProjectCapabilities = {
+  schemaVersion: number;
+  capabilities: ProjectListItemResponseCapabilities;
+};
+
 export type ProjectListItemResponse = {
   /**
    * Unique identifier for the project.
@@ -310,6 +394,13 @@ export type ProjectListItemResponse = {
    * Project default private managers for new push deployments.
    */
   defaultManagers?: ProjectListItemResponseDefaultManagers | null | undefined;
+  /**
+   * Capabilities this Project may offer through setup links.
+   */
+  projectCapabilities?:
+    | ProjectListItemResponseProjectCapabilities
+    | null
+    | undefined;
   createdAt: Date;
   /**
    * Unique identifier for the workspace.
@@ -539,6 +630,199 @@ export function projectListItemResponseDefaultManagersFromJSON(
   );
 }
 
+/** @internal */
+export const ProjectListItemResponseDeployments$inboundSchema: z.ZodType<
+  ProjectListItemResponseDeployments,
+  unknown
+> = z.object({
+  enabled: z.boolean(),
+});
+
+export function projectListItemResponseDeploymentsFromJSON(
+  jsonString: string,
+): SafeParseResult<ProjectListItemResponseDeployments, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) =>
+      ProjectListItemResponseDeployments$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'ProjectListItemResponseDeployments' from JSON`,
+  );
+}
+
+/** @internal */
+export const ProjectListItemResponseKeys$inboundSchema: z.ZodType<
+  ProjectListItemResponseKeys,
+  unknown
+> = z.object({
+  enabled: z.boolean(),
+  applicationEncryption: z.boolean(),
+});
+
+export function projectListItemResponseKeysFromJSON(
+  jsonString: string,
+): SafeParseResult<ProjectListItemResponseKeys, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => ProjectListItemResponseKeys$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'ProjectListItemResponseKeys' from JSON`,
+  );
+}
+
+/** @internal */
+export const ProjectListItemResponseAllowedProvider$inboundSchema: z.ZodEnum<
+  typeof ProjectListItemResponseAllowedProvider
+> = z.enum(ProjectListItemResponseAllowedProvider);
+
+/** @internal */
+export const ProjectListItemResponseClientApi$inboundSchema: z.ZodEnum<
+  typeof ProjectListItemResponseClientApi
+> = z.enum(ProjectListItemResponseClientApi);
+
+/** @internal */
+export const ProjectListItemResponseRequirement$inboundSchema: z.ZodType<
+  ProjectListItemResponseRequirement,
+  unknown
+> = z.object({
+  publicModelId: z.string(),
+  clientApis: z.array(ProjectListItemResponseClientApi$inboundSchema),
+  required: z.boolean(),
+});
+
+export function projectListItemResponseRequirementFromJSON(
+  jsonString: string,
+): SafeParseResult<ProjectListItemResponseRequirement, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) =>
+      ProjectListItemResponseRequirement$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'ProjectListItemResponseRequirement' from JSON`,
+  );
+}
+
+/** @internal */
+export const ProjectListItemResponseModels$inboundSchema: z.ZodType<
+  ProjectListItemResponseModels,
+  unknown
+> = z.object({
+  enabled: z.boolean(),
+  allowedProviders: z.array(
+    ProjectListItemResponseAllowedProvider$inboundSchema,
+  ),
+  requirements: z.array(
+    z.lazy(() => ProjectListItemResponseRequirement$inboundSchema),
+  ),
+});
+
+export function projectListItemResponseModelsFromJSON(
+  jsonString: string,
+): SafeParseResult<ProjectListItemResponseModels, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => ProjectListItemResponseModels$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'ProjectListItemResponseModels' from JSON`,
+  );
+}
+
+/** @internal */
+export const ProjectListItemResponseAccess$inboundSchema: z.ZodEnum<
+  typeof ProjectListItemResponseAccess
+> = z.enum(ProjectListItemResponseAccess);
+
+/** @internal */
+export const ProjectListItemResponseBuckets$inboundSchema: z.ZodType<
+  ProjectListItemResponseBuckets,
+  unknown
+> = z.object({
+  enabled: z.boolean(),
+  access: ProjectListItemResponseAccess$inboundSchema,
+});
+
+export function projectListItemResponseBucketsFromJSON(
+  jsonString: string,
+): SafeParseResult<ProjectListItemResponseBuckets, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => ProjectListItemResponseBuckets$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'ProjectListItemResponseBuckets' from JSON`,
+  );
+}
+
+/** @internal */
+export const ProjectListItemResponseCredentialPolicy$inboundSchema: z.ZodEnum<
+  typeof ProjectListItemResponseCredentialPolicy
+> = z.enum(ProjectListItemResponseCredentialPolicy);
+
+/** @internal */
+export const ProjectListItemResponseRegistry$inboundSchema: z.ZodType<
+  ProjectListItemResponseRegistry,
+  unknown
+> = z.object({
+  enabled: z.boolean(),
+  repositories: z.array(z.string()),
+  credentialPolicy: ProjectListItemResponseCredentialPolicy$inboundSchema,
+});
+
+export function projectListItemResponseRegistryFromJSON(
+  jsonString: string,
+): SafeParseResult<ProjectListItemResponseRegistry, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => ProjectListItemResponseRegistry$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'ProjectListItemResponseRegistry' from JSON`,
+  );
+}
+
+/** @internal */
+export const ProjectListItemResponseCapabilities$inboundSchema: z.ZodType<
+  ProjectListItemResponseCapabilities,
+  unknown
+> = z.object({
+  deployments: z.lazy(() => ProjectListItemResponseDeployments$inboundSchema)
+    .optional(),
+  keys: z.lazy(() => ProjectListItemResponseKeys$inboundSchema).optional(),
+  models: z.lazy(() => ProjectListItemResponseModels$inboundSchema).optional(),
+  buckets: z.lazy(() => ProjectListItemResponseBuckets$inboundSchema)
+    .optional(),
+  registry: z.lazy(() => ProjectListItemResponseRegistry$inboundSchema)
+    .optional(),
+});
+
+export function projectListItemResponseCapabilitiesFromJSON(
+  jsonString: string,
+): SafeParseResult<ProjectListItemResponseCapabilities, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) =>
+      ProjectListItemResponseCapabilities$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'ProjectListItemResponseCapabilities' from JSON`,
+  );
+}
+
+/** @internal */
+export const ProjectListItemResponseProjectCapabilities$inboundSchema:
+  z.ZodType<ProjectListItemResponseProjectCapabilities, unknown> = z.object({
+    schemaVersion: z.number(),
+    capabilities: z.lazy(() =>
+      ProjectListItemResponseCapabilities$inboundSchema
+    ),
+  });
+
+export function projectListItemResponseProjectCapabilitiesFromJSON(
+  jsonString: string,
+): SafeParseResult<
+  ProjectListItemResponseProjectCapabilities,
+  SDKValidationError
+> {
+  return safeParse(
+    jsonString,
+    (x) =>
+      ProjectListItemResponseProjectCapabilities$inboundSchema.parse(
+        JSON.parse(x),
+      ),
+    `Failed to parse 'ProjectListItemResponseProjectCapabilities' from JSON`,
+  );
+}
+
 /** @internal */
 export const ProjectListItemResponse$inboundSchema: z.ZodType<
   ProjectListItemResponse,
@@ -562,6 +846,9 @@ export const ProjectListItemResponse$inboundSchema: z.ZodType<
   defaultManagers: z.nullable(
     z.lazy(() => ProjectListItemResponseDefaultManagers$inboundSchema),
   ).optional(),
+  projectCapabilities: z.nullable(
+    z.lazy(() => ProjectListItemResponseProjectCapabilities$inboundSchema),
+  ).optional(),
   createdAt: z.iso.datetime({ offset: true }).transform(v => new Date(v)),
   workspaceId: z.string(),
   deploymentCount: z.number().optional(),

package/src/models/projectrole.ts

@@ -11,6 +11,9 @@ import { ClosedEnum } from "../types/enums.js";
 export const ProjectRole = {
   ProjectViewer: "project.viewer",
   ProjectDeveloper: "project.developer",
+  ProjectEncryption: "project.encryption",
+  ProjectAiGateway: "project.ai-gateway",
+  ProjectRemoteBindings: "project.remote-bindings",
 } as const;
 /**
  * Role for project-scoped service accounts

package/src/models/publishoperationspluginrequest.ts

@@ -0,0 +1,74 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ */
+
+import * as z from "zod/v4";
+import { ClosedEnum } from "../types/enums.js";
+
+/**
+ * Plugin-level default risk tier.
+ */
+export const PublishOperationsPluginRequestTier = {
+  ReadOnly: "read-only",
+  Mutating: "mutating",
+  Destructive: "destructive",
+} as const;
+/**
+ * Plugin-level default risk tier.
+ */
+export type PublishOperationsPluginRequestTier = ClosedEnum<
+  typeof PublishOperationsPluginRequestTier
+>;
+
+export type PublishOperationsPluginRequest = {
+  /**
+   * Plugin name (from the bundle's metadata.json).
+   */
+  name: string;
+  /**
+   * Plugin version.
+   */
+  version: string;
+  /**
+   * Plugin-level default risk tier.
+   */
+  tier: PublishOperationsPluginRequestTier;
+  /**
+   * The verbatim metadata.json (operations[], binaries{}).
+   */
+  metadata?: any | null | undefined;
+};
+
+/** @internal */
+export const PublishOperationsPluginRequestTier$outboundSchema: z.ZodEnum<
+  typeof PublishOperationsPluginRequestTier
+> = z.enum(PublishOperationsPluginRequestTier);
+
+/** @internal */
+export type PublishOperationsPluginRequest$Outbound = {
+  name: string;
+  version: string;
+  tier: string;
+  metadata?: any | null | undefined;
+};
+
+/** @internal */
+export const PublishOperationsPluginRequest$outboundSchema: z.ZodType<
+  PublishOperationsPluginRequest$Outbound,
+  PublishOperationsPluginRequest
+> = z.object({
+  name: z.string(),
+  version: z.string(),
+  tier: PublishOperationsPluginRequestTier$outboundSchema,
+  metadata: z.nullable(z.any()).optional(),
+});
+
+export function publishOperationsPluginRequestToJSON(
+  publishOperationsPluginRequest: PublishOperationsPluginRequest,
+): string {
+  return JSON.stringify(
+    PublishOperationsPluginRequest$outboundSchema.parse(
+      publishOperationsPluginRequest,
+    ),
+  );
+}

package/src/models/publishoperationspluginresponse.ts

@@ -0,0 +1,60 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ */
+
+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 { SDKValidationError } from "./errors/sdkvalidationerror.js";
+
+/**
+ * How risky an operation is (declared by the plugin metadata).
+ */
+export const PublishOperationsPluginResponseTier = {
+  ReadOnly: "read-only",
+  Mutating: "mutating",
+  Destructive: "destructive",
+} as const;
+/**
+ * How risky an operation is (declared by the plugin metadata).
+ */
+export type PublishOperationsPluginResponseTier = ClosedEnum<
+  typeof PublishOperationsPluginResponseTier
+>;
+
+export type PublishOperationsPluginResponse = {
+  name: string;
+  version: string;
+  /**
+   * How risky an operation is (declared by the plugin metadata).
+   */
+  tier: PublishOperationsPluginResponseTier;
+  enabled: boolean;
+};
+
+/** @internal */
+export const PublishOperationsPluginResponseTier$inboundSchema: z.ZodEnum<
+  typeof PublishOperationsPluginResponseTier
+> = z.enum(PublishOperationsPluginResponseTier);
+
+/** @internal */
+export const PublishOperationsPluginResponse$inboundSchema: z.ZodType<
+  PublishOperationsPluginResponse,
+  unknown
+> = z.object({
+  name: z.string(),
+  version: z.string(),
+  tier: PublishOperationsPluginResponseTier$inboundSchema,
+  enabled: z.boolean(),
+});
+
+export function publishOperationsPluginResponseFromJSON(
+  jsonString: string,
+): SafeParseResult<PublishOperationsPluginResponse, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => PublishOperationsPluginResponse$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'PublishOperationsPluginResponse' from JSON`,
+  );
+}

package/src/models/putexternalaibindingrequestunion.ts

@@ -0,0 +1,126 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ */
+
+import * as z from "zod/v4";
+import { ClosedEnum } from "../types/enums.js";
+
+export type PutExternalAIBindingRequestDatabricks = {
+  provider: "databricks";
+  workspaceUrl: string;
+  clientId: string;
+  clientSecret: string;
+  acknowledgeAlienCredentialAccess: boolean;
+};
+
+export const PutExternalAIBindingRequestProviderEnum = {
+  Anthropic: "anthropic",
+  Openai: "openai",
+} as const;
+export type PutExternalAIBindingRequestProviderEnum = ClosedEnum<
+  typeof PutExternalAIBindingRequestProviderEnum
+>;
+
+export type PutExternalAIBindingRequest = {
+  provider: PutExternalAIBindingRequestProviderEnum;
+  apiKey: string;
+  acknowledgeAlienCredentialAccess: boolean;
+};
+
+export type PutExternalAIBindingRequestUnion =
+  | (PutExternalAIBindingRequest & { provider: "anthropic" })
+  | (PutExternalAIBindingRequest & { provider: "openai" })
+  | PutExternalAIBindingRequestDatabricks;
+
+/** @internal */
+export type PutExternalAIBindingRequestDatabricks$Outbound = {
+  provider: "databricks";
+  workspaceUrl: string;
+  clientId: string;
+  clientSecret: string;
+  acknowledgeAlienCredentialAccess: boolean;
+};
+
+/** @internal */
+export const PutExternalAIBindingRequestDatabricks$outboundSchema: z.ZodType<
+  PutExternalAIBindingRequestDatabricks$Outbound,
+  PutExternalAIBindingRequestDatabricks
+> = z.object({
+  provider: z.literal("databricks"),
+  workspaceUrl: z.string(),
+  clientId: z.string(),
+  clientSecret: z.string(),
+  acknowledgeAlienCredentialAccess: z.boolean(),
+});
+
+export function putExternalAIBindingRequestDatabricksToJSON(
+  putExternalAIBindingRequestDatabricks: PutExternalAIBindingRequestDatabricks,
+): string {
+  return JSON.stringify(
+    PutExternalAIBindingRequestDatabricks$outboundSchema.parse(
+      putExternalAIBindingRequestDatabricks,
+    ),
+  );
+}
+
+/** @internal */
+export const PutExternalAIBindingRequestProviderEnum$outboundSchema: z.ZodEnum<
+  typeof PutExternalAIBindingRequestProviderEnum
+> = z.enum(PutExternalAIBindingRequestProviderEnum);
+
+/** @internal */
+export type PutExternalAIBindingRequest$Outbound = {
+  provider: string;
+  apiKey: string;
+  acknowledgeAlienCredentialAccess: boolean;
+};
+
+/** @internal */
+export const PutExternalAIBindingRequest$outboundSchema: z.ZodType<
+  PutExternalAIBindingRequest$Outbound,
+  PutExternalAIBindingRequest
+> = z.object({
+  provider: PutExternalAIBindingRequestProviderEnum$outboundSchema,
+  apiKey: z.string(),
+  acknowledgeAlienCredentialAccess: z.boolean(),
+});
+
+export function putExternalAIBindingRequestToJSON(
+  putExternalAIBindingRequest: PutExternalAIBindingRequest,
+): string {
+  return JSON.stringify(
+    PutExternalAIBindingRequest$outboundSchema.parse(
+      putExternalAIBindingRequest,
+    ),
+  );
+}
+
+/** @internal */
+export type PutExternalAIBindingRequestUnion$Outbound =
+  | (PutExternalAIBindingRequest$Outbound & { provider: "anthropic" })
+  | (PutExternalAIBindingRequest$Outbound & { provider: "openai" })
+  | PutExternalAIBindingRequestDatabricks$Outbound;
+
+/** @internal */
+export const PutExternalAIBindingRequestUnion$outboundSchema: z.ZodType<
+  PutExternalAIBindingRequestUnion$Outbound,
+  PutExternalAIBindingRequestUnion
+> = z.union([
+  z.lazy(() => PutExternalAIBindingRequest$outboundSchema).and(
+    z.object({ provider: z.literal("anthropic") }),
+  ),
+  z.lazy(() => PutExternalAIBindingRequest$outboundSchema).and(
+    z.object({ provider: z.literal("openai") }),
+  ),
+  z.lazy(() => PutExternalAIBindingRequestDatabricks$outboundSchema),
+]);
+
+export function putExternalAIBindingRequestUnionToJSON(
+  putExternalAIBindingRequestUnion: PutExternalAIBindingRequestUnion,
+): string {
+  return JSON.stringify(
+    PutExternalAIBindingRequestUnion$outboundSchema.parse(
+      putExternalAIBindingRequestUnion,
+    ),
+  );
+}

package/src/models/release.ts

@@ -11,10 +11,16 @@ import {
   SetupFingerprintInfo,
   SetupFingerprintInfo$inboundSchema,
 } from "./setupfingerprintinfo.js";
-import {
-  StackByPlatform,
-  StackByPlatform$inboundSchema,
-} from "./stackbyplatform.js";
+
+export type ReleaseStack = {
+  aws?: any | null | undefined;
+  gcp?: any | null | undefined;
+  azure?: any | null | undefined;
+  kubernetes?: any | null | undefined;
+  machines?: any | null | undefined;
+  local?: any | null | undefined;
+  test?: any | null | undefined;
+};
 
 export type Release = {
   /**
@@ -25,12 +31,38 @@ export type Release = {
   version: string;
   gitMetadata?: GitMetadata | null | undefined;
   createdAt: Date;
-  stack?: StackByPlatform | null | undefined;
+  stack?: ReleaseStack | null | undefined;
   setupFingerprints: { [k: string]: SetupFingerprintInfo };
   rootDirectory?: string | null | undefined;
+  /**
+   * ID of the platform user who created the release, if known
+   */
+  createdByUserId?: string | null | undefined;
   workspaceId: string;
 };
 
+/** @internal */
+export const ReleaseStack$inboundSchema: z.ZodType<ReleaseStack, unknown> = z
+  .object({
+    aws: z.nullable(z.any()).optional(),
+    gcp: z.nullable(z.any()).optional(),
+    azure: z.nullable(z.any()).optional(),
+    kubernetes: z.nullable(z.any()).optional(),
+    machines: z.nullable(z.any()).optional(),
+    local: z.nullable(z.any()).optional(),
+    test: z.nullable(z.any()).optional(),
+  });
+
+export function releaseStackFromJSON(
+  jsonString: string,
+): SafeParseResult<ReleaseStack, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => ReleaseStack$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'ReleaseStack' from JSON`,
+  );
+}
+
 /** @internal */
 export const Release$inboundSchema: z.ZodType<Release, unknown> = z.object({
   id: z.string(),
@@ -38,9 +70,10 @@ export const Release$inboundSchema: z.ZodType<Release, unknown> = z.object({
   version: z.string(),
   gitMetadata: z.nullable(GitMetadata$inboundSchema).optional(),
   createdAt: z.iso.datetime({ offset: true }).transform(v => new Date(v)),
-  stack: z.nullable(StackByPlatform$inboundSchema).optional(),
+  stack: z.nullable(z.lazy(() => ReleaseStack$inboundSchema)).optional(),
   setupFingerprints: z.record(z.string(), SetupFingerprintInfo$inboundSchema),
   rootDirectory: z.nullable(z.string()).optional(),
+  createdByUserId: z.nullable(z.string()).optional(),
   workspaceId: z.string(),
 });
 

package/src/models/releasechannel.ts

@@ -0,0 +1,49 @@
+/*
+ * 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 { SDKValidationError } from "./errors/sdkvalidationerror.js";
+
+export type ReleaseChannel = {
+  /**
+   * Unique identifier for the workspace.
+   */
+  workspaceId: string;
+  /**
+   * Unique identifier for the project.
+   */
+  projectId: string;
+  name: string;
+  /**
+   * Unique identifier for the release.
+   */
+  currentReleaseId: string | null;
+  deploymentCount?: number | undefined;
+  createdAt: Date;
+  updatedAt: Date;
+};
+
+/** @internal */
+export const ReleaseChannel$inboundSchema: z.ZodType<ReleaseChannel, unknown> =
+  z.object({
+    workspaceId: z.string(),
+    projectId: z.string(),
+    name: z.string(),
+    currentReleaseId: z.nullable(z.string()),
+    deploymentCount: z.int().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 releaseChannelFromJSON(
+  jsonString: string,
+): SafeParseResult<ReleaseChannel, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => ReleaseChannel$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'ReleaseChannel' from JSON`,
+  );
+}