github.com/anthropics/anthropic-sdk-go@v1.70.1/betaenvironment.go

// File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.

package anthropic

import (
	"context"
	"encoding/json"
	"errors"
	"fmt"
	"net/http"
	"net/url"
	"slices"

	"github.com/anthropics/anthropic-sdk-go/internal/apijson"
	"github.com/anthropics/anthropic-sdk-go/internal/apiquery"
	"github.com/anthropics/anthropic-sdk-go/internal/requestconfig"
	"github.com/anthropics/anthropic-sdk-go/option"
	"github.com/anthropics/anthropic-sdk-go/packages/pagination"
	"github.com/anthropics/anthropic-sdk-go/packages/param"
	"github.com/anthropics/anthropic-sdk-go/packages/respjson"
	"github.com/anthropics/anthropic-sdk-go/shared/constant"
)

// BetaEnvironmentService contains methods and other services that help with
// interacting with the anthropic API.
//
// Note, unlike clients, this service does not read variables from the environment
// automatically. You should not instantiate this service directly, and instead use
// the [NewBetaEnvironmentService] method instead.
type BetaEnvironmentService struct {
	Options []option.RequestOption
	Work    BetaEnvironmentWorkService
}

// NewBetaEnvironmentService generates a new service that applies the given options
// to each request. These options are applied after the parent client's options (if
// there is one), and before any request-specific options.
func NewBetaEnvironmentService(opts ...option.RequestOption) (r BetaEnvironmentService) {
	r = BetaEnvironmentService{}
	r.Options = opts
	r.Work = NewBetaEnvironmentWorkService(opts...)
	return
}

// Create a new environment with the specified configuration.
func (r *BetaEnvironmentService) New(ctx context.Context, params BetaEnvironmentNewParams, opts ...option.RequestOption) (res *BetaEnvironment, err error) {
	for _, v := range params.Betas {
		opts = append(opts, option.WithHeaderAdd("anthropic-beta", fmt.Sprintf("%v", v)))
	}
	if !param.IsOmitted(params.WorkspaceID) {
		opts = append(opts, option.WithHeader("anthropic-workspace-id", fmt.Sprintf("%v", params.WorkspaceID.Value)))
	}
	opts = slices.Concat(r.Options, opts)
	opts = append([]option.RequestOption{option.WithHeader("anthropic-beta", "managed-agents-2026-04-01")}, opts...)
	path := "v1/environments?beta=true"
	err = requestconfig.ExecuteNewRequest(ctx, http.MethodPost, path, params, &res, opts...)
	return res, err
}

// Retrieve a specific environment by ID.
func (r *BetaEnvironmentService) Get(ctx context.Context, environmentID string, query BetaEnvironmentGetParams, opts ...option.RequestOption) (res *BetaEnvironment, err error) {
	for _, v := range query.Betas {
		opts = append(opts, option.WithHeaderAdd("anthropic-beta", fmt.Sprintf("%v", v)))
	}
	if !param.IsOmitted(query.WorkspaceID) {
		opts = append(opts, option.WithHeader("anthropic-workspace-id", fmt.Sprintf("%v", query.WorkspaceID.Value)))
	}
	opts = slices.Concat(r.Options, opts)
	opts = append([]option.RequestOption{option.WithHeader("anthropic-beta", "managed-agents-2026-04-01")}, opts...)
	if environmentID == "" {
		err = errors.New("missing required environment_id parameter")
		return nil, err
	}
	path := fmt.Sprintf("v1/environments/%s?beta=true", environmentID)
	err = requestconfig.ExecuteNewRequest(ctx, http.MethodGet, path, nil, &res, opts...)
	return res, err
}

// Update an existing environment's configuration.
func (r *BetaEnvironmentService) Update(ctx context.Context, environmentID string, params BetaEnvironmentUpdateParams, opts ...option.RequestOption) (res *BetaEnvironment, err error) {
	for _, v := range params.Betas {
		opts = append(opts, option.WithHeaderAdd("anthropic-beta", fmt.Sprintf("%v", v)))
	}
	if !param.IsOmitted(params.WorkspaceID) {
		opts = append(opts, option.WithHeader("anthropic-workspace-id", fmt.Sprintf("%v", params.WorkspaceID.Value)))
	}
	opts = slices.Concat(r.Options, opts)
	opts = append([]option.RequestOption{option.WithHeader("anthropic-beta", "managed-agents-2026-04-01")}, opts...)
	if environmentID == "" {
		err = errors.New("missing required environment_id parameter")
		return nil, err
	}
	path := fmt.Sprintf("v1/environments/%s?beta=true", environmentID)
	err = requestconfig.ExecuteNewRequest(ctx, http.MethodPost, path, params, &res, opts...)
	return res, err
}

