@alienplatform/platform-api 3.3.12 → 3.3.13

package/src/models/pinreleaserequest.ts

@@ -9,7 +9,7 @@ import * as z from "zod/v4";
  */
 export type PinReleaseRequest = {
   /**
-   * Release ID to pin the deployment to. Set to null to unpin and use active release.
+   * Release ID to pin the deployment to. Set to null to resume its followed channel.
    */
   releaseId?: string | null | undefined;
 };

package/src/models/prepareddeploymentstack.ts

@@ -1420,6 +1420,17 @@ export type PreparedDeploymentStackResources = {
    * The total dependencies are: resource.get_dependencies() + this list
    */
   dependencies: Array<PreparedDeploymentStackDependency>;
+  /**
+   * Id of the boolean stack input that decides whether this resource is
+   *
+   * @remarks
+   * created at all. `None` means always create it.
+   *
+   * Set by `.enabled(input)` in the SDK. Setup emitters render the resource
+   * conditionally on the matching template variable, so a deployer who says no
+   * never gets the resource, its outputs, or anything derived from it.
+   */
+  enabledWhen?: string | null | undefined;
   /**
    * Describes the lifecycle of a resource within a stack, determining how it's managed and deployed.
    */
@@ -3583,6 +3594,7 @@ export const PreparedDeploymentStackResources$inboundSchema: z.ZodType<
   dependencies: z.array(
     z.lazy(() => PreparedDeploymentStackDependency$inboundSchema),
   ),
+  enabledWhen: z.nullable(z.string()).optional(),
   lifecycle: PreparedDeploymentStackLifecycle$inboundSchema,
   remoteAccess: z.boolean().optional(),
 });

package/src/models/project.ts

@@ -266,6 +266,84 @@ export type ProjectDefaultManagers = {
   local?: string | null | undefined;
 };
 
