@alienplatform/core 1.7.1 → 1.9.0

package/src/generated/zod/stack-input-definition-schema.ts

@@ -0,0 +1,43 @@
+/**
+* Generated by Kubb (https://kubb.dev/).
+* Do not edit manually.
+*/
+
+import * as z from "zod";
+import { PlatformSchema } from "./platform-schema.js";
+import { StackInputDefaultValueSchema } from "./stack-input-default-value-schema.js";
+import { StackInputEnvironmentMappingSchema } from "./stack-input-environment-mapping-schema.js";
+import { StackInputKindSchema } from "./stack-input-kind-schema.js";
+import { StackInputProviderSchema } from "./stack-input-provider-schema.js";
+import { StackInputValidationSchema } from "./stack-input-validation-schema.js";
+
+/**
+ * @description Stack input definition serialized into a release stack.
+ */
+export const StackInputDefinitionSchema = z.object({
+    get "default"(){
+                return z.union([StackInputDefaultValueSchema, z.null()]).optional()
+              },
+"description": z.string().describe("Human-facing helper text."),
+get "env"(){
+                return z.array(StackInputEnvironmentMappingSchema.describe("How a resolved stack input is injected into runtime environment variables.")).describe("Runtime env-var mappings for v1 input resolution.").optional()
+              },
+"id": z.string().describe("Stable input ID used by CLI/API calls."),
+get "kind"(){
+                return StackInputKindSchema.describe("Primitive stack input kind.")
+              },
+"label": z.string().describe("Human-facing field label."),
+"placeholder": z.string().describe("Example placeholder shown in UI.").nullish(),
+get "platforms"(){
+                return z.array(PlatformSchema.describe("Represents the target cloud platform.")).describe("Platforms where this input applies.").nullish()
+              },
+get "providedBy"(){
+                return z.array(StackInputProviderSchema.describe("Who can provide a stack input value.")).describe("Who can provide this value.")
+              },
+"required": z.boolean().describe("Whether a resolved value is required before deployment can proceed."),
+get "validation"(){
+                return z.union([StackInputValidationSchema, z.null()]).optional()
+              }
+    }).describe("Stack input definition serialized into a release stack.")
+
+export type StackInputDefinition = z.infer<typeof StackInputDefinitionSchema>

package/src/generated/zod/stack-input-environment-mapping-schema.ts

@@ -0,0 +1,20 @@
+/**
+* Generated by Kubb (https://kubb.dev/).
+* Do not edit manually.
+*/
+
+import * as z from "zod";
+import { StackInputEnvironmentVariableTypeSchema } from "./stack-input-environment-variable-type-schema.js";
+
+/**
+ * @description How a resolved stack input is injected into runtime environment variables.
+ */
+export const StackInputEnvironmentMappingSchema = z.object({
+    "name": z.string().describe("Environment variable name."),
+"targetResources": z.array(z.string()).describe("Target resource IDs or patterns. None means every env-capable resource.").nullish(),
+get "type"(){
+                return z.union([StackInputEnvironmentVariableTypeSchema, z.null()]).optional()
+              }
+    }).describe("How a resolved stack input is injected into runtime environment variables.")
+
+export type StackInputEnvironmentMapping = z.infer<typeof StackInputEnvironmentMappingSchema>

package/src/generated/zod/stack-input-environment-variable-type-schema.ts

@@ -0,0 +1,13 @@
+/**
+* Generated by Kubb (https://kubb.dev/).
+* Do not edit manually.
+*/
+
+import * as z from "zod";
+
+/**
+ * @description Environment variable handling for a stack input mapping.
+ */
+export const StackInputEnvironmentVariableTypeSchema = z.enum(["plain", "secret"]).describe("Environment variable handling for a stack input mapping.")
+
+export type StackInputEnvironmentVariableType = z.infer<typeof StackInputEnvironmentVariableTypeSchema>

package/src/generated/zod/stack-input-kind-schema.ts

@@ -0,0 +1,13 @@
+/**
+* Generated by Kubb (https://kubb.dev/).
+* Do not edit manually.
+*/
+
+import * as z from "zod";
+
+/**
+ * @description Primitive stack input kind.
+ */
+export const StackInputKindSchema = z.enum(["string", "secret", "number", "integer", "boolean", "enum", "stringList"]).describe("Primitive stack input kind.")
+
+export type StackInputKind = z.infer<typeof StackInputKindSchema>