// List environments with pagination support.
func (r *BetaEnvironmentService) List(ctx context.Context, params BetaEnvironmentListParams, opts ...option.RequestOption) (res *pagination.PageCursor[BetaEnvironment], err error) {
	var raw *http.Response
	for _, v := range params.Betas {
		opts = append(opts, option.WithHeaderAdd("anthropic-beta", fmt.Sprintf("%v", v)))
	}
	if !param.IsOmitted(params.WorkspaceID) {
		opts = append(opts, option.WithHeader("anthropic-workspace-id", fmt.Sprintf("%v", params.WorkspaceID.Value)))
	}
	opts = slices.Concat(r.Options, opts)
	opts = append([]option.RequestOption{option.WithHeader("anthropic-beta", "managed-agents-2026-04-01"), option.WithResponseInto(&raw)}, opts...)
	path := "v1/environments?beta=true"
	cfg, err := requestconfig.NewRequestConfig(ctx, http.MethodGet, path, params, &res, opts...)
	if err != nil {
		return nil, err
	}
	err = cfg.Execute()
	if err != nil {
		return nil, err
	}
	res.SetPageConfig(cfg, raw)
	return res, nil
}

// List environments with pagination support.
func (r *BetaEnvironmentService) ListAutoPaging(ctx context.Context, params BetaEnvironmentListParams, opts ...option.RequestOption) *pagination.PageCursorAutoPager[BetaEnvironment] {
	return pagination.NewPageCursorAutoPager(r.List(ctx, params, opts...))
}

// Delete an environment by ID. Returns a confirmation of the deletion.
func (r *BetaEnvironmentService) Delete(ctx context.Context, environmentID string, body BetaEnvironmentDeleteParams, opts ...option.RequestOption) (res *BetaEnvironmentDeleteResponse, err error) {
	for _, v := range body.Betas {
		opts = append(opts, option.WithHeaderAdd("anthropic-beta", fmt.Sprintf("%v", v)))
	}
	if !param.IsOmitted(body.WorkspaceID) {
		opts = append(opts, option.WithHeader("anthropic-workspace-id", fmt.Sprintf("%v", body.WorkspaceID.Value)))
	}
	opts = slices.Concat(r.Options, opts)
	opts = append([]option.RequestOption{option.WithHeader("anthropic-beta", "managed-agents-2026-04-01")}, opts...)
	if environmentID == "" {
		err = errors.New("missing required environment_id parameter")
		return nil, err
	}
	path := fmt.Sprintf("v1/environments/%s?beta=true", environmentID)
	err = requestconfig.ExecuteNewRequest(ctx, http.MethodDelete, path, nil, &res, opts...)
	return res, err
}

// Archive an environment by ID. Archived environments cannot be used to create new
// sessions.
func (r *BetaEnvironmentService) Archive(ctx context.Context, environmentID string, body BetaEnvironmentArchiveParams, opts ...option.RequestOption) (res *BetaEnvironment, err error) {
	for _, v := range body.Betas {
		opts = append(opts, option.WithHeaderAdd("anthropic-beta", fmt.Sprintf("%v", v)))
	}
	if !param.IsOmitted(body.WorkspaceID) {
		opts = append(opts, option.WithHeader("anthropic-workspace-id", fmt.Sprintf("%v", body.WorkspaceID.Value)))
	}
	opts = slices.Concat(r.Options, opts)
	opts = append([]option.RequestOption{option.WithHeader("anthropic-beta", "managed-agents-2026-04-01")}, opts...)
	if environmentID == "" {
		err = errors.New("missing required environment_id parameter")
		return nil, err
	}
	path := fmt.Sprintf("v1/environments/%s/archive?beta=true", environmentID)
	err = requestconfig.ExecuteNewRequest(ctx, http.MethodPost, path, nil, &res, opts...)
	return res, err
}

// `cloud` environment configuration.
type BetaCloudConfig struct {
	// Network configuration policy.
	Networking BetaCloudConfigNetworkingUnion `json:"networking" api:"required"`
	// Package manager configuration.
	Packages BetaPackages `json:"packages" api:"required"`
	// Environment type
	Type constant.Cloud `json:"type" default:"cloud"`
	// JSON contains metadata for fields, check presence with [respjson.Field.Valid].
	JSON struct {
		Networking  respjson.Field
		Packages    respjson.Field
		Type        respjson.Field
		ExtraFields map[string]respjson.Field
		raw         string
	} `json:"-"`
}

// Returns the unmodified JSON received from the API
func (r BetaCloudConfig) RawJSON() string { return r.JSON.raw }
func (r *BetaCloudConfig) UnmarshalJSON(data []byte) error {
	return apijson.UnmarshalRoot(data, r)
}

// BetaCloudConfigNetworkingUnion contains all possible properties and values from
// [BetaUnrestrictedNetwork], [BetaLimitedNetwork].
//
// Use the [BetaCloudConfigNetworkingUnion.AsAny] method to switch on the variant.
//
// Use the methods beginning with 'As' to cast the union to one of its variants.
type BetaCloudConfigNetworkingUnion struct {
	// Any of "unrestricted", "limited".
	Type string `json:"type"`
	// This field is from variant [BetaLimitedNetwork].
	AllowMCPServers bool `json:"allow_mcp_servers"`
	// This field is from variant [BetaLimitedNetwork].
	AllowPackageManagers bool `json:"allow_package_managers"`
	// This field is from variant [BetaLimitedNetwork].
	AllowedHosts []string `json:"allowed_hosts"`
	JSON         struct {
		Type                 respjson.Field
		AllowMCPServers      respjson.Field
		AllowPackageManagers respjson.Field
		AllowedHosts         respjson.Field
		raw                  string
	} `json:"-"`
}

