@buddy-works/sandbox-sdk 0.1.0-rc.0 → 0.1.0-rc.1

package/dist/index.mjs

@@ -0,0 +1,2600 @@
+import { ZodError, prettifyError, z } from "zod";
+import { inspect } from "node:util";
+import pRetry from "p-retry";
+import * as fs from "node:fs";
+
+//#region src/api/openapi/transformers.gen.ts
+const projectViewSchemaResponseTransformer = (data) => {
+	if (data.create_date) data.create_date = new Date(data.create_date);
+	return data;
+};
+const sandboxResponseSchemaResponseTransformer = (data) => {
+	if (data.project) data.project = projectViewSchemaResponseTransformer(data.project);
+	return data;
+};
+const addSandboxResponseTransformer = async (data) => {
+	data = sandboxResponseSchemaResponseTransformer(data);
+	return data;
+};
+const getSandboxResponseTransformer = async (data) => {
+	data = sandboxResponseSchemaResponseTransformer(data);
+	return data;
+};
+const sandboxContentItemSchemaResponseTransformer = (data) => {
+	if (data.size) data.size = BigInt(data.size.toString());
+	return data;
+};
+const sandboxContentViewSchemaResponseTransformer = (data) => {
+	if (data.contents) data.contents = data.contents.map((item) => sandboxContentItemSchemaResponseTransformer(item));
+	return data;
+};
+const getSandboxContentResponseTransformer = async (data) => {
+	data = sandboxContentViewSchemaResponseTransformer(data);
+	return data;
+};
+const createSandboxDirectoryResponseTransformer = async (data) => {
+	data = sandboxContentItemSchemaResponseTransformer(data);
+	return data;
+};
+const uploadSandboxFileResponseTransformer = async (data) => {
+	data = sandboxContentItemSchemaResponseTransformer(data);
+	return data;
+};
+const restartSandboxResponseTransformer = async (data) => {
+	data = sandboxResponseSchemaResponseTransformer(data);
+	return data;
+};
+const startSandboxResponseTransformer = async (data) => {
+	data = sandboxResponseSchemaResponseTransformer(data);
+	return data;
+};
+const stopSandboxResponseTransformer = async (data) => {
+	data = sandboxResponseSchemaResponseTransformer(data);
+	return data;
+};
+
+//#endregion
+//#region src/api/openapi/zod.gen.ts
+const zUriBuilder = z.record(z.string(), z.unknown());
+const zStatusType = z.object({
+	family: z.optional(z.enum([
+		"INFORMATIONAL",
+		"SUCCESSFUL",
+		"REDIRECTION",
+		"CLIENT_ERROR",
+		"SERVER_ERROR",
+		"OTHER"
+	])),
+	status_code: z.optional(z.int().min(-2147483648, { error: "Invalid value: Expected int32 to be >= -2147483648" }).max(2147483647, { error: "Invalid value: Expected int32 to be <= 2147483647" })),
+	reason_phrase: z.optional(z.string())
+});
+const zEntityTag = z.object({
+	value: z.optional(z.string()),
+	weak: z.optional(z.boolean())
+});
+const zMediaType = z.object({
+	type: z.optional(z.string()),
+	subtype: z.optional(z.string()),
+	parameters: z.optional(z.record(z.string(), z.string())),
+	wildcard_type: z.optional(z.boolean()),
+	wildcard_subtype: z.optional(z.boolean())
+});
+const zLink = z.object({
+	uri: z.optional(z.url()),
+	uri_builder: z.optional(zUriBuilder),
+	rel: z.optional(z.string()),
+	rels: z.optional(z.array(z.string())),
+	type: z.optional(z.string()),
+	params: z.optional(z.record(z.string(), z.string())),
+	title: z.optional(z.string())
+});
+const zNewCookie = z.object({
+	name: z.optional(z.string()),
+	value: z.optional(z.string()),
+	version: z.optional(z.int().min(-2147483648, { error: "Invalid value: Expected int32 to be >= -2147483648" }).max(2147483647, { error: "Invalid value: Expected int32 to be <= 2147483647" })),
+	path: z.optional(z.string()),
+	domain: z.optional(z.string()),
+	comment: z.optional(z.string()),
+	max_age: z.optional(z.int().min(-2147483648, { error: "Invalid value: Expected int32 to be >= -2147483648" }).max(2147483647, { error: "Invalid value: Expected int32 to be <= 2147483647" })),
+	expiry: z.optional(z.iso.datetime()),
+	secure: z.optional(z.boolean()),
+	http_only: z.optional(z.boolean()),
+	same_site: z.optional(z.enum([
+		"NONE",
+		"LAX",
+		"STRICT"
+	]))
+});
+const zResponse = z.object({
+	status_info: z.optional(zStatusType),
+	cookies: z.optional(z.record(z.string(), zNewCookie)),
+	allowed_methods: z.optional(z.array(z.string())),
+	links: z.optional(z.array(zLink)),
+	media_type: z.optional(zMediaType),
+	entity_tag: z.optional(zEntityTag),
+	string_headers: z.optional(z.object({ empty: z.optional(z.boolean()) })),
+	closed: z.optional(z.boolean()),
+	length: z.optional(z.int().min(-2147483648, { error: "Invalid value: Expected int32 to be >= -2147483648" }).max(2147483647, { error: "Invalid value: Expected int32 to be <= 2147483647" })),
+	location: z.optional(z.url()),
+	language: z.optional(z.object({
+		language: z.optional(z.string()),
+		display_name: z.optional(z.string()),
+		country: z.optional(z.string()),
+		variant: z.optional(z.string()),
+		script: z.optional(z.string()),
+		unicode_locale_attributes: z.optional(z.array(z.string())),
+		unicode_locale_keys: z.optional(z.array(z.string())),
+		display_language: z.optional(z.string()),
+		display_script: z.optional(z.string()),
+		display_country: z.optional(z.string()),
+		display_variant: z.optional(z.string()),
+		extension_keys: z.optional(z.array(z.string())),
+		iso3_language: z.optional(z.string()),
+		iso3_country: z.optional(z.string())
+	})),
+	date: z.optional(z.iso.datetime()),
+	last_modified: z.optional(z.iso.datetime()),
+	status: z.optional(z.int().min(-2147483648, { error: "Invalid value: Expected int32 to be >= -2147483648" }).max(2147483647, { error: "Invalid value: Expected int32 to be <= 2147483647" })),
+	metadata: z.optional(z.object({ empty: z.optional(z.boolean()) })),
+	entity: z.optional(z.record(z.string(), z.unknown())),
+	headers: z.optional(z.object({ empty: z.optional(z.boolean()) }))
+});
+/**
+* Sandbox reference
+*/
+const zSandboxIdView = z.object({
+	url: z.optional(z.string().register(z.globalRegistry, { description: "API endpoint to GET this object" }).readonly()),
+	html_url: z.optional(z.string().register(z.globalRegistry, { description: "Web URL to view this object in Buddy.works" }).readonly()),
+	id: z.optional(z.string().register(z.globalRegistry, { description: "The ID of the sandbox" })),
+	identifier: z.optional(z.string().register(z.globalRegistry, { description: "A human-readable ID. Alphanumeric characters, underscores, and hyphens (hyphens cannot appear at the start or end)." })),
+	name: z.optional(z.string().register(z.globalRegistry, { description: "The name of the sandbox" })),
+	status: z.optional(z.enum([
+		"STARTING",
+		"STOPPING",
+		"FAILED",
+		"RUNNING",
+		"STOPPED",
+		"RESTORING"
+	]).register(z.globalRegistry, { description: "The current status of the sandbox" }))
+}).register(z.globalRegistry, { description: "Sandbox reference" });
+/**
+* Integration reference
+*/
+const zIntegrationIdView = z.object({
+	url: z.optional(z.string().register(z.globalRegistry, { description: "API endpoint to GET this object" }).readonly()),
+	html_url: z.optional(z.string().register(z.globalRegistry, { description: "Web URL to view this object in Buddy.works" }).readonly()),
+	identifier: z.optional(z.string().register(z.globalRegistry, { description: "A human-readable ID of the integration" })),
+	hash_id: z.optional(z.string().register(z.globalRegistry, { description: "The unique hash ID of the integration" })),
+	name: z.optional(z.string().register(z.globalRegistry, { description: "The name of the integration" })),
+	type: z.optional(z.enum([
+		"GIT_HUB",
+		"BITBUCKET",
+		"GOOGLE",
+		"DIGITAL_OCEAN",
+		"SLACK",
+		"MODULUS",
+		"HEROKU",
+		"AMAZON",
+		"GIT_LAB",
+		"SHOPIFY",
+		"GIT_HUB_ENTERPRISE",
+		"GIT_LAB_ENTERPRISE",
+		"PUSHOVER",
+		"PUSHBULLET",
+		"RACKSPACE",
+		"CUSTOM",
+		"CLOUDFLARE",
+		"NEW_RELIC",
+		"SENTRY",
+		"ROLLBAR",
+		"DATADOG",
+		"DO_SPACES",
+		"HONEYBADGER",
+		"VULTR",
+		"SENTRY_ENTERPRISE",
+		"LOGGLY",
+		"HIP_CHAT",
+		"FIREBASE",
+		"TELEGRAM",
+		"AZURE",
+		"UPCLOUD",
+		"GHOST_INSPECTOR",
+		"NETLIFY",
+		"AZURE_CLOUD",
+		"MICROSOFT_TEAMS",
+		"GOOGLE_SERVICE_ACCOUNT",
+		"GOOGLE_PLAY_STORE",
+		"DOCKER_HUB",
+		"APP_STORE",
+		"GIT_HUB_APP",
+		"GIT_HUB_APP_ENTERPRISE",
+		"GIT_HUB_API",
+		"ATOP",
+		"SNYK",
+		"STACK_HAWK",
+		"BLACKFIRE",
+		"BACKBLAZE",
+		"ONE_LOGIN",
+		"OKTA",
+		"CONTENTFUL"
+	]).register(z.globalRegistry, { description: "The type of integration" })),
+	auth_type: z.optional(z.enum([
+		"OAUTH",
+		"TOKEN",
+		"API_KEY",
+		"APP",
+		"APP_SPRYKER",
+		"TOKEN_APP_EXTENSION",
+		"DEFAULT",
+		"OIDC",
+		"TRUSTED",
+		"APP_RW"
+	]).register(z.globalRegistry, { description: "The authentication method used by the integration" })),
+	host_url: z.optional(z.string().register(z.globalRegistry, { description: "The host URL for custom integrations" })),
+	webhook_address: z.optional(z.string().register(z.globalRegistry, { description: "The webhook URL for receiving notifications" })),
+	atop_url: z.optional(z.string().register(z.globalRegistry, { description: "The ATOP service URL" })),
+	app_id: z.optional(z.string().register(z.globalRegistry, { description: "The application ID for Azure Cloud integrations" })),
+	google_project: z.optional(z.string().register(z.globalRegistry, { description: "The Google Cloud project ID" })),
+	audience: z.optional(z.string().register(z.globalRegistry, { description: "The JWT audience for token validation" }))
+}).register(z.globalRegistry, { description: "Integration reference" });
+/**
+* User/member reference
+*/
+const zMemberView = z.object({
+	url: z.optional(z.string().register(z.globalRegistry, { description: "API endpoint to GET this object" }).readonly()),
+	html_url: z.optional(z.string().register(z.globalRegistry, { description: "Web URL to view this object in Buddy.works" }).readonly()),
+	id: z.optional(z.int().min(-2147483648, { error: "Invalid value: Expected int32 to be >= -2147483648" }).max(2147483647, { error: "Invalid value: Expected int32 to be <= 2147483647" }).register(z.globalRegistry, { description: "The ID of the user" })),
+	name: z.optional(z.string().register(z.globalRegistry, { description: "The name of the user" })),
+	avatar_url: z.optional(z.string().register(z.globalRegistry, { description: "The avatar URL of the user" })),
+	email: z.optional(z.string().register(z.globalRegistry, { description: "The email address of the user" })),
+	admin: z.optional(z.boolean().register(z.globalRegistry, { description: "Whether the user has admin privileges" })),
+	workspace_owner: z.optional(z.boolean().register(z.globalRegistry, { description: "Whether the user is workspace owner" }))
+}).register(z.globalRegistry, { description: "User/member reference" });
+const zProjectView = z.object({
+	url: z.optional(z.string().register(z.globalRegistry, { description: "API endpoint to GET this object" }).readonly()),
+	html_url: z.optional(z.string().register(z.globalRegistry, { description: "Web URL to view this object in Buddy.works" }).readonly()),
+	name: z.optional(z.string().register(z.globalRegistry, { description: "The human-readable ID of the project" })),
+	display_name: z.string().register(z.globalRegistry, { description: "The Name of the project" }),
+	status: z.optional(z.string().register(z.globalRegistry, { description: "The status of the project" })),
+	access: z.optional(z.enum(["PRIVATE", "PUBLIC"]).register(z.globalRegistry, { description: "Indicates if this is a public project" })),
+	create_date: z.optional(z.iso.datetime().register(z.globalRegistry, { description: "The creation date of the project" })),
+	external_project_id: z.optional(z.string().register(z.globalRegistry, { description: "Repo slug of the Bitbucket, GitHub or GitLab project. Required when adding the integrated project" })),
+	git_lab_project_id: z.optional(z.int().min(-2147483648, { error: "Invalid value: Expected int32 to be >= -2147483648" }).max(2147483647, { error: "Invalid value: Expected int32 to be <= 2147483647" }).register(z.globalRegistry, { description: "ID of the project in GitLab" })),
+	custom_repo_url: z.optional(z.string().register(z.globalRegistry, { description: "SSH or HTTPS url of the git repository. Required when adding the project integrated with custom git repository" })),
+	custom_repo_user: z.optional(z.string().register(z.globalRegistry, { description: "Username used to authorize access to the git repository. Required when adding the project integrated with custom git repository" })),
+	custom_repo_pass: z.optional(z.string().register(z.globalRegistry, { description: "Password used to authorize access to the git repository. Required when adding the project integrated with custom git repository and the provided `custom_repo_url` is the HTTPS url" })),
+	custom_repo_ssh_key_id: z.optional(z.int().min(-2147483648, { error: "Invalid value: Expected int32 to be >= -2147483648" }).max(2147483647, { error: "Invalid value: Expected int32 to be <= 2147483647" }).register(z.globalRegistry, { description: "The ID of the private SSH key used to authorize access to the git repository. Required when adding the project integrated with private git server by SSH url" })),
+	created_by: z.optional(zMemberView),
+	http_repository: z.optional(z.string().register(z.globalRegistry, { description: "The HTTP repository URL" })),
+	ssh_repository: z.optional(z.string().register(z.globalRegistry, { description: "The SSH repository URL" })),
+	default_branch: z.optional(z.string().register(z.globalRegistry, { description: "The default branch name" })),
+	integration: z.optional(zIntegrationIdView),
+	fetch_submodules: z.optional(z.boolean().register(z.globalRegistry, { description: "Defines whether the submodules are fetched during the runs in this project" })),
+	fetch_submodules_env_key: z.optional(z.string().register(z.globalRegistry, { description: "Name of the key that will be used to authorize while fetching the submodules. Required when `fetch_submodules` is set to `true`" })),
+	allow_pull_requests: z.optional(z.boolean().register(z.globalRegistry, { description: "Enables/disables pull requests in the project. Available only for projects synchronized with GitHub or GitHub Enterprise repository" })),
+	update_default_branch_from_external: z.optional(z.boolean().register(z.globalRegistry, { description: "If set to true, the default branch will be updated from GitHub/GitLab/Bitbucket." })),
+	without_repository: z.optional(z.boolean().register(z.globalRegistry, { description: "If set to true, the project is created without any repository attached." }))
+});
+/**
+* The environment variables of the sandbox
+*/
+const zAddVariableInObjectRequest = z.object({
+	url: z.optional(z.string().register(z.globalRegistry, { description: "API endpoint to GET this object" }).readonly()),
+	html_url: z.optional(z.string().register(z.globalRegistry, { description: "Web URL to view this object in Buddy.works" }).readonly()),
+	key: z.string().register(z.globalRegistry, { description: "The name of the variable" }),
+	value: z.optional(z.string().register(z.globalRegistry, { description: "The value of the variable" })),
+	settable: z.optional(z.boolean().register(z.globalRegistry, { description: "If set to `true` the variable value can be set by Buddy actions" })),
+	run_only_settable: z.optional(z.boolean().register(z.globalRegistry, { description: "Available only if `type=VAR`. If set to `true` the variable value can be set by Buddy actions only for execution time" })),
+	encrypted: z.optional(z.boolean().register(z.globalRegistry, { description: "If set to `true` the variable value will be encrypted and hidden" })),
+	description: z.optional(z.string().register(z.globalRegistry, { description: "The optional description of the variable" })),
+	init_path: z.optional(z.string().register(z.globalRegistry, { description: "Initial path for the variable" })),
+	defaults: z.optional(z.string().register(z.globalRegistry, { description: "Default value for the variable" })),
+	file_path: z.optional(z.string().register(z.globalRegistry, { description: "Specifies where to copy the file on each run. Set if `type` is `SSH_KEY`" })),
+	file_chmod: z.optional(z.string().register(z.globalRegistry, { description: "File permission set on copy to a container on each run. Set if `type` is `SSH_KEY`" })),
+	file_place: z.optional(z.enum(["NONE", "CONTAINER"]).register(z.globalRegistry, { description: "Set if `type` is `SSH_KEY`. If it's `NONE`, the variable can be used as a parameter in an action. For `CONTAINER`, the given key is additionally copied to an action container on each run" })),
+	password: z.optional(z.string().register(z.globalRegistry, { description: "Password for certificates" })),
+	passphrase: z.optional(z.string().register(z.globalRegistry, { description: "Passphrase for encrypted SSH keys" })),
+	key_identifier: z.optional(z.string().register(z.globalRegistry, { description: "GPG key identifier" })),
+	type: z.enum([
+		"VAR",
+		"FILE",
+		"SSH_KEY",
+		"IOS_KEYCHAIN",
+		"IOS_PROVISION_PROFILES",
+		"SSH_PUBLIC_KEY",
+		"GPG_KEY"
+	]).register(z.globalRegistry, { description: "The type of the added variable" })
+}).register(z.globalRegistry, { description: "The environment variables of the sandbox" });
+/**
+* The TLS/SSL encryption settings of the tunnel
+*/
+const zTlsSettingsView = z.object({
+	url: z.optional(z.string().register(z.globalRegistry, { description: "API endpoint to GET this object" }).readonly()),
+	html_url: z.optional(z.string().register(z.globalRegistry, { description: "Web URL to view this object in Buddy.works" }).readonly()),
+	terminate_at: z.optional(z.enum([
+		"REGION",
+		"AGENT",
+		"TARGET"
+	]).register(z.globalRegistry, { description: "Where to terminate TLS connection" }))
+}).register(z.globalRegistry, { description: "The TLS/SSL encryption settings of the tunnel" });
+/**
+* The HTTP-specific settings of the tunnel
+*/
+const zHttpSettingsView = z.object({
+	url: z.optional(z.string().register(z.globalRegistry, { description: "API endpoint to GET this object" }).readonly()),
+	html_url: z.optional(z.string().register(z.globalRegistry, { description: "Web URL to view this object in Buddy.works" }).readonly()),
+	verify_certificate: z.optional(z.boolean().register(z.globalRegistry, { description: "Whether to verify SSL/TLS certificates" })),
+	compression: z.optional(z.boolean().register(z.globalRegistry, { description: "Enable HTTP compression" })),
+	http2: z.optional(z.boolean().register(z.globalRegistry, { description: "Enable HTTP/2 protocol support" })),
+	log_requests: z.optional(z.boolean().register(z.globalRegistry, { description: "Log incoming HTTP requests" })),
+	request_headers: z.optional(z.array(z.record(z.string(), z.string())).register(z.globalRegistry, { description: "Custom HTTP headers to add to requests" })),
+	whitelist_user_agents: z.optional(z.array(z.string()).register(z.globalRegistry, { description: "List of allowed User-Agent strings" })),
+	rewrite_host_header: z.optional(z.string().register(z.globalRegistry, { description: "Rewrite the Host header to this value" })),
+	response_headers: z.optional(z.array(z.record(z.string(), z.string())).register(z.globalRegistry, { description: "Custom HTTP headers to add to responses" })),
+	login: z.optional(z.string().register(z.globalRegistry, { description: "Basic authentication username" })),
+	circuit_breaker: z.optional(z.int().min(-2147483648, { error: "Invalid value: Expected int32 to be >= -2147483648" }).max(2147483647, { error: "Invalid value: Expected int32 to be <= 2147483647" }).register(z.globalRegistry, { description: "Circuit breaker threshold (number of failed requests)" })),
+	serve_path: z.optional(z.string().register(z.globalRegistry, { description: "Base path for serving requests" })),
+	auth_type: z.optional(z.enum([
+		"NONE",
+		"BASIC",
+		"BUDDY"
+	]).register(z.globalRegistry, { description: "Type of authentication used" }))
+}).register(z.globalRegistry, { description: "The HTTP-specific settings of the tunnel" });
+const zTunnelView = z.object({
+	url: z.optional(z.string().register(z.globalRegistry, { description: "API endpoint to GET this object" }).readonly()),
+	html_url: z.optional(z.string().register(z.globalRegistry, { description: "Web URL to view this object in Buddy.works" }).readonly()),
+	name: z.string().register(z.globalRegistry, { description: "The name of the tunnel" }),
+	endpoint: z.string().register(z.globalRegistry, { description: "The endpoint URL of the tunnel" }),
+	type: z.enum([
+		"TCP",
+		"TLS",
+		"HTTP",
+		"SSH"
+	]).register(z.globalRegistry, { description: "The type of the tunnel" }),
+	region: z.enum([
+		"US",
+		"EU",
+		"AS"
+	]).register(z.globalRegistry, { description: "The region where the tunnel is deployed" }),
+	whitelist: z.optional(z.array(z.string()).register(z.globalRegistry, { description: "The IP addresses or domains allowed to access the tunnel" })),
+	timeout: z.optional(z.int().min(-2147483648, { error: "Invalid value: Expected int32 to be >= -2147483648" }).max(2147483647, { error: "Invalid value: Expected int32 to be <= 2147483647" }).register(z.globalRegistry, { description: "The connection timeout of the tunnel in seconds" })),
+	http: z.optional(zHttpSettingsView),
+	tls: z.optional(zTlsSettingsView),
+	endpoint_url: z.optional(z.string().register(z.globalRegistry, { description: "The url of the tunnel" }))
+});
+const zUpdateSandboxRequest = z.object({
+	name: z.optional(z.string().register(z.globalRegistry, { description: "The name of the sandbox" })),
+	identifier: z.optional(z.string().register(z.globalRegistry, { description: "A human-readable ID. Alphanumeric characters, underscores, and hyphens (hyphens cannot appear at the start or end)." })),
+	resources: z.optional(z.enum([
+		"1x2",
+		"2x4",
+		"3x6",
+		"4x8",
+		"5x10",
+		"6x12",
+		"7x14",
+		"8x16",
+		"9x18",
+		"10x20",
+		"11x22",
+		"12x24",
+		"CUSTOM"
+	]).register(z.globalRegistry, { description: "The resource configuration of the sandbox (CPU x RAM)" })),
+	install_commands: z.optional(z.string().register(z.globalRegistry, { description: "The commands to run during setup of the sandbox" })),
+	run_command: z.optional(z.string().register(z.globalRegistry, { description: "The run command of the sandbox" })),
+	app_dir: z.optional(z.string().register(z.globalRegistry, { description: "The application directory of the sandbox" })),
+	app_type: z.optional(z.enum(["CMD", "SERVICE"]).register(z.globalRegistry, { description: "The application type of the sandbox (passed command or existent service eg. apache2)" })),
+	tags: z.optional(z.array(z.string().register(z.globalRegistry, { description: "The list of tags associated with the sandbox" })).register(z.globalRegistry, { description: "The list of tags associated with the sandbox" })),
+	endpoints: z.optional(z.array(zTunnelView).register(z.globalRegistry, { description: "The tunnel endpoints of the sandbox" })),
+	variables: z.optional(z.array(zAddVariableInObjectRequest).register(z.globalRegistry, { description: "The environment variables of the sandbox" }))
+});
+const zSandboxesView = z.object({
+	url: z.optional(z.string().register(z.globalRegistry, { description: "API endpoint to GET this object" }).readonly()),
+	html_url: z.optional(z.string().register(z.globalRegistry, { description: "Web URL to view this object in Buddy.works" }).readonly()),
+	sandboxes: z.optional(z.array(zSandboxIdView))
+});
+/**
+* Content item in a sandbox
+*/
+const zSandboxContentItem = z.object({
+	url: z.optional(z.string().register(z.globalRegistry, { description: "API endpoint to GET this object" }).readonly()),
+	html_url: z.optional(z.string().register(z.globalRegistry, { description: "Web URL to view this object in Buddy.works" }).readonly()),
+	type: z.optional(z.enum(["FILE", "DIR"]).register(z.globalRegistry, { description: "The content type (FILE or DIR)" })),
+	name: z.optional(z.string().register(z.globalRegistry, { description: "The name of the file or directory" })),
+	path: z.optional(z.string().register(z.globalRegistry, { description: "The path to the file or directory" })),
+	size: z.optional(z.coerce.bigint().min(BigInt("-9223372036854775808"), { error: "Invalid value: Expected int64 to be >= -9223372036854775808" }).max(BigInt("9223372036854775807"), { error: "Invalid value: Expected int64 to be <= 9223372036854775807" }).register(z.globalRegistry, { description: "The size of the file in bytes" }))
+}).register(z.globalRegistry, { description: "Content item in a sandbox" });
+/**
+* Sandbox content listing
+*/
+const zSandboxContentView = z.object({
+	url: z.optional(z.string().register(z.globalRegistry, { description: "API endpoint to GET this object" }).readonly()),
+	html_url: z.optional(z.string().register(z.globalRegistry, { description: "Web URL to view this object in Buddy.works" }).readonly()),
+	contents: z.optional(z.array(zSandboxContentItem).register(z.globalRegistry, { description: "List of content items in the directory" }))
+}).register(z.globalRegistry, { description: "Sandbox content listing" });
+const zSandboxCommandView = z.object({
+	url: z.optional(z.string().register(z.globalRegistry, { description: "API endpoint to GET this object" }).readonly()),
+	html_url: z.optional(z.string().register(z.globalRegistry, { description: "Web URL to view this object in Buddy.works" }).readonly()),
+	id: z.optional(z.string().register(z.globalRegistry, { description: "The ID of the command" })),
+	command: z.optional(z.string().register(z.globalRegistry, { description: "Command to execute in the sandbox" })),
+	runtime: z.optional(z.enum([
+		"BASH",
+		"JAVASCRIPT",
+		"TYPESCRIPT",
+		"PYTHON"
+	]).register(z.globalRegistry, { description: "Runtime environment for command execution (default: `BASH`)" })),
+	status: z.optional(z.enum([
+		"INPROGRESS",
+		"SUCCESSFUL",
+		"FAILED"
+	]).register(z.globalRegistry, { description: "Command execution status" })),
+	exit_code: z.optional(z.int().min(-2147483648, { error: "Invalid value: Expected int32 to be >= -2147483648" }).max(2147483647, { error: "Invalid value: Expected int32 to be <= 2147483647" }).register(z.globalRegistry, { description: "Command exit code" })),
+	logs_url: z.optional(z.string().register(z.globalRegistry, { description: "API endpoint URL to retrieve logs for this command" }))
+});
+const zSandboxCommandsView = z.object({
+	url: z.optional(z.string().register(z.globalRegistry, { description: "API endpoint to GET this object" }).readonly()),
+	html_url: z.optional(z.string().register(z.globalRegistry, { description: "Web URL to view this object in Buddy.works" }).readonly()),
+	commands: z.optional(z.array(zSandboxCommandView))
+});
+const zSandboxCommandLog = z.object({
+	type: z.optional(z.enum(["STDOUT", "STDERR"]).register(z.globalRegistry, { description: "The type of command output stream" })),
+	data: z.optional(z.string().register(z.globalRegistry, { description: "The command execution logs." }))
+});
+const zSandboxAppLogsView = z.object({
+	url: z.optional(z.string().register(z.globalRegistry, { description: "API endpoint to GET this object" }).readonly()),
+	html_url: z.optional(z.string().register(z.globalRegistry, { description: "Web URL to view this object in Buddy.works" }).readonly()),
+	cursor: z.optional(z.string().register(z.globalRegistry, { description: "Cursor for pagination" })),
+	logs: z.optional(z.array(z.string()).register(z.globalRegistry, { description: "Application log entries" }))
+});
+const zShortSnapshotView = z.object({
+	url: z.optional(z.string().register(z.globalRegistry, { description: "API endpoint to GET this object" }).readonly()),
+	html_url: z.optional(z.string().register(z.globalRegistry, { description: "Web URL to view this object in Buddy.works" }).readonly()),
+	id: z.optional(z.string().register(z.globalRegistry, { description: "The ID of the snapshot" })),
+	name: z.optional(z.string().register(z.globalRegistry, { description: "Snapshot name" })),
+	size: z.optional(z.int().min(-2147483648, { error: "Invalid value: Expected int32 to be >= -2147483648" }).max(2147483647, { error: "Invalid value: Expected int32 to be <= 2147483647" }).register(z.globalRegistry, { description: "Snapshot size in GB" })),
+	status: z.optional(z.enum([
+		"CREATING",
+		"CREATED",
+		"DELETING",
+		"FAILED"
+	]).register(z.globalRegistry, { description: "Snapshot status" })),
+	create_date: z.optional(z.iso.datetime().register(z.globalRegistry, { description: "Snapshot creation date" }))
+});
+const zSnapshotsView = z.object({
+	url: z.optional(z.string().register(z.globalRegistry, { description: "API endpoint to GET this object" }).readonly()),
+	html_url: z.optional(z.string().register(z.globalRegistry, { description: "Web URL to view this object in Buddy.works" }).readonly()),
+	snapshots: z.optional(z.array(zShortSnapshotView).register(z.globalRegistry, { description: "Collection of snapshots" }))
+});
+const zExecuteSandboxCommandRequest = z.object({
+	command: z.string().register(z.globalRegistry, { description: "Command to execute in the sandbox" }),
+	runtime: z.optional(z.enum([
+		"BASH",
+		"JAVASCRIPT",
+		"TYPESCRIPT",
+		"PYTHON"
+	]).register(z.globalRegistry, { description: "Runtime environment for command execution (default: `BASH`)" }))
+});
+const zAddSnapshotRequest = z.object({ name: z.optional(z.string().register(z.globalRegistry, { description: "Snapshot name" })) });
+const zSnapshotView = z.object({
+	url: z.optional(z.string().register(z.globalRegistry, { description: "API endpoint to GET this object" }).readonly()),
+	html_url: z.optional(z.string().register(z.globalRegistry, { description: "Web URL to view this object in Buddy.works" }).readonly()),
+	id: z.optional(z.string().register(z.globalRegistry, { description: "The ID of the snapshot" })),
+	name: z.optional(z.string().register(z.globalRegistry, { description: "Snapshot name" })),
+	size: z.optional(z.int().min(-2147483648, { error: "Invalid value: Expected int32 to be >= -2147483648" }).max(2147483647, { error: "Invalid value: Expected int32 to be <= 2147483647" }).register(z.globalRegistry, { description: "Snapshot size in GB" })),
+	status: z.optional(z.enum([
+		"CREATING",
+		"CREATED",
+		"DELETING",
+		"FAILED"
+	]).register(z.globalRegistry, { description: "Snapshot status" })),
+	create_date: z.optional(z.iso.datetime().register(z.globalRegistry, { description: "Snapshot creation date" })),
+	created_by: z.optional(zMemberView)
+});
+const zSandboxYamlView = z.object({
+	url: z.optional(z.string().register(z.globalRegistry, { description: "API endpoint to GET this object" }).readonly()),
+	html_url: z.optional(z.string().register(z.globalRegistry, { description: "Web URL to view this object in Buddy.works" }).readonly()),
+	yaml: z.optional(z.string().register(z.globalRegistry, { description: "The base64-encoded YAML configuration of the sandbox" }))
+});
+const zCreateNewSandboxRequest = z.object({
+	name: z.string().register(z.globalRegistry, { description: "The name of the sandbox" }),
+	identifier: z.optional(z.string().register(z.globalRegistry, { description: "A human-readable ID. Alphanumeric characters, underscores, and hyphens (hyphens cannot appear at the start or end)." })),
+	os: z.string().register(z.globalRegistry, { description: "The operating system of the sandbox [\"ubuntu:22.04\", \"ubuntu:24.04\"]" }),
+	resources: z.optional(z.enum([
+		"1x2",
+		"2x4",
+		"3x6",
+		"4x8",
+		"5x10",
+		"6x12",
+		"7x14",
+		"8x16",
+		"9x18",
+		"10x20",
+		"11x22",
+		"12x24",
+		"CUSTOM"
+	]).register(z.globalRegistry, { description: "The resource configuration of the sandbox (CPU x RAM)" })),
+	install_commands: z.optional(z.string().register(z.globalRegistry, { description: "The commands to run during setup of the sandbox" })),
+	run_command: z.optional(z.string().register(z.globalRegistry, { description: "The run command of the sandbox" })),
+	app_dir: z.optional(z.string().register(z.globalRegistry, { description: "The application directory of the sandbox" })),
+	app_type: z.optional(z.enum(["CMD", "SERVICE"]).register(z.globalRegistry, { description: "The application type of the sandbox (passed command or existent service eg. apache2)" })),
+	tags: z.optional(z.array(z.string().register(z.globalRegistry, { description: "The list of tags associated with the sandbox" })).register(z.globalRegistry, { description: "The list of tags associated with the sandbox" })),
+	endpoints: z.optional(z.array(zTunnelView).register(z.globalRegistry, { description: "The tunnel endpoints of the sandbox" })),
+	variables: z.optional(z.array(zAddVariableInObjectRequest).register(z.globalRegistry, { description: "The environment variables of the sandbox" }))
+});
+/**
+* The list of variables you can use the action
+*/
+const zEnvironmentVariableView = z.object({
+	id: z.optional(z.int().min(-2147483648, { error: "Invalid value: Expected int32 to be >= -2147483648" }).max(2147483647, { error: "Invalid value: Expected int32 to be <= 2147483647" }).register(z.globalRegistry, { description: "The ID of the variable" })),
+	key: z.optional(z.string().register(z.globalRegistry, { description: "The name of the variable" })),
+	value: z.optional(z.string().register(z.globalRegistry, { description: "The value of the variable" })),
+	type: z.optional(z.enum([
+		"VAR",
+		"FILE",
+		"SSH_KEY",
+		"IOS_KEYCHAIN",
+		"IOS_PROVISION_PROFILES",
+		"SSH_PUBLIC_KEY",
+		"GPG_KEY"
+	]).register(z.globalRegistry, { description: "The type of the added variable" })),
+	encrypted: z.optional(z.boolean().register(z.globalRegistry, { description: "If set to `true` the variable value will be encrypted and hidden" })),
+	settable: z.optional(z.boolean().register(z.globalRegistry, { description: "If set to `true` the variable value can be set by Buddy actions" })),
+	run_only_settable: z.optional(z.boolean().register(z.globalRegistry, { description: "Available only if `type=VAR`. If set to `true` the variable value can be set by Buddy actions only for execution time" })),
+	description: z.optional(z.string().register(z.globalRegistry, { description: "The optional description of the variable" })),
+	init_path: z.optional(z.string().register(z.globalRegistry, { description: "Initial path for the variable" })),
+	defaults: z.optional(z.string().register(z.globalRegistry, { description: "Default value for the variable" })),
+	file_path: z.optional(z.string().register(z.globalRegistry, { description: "Specifies where to copy the file on each run. Set if `type` is `SSH_KEY`" })),
+	file_chmod: z.optional(z.string().register(z.globalRegistry, { description: "File permission set on copy to a container on each run. Set if `type` is `SSH_KEY`" })),
+	file_place: z.optional(z.enum(["NONE", "CONTAINER"]).register(z.globalRegistry, { description: "Set if `type` is `SSH_KEY`. If it's `NONE`, the variable can be used as a parameter in an action. For `CONTAINER`, the given key is additionally copied to an action container on each run" })),
+	binary: z.optional(z.boolean().register(z.globalRegistry, { description: "Whether the file is binary" })),
+	public_value: z.optional(z.string().register(z.globalRegistry, { description: "Public value for SSH key type variables" })),
+	key_fingerprint: z.optional(z.string().register(z.globalRegistry, { description: "Fingerprint of SSH key" })),
+	checksum: z.optional(z.string().register(z.globalRegistry, { description: "Checksum of the variable value" })),
+	password: z.optional(z.string().register(z.globalRegistry, { description: "Password for certificates" })),
+	passphrase: z.optional(z.string().register(z.globalRegistry, { description: "Passphrase for encrypted SSH keys" })),
+	key_identifier: z.optional(z.string().register(z.globalRegistry, { description: "GPG key identifier" }))
+}).register(z.globalRegistry, { description: "The list of variables you can use the action" });
+const zCreateFromSnapshotRequest = z.object({
+	snapshot_id: z.string().register(z.globalRegistry, { description: "The ID of the snapshot to create from" }),
+	name: z.string().register(z.globalRegistry, { description: "The name of the sandbox" }),
+	identifier: z.optional(z.string().register(z.globalRegistry, { description: "A human-readable ID. Alphanumeric characters, underscores, and hyphens (hyphens cannot appear at the start or end)." })),
+	os: z.optional(z.string().register(z.globalRegistry, { description: "The operating system of the sandbox [\"ubuntu:22.04\", \"ubuntu:24.04\"]" })),
+	resources: z.optional(z.enum([
+		"1x2",
+		"2x4",
+		"3x6",
+		"4x8",
+		"5x10",
+		"6x12",
+		"7x14",
+		"8x16",
+		"9x18",
+		"10x20",
+		"11x22",
+		"12x24",
+		"CUSTOM"
+	]).register(z.globalRegistry, { description: "The resource configuration of the sandbox (CPU x RAM)" })),
+	install_commands: z.optional(z.string().register(z.globalRegistry, { description: "The commands to run during setup of the sandbox" })),
+	run_command: z.optional(z.string().register(z.globalRegistry, { description: "The run command of the sandbox" })),
+	app_dir: z.optional(z.string().register(z.globalRegistry, { description: "The application directory of the sandbox" })),
+	app_type: z.optional(z.enum(["CMD", "SERVICE"]).register(z.globalRegistry, { description: "The application type of the sandbox (passed command or existent service eg. apache2)" })),
+	tags: z.optional(z.array(z.string().register(z.globalRegistry, { description: "The list of tags associated with the sandbox" })).register(z.globalRegistry, { description: "The list of tags associated with the sandbox" })),
+	endpoints: z.optional(z.array(zTunnelView).register(z.globalRegistry, { description: "The tunnel endpoints of the sandbox" })),
+	variables: z.optional(z.array(zEnvironmentVariableView).register(z.globalRegistry, { description: "The environment variables of the sandbox" }))
+});
+const zCloneSandboxRequest = z.object({
+	source_sandbox_id: z.string().register(z.globalRegistry, { description: "The ID of the sandbox to clone" }),
+	name: z.string().register(z.globalRegistry, { description: "The name of the sandbox" }),
+	identifier: z.optional(z.string().register(z.globalRegistry, { description: "A human-readable ID. Alphanumeric characters, underscores, and hyphens (hyphens cannot appear at the start or end)." }))
+});
+const zSandboxResponse = z.object({
+	url: z.optional(z.string().register(z.globalRegistry, { description: "API endpoint to GET this object" }).readonly()),
+	html_url: z.optional(z.string().register(z.globalRegistry, { description: "Web URL to view this object in Buddy.works" }).readonly()),
+	id: z.optional(z.string().register(z.globalRegistry, { description: "The ID of the sandbox" })),
+	identifier: z.optional(z.string().register(z.globalRegistry, { description: "A human-readable ID. Alphanumeric characters, underscores, and hyphens (hyphens cannot appear at the start or end)." })),
+	name: z.optional(z.string().register(z.globalRegistry, { description: "The name of the sandbox" })),
+	status: z.optional(z.enum([
+		"STARTING",
+		"STOPPING",
+		"FAILED",
+		"RUNNING",
+		"STOPPED",
+		"RESTORING"
+	]).register(z.globalRegistry, { description: "The current status of the sandbox" })),
+	os: z.optional(z.string().register(z.globalRegistry, { description: "The operating system of the sandbox [\"ubuntu:22.04\", \"ubuntu:24.04\"]" })),
+	resources: z.optional(z.enum([
+		"1x2",
+		"2x4",
+		"3x6",
+		"4x8",
+		"5x10",
+		"6x12",
+		"7x14",
+		"8x16",
+		"9x18",
+		"10x20",
+		"11x22",
+		"12x24",
+		"CUSTOM"
+	]).register(z.globalRegistry, { description: "The resource configuration of the sandbox (CPU x RAM)" })),
+	install_commands: z.optional(z.string().register(z.globalRegistry, { description: "The commands to run during setup of the sandbox" })),
+	run_command: z.optional(z.string().register(z.globalRegistry, { description: "The run command of the sandbox" })),
+	app_dir: z.optional(z.string().register(z.globalRegistry, { description: "The application directory of the sandbox" })),
+	app_type: z.optional(z.enum(["CMD", "SERVICE"]).register(z.globalRegistry, { description: "The application type of the sandbox (passed command or existent service eg. apache2)" })),
+	tags: z.optional(z.array(z.string()).register(z.globalRegistry, { description: "The list of tags associated with the sandbox" })),
+	app_status: z.optional(z.enum([
+		"NONE",
+		"RUNNING",
+		"ENDED",
+		"FAILED"
+	]).register(z.globalRegistry, { description: "The current application status of the sandbox" })),
+	boot_logs: z.optional(z.array(z.string()).register(z.globalRegistry, { description: "The boot logs of the sandbox" })),
+	setup_status: z.optional(z.enum([
+		"INPROGRESS",
+		"SUCCESS",
+		"FAILED"
+	]).register(z.globalRegistry, { description: "The current setup status of the sandbox" })),
+	endpoints: z.optional(z.array(zTunnelView).register(z.globalRegistry, { description: "The tunnel endpoints of the sandbox" })),
+	project: z.optional(zProjectView),
+	variables: z.optional(z.array(zEnvironmentVariableView).register(z.globalRegistry, { description: "The environment variables of the sandbox" }))
+});
+/**
+* Sandbox reference
+*/
+const zSandboxIdViewWritable = z.object({
+	id: z.optional(z.string().register(z.globalRegistry, { description: "The ID of the sandbox" })),
+	identifier: z.optional(z.string().register(z.globalRegistry, { description: "A human-readable ID. Alphanumeric characters, underscores, and hyphens (hyphens cannot appear at the start or end)." })),
+	name: z.optional(z.string().register(z.globalRegistry, { description: "The name of the sandbox" })),
+	status: z.optional(z.enum([
+		"STARTING",
+		"STOPPING",
+		"FAILED",
+		"RUNNING",
+		"STOPPED",
+		"RESTORING"
+	]).register(z.globalRegistry, { description: "The current status of the sandbox" }))
+}).register(z.globalRegistry, { description: "Sandbox reference" });
+/**
+* Integration reference
+*/
+const zIntegrationIdViewWritable = z.object({
+	identifier: z.optional(z.string().register(z.globalRegistry, { description: "A human-readable ID of the integration" })),
+	hash_id: z.optional(z.string().register(z.globalRegistry, { description: "The unique hash ID of the integration" })),
+	name: z.optional(z.string().register(z.globalRegistry, { description: "The name of the integration" })),
+	type: z.optional(z.enum([
+		"GIT_HUB",
+		"BITBUCKET",
+		"GOOGLE",
+		"DIGITAL_OCEAN",
+		"SLACK",
+		"MODULUS",
+		"HEROKU",
+		"AMAZON",
+		"GIT_LAB",
+		"SHOPIFY",
+		"GIT_HUB_ENTERPRISE",
+		"GIT_LAB_ENTERPRISE",
+		"PUSHOVER",
+		"PUSHBULLET",
+		"RACKSPACE",
+		"CUSTOM",
+		"CLOUDFLARE",
+		"NEW_RELIC",
+		"SENTRY",
+		"ROLLBAR",
+		"DATADOG",
+		"DO_SPACES",
+		"HONEYBADGER",
+		"VULTR",
+		"SENTRY_ENTERPRISE",
+		"LOGGLY",
+		"HIP_CHAT",
+		"FIREBASE",
+		"TELEGRAM",
+		"AZURE",
+		"UPCLOUD",
+		"GHOST_INSPECTOR",
+		"NETLIFY",
+		"AZURE_CLOUD",
+		"MICROSOFT_TEAMS",
+		"GOOGLE_SERVICE_ACCOUNT",
+		"GOOGLE_PLAY_STORE",
+		"DOCKER_HUB",
+		"APP_STORE",
+		"GIT_HUB_APP",
+		"GIT_HUB_APP_ENTERPRISE",
+		"GIT_HUB_API",
+		"ATOP",
+		"SNYK",
+		"STACK_HAWK",
+		"BLACKFIRE",
+		"BACKBLAZE",
+		"ONE_LOGIN",
+		"OKTA",
+		"CONTENTFUL"
+	]).register(z.globalRegistry, { description: "The type of integration" })),
+	auth_type: z.optional(z.enum([
+		"OAUTH",
+		"TOKEN",
+		"API_KEY",
+		"APP",
+		"APP_SPRYKER",
+		"TOKEN_APP_EXTENSION",
+		"DEFAULT",
+		"OIDC",
+		"TRUSTED",
+		"APP_RW"
+	]).register(z.globalRegistry, { description: "The authentication method used by the integration" })),
+	host_url: z.optional(z.string().register(z.globalRegistry, { description: "The host URL for custom integrations" })),
+	webhook_address: z.optional(z.string().register(z.globalRegistry, { description: "The webhook URL for receiving notifications" })),
+	atop_url: z.optional(z.string().register(z.globalRegistry, { description: "The ATOP service URL" })),
+	app_id: z.optional(z.string().register(z.globalRegistry, { description: "The application ID for Azure Cloud integrations" })),
+	google_project: z.optional(z.string().register(z.globalRegistry, { description: "The Google Cloud project ID" })),
+	audience: z.optional(z.string().register(z.globalRegistry, { description: "The JWT audience for token validation" }))
+}).register(z.globalRegistry, { description: "Integration reference" });
+/**
+* User/member reference
+*/
+const zMemberViewWritable = z.object({
+	id: z.optional(z.int().min(-2147483648, { error: "Invalid value: Expected int32 to be >= -2147483648" }).max(2147483647, { error: "Invalid value: Expected int32 to be <= 2147483647" }).register(z.globalRegistry, { description: "The ID of the user" })),
+	name: z.optional(z.string().register(z.globalRegistry, { description: "The name of the user" })),
+	avatar_url: z.optional(z.string().register(z.globalRegistry, { description: "The avatar URL of the user" })),
+	email: z.optional(z.string().register(z.globalRegistry, { description: "The email address of the user" })),
+	admin: z.optional(z.boolean().register(z.globalRegistry, { description: "Whether the user has admin privileges" })),
+	workspace_owner: z.optional(z.boolean().register(z.globalRegistry, { description: "Whether the user is workspace owner" }))
+}).register(z.globalRegistry, { description: "User/member reference" });
+const zProjectViewWritable = z.object({
+	name: z.optional(z.string().register(z.globalRegistry, { description: "The human-readable ID of the project" })),
+	display_name: z.string().register(z.globalRegistry, { description: "The Name of the project" }),
+	status: z.optional(z.string().register(z.globalRegistry, { description: "The status of the project" })),
+	access: z.optional(z.enum(["PRIVATE", "PUBLIC"]).register(z.globalRegistry, { description: "Indicates if this is a public project" })),
+	create_date: z.optional(z.iso.datetime().register(z.globalRegistry, { description: "The creation date of the project" })),
+	external_project_id: z.optional(z.string().register(z.globalRegistry, { description: "Repo slug of the Bitbucket, GitHub or GitLab project. Required when adding the integrated project" })),
+	git_lab_project_id: z.optional(z.int().min(-2147483648, { error: "Invalid value: Expected int32 to be >= -2147483648" }).max(2147483647, { error: "Invalid value: Expected int32 to be <= 2147483647" }).register(z.globalRegistry, { description: "ID of the project in GitLab" })),
+	custom_repo_url: z.optional(z.string().register(z.globalRegistry, { description: "SSH or HTTPS url of the git repository. Required when adding the project integrated with custom git repository" })),
+	custom_repo_user: z.optional(z.string().register(z.globalRegistry, { description: "Username used to authorize access to the git repository. Required when adding the project integrated with custom git repository" })),
+	custom_repo_pass: z.optional(z.string().register(z.globalRegistry, { description: "Password used to authorize access to the git repository. Required when adding the project integrated with custom git repository and the provided `custom_repo_url` is the HTTPS url" })),
+	custom_repo_ssh_key_id: z.optional(z.int().min(-2147483648, { error: "Invalid value: Expected int32 to be >= -2147483648" }).max(2147483647, { error: "Invalid value: Expected int32 to be <= 2147483647" }).register(z.globalRegistry, { description: "The ID of the private SSH key used to authorize access to the git repository. Required when adding the project integrated with private git server by SSH url" })),
+	created_by: z.optional(zMemberViewWritable),
+	http_repository: z.optional(z.string().register(z.globalRegistry, { description: "The HTTP repository URL" })),
+	ssh_repository: z.optional(z.string().register(z.globalRegistry, { description: "The SSH repository URL" })),
+	default_branch: z.optional(z.string().register(z.globalRegistry, { description: "The default branch name" })),
+	integration: z.optional(zIntegrationIdViewWritable),
+	fetch_submodules: z.optional(z.boolean().register(z.globalRegistry, { description: "Defines whether the submodules are fetched during the runs in this project" })),
+	fetch_submodules_env_key: z.optional(z.string().register(z.globalRegistry, { description: "Name of the key that will be used to authorize while fetching the submodules. Required when `fetch_submodules` is set to `true`" })),
+	allow_pull_requests: z.optional(z.boolean().register(z.globalRegistry, { description: "Enables/disables pull requests in the project. Available only for projects synchronized with GitHub or GitHub Enterprise repository" })),
+	update_default_branch_from_external: z.optional(z.boolean().register(z.globalRegistry, { description: "If set to true, the default branch will be updated from GitHub/GitLab/Bitbucket." })),
+	without_repository: z.optional(z.boolean().register(z.globalRegistry, { description: "If set to true, the project is created without any repository attached." }))
+});
+/**
+* The environment variables of the sandbox
+*/
+const zAddVariableInObjectRequestWritable = z.object({
+	key: z.string().register(z.globalRegistry, { description: "The name of the variable" }),
+	value: z.optional(z.string().register(z.globalRegistry, { description: "The value of the variable" })),
+	settable: z.optional(z.boolean().register(z.globalRegistry, { description: "If set to `true` the variable value can be set by Buddy actions" })),
+	run_only_settable: z.optional(z.boolean().register(z.globalRegistry, { description: "Available only if `type=VAR`. If set to `true` the variable value can be set by Buddy actions only for execution time" })),
+	encrypted: z.optional(z.boolean().register(z.globalRegistry, { description: "If set to `true` the variable value will be encrypted and hidden" })),
+	description: z.optional(z.string().register(z.globalRegistry, { description: "The optional description of the variable" })),
+	init_path: z.optional(z.string().register(z.globalRegistry, { description: "Initial path for the variable" })),
+	defaults: z.optional(z.string().register(z.globalRegistry, { description: "Default value for the variable" })),
+	file_path: z.optional(z.string().register(z.globalRegistry, { description: "Specifies where to copy the file on each run. Set if `type` is `SSH_KEY`" })),
+	file_chmod: z.optional(z.string().register(z.globalRegistry, { description: "File permission set on copy to a container on each run. Set if `type` is `SSH_KEY`" })),
+	file_place: z.optional(z.enum(["NONE", "CONTAINER"]).register(z.globalRegistry, { description: "Set if `type` is `SSH_KEY`. If it's `NONE`, the variable can be used as a parameter in an action. For `CONTAINER`, the given key is additionally copied to an action container on each run" })),
+	password: z.optional(z.string().register(z.globalRegistry, { description: "Password for certificates" })),
+	passphrase: z.optional(z.string().register(z.globalRegistry, { description: "Passphrase for encrypted SSH keys" })),
+	key_identifier: z.optional(z.string().register(z.globalRegistry, { description: "GPG key identifier" })),
+	type: z.enum([
+		"VAR",
+		"FILE",
+		"SSH_KEY",
+		"IOS_KEYCHAIN",
+		"IOS_PROVISION_PROFILES",
+		"SSH_PUBLIC_KEY",
+		"GPG_KEY"
+	]).register(z.globalRegistry, { description: "The type of the added variable" })
+}).register(z.globalRegistry, { description: "The environment variables of the sandbox" });
+/**
+* The TLS/SSL encryption settings of the tunnel
+*/
+const zTlsSettingsViewWritable = z.object({
+	private_key: z.optional(z.string().register(z.globalRegistry, { description: "Private key for TLS certificate" })),
+	certificate: z.optional(z.string().register(z.globalRegistry, { description: "TLS certificate" })),
+	ca_certificate: z.optional(z.string().register(z.globalRegistry, { description: "Certificate Authority certificate" })),
+	terminate_at: z.optional(z.enum([
+		"REGION",
+		"AGENT",
+		"TARGET"
+	]).register(z.globalRegistry, { description: "Where to terminate TLS connection" }))
+}).register(z.globalRegistry, { description: "The TLS/SSL encryption settings of the tunnel" });
+/**
+* The HTTP-specific settings of the tunnel
+*/
+const zHttpSettingsViewWritable = z.object({
+	verify_certificate: z.optional(z.boolean().register(z.globalRegistry, { description: "Whether to verify SSL/TLS certificates" })),
+	compression: z.optional(z.boolean().register(z.globalRegistry, { description: "Enable HTTP compression" })),
+	http2: z.optional(z.boolean().register(z.globalRegistry, { description: "Enable HTTP/2 protocol support" })),
+	log_requests: z.optional(z.boolean().register(z.globalRegistry, { description: "Log incoming HTTP requests" })),
+	request_headers: z.optional(z.array(z.record(z.string(), z.string())).register(z.globalRegistry, { description: "Custom HTTP headers to add to requests" })),
+	whitelist_user_agents: z.optional(z.array(z.string()).register(z.globalRegistry, { description: "List of allowed User-Agent strings" })),
+	rewrite_host_header: z.optional(z.string().register(z.globalRegistry, { description: "Rewrite the Host header to this value" })),
+	response_headers: z.optional(z.array(z.record(z.string(), z.string())).register(z.globalRegistry, { description: "Custom HTTP headers to add to responses" })),
+	login: z.optional(z.string().register(z.globalRegistry, { description: "Basic authentication username" })),
+	password: z.optional(z.string().register(z.globalRegistry, { description: "Basic authentication password" })),
+	tls_ca: z.optional(z.string().register(z.globalRegistry, { description: "Custom TLS Certificate Authority" })),
+	circuit_breaker: z.optional(z.int().min(-2147483648, { error: "Invalid value: Expected int32 to be >= -2147483648" }).max(2147483647, { error: "Invalid value: Expected int32 to be <= 2147483647" }).register(z.globalRegistry, { description: "Circuit breaker threshold (number of failed requests)" })),
+	serve_path: z.optional(z.string().register(z.globalRegistry, { description: "Base path for serving requests" })),
+	auth_type: z.optional(z.enum([
+		"NONE",
+		"BASIC",
+		"BUDDY"
+	]).register(z.globalRegistry, { description: "Type of authentication used" }))
+}).register(z.globalRegistry, { description: "The HTTP-specific settings of the tunnel" });
+const zTunnelViewWritable = z.object({
+	name: z.string().register(z.globalRegistry, { description: "The name of the tunnel" }),
+	endpoint: z.string().register(z.globalRegistry, { description: "The endpoint URL of the tunnel" }),
+	type: z.enum([
+		"TCP",
+		"TLS",
+		"HTTP",
+		"SSH"
+	]).register(z.globalRegistry, { description: "The type of the tunnel" }),
+	region: z.enum([
+		"US",
+		"EU",
+		"AS"
+	]).register(z.globalRegistry, { description: "The region where the tunnel is deployed" }),
+	whitelist: z.optional(z.array(z.string()).register(z.globalRegistry, { description: "The IP addresses or domains allowed to access the tunnel" })),
+	timeout: z.optional(z.int().min(-2147483648, { error: "Invalid value: Expected int32 to be >= -2147483648" }).max(2147483647, { error: "Invalid value: Expected int32 to be <= 2147483647" }).register(z.globalRegistry, { description: "The connection timeout of the tunnel in seconds" })),
+	http: z.optional(zHttpSettingsViewWritable),
+	tls: z.optional(zTlsSettingsViewWritable),
+	endpoint_url: z.optional(z.string().register(z.globalRegistry, { description: "The url of the tunnel" }))
+});
+const zUpdateSandboxRequestWritable = z.object({
+	name: z.optional(z.string().register(z.globalRegistry, { description: "The name of the sandbox" })),
+	identifier: z.optional(z.string().register(z.globalRegistry, { description: "A human-readable ID. Alphanumeric characters, underscores, and hyphens (hyphens cannot appear at the start or end)." })),
+	resources: z.optional(z.enum([
+		"1x2",
+		"2x4",
+		"3x6",
+		"4x8",
+		"5x10",
+		"6x12",
+		"7x14",
+		"8x16",
+		"9x18",
+		"10x20",
+		"11x22",
+		"12x24",
+		"CUSTOM"
+	]).register(z.globalRegistry, { description: "The resource configuration of the sandbox (CPU x RAM)" })),
+	install_commands: z.optional(z.string().register(z.globalRegistry, { description: "The commands to run during setup of the sandbox" })),
+	run_command: z.optional(z.string().register(z.globalRegistry, { description: "The run command of the sandbox" })),
+	app_dir: z.optional(z.string().register(z.globalRegistry, { description: "The application directory of the sandbox" })),
+	app_type: z.optional(z.enum(["CMD", "SERVICE"]).register(z.globalRegistry, { description: "The application type of the sandbox (passed command or existent service eg. apache2)" })),
+	tags: z.optional(z.array(z.string().register(z.globalRegistry, { description: "The list of tags associated with the sandbox" })).register(z.globalRegistry, { description: "The list of tags associated with the sandbox" })),
+	endpoints: z.optional(z.array(zTunnelViewWritable).register(z.globalRegistry, { description: "The tunnel endpoints of the sandbox" })),
+	variables: z.optional(z.array(zAddVariableInObjectRequestWritable).register(z.globalRegistry, { description: "The environment variables of the sandbox" }))
+});
+const zSandboxesViewWritable = z.object({ sandboxes: z.optional(z.array(zSandboxIdViewWritable)) });
+/**
+* Content item in a sandbox
+*/
+const zSandboxContentItemWritable = z.object({
+	type: z.optional(z.enum(["FILE", "DIR"]).register(z.globalRegistry, { description: "The content type (FILE or DIR)" })),
+	name: z.optional(z.string().register(z.globalRegistry, { description: "The name of the file or directory" })),
+	path: z.optional(z.string().register(z.globalRegistry, { description: "The path to the file or directory" })),
+	size: z.optional(z.coerce.bigint().min(BigInt("-9223372036854775808"), { error: "Invalid value: Expected int64 to be >= -9223372036854775808" }).max(BigInt("9223372036854775807"), { error: "Invalid value: Expected int64 to be <= 9223372036854775807" }).register(z.globalRegistry, { description: "The size of the file in bytes" }))
+}).register(z.globalRegistry, { description: "Content item in a sandbox" });
+/**
+* Sandbox content listing
+*/
+const zSandboxContentViewWritable = z.object({ contents: z.optional(z.array(zSandboxContentItemWritable).register(z.globalRegistry, { description: "List of content items in the directory" })) }).register(z.globalRegistry, { description: "Sandbox content listing" });
+const zSandboxCommandViewWritable = z.object({
+	id: z.optional(z.string().register(z.globalRegistry, { description: "The ID of the command" })),
+	command: z.optional(z.string().register(z.globalRegistry, { description: "Command to execute in the sandbox" })),
+	runtime: z.optional(z.enum([
+		"BASH",
+		"JAVASCRIPT",
+		"TYPESCRIPT",
+		"PYTHON"
+	]).register(z.globalRegistry, { description: "Runtime environment for command execution (default: `BASH`)" })),
+	status: z.optional(z.enum([
+		"INPROGRESS",
+		"SUCCESSFUL",
+		"FAILED"
+	]).register(z.globalRegistry, { description: "Command execution status" })),
+	exit_code: z.optional(z.int().min(-2147483648, { error: "Invalid value: Expected int32 to be >= -2147483648" }).max(2147483647, { error: "Invalid value: Expected int32 to be <= 2147483647" }).register(z.globalRegistry, { description: "Command exit code" })),
+	logs_url: z.optional(z.string().register(z.globalRegistry, { description: "API endpoint URL to retrieve logs for this command" }))
+});
+const zSandboxCommandsViewWritable = z.object({ commands: z.optional(z.array(zSandboxCommandViewWritable)) });
+const zSandboxAppLogsViewWritable = z.object({
+	cursor: z.optional(z.string().register(z.globalRegistry, { description: "Cursor for pagination" })),
+	logs: z.optional(z.array(z.string()).register(z.globalRegistry, { description: "Application log entries" }))
+});
+const zShortSnapshotViewWritable = z.object({
+	id: z.optional(z.string().register(z.globalRegistry, { description: "The ID of the snapshot" })),
+	name: z.optional(z.string().register(z.globalRegistry, { description: "Snapshot name" })),
+	size: z.optional(z.int().min(-2147483648, { error: "Invalid value: Expected int32 to be >= -2147483648" }).max(2147483647, { error: "Invalid value: Expected int32 to be <= 2147483647" }).register(z.globalRegistry, { description: "Snapshot size in GB" })),
+	status: z.optional(z.enum([
+		"CREATING",
+		"CREATED",
+		"DELETING",
+		"FAILED"
+	]).register(z.globalRegistry, { description: "Snapshot status" })),
+	create_date: z.optional(z.iso.datetime().register(z.globalRegistry, { description: "Snapshot creation date" }))
+});
+const zSnapshotsViewWritable = z.object({ snapshots: z.optional(z.array(zShortSnapshotViewWritable).register(z.globalRegistry, { description: "Collection of snapshots" })) });
+const zSnapshotViewWritable = z.object({
+	id: z.optional(z.string().register(z.globalRegistry, { description: "The ID of the snapshot" })),
+	name: z.optional(z.string().register(z.globalRegistry, { description: "Snapshot name" })),
+	size: z.optional(z.int().min(-2147483648, { error: "Invalid value: Expected int32 to be >= -2147483648" }).max(2147483647, { error: "Invalid value: Expected int32 to be <= 2147483647" }).register(z.globalRegistry, { description: "Snapshot size in GB" })),
+	status: z.optional(z.enum([
+		"CREATING",
+		"CREATED",
+		"DELETING",
+		"FAILED"
+	]).register(z.globalRegistry, { description: "Snapshot status" })),
+	create_date: z.optional(z.iso.datetime().register(z.globalRegistry, { description: "Snapshot creation date" })),
+	created_by: z.optional(zMemberViewWritable)
+});
+const zSandboxYamlViewWritable = z.object({ yaml: z.optional(z.string().register(z.globalRegistry, { description: "The base64-encoded YAML configuration of the sandbox" })) });
+const zCreateNewSandboxRequestWritable = z.object({
+	name: z.string().register(z.globalRegistry, { description: "The name of the sandbox" }),
+	identifier: z.optional(z.string().register(z.globalRegistry, { description: "A human-readable ID. Alphanumeric characters, underscores, and hyphens (hyphens cannot appear at the start or end)." })),
+	os: z.string().register(z.globalRegistry, { description: "The operating system of the sandbox [\"ubuntu:22.04\", \"ubuntu:24.04\"]" }),
+	resources: z.optional(z.enum([
+		"1x2",
+		"2x4",
+		"3x6",
+		"4x8",
+		"5x10",
+		"6x12",
+		"7x14",
+		"8x16",
+		"9x18",
+		"10x20",
+		"11x22",
+		"12x24",
+		"CUSTOM"
+	]).register(z.globalRegistry, { description: "The resource configuration of the sandbox (CPU x RAM)" })),
+	install_commands: z.optional(z.string().register(z.globalRegistry, { description: "The commands to run during setup of the sandbox" })),
+	run_command: z.optional(z.string().register(z.globalRegistry, { description: "The run command of the sandbox" })),
+	app_dir: z.optional(z.string().register(z.globalRegistry, { description: "The application directory of the sandbox" })),
+	app_type: z.optional(z.enum(["CMD", "SERVICE"]).register(z.globalRegistry, { description: "The application type of the sandbox (passed command or existent service eg. apache2)" })),
+	tags: z.optional(z.array(z.string().register(z.globalRegistry, { description: "The list of tags associated with the sandbox" })).register(z.globalRegistry, { description: "The list of tags associated with the sandbox" })),
+	endpoints: z.optional(z.array(zTunnelViewWritable).register(z.globalRegistry, { description: "The tunnel endpoints of the sandbox" })),
+	variables: z.optional(z.array(zAddVariableInObjectRequestWritable).register(z.globalRegistry, { description: "The environment variables of the sandbox" }))
+});
+const zCreateFromSnapshotRequestWritable = z.object({
+	snapshot_id: z.string().register(z.globalRegistry, { description: "The ID of the snapshot to create from" }),
+	name: z.string().register(z.globalRegistry, { description: "The name of the sandbox" }),
+	identifier: z.optional(z.string().register(z.globalRegistry, { description: "A human-readable ID. Alphanumeric characters, underscores, and hyphens (hyphens cannot appear at the start or end)." })),
+	os: z.optional(z.string().register(z.globalRegistry, { description: "The operating system of the sandbox [\"ubuntu:22.04\", \"ubuntu:24.04\"]" })),
+	resources: z.optional(z.enum([
+		"1x2",
+		"2x4",
+		"3x6",
+		"4x8",
+		"5x10",
+		"6x12",
+		"7x14",
+		"8x16",
+		"9x18",
+		"10x20",
+		"11x22",
+		"12x24",
+		"CUSTOM"
+	]).register(z.globalRegistry, { description: "The resource configuration of the sandbox (CPU x RAM)" })),
+	install_commands: z.optional(z.string().register(z.globalRegistry, { description: "The commands to run during setup of the sandbox" })),
+	run_command: z.optional(z.string().register(z.globalRegistry, { description: "The run command of the sandbox" })),
+	app_dir: z.optional(z.string().register(z.globalRegistry, { description: "The application directory of the sandbox" })),
+	app_type: z.optional(z.enum(["CMD", "SERVICE"]).register(z.globalRegistry, { description: "The application type of the sandbox (passed command or existent service eg. apache2)" })),
+	tags: z.optional(z.array(z.string().register(z.globalRegistry, { description: "The list of tags associated with the sandbox" })).register(z.globalRegistry, { description: "The list of tags associated with the sandbox" })),
+	endpoints: z.optional(z.array(zTunnelViewWritable).register(z.globalRegistry, { description: "The tunnel endpoints of the sandbox" })),
+	variables: z.optional(z.array(zEnvironmentVariableView).register(z.globalRegistry, { description: "The environment variables of the sandbox" }))
+});
+const zSandboxResponseWritable = z.object({
+	id: z.optional(z.string().register(z.globalRegistry, { description: "The ID of the sandbox" })),
+	identifier: z.optional(z.string().register(z.globalRegistry, { description: "A human-readable ID. Alphanumeric characters, underscores, and hyphens (hyphens cannot appear at the start or end)." })),
+	name: z.optional(z.string().register(z.globalRegistry, { description: "The name of the sandbox" })),
+	status: z.optional(z.enum([
+		"STARTING",
+		"STOPPING",
+		"FAILED",
+		"RUNNING",
+		"STOPPED",
+		"RESTORING"
+	]).register(z.globalRegistry, { description: "The current status of the sandbox" })),
+	os: z.optional(z.string().register(z.globalRegistry, { description: "The operating system of the sandbox [\"ubuntu:22.04\", \"ubuntu:24.04\"]" })),
+	resources: z.optional(z.enum([
+		"1x2",
+		"2x4",
+		"3x6",
+		"4x8",
+		"5x10",
+		"6x12",
+		"7x14",
+		"8x16",
+		"9x18",
+		"10x20",
+		"11x22",
+		"12x24",
+		"CUSTOM"
+	]).register(z.globalRegistry, { description: "The resource configuration of the sandbox (CPU x RAM)" })),
+	install_commands: z.optional(z.string().register(z.globalRegistry, { description: "The commands to run during setup of the sandbox" })),
+	run_command: z.optional(z.string().register(z.globalRegistry, { description: "The run command of the sandbox" })),
+	app_dir: z.optional(z.string().register(z.globalRegistry, { description: "The application directory of the sandbox" })),
+	app_type: z.optional(z.enum(["CMD", "SERVICE"]).register(z.globalRegistry, { description: "The application type of the sandbox (passed command or existent service eg. apache2)" })),
+	tags: z.optional(z.array(z.string()).register(z.globalRegistry, { description: "The list of tags associated with the sandbox" })),
+	app_status: z.optional(z.enum([
+		"NONE",
+		"RUNNING",
+		"ENDED",
+		"FAILED"
+	]).register(z.globalRegistry, { description: "The current application status of the sandbox" })),
+	boot_logs: z.optional(z.array(z.string()).register(z.globalRegistry, { description: "The boot logs of the sandbox" })),
+	setup_status: z.optional(z.enum([
+		"INPROGRESS",
+		"SUCCESS",
+		"FAILED"
+	]).register(z.globalRegistry, { description: "The current setup status of the sandbox" })),
+	endpoints: z.optional(z.array(zTunnelViewWritable).register(z.globalRegistry, { description: "The tunnel endpoints of the sandbox" })),
+	project: z.optional(zProjectViewWritable),
+	variables: z.optional(z.array(zEnvironmentVariableView).register(z.globalRegistry, { description: "The environment variables of the sandbox" }))
+});
+const zGetSandboxesData = z.object({
+	body: z.optional(z.never()),
+	path: z.object({ workspace_domain: z.string().register(z.globalRegistry, { description: "The human-readable ID of the workspace" }) }),
+	query: z.object({ project_name: z.string().register(z.globalRegistry, { description: "The human-readable ID of the project to filter sandboxes" }) })
+});
+const zGetSandboxesResponse = zSandboxesView;
+const zAddSandboxData = z.object({
+	body: z.optional(z.union([
+		zCloneSandboxRequest,
+		zCreateFromSnapshotRequestWritable,
+		zCreateNewSandboxRequestWritable
+	])),
+	path: z.object({ workspace_domain: z.string().register(z.globalRegistry, { description: "The human-readable ID of the workspace" }) }),
+	query: z.object({ project_name: z.string().register(z.globalRegistry, { description: "The human-readable ID of the project to filter sandboxes" }) })
+});
+const zAddSandboxResponse = zSandboxResponse;
+const zDeleteSandboxData = z.object({
+	body: z.optional(z.never()),
+	path: z.object({
+		workspace_domain: z.string().register(z.globalRegistry, { description: "The human-readable ID of the workspace" }),
+		id: z.string().register(z.globalRegistry, { description: "The ID of the sandbox" })
+	}),
+	query: z.optional(z.never())
+});
+/**
+* Sandbox deleted successfully
+*/
+const zDeleteSandboxResponse = z.void().register(z.globalRegistry, { description: "Sandbox deleted successfully" });
+const zGetSandboxData = z.object({
+	body: z.optional(z.never()),
+	path: z.object({
+		workspace_domain: z.string().register(z.globalRegistry, { description: "The human-readable ID of the workspace" }),
+		id: z.string().register(z.globalRegistry, { description: "The ID of the sandbox" })
+	}),
+	query: z.optional(z.never())
+});
+const zGetSandboxResponse = zSandboxResponse;
+const zUpdateSandboxData = z.object({
+	body: z.optional(zUpdateSandboxRequestWritable),
+	path: z.object({
+		workspace_domain: z.string().register(z.globalRegistry, { description: "The human-readable ID of the workspace" }),
+		id: z.string().register(z.globalRegistry, { description: "The ID of the sandbox" })
+	}),
+	query: z.optional(z.never())
+});
+const zGetSandboxAppLogsData = z.object({
+	body: z.optional(z.never()),
+	path: z.object({
+		workspace_domain: z.string().register(z.globalRegistry, { description: "The human-readable ID of the workspace" }),
+		sandbox_id: z.string().register(z.globalRegistry, { description: "The ID of the sandbox" })
+	}),
+	query: z.optional(z.object({ cursor: z.optional(z.string().register(z.globalRegistry, { description: "Cursor for pagination" })) }))
+});
+const zGetSandboxCommandsData = z.object({
+	body: z.optional(z.never()),
+	path: z.object({
+		workspace_domain: z.string().register(z.globalRegistry, { description: "The human-readable ID of the workspace" }),
+		sandbox_id: z.string().register(z.globalRegistry, { description: "The ID of the sandbox" })
+	}),
+	query: z.optional(z.never())
+});
+const zExecuteSandboxCommandData = z.object({
+	body: z.optional(zExecuteSandboxCommandRequest),
+	path: z.object({
+		workspace_domain: z.string().register(z.globalRegistry, { description: "The human-readable ID of the workspace" }),
+		sandbox_id: z.string().register(z.globalRegistry, { description: "The ID of the sandbox" })
+	}),
+	query: z.optional(z.never())
+});
+const zExecuteSandboxCommandResponse = zSandboxCommandView;
+const zGetSandboxCommandData = z.object({
+	body: z.optional(z.never()),
+	path: z.object({
+		workspace_domain: z.string().register(z.globalRegistry, { description: "The human-readable ID of the workspace" }),
+		sandbox_id: z.string().register(z.globalRegistry, { description: "The ID of the sandbox" }),
+		id: z.string().register(z.globalRegistry, { description: "The ID of the command" })
+	}),
+	query: z.optional(z.never())
+});
+const zGetSandboxCommandResponse = zSandboxCommandView;
+const zGetSandboxCommandLogsData = z.object({
+	body: z.optional(z.never()),
+	path: z.object({
+		workspace_domain: z.string().register(z.globalRegistry, { description: "The human-readable ID of the workspace" }),
+		sandbox_id: z.string().register(z.globalRegistry, { description: "The ID of the sandbox" }),
+		command_id: z.string().register(z.globalRegistry, { description: "The ID of the command" })
+	}),
+	query: z.optional(z.object({ follow: z.optional(z.boolean().register(z.globalRegistry, { description: "If true, streams logs until the command completes" })) }))
+});
+const zTerminateSandboxCommandData = z.object({
+	body: z.optional(z.never()),
+	path: z.object({
+		workspace_domain: z.string().register(z.globalRegistry, { description: "The human-readable ID of the workspace" }),
+		sandbox_id: z.string().register(z.globalRegistry, { description: "The ID of the sandbox" }),
+		command_id: z.string().register(z.globalRegistry, { description: "The ID of the command" })
+	}),
+	query: z.optional(z.never())
+});
+const zTerminateSandboxCommandResponse = zSandboxCommandView;
+const zDeleteSandboxFileData = z.object({
+	body: z.optional(z.never()),
+	path: z.object({
+		workspace_domain: z.string().register(z.globalRegistry, { description: "The human-readable ID of the workspace" }),
+		sandbox_id: z.string().register(z.globalRegistry, { description: "The ID of the sandbox" }),
+		path: z.string().regex(/.*/).register(z.globalRegistry, { description: "Absolute path to the file or directory to delete" })
+	}),
+	query: z.optional(z.never())
+});
+/**
+* File or directory deleted successfully
+*/
+const zDeleteSandboxFileResponse = z.void().register(z.globalRegistry, { description: "File or directory deleted successfully" });
+const zGetSandboxContentData = z.object({
+	body: z.optional(z.never()),
+	path: z.object({
+		workspace_domain: z.string().register(z.globalRegistry, { description: "The human-readable ID of the workspace" }),
+		sandbox_id: z.string().register(z.globalRegistry, { description: "The ID of the sandbox" }),
+		path: z.string().regex(/.*/).register(z.globalRegistry, { description: "Absolute path to the file or directory. Recommended directory is `/buddy`" })
+	}),
+	query: z.optional(z.never())
+});
+/**
+* Content retrieved successfully
+*/
+const zGetSandboxContentResponse = zSandboxContentView;
+const zCreateSandboxDirectoryData = z.object({
+	body: z.optional(z.never()),
+	path: z.object({
+		workspace_domain: z.string().register(z.globalRegistry, { description: "The human-readable ID of the workspace" }),
+		sandbox_id: z.string().register(z.globalRegistry, { description: "The ID of the sandbox" }),
+		path: z.string().regex(/.*/).register(z.globalRegistry, { description: "Absolute path where the directory should be created" })
+	}),
+	query: z.optional(z.never())
+});
+/**
+* Directory created successfully
+*/
+const zCreateSandboxDirectoryResponse = zSandboxContentItem;
+const zUploadSandboxFileData = z.object({
+	body: z.optional(z.string().register(z.globalRegistry, { description: "File to upload" })),
+	path: z.object({
+		workspace_domain: z.string().register(z.globalRegistry, { description: "The human-readable ID of the workspace" }),
+		sandbox_id: z.string().register(z.globalRegistry, { description: "The ID of the sandbox" }),
+		path: z.string().regex(/.*/).register(z.globalRegistry, { description: "Absolute path where the file should be uploaded. Recommended directory is `/buddy`" })
+	}),
+	query: z.optional(z.never())
+});
+/**
+* File uploaded successfully
+*/
+const zUploadSandboxFileResponse = zSandboxContentItem;
+const zDownloadSandboxContentData = z.object({
+	body: z.optional(z.never()),
+	path: z.object({
+		workspace_domain: z.string().register(z.globalRegistry, { description: "The human-readable ID of the workspace" }),
+		sandbox_id: z.string().register(z.globalRegistry, { description: "The ID of the sandbox" }),
+		path: z.string().regex(/.*/).register(z.globalRegistry, { description: "Absolute path to the file or directory to download" })
+	}),
+	query: z.optional(z.never())
+});
+const zRestartSandboxData = z.object({
+	body: z.optional(z.never()),
+	path: z.object({
+		workspace_domain: z.string().register(z.globalRegistry, { description: "The human-readable ID of the workspace" }),
+		sandbox_id: z.string().register(z.globalRegistry, { description: "The ID of the sandbox" })
+	}),
+	query: z.optional(z.never())
+});
+const zRestartSandboxResponse = zSandboxResponse;
+const zGetSandboxSnapshotsData = z.object({
+	body: z.optional(z.never()),
+	path: z.object({
+		workspace_domain: z.string().register(z.globalRegistry, { description: "The human-readable ID of the workspace" }),
+		sandbox_id: z.string().register(z.globalRegistry, { description: "The ID of the sandbox" })
+	}),
+	query: z.optional(z.never())
+});
+const zAddSandboxSnapshotData = z.object({
+	body: z.optional(zAddSnapshotRequest),
+	path: z.object({
+		workspace_domain: z.string().register(z.globalRegistry, { description: "The human-readable ID of the workspace" }),
+		sandbox_id: z.string().register(z.globalRegistry, { description: "The ID of the sandbox" })
+	}),
+	query: z.optional(z.never())
+});
+const zDeleteSandboxSnapshotData = z.object({
+	body: z.optional(z.never()),
+	path: z.object({
+		workspace_domain: z.string().register(z.globalRegistry, { description: "The human-readable ID of the workspace" }),
+		sandbox_id: z.string().register(z.globalRegistry, { description: "The ID of the sandbox" }),
+		id: z.string().register(z.globalRegistry, { description: "The ID of the snapshot" })
+	}),
+	query: z.optional(z.never())
+});
+/**
+* Sandbox snapshot deleted successfully
+*/
+const zDeleteSandboxSnapshotResponse = z.void().register(z.globalRegistry, { description: "Sandbox snapshot deleted successfully" });
+const zGetSandboxSnapshotData = z.object({
+	body: z.optional(z.never()),
+	path: z.object({
+		workspace_domain: z.string().register(z.globalRegistry, { description: "The human-readable ID of the workspace" }),
+		sandbox_id: z.string().register(z.globalRegistry, { description: "The ID of the sandbox" }),
+		id: z.string().register(z.globalRegistry, { description: "The ID of the snapshot" })
+	}),
+	query: z.optional(z.never())
+});
+const zStartSandboxData = z.object({
+	body: z.optional(z.never()),
+	path: z.object({
+		workspace_domain: z.string().register(z.globalRegistry, { description: "The human-readable ID of the workspace" }),
+		sandbox_id: z.string().register(z.globalRegistry, { description: "The ID of the sandbox" })
+	}),
+	query: z.optional(z.never())
+});
+const zStartSandboxResponse = zSandboxResponse;
+const zStopSandboxData = z.object({
+	body: z.optional(z.never()),
+	path: z.object({
+		workspace_domain: z.string().register(z.globalRegistry, { description: "The human-readable ID of the workspace" }),
+		sandbox_id: z.string().register(z.globalRegistry, { description: "The ID of the sandbox" })
+	}),
+	query: z.optional(z.never())
+});
+const zStopSandboxResponse = zSandboxResponse;
+const zGetSandboxYamlData = z.object({
+	body: z.optional(z.never()),
+	path: z.object({
+		workspace_domain: z.string().register(z.globalRegistry, { description: "The human-readable ID of the workspace" }),
+		sandbox_id: z.string().register(z.globalRegistry, { description: "The ID of the sandbox" })
+	}),
+	query: z.optional(z.never())
+});
+const zUpdateSandboxByYamlData = z.object({
+	body: z.optional(zSandboxYamlViewWritable),
+	path: z.object({
+		workspace_domain: z.string().register(z.globalRegistry, { description: "The human-readable ID of the workspace" }),
+		sandbox_id: z.string().register(z.globalRegistry, { description: "The ID of the sandbox" })
+	}),
+	query: z.optional(z.never())
+});
+const zGetProjectSnapshotsData = z.object({
+	body: z.optional(z.never()),
+	path: z.object({ workspace_domain: z.string().register(z.globalRegistry, { description: "The human-readable ID of the workspace" }) }),
+	query: z.object({ project_name: z.string().register(z.globalRegistry, { description: "The human-readable ID of the project to filter sandboxes" }) })
+});
+const zDeleteSnapshotData = z.object({
+	body: z.optional(z.never()),
+	path: z.object({
+		workspace_domain: z.string().register(z.globalRegistry, { description: "The human-readable ID of the workspace" }),
+		id: z.string().register(z.globalRegistry, { description: "The ID of the snapshot" })
+	}),
+	query: z.optional(z.never())
+});
+/**
+* Sandbox snapshot deleted successfully
+*/
+const zDeleteSnapshotResponse = z.void().register(z.globalRegistry, { description: "Sandbox snapshot deleted successfully" });
+const zAddSandboxByYamlData = z.object({
+	body: z.optional(zSandboxYamlViewWritable),
+	path: z.object({ workspace_domain: z.string().register(z.globalRegistry, { description: "The human-readable ID of the workspace" }) }),
+	query: z.object({ project_name: z.string().register(z.globalRegistry, { description: "The human-readable ID of the project to filter sandboxes" }) })
+});
+
+//#endregion
+//#region package.json
+var name = "@buddy-works/sandbox-sdk";
+var version = "0.1.0-rc.1";
+
+//#endregion
+//#region src/utils/environment.ts
+const environmentConfig = {
+	BUDDY_TOKEN: {
+		type: "string",
+		secret: true
+	},
+	BUDDY_API_URL: { type: "string" },
+	BUDDY_REGION: { type: "string" },
+	BUDDY_WORKSPACE: { type: "string" },
+	BUDDY_PROJECT: { type: "string" },
+	BUDDY_LOGGER_LEVEL: { type: "string" }
+};
+function processConfigEntry(key, config) {
+	return config.required === true ? getEnvironment(key, true) : getEnvironment(key, false);
+}
+function loadEnvironment() {
+	const variables = {};
+	for (const key of Object.keys(environmentConfig)) try {
+		const config = environmentConfig[key];
+		if (config.type === "string" && config.required) getEnvironment(key, true);
+	} catch (error) {
+		return {
+			error,
+			variables: {}
+		};
+	}
+	for (const key of Object.keys(environmentConfig)) Object.defineProperty(variables, key, {
+		get() {
+			return processConfigEntry(key, environmentConfig[key]);
+		},
+		enumerable: true,
+		configurable: true
+	});
+	return { variables };
+}
+function getEnvironment(key, required = false) {
+	const MISSING_REQUIRED_ENVIRONMENT_VARIABLE_ERROR = `Missing required configuration. Please set the ${key} environment variable.`;
+	const value = process.env[key];
+	if (value === void 0) {
+		if (required) throw new Error(MISSING_REQUIRED_ENVIRONMENT_VARIABLE_ERROR);
+		return;
+	}
+	const trimmedValue = value.trim();
+	if (trimmedValue === "") {
+		if (required) throw new Error(MISSING_REQUIRED_ENVIRONMENT_VARIABLE_ERROR);
+		return;
+	}
+	return trimmedValue;
+}
+const environmentResult = loadEnvironment();
+var environment_default = environmentResult.variables;
+
+//#endregion
+//#region src/utils/logger.ts
+const LOG_LEVELS = {
+	debug: 5,
+	info: 4,
+	warn: 3,
+	error: 2,
+	silent: 0
+};
+var Logger = class {
+	#prefix;
+	#MAX_ERROR_DEPTH = 10;
+	level;
+	constructor() {
+		this.#prefix = `${name}@${version}`;
+		this.level = LOG_LEVELS[environment_default.BUDDY_LOGGER_LEVEL ?? ""] ?? LOG_LEVELS.warn;
+	}
+	get prefix() {
+		return this.#prefix;
+	}
+	safeStringify(object) {
+		if (object === null || object === void 0) return "";
+		const cache = /* @__PURE__ */ new Set();
+		return JSON.stringify(object, (_key, value) => {
+			if (typeof value === "object" && value !== null) {
+				if (cache.has(value)) return "[Circular chain]";
+				cache.add(value);
+			}
+			return value;
+		}, 2);
+	}
+	#safeGetProperties(error) {
+		try {
+			const customProperties = Object.keys(error).filter((k) => k !== "cause");
+			return customProperties.length > 0 ? Object.fromEntries(customProperties.map((k) => [k, Reflect.get(error, k)])) : void 0;
+		} catch {
+			return;
+		}
+	}
+	#formatCompactError(error) {
+		let output = `${error.name}: ${error.message}`;
+		const properties = this.#safeGetProperties(error);
+		if (properties) try {
+			const propertyPairs = Object.entries(properties).map(([key, value]) => `${key}: ${this.safeStringify(value)}`).join(", ");
+			output += ` (${propertyPairs})`;
+		} catch {
+			output += " (properties unavailable)";
+		}
+		return output;
+	}
+	#formatFullError(error, depth) {
+		let output = error.stack ? `${error.stack}\n` : `${error.name}: ${error.message}\n`;
+		const properties = this.#safeGetProperties(error);
+		if (properties) try {
+			output += `Properties: ${this.safeStringify(properties)}\n`;
+		} catch {
+			output += "Properties: [unable to serialize]\n";
+		}
+		if ("cause" in error && error.cause) {
+			output += `  Caused by: ${this.#formatErrorForDebug(error.cause, true, depth + 1)}`;
+			let currentCause = error.cause;
+			let currentDepth = depth + 1;
+			while (currentDepth < this.#MAX_ERROR_DEPTH && typeof currentCause === "object" && "cause" in currentCause && currentCause.cause) {
+				output += `\n  → ${this.#formatErrorForDebug(currentCause.cause, true, currentDepth + 1)}`;
+				currentCause = currentCause.cause;
+				currentDepth++;
+			}
+			output += "\n";
+		}
+		return output;
+	}
+	#formatErrorForDebug(error, compact = false, depth = 0) {
+		try {
+			if (depth >= this.#MAX_ERROR_DEPTH) return "[Max depth reached - possible circular cause chain]";
+			if (!(error instanceof Error)) return this.safeStringify(error);
+			return compact ? this.#formatCompactError(error) : this.#formatFullError(error, depth);
+		} catch {
+			return "[Logger Error: Unable to format error details]";
+		}
+	}
+	debug(message, data) {
+		if (this.level >= LOG_LEVELS.debug) console.debug(`[${this.#prefix}] DEBUG: ${message}`, data ? this.safeStringify(data) : "");
+	}
+	info(message, data) {
+		if (this.level >= LOG_LEVELS.info) console.log(`[${this.#prefix}] INFO: ${message}`, data ? this.safeStringify(data) : "");
+	}
+	warn(message, data) {
+		if (this.level >= LOG_LEVELS.warn) console.warn(`[${this.#prefix}] WARN: ${message}`, data ? this.safeStringify(data) : "");
+	}
+	error(message, error) {
+		if (this.level >= LOG_LEVELS.error) if (this.level >= LOG_LEVELS.debug) {
+			const fullError = this.#formatErrorForDebug(error);
+			console.error(`[${this.#prefix}] ERROR: ${message}\n${fullError}`);
+		} else {
+			const errorMessage = error instanceof Error ? error.message : this.safeStringify(error);
+			console.error(`[${this.#prefix}] ERROR: ${message}${errorMessage ? ` - ${errorMessage}` : ""}`);
+		}
+	}
+};
+var logger_default = new Logger();
+
+//#endregion
+//#region src/core/http-client.ts
+/** Custom error class for HTTP request failures with status and response details */
+var HttpError = class HttpError extends Error {
+	status;
+	response;
+	errors;
+	/** Create an HttpError with message, status code, and optional response */
+	constructor(message, status, response) {
+		const apiErrors = response?.data && typeof response.data === "object" && "errors" in response.data ? response.data.errors : void 0;
+		let fullMessage = message;
+		if (status) fullMessage = `HTTP ${String(status)}: ${message}`;
+		if (apiErrors && Array.isArray(apiErrors) && apiErrors.length > 0) {
+			const errorMessages = apiErrors.map((error) => typeof error === "object" && error && "message" in error ? error.message : String(error)).filter(Boolean);
+			if (errorMessages.length > 0) fullMessage += `\n${errorMessages.join("\n")}`;
+		}
+		super(fullMessage);
+		this.name = "HttpError";
+		this.status = status;
+		Object.defineProperty(this, "response", {
+			value: response,
+			enumerable: false,
+			writable: false,
+			configurable: true
+		});
+		Object.defineProperty(this, "errors", {
+			value: apiErrors,
+			enumerable: false,
+			writable: false,
+			configurable: true
+		});
+		Object.setPrototypeOf(this, HttpError.prototype);
+	}
+	/** Custom inspect output for Node.js util.inspect */
+	[inspect.custom]() {
+		return this.stack ?? `${this.name}: ${this.message}`;
+	}
+};
+/** Base HTTP client with retry logic, timeout handling, and authentication support */
+var HttpClient = class {
+	#baseURL;
+	#timeout;
+	#defaultHeaders;
+	debugMode;
+	#authToken;
+	/** Create a new HTTP client with optional base URL, timeout, and headers */
+	constructor(config = {}) {
+		this.debugMode = config.debugMode ?? logger_default.level >= 5;
+		this.#baseURL = config.baseURL ?? "";
+		this.#timeout = config.timeout ?? 3e4;
+		this.#defaultHeaders = {
+			"Content-Type": "application/json",
+			...config.headers
+		};
+	}
+	/** Build a full URL from path and optional query parameters */
+	#buildUrl(path, queryParameters) {
+		const url = new URL(path, this.#baseURL);
+		if (queryParameters) {
+			for (const [key, value] of Object.entries(queryParameters)) if (value !== void 0) url.searchParams.set(key, String(value));
+		}
+		return url.toString();
+	}
+	/** Merge default headers with additional headers and auth token */
+	#getHeaders(additionalHeaders) {
+		const headers = {
+			...this.#defaultHeaders,
+			...additionalHeaders
+		};
+		if (this.#authToken) headers["Authorization"] = `Bearer ${this.#authToken}`;
+		return headers;
+	}
+	/** Execute a request function with automatic retry on transient failures */
+	async #executeWithRetry(requestFunction, skipRetry = false) {
+		if (skipRetry) return requestFunction();
+		return pRetry(requestFunction, {
+			retries: 3,
+			minTimeout: 1e3,
+			maxTimeout: 1e4,
+			onFailedAttempt: ({ error }) => {
+				if (error instanceof HttpError) {
+					const status = error.status;
+					if (status && status >= 400 && status < 500 && status !== 429) throw error;
+				}
+			}
+		});
+	}
+	/** Execute an HTTP request with timeout, retry, and error handling */
+	async #request(method, url, data, config) {
+		const { skipRetry, queryParams, headers: additionalHeaders, responseType = "json" } = config ?? {};
+		const fullUrl = this.#buildUrl(url, queryParams);
+		const headers = this.#getHeaders(additionalHeaders);
+		const makeRequest = async () => {
+			const controller = new AbortController();
+			const timeoutId = setTimeout(() => {
+				controller.abort();
+			}, this.#timeout);
+			try {
+				if (this.debugMode) logger_default.debug("[HTTP REQUEST]", {
+					method,
+					url: fullUrl,
+					headers: {
+						...headers,
+						Authorization: headers["Authorization"] ? "***" : void 0
+					},
+					body: data
+				});
+				const fetchOptions = {
+					method,
+					headers,
+					signal: controller.signal
+				};
+				if (data !== void 0) fetchOptions.body = JSON.stringify(data);
+				const response = await fetch(fullUrl, fetchOptions);
+				let responseData;
+				if (responseType === "text") responseData = await response.text();
+				else {
+					const text = await response.text();
+					responseData = text ? JSON.parse(text) : void 0;
+				}
+				const httpResponse = {
+					status: response.status,
+					statusText: response.statusText,
+					data: responseData,
+					headers: response.headers
+				};
+				if (this.debugMode) logger_default.debug("[HTTP RESPONSE]", {
+					status: response.status,
+					body: responseData
+				});
+				clearTimeout(timeoutId);
+				if (!response.ok) throw new HttpError(response.statusText || "Request failed", response.status, httpResponse);
+				return httpResponse;
+			} catch (error) {
+				clearTimeout(timeoutId);
+				if (error instanceof HttpError) throw error;
+				if (error instanceof Error && error.name === "AbortError") throw new HttpError("Request timeout", 0);
+				throw new HttpError(error instanceof Error ? error.message : "Request failed", 0);
+			}
+		};
+		return this.#executeWithRetry(makeRequest, skipRetry);
+	}
+	/** Perform a GET request */
+	async get(url, config) {
+		return this.#request("GET", url, void 0, config);
+	}
+	/** Perform a POST request with optional body data */
+	async post(url, data, config) {
+		return this.#request("POST", url, data ?? {}, config);
+	}
+	/** Perform a DELETE request */
+	async delete(url, config) {
+		return this.#request("DELETE", url, void 0, config);
+	}
+	/** Set the Bearer token for authenticated requests */
+	setAuthToken(token) {
+		this.#authToken = token;
+	}
+};
+
+//#endregion
+//#region src/core/buddy-api-client.ts
+/** API client for Buddy sandbox operations with request validation and response transformation */
+var BuddyApiClient = class extends HttpClient {
+	workspace;
+	project_name;
+	#apiUrl;
+	#token;
+	/** Builds a parameterized URL by replacing path placeholders */
+	#buildUrl(params) {
+		const { path = {}, url } = params;
+		return url.replace(/{(\w+)}/g, (_, key) => {
+			const value = path[key];
+			if (value === void 0) throw new Error(`Missing path parameter: ${key}`);
+			return value;
+		});
+	}
+	/** Parse and validate HTTP response data against a Zod schema */
+	async #parseResponse(schema, response) {
+		const result = await schema.safeParseAsync(response.data);
+		if (!result.success) throw new HttpError(`Response validation failed:\n${prettifyError(result.error)}`, response.status, response);
+		return result.data;
+	}
+	/** Check if a schema expects query parameters (not ZodNever) */
+	#schemaExpectsQuery(schema) {
+		const querySchema = schema.shape.query;
+		if (querySchema instanceof z.ZodOptional) {
+			if (querySchema._def.innerType instanceof z.ZodNever) return false;
+		}
+		return true;
+	}
+	/** Execute an HTTP request with input/output validation */
+	async #requestWithValidation({ method, url, data, dataSchema, responseSchema, skipRetry }) {
+		const expectsQuery = this.#schemaExpectsQuery(dataSchema);
+		const fullData = {
+			body: data.body,
+			path: {
+				workspace_domain: this.workspace,
+				...data.path ?? {}
+			},
+			query: expectsQuery ? {
+				project_name: this.project_name,
+				...data.query ?? {}
+			} : void 0
+		};
+		const result = await dataSchema.safeParseAsync(fullData);
+		if (!result.success) throw result.error;
+		const validatedData = result.data;
+		const parameterizedUrl = this.#buildUrl({
+			url,
+			path: validatedData.path
+		});
+		const requestConfig = {
+			queryParams: validatedData.query,
+			skipRetry
+		};
+		let request;
+		switch (method) {
+			case "POST":
+				request = this.post(parameterizedUrl, validatedData.body ?? {}, requestConfig);
+				break;
+			case "GET":
+				request = this.get(parameterizedUrl, requestConfig);
+				break;
+			case "DELETE":
+				request = this.delete(parameterizedUrl, requestConfig);
+				break;
+		}
+		const response = await request;
+		return await this.#parseResponse(responseSchema, response);
+	}
+	/** Create a new sandbox */
+	async addSandbox(data) {
+		return this.#requestWithValidation({
+			method: "POST",
+			data,
+			url: "/workspaces/{workspace_domain}/sandboxes",
+			dataSchema: zAddSandboxData,
+			responseSchema: zAddSandboxResponse.transform(addSandboxResponseTransformer)
+		});
+	}
+	/** Get a specific sandbox by its ID */
+	async getSandboxById(data) {
+		return this.#requestWithValidation({
+			method: "GET",
+			data,
+			url: "/workspaces/{workspace_domain}/sandboxes/{id}",
+			dataSchema: zGetSandboxData,
+			responseSchema: zGetSandboxResponse.transform(getSandboxResponseTransformer)
+		});
+	}
+	/** Execute a command in a sandbox */
+	async executeCommand(data) {
+		return this.#requestWithValidation({
+			method: "POST",
+			data,
+			url: "/workspaces/{workspace_domain}/sandboxes/{sandbox_id}/commands",
+			dataSchema: zExecuteSandboxCommandData,
+			responseSchema: zExecuteSandboxCommandResponse
+		});
+	}
+	/** Get a specific command execution details */
+	async getCommandDetails(data) {
+		return this.#requestWithValidation({
+			method: "GET",
+			data,
+			url: "/workspaces/{workspace_domain}/sandboxes/{sandbox_id}/commands/{id}",
+			dataSchema: zGetSandboxCommandData,
+			responseSchema: zGetSandboxCommandResponse
+		});
+	}
+	/** Terminate a running command in a sandbox */
+	async terminateCommand(data) {
+		return this.#requestWithValidation({
+			method: "POST",
+			data,
+			url: "/workspaces/{workspace_domain}/sandboxes/{sandbox_id}/commands/{command_id}/terminate",
+			dataSchema: zTerminateSandboxCommandData,
+			responseSchema: zTerminateSandboxCommandResponse
+		});
+	}
+	/** Delete a sandbox by its ID */
+	async deleteSandboxById(data) {
+		try {
+			return await this.#requestWithValidation({
+				method: "DELETE",
+				data,
+				url: "/workspaces/{workspace_domain}/sandboxes/{id}",
+				dataSchema: zDeleteSandboxData,
+				responseSchema: zDeleteSandboxResponse,
+				skipRetry: true
+			});
+		} catch (error) {
+			if (error instanceof HttpError && error.status === 404) return;
+			throw error;
+		}
+	}
+	/** Get all sandboxes in the workspace for a specific project */
+	async getSandboxes(data) {
+		return this.#requestWithValidation({
+			method: "GET",
+			data,
+			url: "/workspaces/{workspace_domain}/sandboxes",
+			dataSchema: zGetSandboxesData,
+			responseSchema: zGetSandboxesResponse
+		});
+	}
+	/** Start a sandbox */
+	async startSandbox(data) {
+		return this.#requestWithValidation({
+			method: "POST",
+			data,
+			url: "/workspaces/{workspace_domain}/sandboxes/{sandbox_id}/start",
+			dataSchema: zStartSandboxData,
+			responseSchema: zStartSandboxResponse.transform(startSandboxResponseTransformer)
+		});
+	}
+	/** Stop a sandbox */
+	async stopSandbox(data) {
+		return this.#requestWithValidation({
+			method: "POST",
+			data,
+			url: "/workspaces/{workspace_domain}/sandboxes/{sandbox_id}/stop",
+			dataSchema: zStopSandboxData,
+			responseSchema: zStopSandboxResponse.transform(stopSandboxResponseTransformer)
+		});
+	}
+	/** Restart a sandbox */
+	async restartSandbox(data) {
+		return this.#requestWithValidation({
+			method: "POST",
+			data,
+			url: "/workspaces/{workspace_domain}/sandboxes/{sandbox_id}/restart",
+			dataSchema: zRestartSandboxData,
+			responseSchema: zRestartSandboxResponse.transform(restartSandboxResponseTransformer)
+		});
+	}
+	/** Get sandbox content (list files/directories at a path) */
+	async getSandboxContent(data) {
+		return this.#requestWithValidation({
+			method: "GET",
+			data,
+			url: "/workspaces/{workspace_domain}/sandboxes/{sandbox_id}/content/{path}",
+			dataSchema: zGetSandboxContentData,
+			responseSchema: zGetSandboxContentResponse.transform(getSandboxContentResponseTransformer)
+		});
+	}
+	/** Delete a file or directory from a sandbox */
+	async deleteSandboxFile(data) {
+		return this.#requestWithValidation({
+			method: "DELETE",
+			data,
+			url: "/workspaces/{workspace_domain}/sandboxes/{sandbox_id}/content/{path}",
+			dataSchema: zDeleteSandboxFileData,
+			responseSchema: zDeleteSandboxFileResponse
+		});
+	}
+	/** Create a directory in a sandbox */
+	async createSandboxDirectory(data) {
+		return this.#requestWithValidation({
+			method: "POST",
+			data,
+			url: "/workspaces/{workspace_domain}/sandboxes/{sandbox_id}/content/{path}",
+			dataSchema: zCreateSandboxDirectoryData,
+			responseSchema: zCreateSandboxDirectoryResponse.transform(createSandboxDirectoryResponseTransformer)
+		});
+	}
+	/** Upload a file to a sandbox */
+	async uploadSandboxFile(data) {
+		const fullData = {
+			body: data.body,
+			path: {
+				workspace_domain: this.workspace,
+				...data.path ?? {}
+			},
+			query: void 0
+		};
+		const validationResult = await zUploadSandboxFileData.safeParseAsync({
+			...fullData,
+			body: void 0
+		});
+		if (!validationResult.success) throw validationResult.error;
+		const validatedData = validationResult.data;
+		const parameterizedUrl = this.#buildUrl({
+			url: "/workspaces/{workspace_domain}/sandboxes/{sandbox_id}/content/upload/{path}",
+			path: validatedData.path
+		});
+		const url = new URL(parameterizedUrl, this.#apiUrl);
+		url.searchParams.set("project_name", this.project_name);
+		const filename = data.path.path.split("/").pop() ?? "file";
+		const formData = new FormData();
+		formData.append("file", data.body, filename);
+		const headers = { Authorization: `Bearer ${this.#token}` };
+		if (this.debugMode) logger_default.debug("[HTTP REQUEST - Upload]", {
+			method: "POST",
+			url: url.toString(),
+			headers: {
+				...headers,
+				Authorization: "***"
+			},
+			formData
+		});
+		const response = await fetch(url.toString(), {
+			method: "POST",
+			headers,
+			body: formData
+		});
+		if (!response.ok) throw new HttpError(`Failed to upload file: ${response.statusText}`, response.status);
+		const responseData = await response.json();
+		const result = await zUploadSandboxFileResponse.transform(uploadSandboxFileResponseTransformer).safeParseAsync(responseData);
+		if (!result.success) throw new HttpError(`Response validation failed:\n${prettifyError(result.error)}`, response.status);
+		return result.data;
+	}
+	/** Download content from a sandbox (file or directory as tar.gz) */
+	async downloadSandboxContent(data) {
+		const fullData = {
+			body: void 0,
+			path: {
+				workspace_domain: this.workspace,
+				...data.path
+			},
+			query: void 0
+		};
+		const validationResult = await zDownloadSandboxContentData.safeParseAsync(fullData);
+		if (!validationResult.success) throw validationResult.error;
+		const validatedData = validationResult.data;
+		const parameterizedUrl = this.#buildUrl({
+			url: "/workspaces/{workspace_domain}/sandboxes/{sandbox_id}/download/{path}",
+			path: validatedData.path
+		});
+		const url = new URL(parameterizedUrl, this.#apiUrl);
+		const headers = {
+			Accept: "application/octet-stream",
+			Authorization: `Bearer ${this.#token}`
+		};
+		if (this.debugMode) logger_default.debug("[HTTP REQUEST - Download]", {
+			method: "GET",
+			url: url.toString(),
+			headers: {
+				...headers,
+				Authorization: "***"
+			}
+		});
+		const response = await fetch(url.toString(), {
+			method: "GET",
+			headers
+		});
+		if (!response.ok) throw new HttpError(`Failed to download content: ${response.statusText}`, response.status);
+		const contentDisposition = response.headers.get("Content-Disposition");
+		let filename = "download";
+		if (contentDisposition) {
+			const match = contentDisposition.match(/filename="?([^";\n]+)"?/);
+			if (match?.[1]) filename = match[1];
+		}
+		return {
+			data: await response.arrayBuffer(),
+			filename
+		};
+	}
+	/** Stream logs from a specific command execution */
+	async *streamCommandLogs(data) {
+		const fullData = {
+			body: data.body,
+			path: {
+				workspace_domain: this.workspace,
+				...data.path ?? {}
+			},
+			query: data.query
+		};
+		const validationResult = await zGetSandboxCommandLogsData.safeParseAsync(fullData);
+		if (!validationResult.success) throw validationResult.error;
+		const validatedData = validationResult.data;
+		const parameterizedUrl = this.#buildUrl({
+			url: "/workspaces/{workspace_domain}/sandboxes/{sandbox_id}/commands/{command_id}/logs",
+			path: validatedData.path
+		});
+		const url = new URL(parameterizedUrl, this.#apiUrl);
+		if (validatedData.query?.follow !== void 0) url.searchParams.set("follow", String(validatedData.query.follow));
+		const headers = {
+			Accept: "application/jsonl",
+			"Content-Type": "application/json",
+			Authorization: `Bearer ${this.#token}`
+		};
+		const response = await fetch(url.toString(), {
+			method: "GET",
+			headers
+		});
+		if (this.debugMode) logger_default.debug("[HTTP REQUEST - Streaming]", {
+			method: "GET",
+			url: url.toString(),
+			headers: {
+				...headers,
+				Authorization: "***"
+			}
+		});
+		if (!response.ok) throw new HttpError(`Failed to stream logs: ${response.statusText}`, response.status);
+		const contentType = response.headers.get("content-type");
+		if (!contentType?.includes("application/jsonl")) throw new Error(`Expected application/jsonl content type, got: ${contentType ?? "none"}`);
+		if (!response.body) throw new Error("No response body available for streaming");
+		const reader = response.body.getReader();
+		const decoder = new TextDecoder();
+		let buffer = "";
+		try {
+			while (true) {
+				const readResult = await reader.read();
+				if (readResult.done) break;
+				const chunk = readResult.value;
+				buffer += decoder.decode(chunk, { stream: true });
+				const lines = buffer.split("\n");
+				buffer = lines.pop() || "";
+				for (const line of lines) {
+					if (!line.trim()) continue;
+					const logEntry = await this.#parseAndValidateLogEntry(line);
+					if (this.debugMode) logger_default.debug(`[STREAM] ${logEntry.type}`, { content: logEntry.data });
+					yield logEntry;
+				}
+			}
+			if (buffer.trim()) yield this.#parseAndValidateLogEntry(buffer);
+		} finally {
+			reader.releaseLock();
+		}
+	}
+	/** Parse a JSON line and validate it as a SandboxCommandLog */
+	async #parseAndValidateLogEntry(line) {
+		let parsed;
+		try {
+			parsed = JSON.parse(line);
+		} catch (error) {
+			throw new Error(`Failed to parse log entry as JSON: ${error instanceof Error ? error.message : String(error)}. Line: ${line}`);
+		}
+		const result = await zSandboxCommandLog.safeParseAsync(parsed);
+		if (!result.success) throw result.error;
+		return result.data;
+	}
+	/** Create a new Buddy API client instance */
+	constructor(config) {
+		const token = config.token ?? environment_default.BUDDY_TOKEN;
+		if (!token) throw new Error("Buddy API token is required. Set BUDDY_TOKEN environment variable or pass token in config.");
+		super({
+			...config,
+			baseURL: config.apiUrl,
+			headers: {
+				Accept: "application/json",
+				"Content-Type": "application/json",
+				...config.headers
+			}
+		});
+		this.workspace = config.workspace;
+		this.project_name = config.project_name;
+		this.#apiUrl = config.apiUrl;
+		this.#token = token;
+		this.setAuthToken(token);
+	}
+};
+
+//#endregion
+//#region src/entity/command.ts
+/** Represents a running or completed command execution in a sandbox */
+var Command = class Command {
+	commandResponse;
+	client;
+	sandboxId;
+	commandId;
+	/** Create a new Command instance from an API response */
+	constructor({ commandResponse, client, sandboxId }) {
+		if (!commandResponse.id) throw new Error("Command response must have an id");
+		this.commandResponse = commandResponse;
+		this.client = client;
+		this.sandboxId = sandboxId;
+		this.commandId = commandResponse.id;
+	}
+	/** The raw command response data from the API */
+	get data() {
+		return this.commandResponse;
+	}
+	/**
+	* Stream logs from the command in real-time
+	* @returns AsyncGenerator yielding log entries with type and data
+	*/
+	logs({ follow } = {}) {
+		return this.client.streamCommandLogs({
+			path: {
+				command_id: this.commandId,
+				sandbox_id: this.sandboxId
+			},
+			query: { follow }
+		});
+	}
+	/**
+	* Wait for the command to finish execution
+	* @returns Command instance with final response data
+	*/
+	async wait() {
+		return new Command({
+			commandResponse: await this.pollForCommandCompletion(),
+			client: this.client,
+			sandboxId: this.sandboxId
+		});
+	}
+	/**
+	* Get all output from the command (waits for completion)
+	* @returns Complete output as a string
+	*/
+	async output(stream = "BOTH") {
+		let data = "";
+		for await (const log of this.logs({ follow: true })) if (stream === "BOTH" || log.type === stream) data += `${log.data ?? ""}\n`;
+		return data;
+	}
+	/**
+	* Get all stdout output from the command (waits for completion)
+	* @returns Stdout as a string
+	*/
+	async stdout() {
+		return this.output("STDOUT");
+	}
+	/**
+	* Get all stderr output from the command (waits for completion)
+	* @returns Stderr as a string
+	*/
+	async stderr() {
+		return this.output("STDERR");
+	}
+	/** Terminate the running command */
+	async kill() {
+		await this.client.terminateCommand({ path: {
+			sandbox_id: this.sandboxId,
+			command_id: this.commandId
+		} });
+	}
+	/**
+	* Poll the API until the command reaches a terminal state
+	* @returns Final command response
+	*/
+	async pollForCommandCompletion(pollIntervalMs = 1e3) {
+		while (true) {
+			const commandResponse = await this.client.getCommandDetails({ path: {
+				sandbox_id: this.sandboxId,
+				id: this.commandId
+			} });
+			if (commandResponse.status === "SUCCESSFUL" || commandResponse.status === "FAILED") return commandResponse;
+			await new Promise((resolve) => setTimeout(resolve, pollIntervalMs));
+		}
+	}
+};
+
+//#endregion
+//#region src/errors/index.ts
+const ERROR_CODES = {
+	HTTP_ERROR: "HTTP_ERROR",
+	VALIDATION_ERROR: "VALIDATION_ERROR",
+	GENERIC_ERROR: "GENERIC_ERROR"
+};
+var BuddySDKError = class BuddySDKError extends Error {
+	code;
+	constructor(message, options) {
+		super(message);
+		this.name = "BuddySDKError";
+		this.code = options?.code ?? ERROR_CODES.GENERIC_ERROR;
+		if (options?.statusCode !== void 0) Object.defineProperty(this, "statusCode", {
+			value: options.statusCode,
+			enumerable: false,
+			writable: false,
+			configurable: true
+		});
+		if (options?.details !== void 0) Object.defineProperty(this, "details", {
+			value: options.details,
+			enumerable: false,
+			writable: false,
+			configurable: true
+		});
+		if (options?.cause !== void 0) Object.defineProperty(this, "cause", {
+			value: options.cause,
+			enumerable: false,
+			writable: false,
+			configurable: true
+		});
+		Object.setPrototypeOf(this, BuddySDKError.prototype);
+	}
+};
+function fromHttpError(operation, httpError) {
+	return new BuddySDKError(`${operation}${httpError.status ? ` (HTTP ${httpError.status})` : ""}: ${httpError.errors && httpError.errors.length > 0 ? httpError.errors.map((error) => typeof error === "object" && error && "message" in error ? error.message : String(error)).join(", ") : httpError.message}`, {
+		code: ERROR_CODES.HTTP_ERROR,
+		statusCode: httpError.status,
+		details: httpError.errors
+	});
+}
+function fromZodError(operation, zodError) {
+	return new BuddySDKError(`${operation}:\n${prettifyError(zodError)}`, { code: ERROR_CODES.VALIDATION_ERROR });
+}
+async function withErrorHandler(operation, fn) {
+	try {
+		return await fn();
+	} catch (error) {
+		if (error instanceof BuddySDKError) throw error;
+		let sdkError;
+		if (error instanceof HttpError) sdkError = fromHttpError(operation, error);
+		else if (error instanceof ZodError) sdkError = fromZodError(operation, error);
+		else sdkError = new BuddySDKError(error instanceof Error ? error.message : String(error), {
+			code: ERROR_CODES.GENERIC_ERROR,
+			...error instanceof Error && { cause: error }
+		});
+		throw sdkError;
+	}
+}
+
+//#endregion
+//#region src/utils/regions.ts
+const REGIONS = {
+	US: "US",
+	EU: "EU",
+	AP: "AP"
+};
+const API_URLS = {
+	US: "https://api.buddy.works",
+	EU: "https://api.eu.buddy.works",
+	AP: "https://api.asia.buddy.works"
+};
+function getApiUrlFromRegion(region) {
+	return API_URLS[region];
+}
+function parseRegion(input) {
+	if (!input) return REGIONS.US;
+	const normalized = input.toUpperCase().trim();
+	if (normalized === "US" || normalized === "EU" || normalized === "AP") return normalized;
+	throw new Error(`Invalid region: "${input}". Valid regions are: US, EU, AP`);
+}
+
+//#endregion
+//#region src/utils/client.ts
+/** Resolve connection config with environment variable fallbacks */
+function getConfig(connection) {
+	const workspace = connection?.workspace ?? environment_default.BUDDY_WORKSPACE;
+	if (!workspace) throw new Error("Workspace not found. Set workspace in config.connection or BUDDY_WORKSPACE env var.");
+	const project = connection?.project ?? environment_default.BUDDY_PROJECT;
+	if (!project) throw new Error("Project not found. Set project in config.connection or BUDDY_PROJECT env var.");
+	let apiUrl;
+	if (connection?.apiUrl) apiUrl = connection.apiUrl;
+	else if (environment_default.BUDDY_API_URL) apiUrl = environment_default.BUDDY_API_URL;
+	else if (connection?.region) apiUrl = getApiUrlFromRegion(parseRegion(connection.region));
+	else if (environment_default.BUDDY_REGION) apiUrl = getApiUrlFromRegion(parseRegion(environment_default.BUDDY_REGION));
+	else apiUrl = API_URLS.US;
+	return {
+		workspace,
+		projectName: project,
+		token: connection?.token,
+		apiUrl
+	};
+}
+/** Create a BuddyApiClient from connection config */
+function createClient(connection) {
+	const { workspace, projectName, token, apiUrl } = getConfig(connection);
+	return new BuddyApiClient({
+		workspace,
+		project_name: projectName,
+		apiUrl,
+		...token ? { token } : {}
+	});
+}
+
+//#endregion
+//#region src/entity/filesystem.ts
+/**
+* Provides file system operations within a Sandbox.
+*
+* FileSystem instances can be created either direct via `FileSystem.forSandbox()`
+* or accessed via the `Sandbox.fs` property.
+*/
+var FileSystem = class FileSystem {
+	#client;
+	#sandboxId;
+	/**
+	* Create a FileSystem instance for a specific sandbox.
+	*
+	* @param sandboxId - The ID of the sandbox
+	* @param config - Optional configuration including connection settings
+	* @returns A FileSystem instance for the specified sandbox
+	*/
+	static forSandbox(sandboxId, config) {
+		return new FileSystem(createClient(config?.connection), sandboxId);
+	}
+	constructor(client, sandboxId) {
+		this.#client = client;
+		this.#sandboxId = sandboxId;
+	}
+	/**
+	* Lists contents of a directory in the Sandbox.
+	*
+	* @param dirPath - Directory path to list. Relative paths are resolved based on the sandbox working directory.
+	* @returns Array of file and directory information
+	*/
+	async listFiles(dirPath) {
+		return withErrorHandler("Failed to list files", async () => {
+			return ((await this.#client.getSandboxContent({ path: {
+				sandbox_id: this.#sandboxId,
+				path: this.#normalizePath(dirPath)
+			} })).contents ?? []).map((item) => this.#mapContentItemToFileInfo(item));
+		});
+	}
+	/**
+	* Create a new directory in the Sandbox.
+	*
+	* @param dirPath - Path where the directory should be created
+	*/
+	async createFolder(dirPath) {
+		return withErrorHandler("Failed to create folder", async () => {
+			await this.#client.createSandboxDirectory({ path: {
+				sandbox_id: this.#sandboxId,
+				path: this.#normalizePath(dirPath)
+			} });
+		});
+	}
+	/**
+	* Deletes a file or directory from the Sandbox.
+	*
+	* @param filePath - Path to the file or directory to delete
+	*/
+	async deleteFile(filePath) {
+		return withErrorHandler("Failed to delete file", async () => {
+			await this.#client.deleteSandboxFile({ path: {
+				sandbox_id: this.#sandboxId,
+				path: this.#normalizePath(filePath)
+			} });
+		});
+	}
+	/**
+	* Downloads a file from the Sandbox.
+	*
+	* @param remotePath - Path to the file in the Sandbox
+	* @param localPath - Optional local path to save the file
+	* @returns File contents as a Buffer
+	*/
+	async downloadFile(remotePath, localPath) {
+		return withErrorHandler("Failed to download file", async () => {
+			const { data } = await this.#client.downloadSandboxContent({ path: {
+				sandbox_id: this.#sandboxId,
+				path: this.#normalizePath(remotePath)
+			} });
+			const buffer = Buffer.from(data);
+			if (localPath) await fs.promises.writeFile(localPath, buffer);
+			return buffer;
+		});
+	}
+	/**
+	* Uploads a file to the Sandbox.
+	*
+	* @param source - Buffer with content or path to local file
+	* @param remotePath - Destination path in the Sandbox
+	*/
+	async uploadFile(source, remotePath) {
+		return withErrorHandler("Failed to upload file", async () => {
+			let blob;
+			if (Buffer.isBuffer(source)) blob = new Blob([source]);
+			else {
+				const fileContent = await fs.promises.readFile(source);
+				blob = new Blob([fileContent]);
+			}
+			await this.#client.uploadSandboxFile({
+				body: blob,
+				path: {
+					sandbox_id: this.#sandboxId,
+					path: this.#normalizePath(remotePath)
+				}
+			});
+		});
+	}
+	#mapContentItemToFileInfo(item) {
+		return {
+			name: item.name ?? "",
+			path: item.path ?? "",
+			type: item.type ?? "FILE",
+			size: item.size,
+			url: item.url,
+			htmlUrl: item.html_url
+		};
+	}
+	/**
+	* Normalize path for API calls - strip leading slash.
+	* API expects: "buddy/src" not "/buddy/src"
+	*/
+	#normalizePath(filePath) {
+		return filePath.startsWith("/") ? filePath.slice(1) : filePath;
+	}
+};
+
+//#endregion
+//#region src/entity/sandbox.ts
+const PRIVATE_CONSTRUCTOR_KEY = Symbol("SandboxConstructor");
+const INITIALIZE_INSTRUCTIONS = "Use Sandbox.create(), Sandbox.getById(), or Sandbox.getByIdentifier() to obtain an instance.";
+var Sandbox = class Sandbox {
+	#sandboxData;
+	#client;
+	#fs;
+	/** The raw sandbox response data from the API */
+	get data() {
+		return this.#sandboxData ?? {};
+	}
+	/** The sandbox ID, throws if not initialized */
+	get initializedId() {
+		const id = this.#sandboxData?.id;
+		if (!id) throw new Error(`Sandbox ID is missing. The sandbox may have been deleted or not properly initialized. ${INITIALIZE_INSTRUCTIONS}`);
+		return id;
+	}
+	/**
+	* File system operations for this sandbox.
+	* Provides methods for listing, uploading, downloading, and managing files.
+	*/
+	get fs() {
+		const sandboxId = this.initializedId;
+		if (!this.#fs) this.#fs = new FileSystem(this.#client, sandboxId);
+		return this.#fs;
+	}
+	/**
+	* Create a new sandbox
+	* @param config - Sandbox configuration including identifier, name, os, and optional connection settings
+	* @returns A ready-to-use Sandbox instance
+	*/
+	static async create(config) {
+		return withErrorHandler("Failed to create sandbox", async () => {
+			const { connection, ...sandboxConfig } = config ?? {};
+			const client = createClient(connection);
+			const requestBody = {
+				name: `Sandbox ${(/* @__PURE__ */ new Date()).toISOString()}`,
+				identifier: config?.identifier || `sandbox_${String(Date.now())}`,
+				os: "ubuntu:24.04",
+				...sandboxConfig
+			};
+			const sandbox = new Sandbox(await client.addSandbox({ body: requestBody }), client, PRIVATE_CONSTRUCTOR_KEY);
+			logger_default.debug(`Waiting for sandbox ${sandbox.data.id} to be ready...`);
+			await sandbox.waitUntilReady();
+			logger_default.debug(`Sandbox ${sandbox.data.id} is ready (Setup status: ${sandbox.data.setup_status})`);
+			return sandbox;
+		});
+	}
+	/**
+	* Get an existing sandbox by its identifier
+	* @param identifier - Identifier of the sandbox to retrieve
+	* @param config - Optional configuration including connection settings
+	* @returns The Sandbox instance
+	*/
+	static async getByIdentifier(identifier, config) {
+		return withErrorHandler("Failed to get sandbox by identifier", async () => {
+			const { connection } = config ?? {};
+			const client = createClient(connection);
+			const sandboxId = ((await client.getSandboxes({}))?.sandboxes ?? []).find((s) => s.identifier === identifier)?.id;
+			if (!sandboxId) throw new Error(`Sandbox with identifier '${identifier}' not found`);
+			const sandboxResponse = await client.getSandboxById({ path: { id: sandboxId } });
+			if (!sandboxResponse) throw new Error(`Sandbox with ID '${sandboxId}' not found`);
+			return new Sandbox(sandboxResponse, client, PRIVATE_CONSTRUCTOR_KEY);
+		});
+	}
+	/**
+	* Get an existing sandbox by its ID
+	* @param sandboxId - ID of the sandbox to retrieve
+	* @param config - Optional configuration including connection settings
+	* @returns The Sandbox instance
+	*/
+	static async getById(sandboxId, config) {
+		return withErrorHandler("Failed to get sandbox", async () => {
+			const { connection } = config ?? {};
+			const client = createClient(connection);
+			const sandboxResponse = await client.getSandboxById({ path: { id: sandboxId } });
+			if (!sandboxResponse) throw new Error(`Sandbox with ID '${sandboxId}' not found`);
+			return new Sandbox(sandboxResponse, client, PRIVATE_CONSTRUCTOR_KEY);
+		});
+	}
+	/**
+	* List all sandboxes in the workspace
+	*
+	* Returns a simplified view of each sandbox (id, identifier, name, status, urls)
+	* rather than full Sandbox instances. Use `getById()` or `getByIdentifier()`
+	* to get a full Sandbox instance for a specific sandbox.
+	*
+	* @param config - Optional configuration including connection settings
+	* @returns Array of simplified sandbox objects
+	*/
+	static async list(config) {
+		return withErrorHandler("Failed to list sandboxes", async () => {
+			const { connection } = config ?? {};
+			return (await createClient(connection).getSandboxes({}))?.sandboxes ?? [];
+		});
+	}
+	/**
+	* Execute a command in the sandbox
+	* @returns Command instance (call wait() for blocking execution)
+	*/
+	async runCommand(options) {
+		const sandboxId = this.initializedId;
+		return withErrorHandler("Failed to run command", async () => {
+			const { stdout, stderr, detached, ...commandRequest } = options;
+			const outputStdout = stdout === null ? null : stdout ?? process.stdout;
+			const outputStderr = stderr === null ? null : stderr ?? process.stderr;
+			logger_default.debug(`Executing command: $ ${commandRequest.command}`);
+			const command = new Command({
+				commandResponse: await this.#client.executeCommand({
+					body: commandRequest,
+					path: { sandbox_id: sandboxId }
+				}),
+				client: this.#client,
+				sandboxId
+			});
+			const streamingPromise = outputStdout || outputStderr ? await (async () => {
+				for await (const log of command.logs({ follow: true })) {
+					const output = `${log.data ?? ""}\n`;
+					if (log.type === "STDOUT" && outputStdout) outputStdout.write(output);
+					else if (log.type === "STDERR" && outputStderr) outputStderr.write(output);
+				}
+			})() : Promise.resolve();
+			if (detached) return command;
+			const [finishedCommand] = await Promise.all([command.wait(), streamingPromise]);
+			return finishedCommand;
+		});
+	}
+	/**
+	* Delete the sandbox permanently
+	*/
+	async destroy() {
+		const sandboxId = this.initializedId;
+		return withErrorHandler("Failed to destroy sandbox", async () => {
+			await this.#client.deleteSandboxById({ path: { id: sandboxId } });
+		});
+	}
+	/**
+	* Refresh the sandbox data from the API
+	* Updates the internal state with the latest sandbox information
+	*/
+	async refresh() {
+		const sandboxId = this.initializedId;
+		return withErrorHandler("Failed to refresh sandbox", async () => {
+			this.#sandboxData = await this.#client.getSandboxById({ path: { id: sandboxId } });
+		});
+	}
+	/**
+	* Wait until the sandbox setup is complete
+	* @param pollIntervalMs - How often to check the status (default: 1000ms)
+	*/
+	async waitUntilReady(pollIntervalMs = 1e3) {
+		const sandboxId = this.initializedId;
+		return withErrorHandler("Sandbox not ready", async () => {
+			while (true) {
+				await this.refresh();
+				if (this.data.setup_status === "SUCCESS") return;
+				if (this.data.setup_status === "FAILED") throw new Error(`Sandbox ${sandboxId} setup failed. Status: ${this.data.setup_status}`);
+				await new Promise((resolve) => setTimeout(resolve, pollIntervalMs));
+			}
+		});
+	}
+	/**
+	* Wait until the sandbox is in RUNNING state
+	* @param pollIntervalMs - How often to check the status (default: 1000ms)
+	* @param maxWaitMs - Maximum time to wait before timing out (default: 60000ms)
+	*/
+	async waitUntilRunning(pollIntervalMs = 1e3, maxWaitMs = 6e4) {
+		const sandboxId = this.initializedId;
+		return withErrorHandler("Sandbox not running", async () => {
+			const startTime = Date.now();
+			while (true) {
+				await this.refresh();
+				if (this.data.status === "RUNNING") return;
+				if (this.data.status === "FAILED") throw new Error(`Sandbox ${sandboxId} failed. Status: ${this.data.status}`);
+				if (Date.now() - startTime > maxWaitMs) throw new Error(`Timeout waiting for sandbox ${sandboxId} to be RUNNING. Current: ${this.data.status}`);
+				await new Promise((resolve) => setTimeout(resolve, pollIntervalMs));
+			}
+		});
+	}
+	/**
+	* Wait until the sandbox is in STOPPED state
+	* @param pollIntervalMs - How often to check the status (default: 1000ms)
+	* @param maxWaitMs - Maximum time to wait before timing out (default: 60000ms)
+	*/
+	async waitUntilStopped(pollIntervalMs = 1e3, maxWaitMs = 6e4) {
+		const sandboxId = this.initializedId;
+		return withErrorHandler("Sandbox not stopped", async () => {
+			const startTime = Date.now();
+			while (true) {
+				await this.refresh();
+				if (this.data.status === "STOPPED") return;
+				if (this.data.status === "FAILED") throw new Error(`Sandbox ${sandboxId} failed. Status: ${this.data.status}`);
+				if (Date.now() - startTime > maxWaitMs) throw new Error(`Timeout waiting for sandbox ${sandboxId} to be STOPPED. Current: ${this.data.status}`);
+				await new Promise((resolve) => setTimeout(resolve, pollIntervalMs));
+			}
+		});
+	}
+	/**
+	* Start a stopped sandbox
+	* Waits until the sandbox reaches RUNNING state
+	*/
+	async start() {
+		const sandboxId = this.initializedId;
+		return withErrorHandler("Failed to start sandbox", async () => {
+			logger_default.debug(`Starting sandbox ${sandboxId}...`);
+			this.#sandboxData = await this.#client.startSandbox({ path: { sandbox_id: sandboxId } });
+			await this.waitUntilRunning();
+			logger_default.debug(`Sandbox ${sandboxId} is now running. Status: ${this.data.status}`);
+		});
+	}
+	/**
+	* Stop a running sandbox
+	* Waits until the sandbox reaches STOPPED state
+	*/
+	async stop() {
+		const sandboxId = this.initializedId;
+		return withErrorHandler("Failed to stop sandbox", async () => {
+			logger_default.debug(`Stopping sandbox ${sandboxId}...`);
+			this.#sandboxData = await this.#client.stopSandbox({ path: { sandbox_id: sandboxId } });
+			await this.waitUntilStopped();
+			logger_default.debug(`Sandbox ${sandboxId} is now stopped. Status: ${this.data.status}`);
+		});
+	}
+	/**
+	* Restart the sandbox
+	* Waits until the sandbox reaches RUNNING state and setup is complete
+	*/
+	async restart() {
+		const sandboxId = this.initializedId;
+		return withErrorHandler("Failed to restart sandbox", async () => {
+			logger_default.debug(`Restarting sandbox ${sandboxId}...`);
+			this.#sandboxData = await this.#client.restartSandbox({ path: { sandbox_id: sandboxId } });
+			await this.waitUntilRunning();
+			await this.waitUntilReady();
+			logger_default.debug(`Sandbox ${sandboxId} has been restarted and is ready. Status: ${this.data.status}, Setup status: ${this.data.setup_status}`);
+		});
+	}
+	constructor(sandboxData, client, constructorKey) {
+		if (constructorKey !== PRIVATE_CONSTRUCTOR_KEY) throw new Error(`Cannot construct Sandbox directly. ${INITIALIZE_INSTRUCTIONS}`);
+		this.#sandboxData = sandboxData;
+		this.#client = client;
+	}
+};
+
+//#endregion
+export { API_URLS, BuddyApiClient, BuddySDKError, Command, ERROR_CODES, FileSystem, REGIONS, Sandbox };