package/src/generated/zod/stack-input-provider-schema.ts

@@ -0,0 +1,13 @@
+/**
+* Generated by Kubb (https://kubb.dev/).
+* Do not edit manually.
+*/
+
+import * as z from "zod";
+
+/**
+ * @description Who can provide a stack input value.
+ */
+export const StackInputProviderSchema = z.enum(["developer", "deployer"]).describe("Who can provide a stack input value.")
+
+export type StackInputProvider = z.infer<typeof StackInputProviderSchema>

package/src/generated/zod/stack-input-validation-schema.ts

@@ -0,0 +1,23 @@
+/**
+* Generated by Kubb (https://kubb.dev/).
+* Do not edit manually.
+*/
+
+import * as z from "zod";
+
+/**
+ * @description Portable stack input validation constraints.
+ */
+export const StackInputValidationSchema = z.object({
+    "format": z.string().describe("Semantic format hint such as url.").nullish(),
+"max": z.string().describe("Maximum number.").nullish(),
+"maxItems": z.int().min(0).describe("Maximum string-list items.").nullish(),
+"maxLength": z.int().min(0).describe("Maximum string length.").nullish(),
+"min": z.string().describe("Minimum number.").nullish(),
+"minItems": z.int().min(0).describe("Minimum string-list items.").nullish(),
+"minLength": z.int().min(0).describe("Minimum string length.").nullish(),
+"pattern": z.string().describe("Portable whole-value regex pattern.").nullish(),
+"values": z.array(z.string()).describe("Allowed string enum values.").nullish()
+    }).describe("Portable stack input validation constraints.")
+
+export type StackInputValidation = z.infer<typeof StackInputValidationSchema>

package/src/generated/zod/stack-schema.ts

@@ -7,12 +7,16 @@ import * as z from "zod";
 import { PermissionsConfigSchema } from "./permissions-config-schema.js";
 import { PlatformSchema } from "./platform-schema.js";
 import { ResourceEntrySchema } from "./resource-entry-schema.js";