// anyBetaCloudConfigNetworking is implemented by each variant of
// [BetaCloudConfigNetworkingUnion] to add type safety for the return type of
// [BetaCloudConfigNetworkingUnion.AsAny]
type anyBetaCloudConfigNetworking interface {
	implBetaCloudConfigNetworkingUnion()
}

func (BetaUnrestrictedNetwork) implBetaCloudConfigNetworkingUnion() {}
func (BetaLimitedNetwork) implBetaCloudConfigNetworkingUnion()      {}

// Use the following switch statement to find the correct variant
//
//	switch variant := BetaCloudConfigNetworkingUnion.AsAny().(type) {
//	case anthropic.BetaUnrestrictedNetwork:
//	case anthropic.BetaLimitedNetwork:
//	default:
//	  fmt.Errorf("no variant present")
//	}
func (u BetaCloudConfigNetworkingUnion) AsAny() anyBetaCloudConfigNetworking {
	switch u.Type {
	case "unrestricted":
		return u.AsUnrestricted()
	case "limited":
		return u.AsLimited()
	}
	return nil
}

func (u BetaCloudConfigNetworkingUnion) AsUnrestricted() (v BetaUnrestrictedNetwork) {
	apijson.UnmarshalRoot(json.RawMessage(u.JSON.raw), &v)
	return
}

func (u BetaCloudConfigNetworkingUnion) AsLimited() (v BetaLimitedNetwork) {
	apijson.UnmarshalRoot(json.RawMessage(u.JSON.raw), &v)
	return
}

// Returns the unmodified JSON received from the API
func (u BetaCloudConfigNetworkingUnion) RawJSON() string { return u.JSON.raw }

func (r *BetaCloudConfigNetworkingUnion) UnmarshalJSON(data []byte) error {
	return apijson.UnmarshalRoot(data, r)
}

// Request params for `cloud` environment configuration.
//
// Fields default to null; on update, omitted fields preserve the existing value.
//
// The property Type is required.
type BetaCloudConfigParams struct {
	// Network configuration policy. Omit on update to preserve the existing value.
	Networking BetaCloudConfigParamsNetworkingUnion `json:"networking,omitzero"`
	// Specify packages (and optionally their versions) available in this environment.
	//
	// When versioning, use the version semantics relevant for the package manager,
	// e.g. for `pip` use `package==1.0.0`. You are responsible for validating the
	// package and version exist. Unversioned installs the latest.
	//
	// Under `limited` networking, requires `networking.allow_package_managers` to be
	// `true`.
	Packages BetaPackagesParams `json:"packages,omitzero"`
	// Environment type
	//
	// This field can be elided, and will marshal its zero value as "cloud".
	Type constant.Cloud `json:"type" default:"cloud"`
	paramObj
}

func (r BetaCloudConfigParams) MarshalJSON() (data []byte, err error) {
	type shadow BetaCloudConfigParams
	return param.MarshalObject(r, (*shadow)(&r))
}
func (r *BetaCloudConfigParams) UnmarshalJSON(data []byte) error {
	return apijson.UnmarshalRoot(data, r)
}

// Only one field can be non-zero.
//
// Use [param.IsOmitted] to confirm if a field is set.
type BetaCloudConfigParamsNetworkingUnion struct {
	OfUnrestricted *BetaUnrestrictedNetworkParam `json:",omitzero,inline"`
	OfLimited      *BetaLimitedNetworkParams     `json:",omitzero,inline"`
	paramUnion
}

func (u BetaCloudConfigParamsNetworkingUnion) MarshalJSON() ([]byte, error) {
	return param.MarshalUnion(u, u.OfUnrestricted, u.OfLimited)
}
func (u *BetaCloudConfigParamsNetworkingUnion) UnmarshalJSON(data []byte) error {
	return apijson.UnmarshalRoot(data, u)
}

func (u *BetaCloudConfigParamsNetworkingUnion) asAny() any {
	if !param.IsOmitted(u.OfUnrestricted) {
		return u.OfUnrestricted
	} else if !param.IsOmitted(u.OfLimited) {
		return u.OfLimited
	}
	return nil
}

// Returns a pointer to the underlying variant's property, if present.
func (u BetaCloudConfigParamsNetworkingUnion) GetAllowMCPServers() *bool {
	if vt := u.OfLimited; vt != nil && vt.AllowMCPServers.Valid() {
		return &vt.AllowMCPServers.Value
	}
	return nil
}

// Returns a pointer to the underlying variant's property, if present.
func (u BetaCloudConfigParamsNetworkingUnion) GetAllowPackageManagers() *bool {
	if vt := u.OfLimited; vt != nil && vt.AllowPackageManagers.Valid() {
		return &vt.AllowPackageManagers.Value
	}
	return nil
}

// Returns a pointer to the underlying variant's property, if present.
func (u BetaCloudConfigParamsNetworkingUnion) GetAllowedHosts() []string {
	if vt := u.OfLimited; vt != nil {
		return vt.AllowedHosts
	}
	return nil
}