+export type ProjectDeployments = {
+  enabled: boolean;
+};
+
+export type ProjectKeys = {
+  enabled: boolean;
+  applicationEncryption: boolean;
+};
+
+export const ProjectAllowedProvider = {
+  AwsBedrock: "aws-bedrock",
+  GcpVertex: "gcp-vertex",
+  AzureFoundry: "azure-foundry",
+  Anthropic: "anthropic",
+  Databricks: "databricks",
+  Openai: "openai",
+} as const;
+export type ProjectAllowedProvider = ClosedEnum<typeof ProjectAllowedProvider>;
+
+export const ProjectClientApi = {
+  OpenaiChat: "openai-chat",
+  OpenaiResponses: "openai-responses",
+  AnthropicMessages: "anthropic-messages",
+} as const;
+export type ProjectClientApi = ClosedEnum<typeof ProjectClientApi>;
+
+export type ProjectRequirement = {
+  publicModelId: string;
+  clientApis: Array<ProjectClientApi>;
+  required: boolean;
+};
+
+export type ProjectModels = {
+  enabled: boolean;
+  allowedProviders: Array<ProjectAllowedProvider>;
+  requirements: Array<ProjectRequirement>;
+};
+
+export const ProjectAccess = {
+  ReadWrite: "read-write",
+} as const;
+export type ProjectAccess = ClosedEnum<typeof ProjectAccess>;
+
+export type ProjectBuckets = {
+  enabled: boolean;
+  access: ProjectAccess;
+};
+
+export const ProjectCredentialPolicy = {
+  PullOnly: "pull-only",
+  PushAndPull: "push-and-pull",
+} as const;
+export type ProjectCredentialPolicy = ClosedEnum<
+  typeof ProjectCredentialPolicy
+>;
+
+export type ProjectRegistry = {
+  enabled: boolean;
+  repositories: Array<string>;
+  credentialPolicy: ProjectCredentialPolicy;
+};
+
+export type ProjectProjectCapabilitiesCapabilities = {
+  deployments?: ProjectDeployments | undefined;
+  keys?: ProjectKeys | undefined;
+  models?: ProjectModels | undefined;
+  buckets?: ProjectBuckets | undefined;
+  registry?: ProjectRegistry | undefined;
+};
+
+/**
+ * Capabilities this Project may offer through setup links.
+ */
+export type ProjectProjectCapabilities = {
+  schemaVersion: number;
+  capabilities: ProjectProjectCapabilitiesCapabilities;
+};
+
 export type Project = {
   /**
    * Unique identifier for the project.
@@ -302,6 +380,10 @@ export type Project = {
    * Project default private managers for new push deployments.
    */
   defaultManagers?: ProjectDefaultManagers | null | undefined;
+  /**
+   * Capabilities this Project may offer through setup links.
+   */
+  projectCapabilities?: ProjectProjectCapabilities | null | undefined;
   createdAt: Date;
   /**
    * Unique identifier for the workspace.
@@ -509,6 +591,179 @@ export function projectDefaultManagersFromJSON(
   );
 }
 
+/** @internal */
+export const ProjectDeployments$inboundSchema: z.ZodType<
+  ProjectDeployments,
+  unknown
+> = z.object({
+  enabled: z.boolean(),
+});
+
+export function projectDeploymentsFromJSON(
+  jsonString: string,
+): SafeParseResult<ProjectDeployments, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => ProjectDeployments$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'ProjectDeployments' from JSON`,
+  );
+}
+
+/** @internal */
+export const ProjectKeys$inboundSchema: z.ZodType<ProjectKeys, unknown> = z
+  .object({
+    enabled: z.boolean(),
+    applicationEncryption: z.boolean(),
+  });
+
+export function projectKeysFromJSON(
+  jsonString: string,
+): SafeParseResult<ProjectKeys, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => ProjectKeys$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'ProjectKeys' from JSON`,
+  );
+}
+
+/** @internal */
+export const ProjectAllowedProvider$inboundSchema: z.ZodEnum<
+  typeof ProjectAllowedProvider
+> = z.enum(ProjectAllowedProvider);
+
+/** @internal */
+export const ProjectClientApi$inboundSchema: z.ZodEnum<
+  typeof ProjectClientApi
+> = z.enum(ProjectClientApi);
+
+/** @internal */
+export const ProjectRequirement$inboundSchema: z.ZodType<
+  ProjectRequirement,
+  unknown
+> = z.object({
+  publicModelId: z.string(),
+  clientApis: z.array(ProjectClientApi$inboundSchema),
+  required: z.boolean(),
+});
+
+export function projectRequirementFromJSON(
+  jsonString: string,
+): SafeParseResult<ProjectRequirement, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => ProjectRequirement$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'ProjectRequirement' from JSON`,
+  );
+}
+
+/** @internal */
+export const ProjectModels$inboundSchema: z.ZodType<ProjectModels, unknown> = z
+  .object({
+    enabled: z.boolean(),
+    allowedProviders: z.array(ProjectAllowedProvider$inboundSchema),
+    requirements: z.array(z.lazy(() => ProjectRequirement$inboundSchema)),
+  });
+
+export function projectModelsFromJSON(
+  jsonString: string,
+): SafeParseResult<ProjectModels, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => ProjectModels$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'ProjectModels' from JSON`,
+  );
+}
+
+/** @internal */
+export const ProjectAccess$inboundSchema: z.ZodEnum<typeof ProjectAccess> = z
+  .enum(ProjectAccess);
+
+/** @internal */
+export const ProjectBuckets$inboundSchema: z.ZodType<ProjectBuckets, unknown> =
+  z.object({
+    enabled: z.boolean(),
+    access: ProjectAccess$inboundSchema,
+  });
+
+export function projectBucketsFromJSON(
+  jsonString: string,
+): SafeParseResult<ProjectBuckets, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => ProjectBuckets$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'ProjectBuckets' from JSON`,
+  );
+}
+
+/** @internal */
+export const ProjectCredentialPolicy$inboundSchema: z.ZodEnum<
+  typeof ProjectCredentialPolicy
+> = z.enum(ProjectCredentialPolicy);
+
+/** @internal */
+export const ProjectRegistry$inboundSchema: z.ZodType<
+  ProjectRegistry,
+  unknown
+> = z.object({
+  enabled: z.boolean(),
+  repositories: z.array(z.string()),
+  credentialPolicy: ProjectCredentialPolicy$inboundSchema,
+});
+
+export function projectRegistryFromJSON(
+  jsonString: string,
+): SafeParseResult<ProjectRegistry, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => ProjectRegistry$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'ProjectRegistry' from JSON`,
+  );
+}
+
+/** @internal */
+export const ProjectProjectCapabilitiesCapabilities$inboundSchema: z.ZodType<
+  ProjectProjectCapabilitiesCapabilities,
+  unknown
+> = z.object({
+  deployments: z.lazy(() => ProjectDeployments$inboundSchema).optional(),
+  keys: z.lazy(() => ProjectKeys$inboundSchema).optional(),
+  models: z.lazy(() => ProjectModels$inboundSchema).optional(),
+  buckets: z.lazy(() => ProjectBuckets$inboundSchema).optional(),
+  registry: z.lazy(() => ProjectRegistry$inboundSchema).optional(),
+});
+
+export function projectProjectCapabilitiesCapabilitiesFromJSON(
+  jsonString: string,
+): SafeParseResult<ProjectProjectCapabilitiesCapabilities, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) =>
+      ProjectProjectCapabilitiesCapabilities$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'ProjectProjectCapabilitiesCapabilities' from JSON`,
+  );
+}
+
+/** @internal */
+export const ProjectProjectCapabilities$inboundSchema: z.ZodType<
+  ProjectProjectCapabilities,
+  unknown
+> = z.object({
+  schemaVersion: z.number(),
+  capabilities: z.lazy(() =>
+    ProjectProjectCapabilitiesCapabilities$inboundSchema
+  ),
+});
+
+export function projectProjectCapabilitiesFromJSON(
+  jsonString: string,
+): SafeParseResult<ProjectProjectCapabilities, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => ProjectProjectCapabilities$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'ProjectProjectCapabilities' from JSON`,
+  );
+}
+
 /** @internal */
 export const Project$inboundSchema: z.ZodType<Project, unknown> = z.object({
   id: z.string(),
@@ -525,6 +780,9 @@ export const Project$inboundSchema: z.ZodType<Project, unknown> = z.object({
   defaultManagers: z.nullable(
     z.lazy(() => ProjectDefaultManagers$inboundSchema),
   ).optional(),
+  projectCapabilities: z.nullable(
+    z.lazy(() => ProjectProjectCapabilities$inboundSchema),
+  ).optional(),
   createdAt: z.iso.datetime({ offset: true }).transform(v => new Date(v)),
   workspaceId: z.string(),
 });

package/src/models/projectcapabilities.ts

@@ -0,0 +1,270 @@
+/*
+ * 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";
+
+export type ProjectCapabilitiesDeployments = {
+  enabled: boolean;
+};
+
+export type ProjectCapabilitiesKeys = {
+  enabled: boolean;
+  applicationEncryption: boolean;
+};
+
+export const ProjectCapabilitiesAllowedProvider = {
+  AwsBedrock: "aws-bedrock",
+  GcpVertex: "gcp-vertex",
+  AzureFoundry: "azure-foundry",
+  Anthropic: "anthropic",
+  Databricks: "databricks",
+  Openai: "openai",
+} as const;
+export type ProjectCapabilitiesAllowedProvider = ClosedEnum<
+  typeof ProjectCapabilitiesAllowedProvider
+>;
+
+export const ProjectCapabilitiesClientApi = {
+  OpenaiChat: "openai-chat",
+  OpenaiResponses: "openai-responses",
+  AnthropicMessages: "anthropic-messages",
+} as const;
+export type ProjectCapabilitiesClientApi = ClosedEnum<
+  typeof ProjectCapabilitiesClientApi
+>;
+
+export type ProjectCapabilitiesRequirement = {
+  publicModelId: string;
+  clientApis: Array<ProjectCapabilitiesClientApi>;
+  required: boolean;
+};
+
+export type ProjectCapabilitiesModels = {
+  enabled: boolean;
+  allowedProviders: Array<ProjectCapabilitiesAllowedProvider>;
+  requirements: Array<ProjectCapabilitiesRequirement>;
+};
+
+export const ProjectCapabilitiesAccess = {
+  ReadWrite: "read-write",
+} as const;
+export type ProjectCapabilitiesAccess = ClosedEnum<
+  typeof ProjectCapabilitiesAccess
+>;
+
+export type ProjectCapabilitiesBuckets = {
+  enabled: boolean;
+  access: ProjectCapabilitiesAccess;
+};
+
+export const ProjectCapabilitiesCredentialPolicy = {
+  PullOnly: "pull-only",
+  PushAndPull: "push-and-pull",
+} as const;
+export type ProjectCapabilitiesCredentialPolicy = ClosedEnum<
+  typeof ProjectCapabilitiesCredentialPolicy
+>;
+
+export type ProjectCapabilitiesRegistry = {
+  enabled: boolean;
+  repositories: Array<string>;
+  credentialPolicy: ProjectCapabilitiesCredentialPolicy;
+};
+
+export type ProjectCapabilitiesCapabilities = {
+  deployments?: ProjectCapabilitiesDeployments | undefined;
+  keys?: ProjectCapabilitiesKeys | undefined;
+  models?: ProjectCapabilitiesModels | undefined;
+  buckets?: ProjectCapabilitiesBuckets | undefined;
+  registry?: ProjectCapabilitiesRegistry | undefined;
+};
+
+export type ProjectCapabilities = {
+  schemaVersion: number;
+  capabilities: ProjectCapabilitiesCapabilities;
+};
+
+/** @internal */
+export const ProjectCapabilitiesDeployments$inboundSchema: z.ZodType<
+  ProjectCapabilitiesDeployments,
+  unknown
+> = z.object({
+  enabled: z.boolean(),
+});
+
+export function projectCapabilitiesDeploymentsFromJSON(
+  jsonString: string,
+): SafeParseResult<ProjectCapabilitiesDeployments, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => ProjectCapabilitiesDeployments$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'ProjectCapabilitiesDeployments' from JSON`,
+  );
+}
+
+/** @internal */
+export const ProjectCapabilitiesKeys$inboundSchema: z.ZodType<
+  ProjectCapabilitiesKeys,
+  unknown
+> = z.object({
+  enabled: z.boolean(),
+  applicationEncryption: z.boolean(),
+});
+
+export function projectCapabilitiesKeysFromJSON(
+  jsonString: string,
+): SafeParseResult<ProjectCapabilitiesKeys, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => ProjectCapabilitiesKeys$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'ProjectCapabilitiesKeys' from JSON`,
+  );
+}
+
+/** @internal */
+export const ProjectCapabilitiesAllowedProvider$inboundSchema: z.ZodEnum<
+  typeof ProjectCapabilitiesAllowedProvider
+> = z.enum(ProjectCapabilitiesAllowedProvider);
+
+/** @internal */
+export const ProjectCapabilitiesClientApi$inboundSchema: z.ZodEnum<
+  typeof ProjectCapabilitiesClientApi
+> = z.enum(ProjectCapabilitiesClientApi);
+
+/** @internal */
+export const ProjectCapabilitiesRequirement$inboundSchema: z.ZodType<
+  ProjectCapabilitiesRequirement,
+  unknown
+> = z.object({
+  publicModelId: z.string(),
+  clientApis: z.array(ProjectCapabilitiesClientApi$inboundSchema),
+  required: z.boolean(),
+});
+
+export function projectCapabilitiesRequirementFromJSON(
+  jsonString: string,
+): SafeParseResult<ProjectCapabilitiesRequirement, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => ProjectCapabilitiesRequirement$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'ProjectCapabilitiesRequirement' from JSON`,
+  );
+}
+
+/** @internal */
+export const ProjectCapabilitiesModels$inboundSchema: z.ZodType<
+  ProjectCapabilitiesModels,
+  unknown
+> = z.object({
+  enabled: z.boolean(),
+  allowedProviders: z.array(ProjectCapabilitiesAllowedProvider$inboundSchema),
+  requirements: z.array(
+    z.lazy(() => ProjectCapabilitiesRequirement$inboundSchema),
+  ),
+});
+
+export function projectCapabilitiesModelsFromJSON(
+  jsonString: string,
+): SafeParseResult<ProjectCapabilitiesModels, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => ProjectCapabilitiesModels$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'ProjectCapabilitiesModels' from JSON`,
+  );
+}
+
+/** @internal */
+export const ProjectCapabilitiesAccess$inboundSchema: z.ZodEnum<
+  typeof ProjectCapabilitiesAccess
+> = z.enum(ProjectCapabilitiesAccess);
+
+/** @internal */
+export const ProjectCapabilitiesBuckets$inboundSchema: z.ZodType<
+  ProjectCapabilitiesBuckets,
+  unknown
+> = z.object({
+  enabled: z.boolean(),
+  access: ProjectCapabilitiesAccess$inboundSchema,
+});
+
+export function projectCapabilitiesBucketsFromJSON(
+  jsonString: string,
+): SafeParseResult<ProjectCapabilitiesBuckets, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => ProjectCapabilitiesBuckets$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'ProjectCapabilitiesBuckets' from JSON`,
+  );
+}
+
+/** @internal */
+export const ProjectCapabilitiesCredentialPolicy$inboundSchema: z.ZodEnum<
+  typeof ProjectCapabilitiesCredentialPolicy
+> = z.enum(ProjectCapabilitiesCredentialPolicy);
+
+/** @internal */
+export const ProjectCapabilitiesRegistry$inboundSchema: z.ZodType<
+  ProjectCapabilitiesRegistry,
+  unknown
+> = z.object({
+  enabled: z.boolean(),
+  repositories: z.array(z.string()),
+  credentialPolicy: ProjectCapabilitiesCredentialPolicy$inboundSchema,
+});
+
+export function projectCapabilitiesRegistryFromJSON(
+  jsonString: string,
+): SafeParseResult<ProjectCapabilitiesRegistry, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => ProjectCapabilitiesRegistry$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'ProjectCapabilitiesRegistry' from JSON`,
+  );
+}
+
+/** @internal */
+export const ProjectCapabilitiesCapabilities$inboundSchema: z.ZodType<
+  ProjectCapabilitiesCapabilities,
+  unknown
+> = z.object({
+  deployments: z.lazy(() => ProjectCapabilitiesDeployments$inboundSchema)
+    .optional(),
+  keys: z.lazy(() => ProjectCapabilitiesKeys$inboundSchema).optional(),
+  models: z.lazy(() => ProjectCapabilitiesModels$inboundSchema).optional(),
+  buckets: z.lazy(() => ProjectCapabilitiesBuckets$inboundSchema).optional(),
+  registry: z.lazy(() => ProjectCapabilitiesRegistry$inboundSchema).optional(),
+});
+
+export function projectCapabilitiesCapabilitiesFromJSON(
+  jsonString: string,
+): SafeParseResult<ProjectCapabilitiesCapabilities, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => ProjectCapabilitiesCapabilities$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'ProjectCapabilitiesCapabilities' from JSON`,
+  );
+}
+
+/** @internal */
+export const ProjectCapabilities$inboundSchema: z.ZodType<
+  ProjectCapabilities,
+  unknown
+> = z.object({
+  schemaVersion: z.number(),
+  capabilities: z.lazy(() => ProjectCapabilitiesCapabilities$inboundSchema),
+});
+
+export function projectCapabilitiesFromJSON(
+  jsonString: string,
+): SafeParseResult<ProjectCapabilities, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => ProjectCapabilities$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'ProjectCapabilities' from JSON`,
+  );
+}