+import { StackInputDefinitionSchema } from "./stack-input-definition-schema.js";
 
 /**
  * @description A bag of resources, unaware of any cloud.
  */
 export const StackSchema = z.object({
     "id": z.string().describe("Unique identifier for the stack"),
+get "inputs"(){
+                return z.array(StackInputDefinitionSchema.describe("Stack input definition serialized into a release stack.")).describe("Input definitions required before setup or deployment can proceed.").optional()
+              },
 get "permissions"(){
                 return PermissionsConfigSchema.describe("Combined permissions configuration that contains both profiles and management").optional()
               },

package/src/generated/zod/stack-settings-schema.ts

@@ -4,6 +4,7 @@
 */
 
 import * as z from "zod";
+import { ComputeSettingsSchema } from "./compute-settings-schema.js";
 import { DeploymentModelSchema } from "./deployment-model-schema.js";
 import { DomainSettingsSchema } from "./domain-settings-schema.js";
 import { HeartbeatsModeSchema } from "./heartbeats-mode-schema.js";
@@ -16,7 +17,10 @@ import { UpdatesModeSchema } from "./updates-mode-schema.js";
  * @description User-customizable deployment settings specified at deploy time.\n\nThese settings are provided by the customer via CloudFormation parameters,\nTerraform attributes, CLI flags, or Helm values. They customize how the\ndeployment runs and what capabilities are enabled.\n\n**Key distinction**: StackSettings is user-customizable, while ManagementConfig\nis platform-derived (from the Manager\'s ServiceAccount).
  */
 export const StackSettingsSchema = z.object({
-    get "deploymentModel"(){
+    get "compute"(){
+                return z.union([ComputeSettingsSchema, z.null()]).optional()
+              },
+get "deploymentModel"(){
                 return DeploymentModelSchema.describe("Deployment model: how updates are delivered to the remote environment.").optional()
               },
 get "domains"(){

package/src/generated/zod/worker-outputs-schema.ts

@@ -4,7 +4,7 @@
 */
 
 import * as z from "zod";
-import { LoadBalancerEndpointSchema } from "./load-balancer-endpoint-schema.js";
+import { PublicEndpointOutputSchema } from "./public-endpoint-output-schema.js";
 
 /**
  * @description Outputs generated by a successfully provisioned Worker.
@@ -12,10 +12,9 @@ import { LoadBalancerEndpointSchema } from "./load-balancer-endpoint-schema.js";
 export const WorkerOutputsSchema = z.object({
     "commandsPushTarget": z.string().describe("Push target for commands delivery. Platform-specific:\n- AWS: Lambda function name or ARN\n- GCP: Full Pub/Sub topic path (projects/{project}/topics/{topic})\n- Azure: Service Bus \"{namespace}/{queue}\"").nullish(),
 "identifier": z.string().describe("The ARN or platform-specific identifier.").nullish(),
-get "loadBalancerEndpoint"(){
-                return z.union([LoadBalancerEndpointSchema, z.null()]).optional()
-              },
-"url": z.string().describe("The invocation URL (if applicable, e.g., for public ingress or specific platforms).").nullish(),
+"publicEndpoints": z.optional(z.object({
+    
+    }).catchall(z.lazy(() => PublicEndpointOutputSchema).describe("Runtime-resolved public endpoint metadata.")).describe("Public endpoints resolved for this worker.")),
 "workerName": z.string().describe("The platform-specific worker name.")
     }).describe("Outputs generated by a successfully provisioned Worker.")
 

package/src/generated/zod/worker-public-endpoint-schema.ts

@@ -0,0 +1,17 @@
+/**
+* Generated by Kubb (https://kubb.dev/).
+* Do not edit manually.
+*/
+
+import * as z from "zod";
+
+/**
+ * @description Public endpoint configuration for Worker resources.
+ */
+export const WorkerPublicEndpointSchema = z.object({
+    "hostLabel": z.string().describe("Optional DNS label override for generated endpoint hostnames.").nullish(),
+"name": z.string().describe("Endpoint name within the resource."),
+"wildcardSubdomains": z.optional(z.boolean().describe("Whether to route wildcard subdomains to this endpoint."))
+    }).describe("Public endpoint configuration for Worker resources.")
+
+export type WorkerPublicEndpoint = z.infer<typeof WorkerPublicEndpointSchema>

package/src/generated/zod/worker-schema.ts

@@ -4,10 +4,10 @@
 */
 
 import * as z from "zod";
-import { IngressSchema } from "./ingress-schema.js";
 import { ReadinessProbeSchema } from "./readiness-probe-schema.js";
 import { ResourceRefSchema } from "./resource-ref-schema.js";
 import { WorkerCodeSchema } from "./worker-code-schema.js";
+import { WorkerPublicEndpointSchema } from "./worker-public-endpoint-schema.js";
 import { WorkerTriggerSchema } from "./worker-trigger-schema.js";
 
 /**
@@ -23,14 +23,14 @@ export const WorkerSchema = z.object({
     
     }).catchall(z.string()).describe("Key-value pairs to set as environment variables for the worker.")),
 "id": z.string().describe("Identifier for the worker. Must contain only alphanumeric characters, hyphens, and underscores ([A-Za-z0-9-_]).\nMaximum 64 characters."),
-get "ingress"(){
-                return IngressSchema.default("private").optional()
-              },
 get "links"(){
                 return z.array(ResourceRefSchema.describe("New ResourceRef that works with any resource type.\nThis can eventually replace the enum-based ResourceRef for full extensibility.")).describe("List of resource references this worker depends on.")
               },
 "memoryMb": z.optional(z.int().min(0).default(256).describe("Memory allocated to the worker in megabytes (MB).\nDefault: 256\n\nPlatform-specific constraints:\n- **AWS Lambda**: 128–10240 MB in 1 MB increments\n- **GCP Cloud Run**: 128–32768 MB\n- **Azure Container Apps**: fixed CPU/memory pairs — 512, 1024, 1536, 2048, 2560,\n  3072, 3584, 4096 MB. Values below 512 are automatically rounded up at deploy time.")),
 "permissions": z.string().describe("Permission profile name that defines the permissions granted to this worker.\nThis references a profile defined in the stack's permission definitions."),
+get "publicEndpoints"(){
+                return z.array(WorkerPublicEndpointSchema.describe("Public endpoint configuration for Worker resources.")).describe("Public endpoints exposed by this worker.")
+              },
 get "readinessProbe"(){
                 return z.union([ReadinessProbeSchema, z.null()]).optional()
               },

package/src/index.ts

@@ -2,6 +2,7 @@ export * from "./resource.js"
 export * from "./storage.js"
 export * from "./worker.js"
 export * from "./container.js"
+export * from "./compute-cluster.js"
 export * from "./daemon.js"
 export * from "./build.js"
 export * from "./artifact-registry.js"
@@ -10,6 +11,7 @@ export * from "./kv.js"
 export * from "./queue.js"
 export * from "./service-account.js"
 export * from "./stack.js"
+export * from "./input.js"
 export * from "./get-resource-outputs.js"
 export * from "./error.js"
 export * from "./common-errors.js"
@@ -177,6 +179,13 @@ export {
   ResourceLifecycleSchema,
   ResourceRefSchema,
   StackStateSchema,
+  StackInputDefaultValueSchema,
+  StackInputDefinitionSchema,
+  StackInputEnvironmentMappingSchema,
+  StackInputEnvironmentVariableTypeSchema,
+  StackInputKindSchema,
+  StackInputProviderSchema,
+  StackInputValidationSchema,
   AwsArtifactRegistryImportDataSchema,
   AwsBuildImportDataSchema,
   AwsComputeClusterImportDataSchema,

package/src/input.ts

@@ -0,0 +1,380 @@
+import type {
+  Platform,
+  StackInputDefaultValue,
+  StackInputDefinition,
+  StackInputEnvironmentMapping,
+  StackInputEnvironmentVariableType,
+  StackInputKind,
+  StackInputProvider,
+  StackInputValidation,
+} from "./generated/index.js"
+
+const stackInputDraftSymbol = Symbol("alien.stackInputDraft")
+const stackInputDefinitionsSymbol = Symbol("alien.stackInputDefinitions")
+
+export type StackInputValue = string | number | boolean | string[]
+
+type OneOrMany<T> = T | readonly T[]
+
+export type StackInputEnvMapping =
+  | string
+  | {
+      name: string
+      targetResources?: readonly string[]
+      type?: StackInputEnvironmentVariableType
+    }
+
+interface CommonInputOptions<TDefault extends StackInputValue> {
+  providedBy: OneOrMany<StackInputProvider>
+  required: boolean
+  label: string
+  description: string
+  placeholder?: string
+  default?: TDefault
+  platforms?: readonly Platform[]
+  env?: OneOrMany<StackInputEnvMapping>
+}
+
+export interface StringInputOptions extends CommonInputOptions<string> {
+  minLength?: number
+  maxLength?: number
+  pattern?: string
+  format?: string
+}
+
+export interface SecretInputOptions extends Omit<CommonInputOptions<string>, "default"> {
+  minLength?: number
+  maxLength?: number
+  pattern?: string
+  format?: string
+}
+
+export interface NumberInputOptions extends CommonInputOptions<number> {
+  min?: number
+  max?: number
+}
+
+export interface IntegerInputOptions extends CommonInputOptions<number> {
+  min?: number
+  max?: number
+}
+
+export interface BooleanInputOptions extends CommonInputOptions<boolean> {}
+
+export interface EnumInputOptions extends CommonInputOptions<string> {
+  placeholder?: string
+}
+
+export interface StringListInputOptions extends CommonInputOptions<string[]> {
+  minItems?: number
+  maxItems?: number
+}
+
+export interface StackInputRef<TValue extends StackInputValue = StackInputValue> {
+  readonly id: string
+  readonly kind: StackInputKind
+  readonly __value?: TValue
+}
+
+export type StackInputCollection = {
+  readonly [stackInputDefinitionsSymbol]: readonly StackInputDefinition[]
+}
+
+interface StackInputDraft<TValue extends StackInputValue = StackInputValue> {
+  readonly [stackInputDraftSymbol]: true
+  readonly kind: StackInputKind
+  readonly options: CommonInputOptions<TValue>
+  readonly validation: StackInputValidation
+}
+
+export type StackInputSet<T extends Record<string, StackInputDraft>> = {
+  readonly [K in keyof T]: T[K] extends StackInputDraft<infer TValue>
+    ? StackInputRef<TValue>
+    : never
+} & StackInputCollection
+
+export function inputs<const T extends Record<string, StackInputDraft>>(
+  drafts: T,
+): StackInputSet<T> {
+  const result = {} as Record<string, StackInputRef>
+  const definitions: StackInputDefinition[] = []
+
+  for (const [id, draft] of Object.entries(drafts)) {
+    validateInputId(id)
+    validateDraft(id, draft)
+
+    result[id] = { id, kind: draft.kind }
+    definitions.push({
+      id,
+      kind: draft.kind,
+      providedBy: normalizeArray(draft.options.providedBy),
+      required: draft.options.required,
+      label: draft.options.label,
+      description: draft.options.description,
+      placeholder: draft.options.placeholder,
+      default: toDefaultValue(draft.kind, draft.options.default),
+      platforms: draft.options.platforms ? [...draft.options.platforms] : undefined,
+      validation: Object.keys(draft.validation).length > 0 ? draft.validation : undefined,
+      env: normalizeEnv(draft.options.env),
+    })
+  }
+
+  Object.defineProperty(result, stackInputDefinitionsSymbol, {
+    value: Object.freeze(definitions),
+    enumerable: false,
+  })
+
+  return result as StackInputSet<T>
+}
+
+export function getStackInputDefinitions(
+  value: StackInputCollection | readonly StackInputDefinition[],
+): StackInputDefinition[] {
+  if (Array.isArray(value)) {
+    return [...(value as readonly StackInputDefinition[])]
+  }
+
+  return [...(value as StackInputCollection)[stackInputDefinitionsSymbol]]
+}
+
+function defineInput<TValue extends StackInputValue>(
+  kind: StackInputKind,
+  options: CommonInputOptions<TValue>,
+  validation: StackInputValidation = {},
+): StackInputDraft<TValue> {
+  return {
+    [stackInputDraftSymbol]: true,
+    kind,
+    options,
+    validation,
+  }
+}
+
+function defineStringInput(options: StringInputOptions): StackInputDraft<string> {
+  return defineInput("string", options, {
+    minLength: options.minLength,
+    maxLength: options.maxLength,
+    pattern: options.pattern,
+    format: options.format,
+  })
+}
+
+function defineSecretInput(options: SecretInputOptions): StackInputDraft<string> {
+  return defineInput("secret", options, {
+    minLength: options.minLength,
+    maxLength: options.maxLength,
+    pattern: options.pattern,
+    format: options.format,
+  })
+}
+
+function defineNumberInput(options: NumberInputOptions): StackInputDraft<number> {
+  return defineInput("number", options, {
+    min: numberToString(options.min),
+    max: numberToString(options.max),
+  })
+}
+
+function defineIntegerInput(options: IntegerInputOptions): StackInputDraft<number> {
+  return defineInput("integer", options, {
+    min: integerToString(options.min, "min"),
+    max: integerToString(options.max, "max"),
+  })
+}
+
+function defineBooleanInput(options: BooleanInputOptions): StackInputDraft<boolean> {
+  return defineInput("boolean", options)
+}
+
+function defineEnumInput<const TValues extends readonly [string, ...string[]]>(
+  values: TValues,
+  options: EnumInputOptions,
+): StackInputDraft<TValues[number]> {
+  return defineInput("enum", options, {
+    values: [...values],
+  }) as StackInputDraft<TValues[number]>
+}
+
+function defineStringListInput(options: StringListInputOptions): StackInputDraft<string[]> {
+  return defineInput("stringList", options, {
+    minItems: options.minItems,
+    maxItems: options.maxItems,
+  })
+}
+
+function normalizeArray<T>(value: OneOrMany<T>): T[] {
+  return Array.isArray(value) ? [...(value as readonly T[])] : [value as T]
+}
+
+function normalizeEnv(
+  value: OneOrMany<StackInputEnvMapping> | undefined,
+): StackInputEnvironmentMapping[] {
+  if (!value) {
+    return []
+  }
+
+  return normalizeArray(value).map(mapping => {
+    if (typeof mapping === "string") {
+      return { name: mapping }
+    }
+
+    return {
+      name: mapping.name,
+      targetResources: mapping.targetResources ? [...mapping.targetResources] : undefined,
+      type: mapping.type,
+    }
+  })
+}
+
+function toDefaultValue(
+  kind: StackInputKind,
+  value: StackInputValue | undefined,
+): StackInputDefaultValue | undefined {
+  if (value === undefined) {
+    return undefined
+  }
+
+  switch (kind) {
+    case "string":
+    case "enum":
+      return { type: "string", value: String(value) }
+    case "number":
+      return { type: "number", value: numberToString(value as number) ?? "" }
+    case "integer":
+      return { type: "number", value: integerToString(value as number, "default") ?? "" }
+    case "boolean":
+      return { type: "boolean", value: Boolean(value) }
+    case "stringList":
+      return { type: "stringList", value: [...(value as string[])] }
+    case "secret":
+      throw new Error("Secret stack inputs cannot declare a default value")
+  }
+}
+
+function validateDraft(id: string, draft: StackInputDraft): void {
+  if (!draft || draft[stackInputDraftSymbol] !== true) {
+    throw new Error(
+      `Stack input '${id}' must be created with alien.string(), alien.secret(), or another input helper`,
+    )
+  }
+
+  if (normalizeArray(draft.options.providedBy).length === 0) {
+    throw new Error(`Stack input '${id}' must include at least one providedBy value`)
+  }
+
+  if (!draft.options.label.trim()) {
+    throw new Error(`Stack input '${id}' must include a label`)
+  }
+
+  if (draft.options.required && !draft.options.description.trim()) {
+    throw new Error(`Stack input '${id}' must include a description when required is true`)
+  }
+
+  validateValidation(id, draft.kind, draft.validation)
+
+  for (const mapping of normalizeEnv(draft.options.env)) {
+    validateEnvName(id, mapping.name)
+    if (mapping.targetResources?.length === 0) {
+      throw new Error(
+        `Stack input '${id}' env mapping '${mapping.name}' cannot use an empty targetResources list`,
+      )
+    }
+  }
+}
+
+function validateInputId(id: string): void {
+  if (!/^[A-Za-z_][A-Za-z0-9_]*$/.test(id)) {
+    throw new Error(
+      `Stack input '${id}' id must start with a letter or underscore and contain only letters, digits, and underscores`,
+    )
+  }
+
+  if (!/[a-z]/.test(id)) {
+    throw new Error(`Stack input '${id}' id must not be all-caps env-var style`)
+  }
+}
+
+function validateEnvName(id: string, name: string): void {
+  if (!/^[A-Z_][A-Z0-9_]*$/.test(name)) {
+    throw new Error(
+      `Stack input '${id}' env name '${name}' must use uppercase letters, digits, and underscores`,
+    )
+  }
+}
+
+function validateValidation(
+  id: string,
+  kind: StackInputKind,
+  validation: StackInputValidation,
+): void {
+  const minLength = validation.minLength ?? undefined
+  const maxLength = validation.maxLength ?? undefined
+  const minItems = validation.minItems ?? undefined
+  const maxItems = validation.maxItems ?? undefined
+
+  if (minLength !== undefined && maxLength !== undefined && minLength > maxLength) {
+    throw new Error(`Stack input '${id}' minLength must be less than or equal to maxLength`)
+  }
+
+  if (minItems !== undefined && maxItems !== undefined && minItems > maxItems) {
+    throw new Error(`Stack input '${id}' minItems must be less than or equal to maxItems`)
+  }
+
+  if (kind === "enum" && (!validation.values || validation.values.length === 0)) {
+    throw new Error(`Stack input '${id}' enum values must not be empty`)
+  }
+
+  if (validation.pattern) {
+    validatePortablePattern(id, validation.pattern)
+  }
+}
+
+function validatePortablePattern(id: string, pattern: string): void {
+  if (pattern.length === 0) {
+    throw new Error(`Stack input '${id}' pattern must not be empty`)
+  }
+
+  if (pattern.startsWith("/") && pattern.endsWith("/") && pattern.length > 1) {
+    throw new Error(`Stack input '${id}' pattern must not use regex delimiters`)
+  }
+
+  if (/\\[1-9pPk]/.test(pattern) || /\(\?/.test(pattern) || /\[[^\]]*\[/.test(pattern)) {
+    throw new Error(
+      `Stack input '${id}' pattern is not portable across TypeScript, CloudFormation, and Terraform`,
+    )
+  }
+}
+
+function numberToString(value: number | undefined): string | undefined {
+  if (value === undefined) {
+    return undefined
+  }
+
+  if (!Number.isFinite(value)) {
+    throw new Error("Stack input number constraints must be finite")
+  }
+
+  return String(value)
+}
+
+function integerToString(value: number | undefined, field: string): string | undefined {
+  if (value === undefined) {
+    return undefined
+  }
+
+  if (!Number.isInteger(value)) {
+    throw new Error(`Stack input integer ${field} must be an integer`)
+  }
+
+  return String(value)
+}
+
+export {
+  defineBooleanInput as boolean,
+  defineEnumInput as enum,
+  defineIntegerInput as integer,
+  defineNumberInput as number,
+  defineSecretInput as secret,
+  defineStringInput as string,
+  defineStringListInput as stringList,
+}