// Returns a pointer to the underlying variant's property, if present.
func (u BetaCloudConfigParamsNetworkingUnion) GetType() *string {
	if vt := u.OfUnrestricted; vt != nil {
		return (*string)(&vt.Type)
	} else if vt := u.OfLimited; vt != nil {
		return (*string)(&vt.Type)
	}
	return nil
}

func init() {
	apijson.RegisterUnion[BetaCloudConfigParamsNetworkingUnion](
		"type",
		apijson.Discriminator[BetaUnrestrictedNetworkParam]("unrestricted"),
		apijson.Discriminator[BetaLimitedNetworkParams]("limited"),
	)
}

// Unified Environment resource for both cloud and self-hosted environments.
type BetaEnvironment struct {
	// Environment identifier (e.g., 'env\_...')
	ID string `json:"id" api:"required"`
	// RFC 3339 timestamp when environment was archived, or null if not archived
	ArchivedAt string `json:"archived_at" api:"required"`
	// Environment configuration (either Anthropic Cloud or self-hosted)
	Config BetaEnvironmentConfigUnion `json:"config" api:"required"`
	// RFC 3339 timestamp when environment was created
	CreatedAt string `json:"created_at" api:"required"`
	// User-provided description for the environment; null when unset
	Description string `json:"description" api:"required"`
	// User-provided metadata key-value pairs
	Metadata map[string]string `json:"metadata" api:"required"`
	// Human-readable name for the environment
	Name string `json:"name" api:"required"`
	// The type of object (always 'environment')
	Type constant.Environment `json:"type" default:"environment"`
	// RFC 3339 timestamp when environment was last updated
	UpdatedAt string `json:"updated_at" api:"required"`
	// The visibility scope for this environment. 'organization' means visible to all
	// accounts. 'account' means visible only to the owning account.
	//
	// Any of "organization", "account".
	Scope BetaEnvironmentScope `json:"scope"`
	// JSON contains metadata for fields, check presence with [respjson.Field.Valid].
	JSON struct {
		ID          respjson.Field
		ArchivedAt  respjson.Field
		Config      respjson.Field
		CreatedAt   respjson.Field
		Description respjson.Field
		Metadata    respjson.Field
		Name        respjson.Field
		Type        respjson.Field
		UpdatedAt   respjson.Field
		Scope       respjson.Field
		ExtraFields map[string]respjson.Field
		raw         string
	} `json:"-"`
}

// Returns the unmodified JSON received from the API
func (r BetaEnvironment) RawJSON() string { return r.JSON.raw }
func (r *BetaEnvironment) UnmarshalJSON(data []byte) error {
	return apijson.UnmarshalRoot(data, r)
}

// BetaEnvironmentConfigUnion contains all possible properties and values from
// [BetaCloudConfig], [BetaSelfHostedConfig].
//
// Use the [BetaEnvironmentConfigUnion.AsAny] method to switch on the variant.
//
// Use the methods beginning with 'As' to cast the union to one of its variants.
type BetaEnvironmentConfigUnion struct {
	// This field is from variant [BetaCloudConfig].
	Networking BetaCloudConfigNetworkingUnion `json:"networking"`
	// This field is from variant [BetaCloudConfig].
	Packages BetaPackages `json:"packages"`
	// Any of "cloud", "self_hosted".
	Type string `json:"type"`
	JSON struct {
		Networking respjson.Field
		Packages   respjson.Field
		Type       respjson.Field
		raw        string
	} `json:"-"`
}

// anyBetaEnvironmentConfig is implemented by each variant of
// [BetaEnvironmentConfigUnion] to add type safety for the return type of
// [BetaEnvironmentConfigUnion.AsAny]
type anyBetaEnvironmentConfig interface {
	implBetaEnvironmentConfigUnion()
}

func (BetaCloudConfig) implBetaEnvironmentConfigUnion()      {}
func (BetaSelfHostedConfig) implBetaEnvironmentConfigUnion() {}

// Use the following switch statement to find the correct variant
//
//	switch variant := BetaEnvironmentConfigUnion.AsAny().(type) {
//	case anthropic.BetaCloudConfig:
//	case anthropic.BetaSelfHostedConfig:
//	default:
//	  fmt.Errorf("no variant present")
//	}
func (u BetaEnvironmentConfigUnion) AsAny() anyBetaEnvironmentConfig {
	switch u.Type {
	case "cloud":
		return u.AsCloud()
	case "self_hosted":
		return u.AsSelfHosted()
	}
	return nil
}

func (u BetaEnvironmentConfigUnion) AsCloud() (v BetaCloudConfig) {
	apijson.UnmarshalRoot(json.RawMessage(u.JSON.raw), &v)
	return
}

func (u BetaEnvironmentConfigUnion) AsSelfHosted() (v BetaSelfHostedConfig) {
	apijson.UnmarshalRoot(json.RawMessage(u.JSON.raw), &v)
	return
}

// Returns the unmodified JSON received from the API
func (u BetaEnvironmentConfigUnion) RawJSON() string { return u.JSON.raw }

func (r *BetaEnvironmentConfigUnion) UnmarshalJSON(data []byte) error {
	return apijson.UnmarshalRoot(data, r)
}

// The visibility scope for this environment. 'organization' means visible to all
// accounts. 'account' means visible only to the owning account.
type BetaEnvironmentScope string

const (
	BetaEnvironmentScopeOrganization BetaEnvironmentScope = "organization"
	BetaEnvironmentScopeAccount      BetaEnvironmentScope = "account"
)

// Response after deleting an environment.
type BetaEnvironmentDeleteResponse struct {
	// Environment identifier
	ID string `json:"id" api:"required"`
	// The type of response
	//
	// Any of "environment_deleted".
	Type BetaEnvironmentDeleteResponseType `json:"type" api:"required"`
	// JSON contains metadata for fields, check presence with [respjson.Field.Valid].
	JSON struct {
		ID          respjson.Field
		Type        respjson.Field
		ExtraFields map[string]respjson.Field
		raw         string
	} `json:"-"`
}

// Returns the unmodified JSON received from the API
func (r BetaEnvironmentDeleteResponse) RawJSON() string { return r.JSON.raw }
func (r *BetaEnvironmentDeleteResponse) UnmarshalJSON(data []byte) error {
	return apijson.UnmarshalRoot(data, r)
}

// The type of response
type BetaEnvironmentDeleteResponseType string

const (
	BetaEnvironmentDeleteResponseTypeEnvironmentDeleted BetaEnvironmentDeleteResponseType = "environment_deleted"
)

// Limited network access.
type BetaLimitedNetwork struct {
	// Permits outbound access to MCP server endpoints configured on the agent, beyond
	// those listed in the `allowed_hosts` array.
	AllowMCPServers bool `json:"allow_mcp_servers" api:"required"`
	// Permits outbound access to public package registries (PyPI, npm, etc.) beyond
	// those listed in the `allowed_hosts` array.
	AllowPackageManagers bool `json:"allow_package_managers" api:"required"`
	// Specifies domains the container can reach.
	AllowedHosts []string `json:"allowed_hosts" api:"required"`
	// Network policy type
	Type constant.Limited `json:"type" default:"limited"`
	// JSON contains metadata for fields, check presence with [respjson.Field.Valid].
	JSON struct {
		AllowMCPServers      respjson.Field
		AllowPackageManagers respjson.Field
		AllowedHosts         respjson.Field
		Type                 respjson.Field
		ExtraFields          map[string]respjson.Field
		raw                  string
	} `json:"-"`
}

// Returns the unmodified JSON received from the API
func (r BetaLimitedNetwork) RawJSON() string { return r.JSON.raw }
func (r *BetaLimitedNetwork) UnmarshalJSON(data []byte) error {
	return apijson.UnmarshalRoot(data, r)
}

// Limited network request params.
//
// Fields default to null; on update, omitted fields preserve the existing value.
//
// The property Type is required.
type BetaLimitedNetworkParams struct {
	// Permits outbound access to MCP server endpoints configured on the agent, beyond
	// those listed in the `allowed_hosts` array. Defaults to `false`.
	AllowMCPServers param.Opt[bool] `json:"allow_mcp_servers,omitzero"`
	// Permits outbound access to public package registries (PyPI, npm, etc.) beyond
	// those listed in the `allowed_hosts` array. Defaults to `false` on creation. Must
	// be `true` when `packages` are specified.
	AllowPackageManagers param.Opt[bool] `json:"allow_package_managers,omitzero"`
	// Specifies domains the container can reach.
	AllowedHosts []string `json:"allowed_hosts,omitzero"`
	// Network policy type
	//
	// This field can be elided, and will marshal its zero value as "limited".
	Type constant.Limited `json:"type" default:"limited"`
	paramObj
}

func (r BetaLimitedNetworkParams) MarshalJSON() (data []byte, err error) {
	type shadow BetaLimitedNetworkParams
	return param.MarshalObject(r, (*shadow)(&r))
}
func (r *BetaLimitedNetworkParams) UnmarshalJSON(data []byte) error {
	return apijson.UnmarshalRoot(data, r)
}

// Packages (and their versions) available in this environment.
type BetaPackages struct {
	// Ubuntu/Debian packages to install
	Apt []string `json:"apt" api:"required"`
	// Rust packages to install
	Cargo []string `json:"cargo" api:"required"`
	// Ruby packages to install
	Gem []string `json:"gem" api:"required"`
	// Go packages to install
	Go []string `json:"go" api:"required"`
	// Node.js packages to install
	Npm []string `json:"npm" api:"required"`
	// Python packages to install
	Pip []string `json:"pip" api:"required"`
	// Package configuration type
	//
	// Any of "packages".
	Type BetaPackagesType `json:"type"`
	// JSON contains metadata for fields, check presence with [respjson.Field.Valid].
	JSON struct {
		Apt         respjson.Field
		Cargo       respjson.Field
		Gem         respjson.Field
		Go          respjson.Field
		Npm         respjson.Field
		Pip         respjson.Field
		Type        respjson.Field
		ExtraFields map[string]respjson.Field
		raw         string
	} `json:"-"`
}

// Returns the unmodified JSON received from the API
func (r BetaPackages) RawJSON() string { return r.JSON.raw }
func (r *BetaPackages) UnmarshalJSON(data []byte) error {
	return apijson.UnmarshalRoot(data, r)
}

// Package configuration type
type BetaPackagesType string

const (
	BetaPackagesTypePackages BetaPackagesType = "packages"
)

// Specify packages (and optionally their versions) available in this environment.
//
// When versioning, use the version semantics relevant for the package manager,
// e.g. for `pip` use `package==1.0.0`. You are responsible for validating the
// package and version exist. Unversioned installs the latest.
//
// Under `limited` networking, requires `networking.allow_package_managers` to be
// `true`.
type BetaPackagesParams struct {
	// Ubuntu/Debian packages to install
	Apt []string `json:"apt,omitzero"`
	// Rust packages to install
	Cargo []string `json:"cargo,omitzero"`
	// Ruby packages to install
	Gem []string `json:"gem,omitzero"`
	// Go packages to install
	Go []string `json:"go,omitzero"`
	// Node.js packages to install
	Npm []string `json:"npm,omitzero"`
	// Python packages to install
	Pip []string `json:"pip,omitzero"`
	// Package configuration type
	//
	// Any of "packages".
	Type BetaPackagesParamsType `json:"type,omitzero"`
	paramObj
}

func (r BetaPackagesParams) MarshalJSON() (data []byte, err error) {
	type shadow BetaPackagesParams
	return param.MarshalObject(r, (*shadow)(&r))
}
func (r *BetaPackagesParams) UnmarshalJSON(data []byte) error {
	return apijson.UnmarshalRoot(data, r)
}

// Package configuration type
type BetaPackagesParamsType string

const (
	BetaPackagesParamsTypePackages BetaPackagesParamsType = "packages"
)

// Configuration for self-hosted environments.
type BetaSelfHostedConfig struct {
	// Environment type
	Type constant.SelfHosted `json:"type" default:"self_hosted"`
	// JSON contains metadata for fields, check presence with [respjson.Field.Valid].
	JSON struct {
		Type        respjson.Field
		ExtraFields map[string]respjson.Field
		raw         string
	} `json:"-"`
}

// Returns the unmodified JSON received from the API
func (r BetaSelfHostedConfig) RawJSON() string { return r.JSON.raw }
func (r *BetaSelfHostedConfig) UnmarshalJSON(data []byte) error {
	return apijson.UnmarshalRoot(data, r)
}

func NewBetaSelfHostedConfigParams() BetaSelfHostedConfigParams {
	return BetaSelfHostedConfigParams{
		Type: "self_hosted",
	}
}

// Request params for `self_hosted` environment configuration.
//
// This struct has a constant value, construct it with
// [NewBetaSelfHostedConfigParams].
type BetaSelfHostedConfigParams struct {
	// Environment type
	Type constant.SelfHosted `json:"type" default:"self_hosted"`
	paramObj
}

func (r BetaSelfHostedConfigParams) MarshalJSON() (data []byte, err error) {
	type shadow BetaSelfHostedConfigParams
	return param.MarshalObject(r, (*shadow)(&r))
}
func (r *BetaSelfHostedConfigParams) UnmarshalJSON(data []byte) error {
	return apijson.UnmarshalRoot(data, r)
}

// Unrestricted network access.
type BetaUnrestrictedNetwork struct {
	// Network policy type
	Type constant.Unrestricted `json:"type" default:"unrestricted"`
	// JSON contains metadata for fields, check presence with [respjson.Field.Valid].
	JSON struct {
		Type        respjson.Field
		ExtraFields map[string]respjson.Field
		raw         string
	} `json:"-"`
}

// Returns the unmodified JSON received from the API
func (r BetaUnrestrictedNetwork) RawJSON() string { return r.JSON.raw }
func (r *BetaUnrestrictedNetwork) UnmarshalJSON(data []byte) error {
	return apijson.UnmarshalRoot(data, r)
}

// ToParam converts this BetaUnrestrictedNetwork to a BetaUnrestrictedNetworkParam.
//
// Warning: the fields of the param type will not be present. ToParam should only
// be used at the last possible moment before sending a request. Test for this with
// BetaUnrestrictedNetworkParam.Overrides()
func (r BetaUnrestrictedNetwork) ToParam() BetaUnrestrictedNetworkParam {
	return param.Override[BetaUnrestrictedNetworkParam](json.RawMessage(r.RawJSON()))
}

func NewBetaUnrestrictedNetworkParam() BetaUnrestrictedNetworkParam {
	return BetaUnrestrictedNetworkParam{
		Type: "unrestricted",
	}
}

// Unrestricted network access.
//
// This struct has a constant value, construct it with
// [NewBetaUnrestrictedNetworkParam].
type BetaUnrestrictedNetworkParam struct {
	// Network policy type
	Type constant.Unrestricted `json:"type" default:"unrestricted"`
	paramObj
}

func (r BetaUnrestrictedNetworkParam) MarshalJSON() (data []byte, err error) {
	type shadow BetaUnrestrictedNetworkParam
	return param.MarshalObject(r, (*shadow)(&r))
}
func (r *BetaUnrestrictedNetworkParam) UnmarshalJSON(data []byte) error {
	return apijson.UnmarshalRoot(data, r)
}

type BetaEnvironmentNewParams struct {
	// Human-readable name for the environment
	Name string `json:"name" api:"required"`
	// Optional description of the environment
	Description param.Opt[string] `json:"description,omitzero"`
	WorkspaceID param.Opt[string] `header:"anthropic-workspace-id,omitzero" json:"-"`
	// Environment configuration
	Config BetaEnvironmentNewParamsConfigUnion `json:"config,omitzero"`
	// The visibility scope for this environment. 'organization' makes the environment
	// visible to all accounts. 'account' restricts visibility to the owning account
	// only. Only applicable for self-hosted environments. If not specified, defaults
	// based on organization type.
	//
	// Any of "organization", "account".
	Scope BetaEnvironmentNewParamsScope `json:"scope,omitzero"`
	// User-provided metadata key-value pairs
	Metadata map[string]string `json:"metadata,omitzero"`
	// Optional header to specify the beta version(s) you want to use.
	Betas []AnthropicBeta `header:"anthropic-beta,omitzero" json:"-"`
	paramObj
}

func (r BetaEnvironmentNewParams) MarshalJSON() (data []byte, err error) {
	type shadow BetaEnvironmentNewParams
	return param.MarshalObject(r, (*shadow)(&r))
}
func (r *BetaEnvironmentNewParams) UnmarshalJSON(data []byte) error {
	return apijson.UnmarshalRoot(data, r)
}

// Only one field can be non-zero.
//
// Use [param.IsOmitted] to confirm if a field is set.
type BetaEnvironmentNewParamsConfigUnion struct {
	OfCloud      *BetaCloudConfigParams      `json:",omitzero,inline"`
	OfSelfHosted *BetaSelfHostedConfigParams `json:",omitzero,inline"`
	paramUnion
}

func (u BetaEnvironmentNewParamsConfigUnion) MarshalJSON() ([]byte, error) {
	return param.MarshalUnion(u, u.OfCloud, u.OfSelfHosted)
}
func (u *BetaEnvironmentNewParamsConfigUnion) UnmarshalJSON(data []byte) error {
	return apijson.UnmarshalRoot(data, u)
}

func (u *BetaEnvironmentNewParamsConfigUnion) asAny() any {
	if !param.IsOmitted(u.OfCloud) {
		return u.OfCloud
	} else if !param.IsOmitted(u.OfSelfHosted) {
		return u.OfSelfHosted
	}
	return nil
}

// Returns a pointer to the underlying variant's property, if present.
func (u BetaEnvironmentNewParamsConfigUnion) GetNetworking() *BetaCloudConfigParamsNetworkingUnion {
	if vt := u.OfCloud; vt != nil {
		return &vt.Networking
	}
	return nil
}

// Returns a pointer to the underlying variant's property, if present.
func (u BetaEnvironmentNewParamsConfigUnion) GetPackages() *BetaPackagesParams {
	if vt := u.OfCloud; vt != nil {
		return &vt.Packages
	}
	return nil
}

// Returns a pointer to the underlying variant's property, if present.
func (u BetaEnvironmentNewParamsConfigUnion) GetType() *string {
	if vt := u.OfCloud; vt != nil {
		return (*string)(&vt.Type)
	} else if vt := u.OfSelfHosted; vt != nil {
		return (*string)(&vt.Type)
	}
	return nil
}

func init() {
	apijson.RegisterUnion[BetaEnvironmentNewParamsConfigUnion](
		"type",
		apijson.Discriminator[BetaCloudConfigParams]("cloud"),
		apijson.Discriminator[BetaSelfHostedConfigParams]("self_hosted"),
	)
}

// The visibility scope for this environment. 'organization' makes the environment
// visible to all accounts. 'account' restricts visibility to the owning account
// only. Only applicable for self-hosted environments. If not specified, defaults
// based on organization type.
type BetaEnvironmentNewParamsScope string

const (
	BetaEnvironmentNewParamsScopeOrganization BetaEnvironmentNewParamsScope = "organization"
	BetaEnvironmentNewParamsScopeAccount      BetaEnvironmentNewParamsScope = "account"
)

type BetaEnvironmentGetParams struct {
	WorkspaceID param.Opt[string] `header:"anthropic-workspace-id,omitzero" json:"-"`
	// Optional header to specify the beta version(s) you want to use.
	Betas []AnthropicBeta `header:"anthropic-beta,omitzero" json:"-"`
	paramObj
}

type BetaEnvironmentUpdateParams struct {
	// Updated description of the environment. Omit to preserve; null clears to null;
	// an empty string is stored as an empty string.
	Description param.Opt[string] `json:"description,omitzero"`
	// Updated name for the environment
	Name        param.Opt[string] `json:"name,omitzero"`
	WorkspaceID param.Opt[string] `header:"anthropic-workspace-id,omitzero" json:"-"`
	// Updated environment configuration
	Config BetaEnvironmentUpdateParamsConfigUnion `json:"config,omitzero"`
	// The visibility scope for this environment. 'organization' makes the environment
	// visible to all accounts. 'account' restricts visibility to the owning account
	// only.
	//
	// Any of "organization", "account".
	Scope BetaEnvironmentUpdateParamsScope `json:"scope,omitzero"`
	// User-provided metadata key-value pairs. Set a value to null or empty string to
	// delete the key.
	Metadata map[string]string `json:"metadata,omitzero"`
	// Optional header to specify the beta version(s) you want to use.
	Betas []AnthropicBeta `header:"anthropic-beta,omitzero" json:"-"`
	paramObj
}

func (r BetaEnvironmentUpdateParams) MarshalJSON() (data []byte, err error) {
	type shadow BetaEnvironmentUpdateParams
	return param.MarshalObject(r, (*shadow)(&r))
}
func (r *BetaEnvironmentUpdateParams) UnmarshalJSON(data []byte) error {
	return apijson.UnmarshalRoot(data, r)
}

// Only one field can be non-zero.
//
// Use [param.IsOmitted] to confirm if a field is set.
type BetaEnvironmentUpdateParamsConfigUnion struct {
	OfCloud      *BetaCloudConfigParams      `json:",omitzero,inline"`
	OfSelfHosted *BetaSelfHostedConfigParams `json:",omitzero,inline"`
	paramUnion
}

func (u BetaEnvironmentUpdateParamsConfigUnion) MarshalJSON() ([]byte, error) {
	return param.MarshalUnion(u, u.OfCloud, u.OfSelfHosted)
}
func (u *BetaEnvironmentUpdateParamsConfigUnion) UnmarshalJSON(data []byte) error {
	return apijson.UnmarshalRoot(data, u)
}

func (u *BetaEnvironmentUpdateParamsConfigUnion) asAny() any {
	if !param.IsOmitted(u.OfCloud) {
		return u.OfCloud
	} else if !param.IsOmitted(u.OfSelfHosted) {
		return u.OfSelfHosted
	}
	return nil
}

// Returns a pointer to the underlying variant's property, if present.
func (u BetaEnvironmentUpdateParamsConfigUnion) GetNetworking() *BetaCloudConfigParamsNetworkingUnion {
	if vt := u.OfCloud; vt != nil {
		return &vt.Networking
	}
	return nil
}

// Returns a pointer to the underlying variant's property, if present.
func (u BetaEnvironmentUpdateParamsConfigUnion) GetPackages() *BetaPackagesParams {
	if vt := u.OfCloud; vt != nil {
		return &vt.Packages
	}
	return nil
}

// Returns a pointer to the underlying variant's property, if present.
func (u BetaEnvironmentUpdateParamsConfigUnion) GetType() *string {
	if vt := u.OfCloud; vt != nil {
		return (*string)(&vt.Type)
	} else if vt := u.OfSelfHosted; vt != nil {
		return (*string)(&vt.Type)
	}
	return nil
}

func init() {
	apijson.RegisterUnion[BetaEnvironmentUpdateParamsConfigUnion](
		"type",
		apijson.Discriminator[BetaCloudConfigParams]("cloud"),
		apijson.Discriminator[BetaSelfHostedConfigParams]("self_hosted"),
	)
}

// The visibility scope for this environment. 'organization' makes the environment
// visible to all accounts. 'account' restricts visibility to the owning account
// only.
type BetaEnvironmentUpdateParamsScope string

const (
	BetaEnvironmentUpdateParamsScopeOrganization BetaEnvironmentUpdateParamsScope = "organization"
	BetaEnvironmentUpdateParamsScopeAccount      BetaEnvironmentUpdateParamsScope = "account"
)

type BetaEnvironmentListParams struct {
	// Opaque cursor from previous response for pagination. Pass the `next_page` value
	// from the previous response.
	Page param.Opt[string] `query:"page,omitzero" json:"-"`
	// Include archived environments in the response
	IncludeArchived param.Opt[bool] `query:"include_archived,omitzero" json:"-"`
	// Maximum number of environments to return
	Limit       param.Opt[int64]  `query:"limit,omitzero" json:"-"`
	WorkspaceID param.Opt[string] `header:"anthropic-workspace-id,omitzero" json:"-"`
	// Optional header to specify the beta version(s) you want to use.
	Betas []AnthropicBeta `header:"anthropic-beta,omitzero" json:"-"`
	paramObj
}

// URLQuery serializes [BetaEnvironmentListParams]'s query parameters as
// `url.Values`.
func (r BetaEnvironmentListParams) URLQuery() (v url.Values, err error) {
	return apiquery.MarshalWithSettings(r, apiquery.QuerySettings{
		ArrayFormat:  apiquery.ArrayQueryFormatBrackets,
		NestedFormat: apiquery.NestedQueryFormatBrackets,
	})
}

type BetaEnvironmentDeleteParams struct {
	WorkspaceID param.Opt[string] `header:"anthropic-workspace-id,omitzero" json:"-"`
	// Optional header to specify the beta version(s) you want to use.
	Betas []AnthropicBeta `header:"anthropic-beta,omitzero" json:"-"`
	paramObj
}

type BetaEnvironmentArchiveParams struct {
	WorkspaceID param.Opt[string] `header:"anthropic-workspace-id,omitzero" json:"-"`
	// Optional header to specify the beta version(s) you want to use.
	Betas []AnthropicBeta `header:"anthropic-beta,omitzero" json:"-"`
	paramObj
}