v20250801preview

type ActionType string

type ApplicationGraphConnection struct {
	// REQUIRED; The direction of the connection. 'Outbound' indicates this connection specifies the ID of the destination and
	// 'Inbound' indicates indicates this connection specifies the ID of the source.
	Direction *Direction

	// REQUIRED; The resource ID
	ID *string

	// REQUIRED; Discriminator identifying the origin of this edge. 'Connection' edges are author-declared entries under properties.connections.
	// 'Dependency' edges are implicit dependencies derived from Bicep's dependsOn list (static graph only in Phase 1). Every
	// emitted edge carries a kind.
	Kind *ConnectionKind
}

type ApplicationGraphOutputResource struct {
	// REQUIRED; The resource ID.
	ID *string

	// REQUIRED; The resource name.
	Name *string

	// REQUIRED; The resource type.
	Type *string

	// A deep link to the underlying resource in its cloud provider's portal (for example, the Azure portal). Empty when no link
	// is available for the resource.
	PortalURL *string
}

type ApplicationGraphResource struct {
	// REQUIRED; The connections between resources in the application graph.
	Connections []*ApplicationGraphConnection

	// REQUIRED; The resource ID.
	ID *string

	// REQUIRED; The resource name.
	Name *string

	// REQUIRED; The resources that comprise this resource.
	OutputResources []*ApplicationGraphOutputResource

	// REQUIRED; provisioningState of this resource.
	ProvisioningState *string

	// REQUIRED; The resource type.
	Type *string

	// Stable hash over the authorable properties of this resource and its sorted dependsOn list. Used by tooling to classify
	// resources as added, removed, modified, or unchanged across graphs. Format: 'sha256:{hex}'.
	DiffHash *string

	// SHA-256 hex of the resource type's icon SVG, matching `iconHash` on the resource-type registry. Null when the type has
	// no icon registered. The bytes themselves are delivered inline via `ApplicationGraphResponse.icons` when the request specifies
	// `includeIcons: true`; otherwise clients fetch bytes by hash from the resource-type icon endpoint.
	IconHash *string

	// Resource-type-specific properties of the resource as returned by its resource provider. The shape of this map varies by
	// `type` (e.g. a `Radius.Compute/containers` resource exposes different keys than `Radius.Datastores/redisCaches` or any
	// user-defined resource type) and matches the `properties` returned by that resource's GET response. Top-level keys already
	// surfaced as first-class fields on this model (`provisioningState`, `connections`) are omitted. The whole `status` object
	// is also omitted because it may contain computed values that include sensitive data (for example, connection strings); the
	// redundant `status.outputResources` list is surfaced via the dedicated `outputResources` field instead. Use `diffHash` rather
	// than a byte-wise compare of this map to detect change.
	Properties map[string]any
}

type ApplicationGraphResponse struct {
	// REQUIRED; The resources in the application graph.
	Resources []*ApplicationGraphResource

	// Map from iconHash to the verbatim SVG UTF-8 bytes for every icon referenced by any resource in this response. Populated
	// only when the request specifies `includeIcons: true`.
	Icons map[string]*string
}

type ApplicationProperties struct {
	// REQUIRED; (Required) Fully qualified resource ID of the environment the application is deployed to
	Environment *string

	// READ-ONLY; (Read Only) The status of the Application resource within the Radius control plane. Does not include the other
	// resources that compose the Application.
	ProvisioningState *ProvisioningState

	// READ-ONLY; (Read Only) Deployment details for the Application, including any output resources Radius created for it.
	Status *ResourceStatus
}

type ApplicationResource struct {
	// REQUIRED; The geo-location where the resource lives
	Location *string

	// REQUIRED; The resource-specific properties for this resource.
	Properties *ApplicationProperties

	// Resource tags.
	Tags map[string]*string

	// READ-ONLY; Fully qualified resource ID for the resource. Ex - /subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/{resourceProviderNamespace}/{resourceType}/{resourceName}
	ID *string

	// READ-ONLY; The name of the resource
	Name *string

	// READ-ONLY; Azure Resource Manager metadata containing createdBy and modifiedBy information.
	SystemData *SystemData

	// READ-ONLY; The type of the resource. E.g. "Microsoft.Compute/virtualMachines" or "Microsoft.Storage/storageAccounts"
	Type *string
}

type ApplicationResourceListResult struct {
	// REQUIRED; The ApplicationResource items on this page
	Value []*ApplicationResource

	// The link to the next page of items
	NextLink *string
}

type ApplicationsClient struct {
	// contains filtered or unexported fields
}

type ApplicationsClientCreateOrUpdateOptions struct {
}

type ApplicationsClientCreateOrUpdateResponse struct {
	// The `Radius.Core/applications` Resource Type represents a Radius Application: a logical grouping of the resources that
	// make up a single Application, such as containers, databases, and message queues, along with the connections between them.
	// Radius uses the Application to build the application graph, apply shared configuration, and manage its resources together
	// throughout their lifecycle.
	// ## Defining an Application
	// An Application is always deployed to a Radius Environment, which is supplied through the `environment` property. To define
	// an Application, add a `Radius.Core/applications` resource to your application definition Bicep file.
	// “`bicep
	// extension radius
	// @description('The Radius Environment ID. Injected automatically by the rad CLI.')
	// param environment string
	// resource myApp 'Radius.Core/applications@2025-08-01-preview' = {
	// name: 'my-app'
	// properties: {
	// environment: environment
	// }
	// }
	// “`
	// ## Deploying an Application
	// An Application is deployed with the `rad deploy` command, which deploys the Application together with the resources that
	// belong to it:
	// “`bash
	// rad deploy ./app.bicep
	// “`
	// ## Adding resources to an Application
	// Resources are composed into an Application by setting their `application` property to the Application's ID. For example,
	// to add a Container to this Application, add the following to the application definition Bicep file and set `application:
	// myApp.id`:
	// “`bicep
	// resource frontend 'Radius.Compute/containers@2025-08-01-preview' = {
	// name: 'frontend'
	// properties: {
	// environment: environment
	// application: myApp.id
	// containers: {
	// frontend: {
	// image: 'ghcr.io/my-org/frontend:latest'
	// }
	// }
	// }
	// }
	// “`
	ApplicationResource
}

type ApplicationsClientDeleteOptions struct {
}

type ApplicationsClientDeleteResponse struct {
}

type ApplicationsClientGetGraphOptions struct {
}

type ApplicationsClientGetGraphResponse struct {
	// Describes the application architecture and its dependencies.
	ApplicationGraphResponse
}

type ApplicationsClientGetOptions struct {
}

type ApplicationsClientGetResponse struct {
	// The `Radius.Core/applications` Resource Type represents a Radius Application: a logical grouping of the resources that
	// make up a single Application, such as containers, databases, and message queues, along with the connections between them.
	// Radius uses the Application to build the application graph, apply shared configuration, and manage its resources together
	// throughout their lifecycle.
	// ## Defining an Application
	// An Application is always deployed to a Radius Environment, which is supplied through the `environment` property. To define
	// an Application, add a `Radius.Core/applications` resource to your application definition Bicep file.
	// “`bicep
	// extension radius
	// @description('The Radius Environment ID. Injected automatically by the rad CLI.')
	// param environment string
	// resource myApp 'Radius.Core/applications@2025-08-01-preview' = {
	// name: 'my-app'
	// properties: {
	// environment: environment
	// }
	// }
	// “`
	// ## Deploying an Application
	// An Application is deployed with the `rad deploy` command, which deploys the Application together with the resources that
	// belong to it:
	// “`bash
	// rad deploy ./app.bicep
	// “`
	// ## Adding resources to an Application
	// Resources are composed into an Application by setting their `application` property to the Application's ID. For example,
	// to add a Container to this Application, add the following to the application definition Bicep file and set `application:
	// myApp.id`:
	// “`bicep
	// resource frontend 'Radius.Compute/containers@2025-08-01-preview' = {
	// name: 'frontend'
	// properties: {
	// environment: environment
	// application: myApp.id
	// containers: {
	// frontend: {
	// image: 'ghcr.io/my-org/frontend:latest'
	// }
	// }
	// }
	// }
	// “`
	ApplicationResource
}

type ApplicationsClientListByScopeOptions struct {
}

type ApplicationsClientListByScopeResponse struct {
	// The response of a ApplicationResource list operation.
	ApplicationResourceListResult
}

type ApplicationsClientUpdateOptions struct {
}

type ApplicationsClientUpdateResponse struct {
	// The `Radius.Core/applications` Resource Type represents a Radius Application: a logical grouping of the resources that
	// make up a single Application, such as containers, databases, and message queues, along with the connections between them.
	// Radius uses the Application to build the application graph, apply shared configuration, and manage its resources together
	// throughout their lifecycle.
	// ## Defining an Application
	// An Application is always deployed to a Radius Environment, which is supplied through the `environment` property. To define
	// an Application, add a `Radius.Core/applications` resource to your application definition Bicep file.
	// “`bicep
	// extension radius
	// @description('The Radius Environment ID. Injected automatically by the rad CLI.')
	// param environment string
	// resource myApp 'Radius.Core/applications@2025-08-01-preview' = {
	// name: 'my-app'
	// properties: {
	// environment: environment
	// }
	// }
	// “`
	// ## Deploying an Application
	// An Application is deployed with the `rad deploy` command, which deploys the Application together with the resources that
	// belong to it:
	// “`bash
	// rad deploy ./app.bicep
	// “`
	// ## Adding resources to an Application
	// Resources are composed into an Application by setting their `application` property to the Application's ID. For example,
	// to add a Container to this Application, add the following to the application definition Bicep file and set `application:
	// myApp.id`:
	// “`bicep
	// resource frontend 'Radius.Compute/containers@2025-08-01-preview' = {
	// name: 'frontend'
	// properties: {
	// environment: environment
	// application: myApp.id
	// containers: {
	// frontend: {
	// image: 'ghcr.io/my-org/frontend:latest'
	// }
	// }
	// }
	// }
	// “`
	ApplicationResource
}

type AzureContainerInstanceCompute struct {
	// REQUIRED; The Azure container instance compute kind
	Kind *string

	// Configuration for supported external identity providers
	Identity *IdentitySettings

	// The resource group to use for the environment.
	ResourceGroup *string

	// The resource id of the compute resource for application environment.
	ResourceID *string
}

type BicepAuthenticationMethod string

type BicepRegistryAuthentication struct {
	// (Optional) How Radius authenticates to the registry.
	AuthenticationMethod *BicepAuthenticationMethod

	// (Optional) AWS IAM Role ARN for IRSA authentication. Required when `authenticationMethod` is `AwsIrsa`.
	AwsIamRoleArn *string

	// (Optional) Azure Workload Identity client ID. Required when `authenticationMethod` is `AzureWI`.
	AzureWiClientID *string

	// (Optional) Azure Workload Identity tenant ID. Required when `authenticationMethod` is `AzureWI`.
	AzureWiTenantID *string

	// (Optional) The ID of a `Radius.Security/secrets` resource containing the username and password. Required when `authenticationMethod`
	// is `BasicAuth`.
	BasicAuthSecretID *string
}

type BicepSettingsClient struct {
	// contains filtered or unexported fields
}

type BicepSettingsClientCreateOrUpdateOptions struct {
}

type BicepSettingsClientCreateOrUpdateResponse struct {
	// The `Radius.Core/bicepSettings` Resource Type holds reusable Bicep engine settings that Environments apply when running
	// Bicep Recipes. Its primary use is authenticating to private Bicep registries: OCI registries, such as Azure Container Registry,
	// that host the Recipe templates referenced by a Recipe Pack.
	// Platform engineers define a `Radius.Core/bicepSettings` resource once and reference it from any Environment whose Recipes
	// pull templates from a private registry.
	// ## Defining Bicep settings
	// Configure `registryAuthentications`, keyed by registry hostname. When a Recipe template is pulled from a matching host,
	// Radius authenticates using the configured method. The example below uses basic authentication, reading the username and
	// password from a secret:
	// “`bicep
	// extension radius
	// @description('The Radius Environment ID. Injected automatically by the rad CLI.')
	// param environment string
	// resource registrySecret 'Radius.Security/secrets@2025-08-01-preview' = {
	// name: 'registry-credentials'
	// properties: {
	// environment: environment
	// data: {
	// username: { value: 'my-username' }
	// password: { value: 'my-password' }
	// }
	// }
	// }
	// resource bicepRegistry 'Radius.Core/bicepSettings@2025-08-01-preview' = {
	// name: 'private-registry'
	// properties: {
	// registryAuthentications: {
	// 'corp.azurecr.io': {
	// authenticationMethod: 'BasicAuth'
	// basicAuthSecretId: registrySecret.id
	// }
	// }
	// }
	// }
	// “`
	// Basic authentication is supported via `BasicAuth` (username and password from a secret). `AwsIrsa` and `AzureWI` will be
	// implemented in the future.
	// ## Deploying Bicep settings
	// Deploy the settings resource with the `rad deploy` command:
	// “`bash
	// rad deploy ./bicep-settings.bicep
	// “`
	// ## Referencing Bicep settings from an Environment
	// Reference the settings from an Environment by setting its `bicepSettings` property to the resource ID. Every Bicep Recipe
	// run in that Environment then uses the configured registry authentication:
	// “`bicep
	// extension radius
	// resource bicepRegistry 'Radius.Core/bicepSettings@2025-08-01-preview' existing = {
	// name: 'private-registry'
	// }
	// resource myEnvironment 'Radius.Core/environments@2025-08-01-preview' = {
	// name: 'my-environment'
	// properties: {
	// bicepSettings: bicepRegistry.id
	// }
	// }
	// “`
	BicepSettingsResource
}

type BicepSettingsClientDeleteOptions struct {
}

type BicepSettingsClientDeleteResponse struct {
}

type BicepSettingsClientGetOptions struct {
}

type BicepSettingsClientGetResponse struct {
	// The `Radius.Core/bicepSettings` Resource Type holds reusable Bicep engine settings that Environments apply when running
	// Bicep Recipes. Its primary use is authenticating to private Bicep registries: OCI registries, such as Azure Container Registry,
	// that host the Recipe templates referenced by a Recipe Pack.
	// Platform engineers define a `Radius.Core/bicepSettings` resource once and reference it from any Environment whose Recipes
	// pull templates from a private registry.
	// ## Defining Bicep settings
	// Configure `registryAuthentications`, keyed by registry hostname. When a Recipe template is pulled from a matching host,
	// Radius authenticates using the configured method. The example below uses basic authentication, reading the username and
	// password from a secret:
	// “`bicep
	// extension radius
	// @description('The Radius Environment ID. Injected automatically by the rad CLI.')
	// param environment string
	// resource registrySecret 'Radius.Security/secrets@2025-08-01-preview' = {
	// name: 'registry-credentials'
	// properties: {
	// environment: environment
	// data: {
	// username: { value: 'my-username' }
	// password: { value: 'my-password' }
	// }
	// }
	// }
	// resource bicepRegistry 'Radius.Core/bicepSettings@2025-08-01-preview' = {
	// name: 'private-registry'
	// properties: {
	// registryAuthentications: {
	// 'corp.azurecr.io': {
	// authenticationMethod: 'BasicAuth'
	// basicAuthSecretId: registrySecret.id
	// }
	// }
	// }
	// }
	// “`
	// Basic authentication is supported via `BasicAuth` (username and password from a secret). `AwsIrsa` and `AzureWI` will be
	// implemented in the future.
	// ## Deploying Bicep settings
	// Deploy the settings resource with the `rad deploy` command:
	// “`bash
	// rad deploy ./bicep-settings.bicep
	// “`
	// ## Referencing Bicep settings from an Environment
	// Reference the settings from an Environment by setting its `bicepSettings` property to the resource ID. Every Bicep Recipe
	// run in that Environment then uses the configured registry authentication:
	// “`bicep
	// extension radius
	// resource bicepRegistry 'Radius.Core/bicepSettings@2025-08-01-preview' existing = {
	// name: 'private-registry'
	// }
	// resource myEnvironment 'Radius.Core/environments@2025-08-01-preview' = {
	// name: 'my-environment'
	// properties: {
	// bicepSettings: bicepRegistry.id
	// }
	// }
	// “`
	BicepSettingsResource
}

type BicepSettingsClientListByScopeOptions struct {
}

type BicepSettingsClientListByScopeResponse struct {
	// The response of a BicepSettingsResource list operation.
	BicepSettingsResourceListResult
}

type BicepSettingsClientUpdateOptions struct {
}

type BicepSettingsClientUpdateResponse struct {
	// The `Radius.Core/bicepSettings` Resource Type holds reusable Bicep engine settings that Environments apply when running
	// Bicep Recipes. Its primary use is authenticating to private Bicep registries: OCI registries, such as Azure Container Registry,
	// that host the Recipe templates referenced by a Recipe Pack.
	// Platform engineers define a `Radius.Core/bicepSettings` resource once and reference it from any Environment whose Recipes
	// pull templates from a private registry.
	// ## Defining Bicep settings
	// Configure `registryAuthentications`, keyed by registry hostname. When a Recipe template is pulled from a matching host,
	// Radius authenticates using the configured method. The example below uses basic authentication, reading the username and
	// password from a secret:
	// “`bicep
	// extension radius
	// @description('The Radius Environment ID. Injected automatically by the rad CLI.')
	// param environment string
	// resource registrySecret 'Radius.Security/secrets@2025-08-01-preview' = {
	// name: 'registry-credentials'
	// properties: {
	// environment: environment
	// data: {
	// username: { value: 'my-username' }
	// password: { value: 'my-password' }
	// }
	// }
	// }
	// resource bicepRegistry 'Radius.Core/bicepSettings@2025-08-01-preview' = {
	// name: 'private-registry'
	// properties: {
	// registryAuthentications: {
	// 'corp.azurecr.io': {
	// authenticationMethod: 'BasicAuth'
	// basicAuthSecretId: registrySecret.id
	// }
	// }
	// }
	// }
	// “`
	// Basic authentication is supported via `BasicAuth` (username and password from a secret). `AwsIrsa` and `AzureWI` will be
	// implemented in the future.
	// ## Deploying Bicep settings
	// Deploy the settings resource with the `rad deploy` command:
	// “`bash
	// rad deploy ./bicep-settings.bicep
	// “`
	// ## Referencing Bicep settings from an Environment
	// Reference the settings from an Environment by setting its `bicepSettings` property to the resource ID. Every Bicep Recipe
	// run in that Environment then uses the configured registry authentication:
	// “`bicep
	// extension radius
	// resource bicepRegistry 'Radius.Core/bicepSettings@2025-08-01-preview' existing = {
	// name: 'private-registry'
	// }
	// resource myEnvironment 'Radius.Core/environments@2025-08-01-preview' = {
	// name: 'my-environment'
	// properties: {
	// bicepSettings: bicepRegistry.id
	// }
	// }
	// “`
	BicepSettingsResource
}

type BicepSettingsProperties struct {
	// (Optional) Authentication for private Bicep registries that host Recipe templates, keyed by registry hostname such as `corp.acr.io`.
	// Radius matches a registry by the hostname in the Recipe source.
	RegistryAuthentications map[string]*BicepRegistryAuthentication

	// READ-ONLY; (Read Only) The status of the Bicep settings resource within the Radius control plane.
	ProvisioningState *ProvisioningState

	// READ-ONLY; (Read Only) Resource IDs of the Environments that reference this Bicep settings resource.
	ReferencedBy []*string
}

type BicepSettingsResource struct {
	// REQUIRED; The geo-location where the resource lives
	Location *string

	// REQUIRED; The resource-specific properties for this resource.
	Properties *BicepSettingsProperties

	// Resource tags.
	Tags map[string]*string

	// READ-ONLY; Fully qualified resource ID for the resource. Ex - /subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/{resourceProviderNamespace}/{resourceType}/{resourceName}
	ID *string

	// READ-ONLY; The name of the resource
	Name *string

	// READ-ONLY; Azure Resource Manager metadata containing createdBy and modifiedBy information.
	SystemData *SystemData

	// READ-ONLY; The type of the resource. E.g. "Microsoft.Compute/virtualMachines" or "Microsoft.Storage/storageAccounts"
	Type *string
}

type BicepSettingsResourceListResult struct {
	// REQUIRED; The BicepSettingsResource items on this page
	Value []*BicepSettingsResource

	// The link to the next page of items
	NextLink *string
}

type ClientFactory struct {
	// contains filtered or unexported fields
}

type ConnectionKind string

type CreatedByType string

type Direction string

type EnvironmentCompute struct {
	// REQUIRED; Discriminator property for EnvironmentCompute.
	Kind *string

	// Configuration for supported external identity providers
	Identity *IdentitySettings

	// The resource id of the compute resource for application environment.
	ResourceID *string
}

type EnvironmentComputeClassification interface {
	// GetEnvironmentCompute returns the EnvironmentCompute content of the underlying type.
	GetEnvironmentCompute() *EnvironmentCompute
}

type EnvironmentProperties struct {
	// (Optional) Resource ID of a `Radius.Core/bicepSettings` resource that supplies Bicep engine settings, such as private registry
	// authentication, used when running Bicep Recipes in this Environment.
	BicepSettings *string

	// (Optional) Target compute platform and cloud provider accounts that resources are deployed into. When created with the
	// Radius CLI, defaults to Kubernetes in the `default` namespace.
	Providers *Providers

	// (Optional) Resource IDs of the Recipe Packs this Environment uses to provision infrastructure for application resources.
	// When created with the Radius CLI, defaults to the `default` Recipe Pack in the `default` resource group.
	RecipePacks []*string

	// (Optional) Parameters passed to Recipes when they run, keyed by resource type. Values here override the default parameters
	// defined in the Recipe Pack for every resource of that type deployed to this Environment.
	RecipeParameters map[string]*RecipeParameterValue

	// (Optional) When true, the Environment is simulated and does not deploy real infrastructure. Recipes are evaluated but no
	// resources are provisioned, which is useful for validating application definitions. Defaults to `false` if not specified.
	Simulated *bool

	// (Optional) Resource ID of a `Radius.Core/terraformSettings` resource that supplies Terraform CLI settings, such as private
	// registry credentials, used when running Terraform Recipes in this Environment.
	TerraformSettings *string

	// READ-ONLY; (Read Only) The status of the Environment resource within the Radius control plane. Does not include the resources
	// deployed to the Environment.
	ProvisioningState *ProvisioningState
}

type EnvironmentResource struct {
	// REQUIRED; The geo-location where the resource lives
	Location *string

	// REQUIRED; The resource-specific properties for this resource.
	Properties *EnvironmentProperties

	// Resource tags.
	Tags map[string]*string

	// READ-ONLY; Fully qualified resource ID for the resource. Ex - /subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/{resourceProviderNamespace}/{resourceType}/{resourceName}
	ID *string

	// READ-ONLY; The name of the resource
	Name *string

	// READ-ONLY; Azure Resource Manager metadata containing createdBy and modifiedBy information.
	SystemData *SystemData

	// READ-ONLY; The type of the resource. E.g. "Microsoft.Compute/virtualMachines" or "Microsoft.Storage/storageAccounts"
	Type *string
}

type EnvironmentResourceListResult struct {
	// REQUIRED; The EnvironmentResource items on this page
	Value []*EnvironmentResource

	// The link to the next page of items
	NextLink *string
}

type EnvironmentsClient struct {
	// contains filtered or unexported fields
}

type EnvironmentsClientCreateOrUpdateOptions struct {
}

type EnvironmentsClientCreateOrUpdateResponse struct {
	// The `Radius.Core/environments` Resource Type represents a Radius Environment: the deployment target that platform engineers
	// configure for their developers. Every Radius Application is deployed to an Environment through its `environment` property.
	// An Environment defines three things for the Applications deployed to it:
	// - **Where resources are deployed**: the target compute platform and cloud provider accounts, set through the `providers`
	// property.
	// - **Which Recipes are used**: the Recipe Packs whose Recipes provision the infrastructure backing application resources,
	// set through the `recipePacks` property.
	// - **Advanced Terraform and Bicep settings**: environment-wide Recipe parameters and Terraform or Bicep engine configuration
	// applied when Recipes run.
	// ## Defining an Environment
	// The simplest Environment can be created directly with the `rad environment create` command, without a Bicep file:
	// “`bash
	// rad environment create my-environment
	// “`
	// For more advanced configurations, define an Environment as a `Radius.Core/environments` resource in a Bicep file. For example:
	// “`bicep
	// extension radius
	// resource myEnvironment 'Radius.Core/environments@2025-08-01-preview' = {
	// name: 'my-environment'
	// properties: {
	// recipePacks: [
	// myRecipePack.id
	// ]
	// providers: {
	// kubernetes: {
	// namespace: 'my-namespace'
	// }
	// }
	// }
	// }
	// resource myRecipePack 'Radius.Core/recipePacks@2025-08-01-preview' existing = {
	// name: 'my-recipe-pack'
	// }
	// “`
	// Both properties are optional. When you create an Environment with the Radius CLI, an omitted `providers` defaults to Kubernetes
	// in the `default` namespace, and an omitted `recipePacks` defaults to the `default` Recipe Pack in the `default` resource
	// group.
	// ## Deploying an Environment
	// Deploy a defined Environment with the `rad deploy` command:
	// “`bash
	// rad deploy ./environment.bicep
	// “`
	// ## Cloud providers
	// To use Recipes that provision resources in a cloud provider, you must configure that provider's account details on the
	// Environment by setting the `providers` property. For AWS, set the account ID and the region resources are deployed to:
	// “`bicep
	// extension radius
	// resource myEnvironment 'Radius.Core/environments@2025-08-01-preview' = {
	// name: 'my-environment'
	// properties: {
	// providers: {
	// aws: {
	// accountId: '123456789012'
	// region: 'us-west-2'
	// }
	// }
	// }
	// }
	// “`
	// For Azure, set the subscription ID and the name of the resource group that resources are deployed to:
	// “`bicep
	// extension radius
	// resource myEnvironment 'Radius.Core/environments@2025-08-01-preview' = {
	// name: 'my-environment'
	// properties: {
	// providers: {
	// azure: {
	// subscriptionId: '00000000-0000-0000-0000-000000000000'
	// resourceGroupName: 'my-resource-group'
	// }
	// }
	// }
	// }
	// “`
	// The `providers` property selects the target account, but the credentials Radius uses to authenticate to AWS and Azure are
	// configured separately with the `rad credential register` command.
	// ## Recipe Packs
	// A Recipe Pack is a collection of Recipes, defined as a separate `Radius.Core/recipePacks` resource. A Recipe is an infrastructure-as-code
	// module, a Terraform module or Bicep template, that provisions the infrastructure backing an application resource. Reference
	// one or more Recipe Packs by their resource IDs in the `recipePacks` property to control which Recipes are used. See the
	// `Radius.Core/recipePacks` documentation for details.
	// Use `recipeParameters` to pass environment-specific parameters to the Recipes defined in the referenced Recipe Packs, for
	// example to standardize configuration such as SKUs or instance sizes across an Environment.
	// ## Advanced Terraform and Bicep settings
	// For advanced Terraform and Bicep settings, such as private module sources and registry authentication, reference a `Radius.Core/terraformSettings`
	// or `Radius.Core/bicepSettings` resource from the `terraformSettings` and `bicepSettings` properties.
	EnvironmentResource
}

type EnvironmentsClientDeleteOptions struct {
}

type EnvironmentsClientDeleteResponse struct {
}

type EnvironmentsClientGetOptions struct {
}

type EnvironmentsClientGetResponse struct {
	// The `Radius.Core/environments` Resource Type represents a Radius Environment: the deployment target that platform engineers
	// configure for their developers. Every Radius Application is deployed to an Environment through its `environment` property.
	// An Environment defines three things for the Applications deployed to it:
	// - **Where resources are deployed**: the target compute platform and cloud provider accounts, set through the `providers`
	// property.
	// - **Which Recipes are used**: the Recipe Packs whose Recipes provision the infrastructure backing application resources,
	// set through the `recipePacks` property.
	// - **Advanced Terraform and Bicep settings**: environment-wide Recipe parameters and Terraform or Bicep engine configuration
	// applied when Recipes run.
	// ## Defining an Environment
	// The simplest Environment can be created directly with the `rad environment create` command, without a Bicep file:
	// “`bash
	// rad environment create my-environment
	// “`
	// For more advanced configurations, define an Environment as a `Radius.Core/environments` resource in a Bicep file. For example:
	// “`bicep
	// extension radius
	// resource myEnvironment 'Radius.Core/environments@2025-08-01-preview' = {
	// name: 'my-environment'
	// properties: {
	// recipePacks: [
	// myRecipePack.id
	// ]
	// providers: {
	// kubernetes: {
	// namespace: 'my-namespace'
	// }
	// }
	// }
	// }
	// resource myRecipePack 'Radius.Core/recipePacks@2025-08-01-preview' existing = {
	// name: 'my-recipe-pack'
	// }
	// “`
	// Both properties are optional. When you create an Environment with the Radius CLI, an omitted `providers` defaults to Kubernetes
	// in the `default` namespace, and an omitted `recipePacks` defaults to the `default` Recipe Pack in the `default` resource
	// group.
	// ## Deploying an Environment
	// Deploy a defined Environment with the `rad deploy` command:
	// “`bash
	// rad deploy ./environment.bicep
	// “`
	// ## Cloud providers
	// To use Recipes that provision resources in a cloud provider, you must configure that provider's account details on the
	// Environment by setting the `providers` property. For AWS, set the account ID and the region resources are deployed to:
	// “`bicep
	// extension radius
	// resource myEnvironment 'Radius.Core/environments@2025-08-01-preview' = {
	// name: 'my-environment'
	// properties: {
	// providers: {
	// aws: {
	// accountId: '123456789012'
	// region: 'us-west-2'
	// }
	// }
	// }
	// }
	// “`
	// For Azure, set the subscription ID and the name of the resource group that resources are deployed to:
	// “`bicep
	// extension radius
	// resource myEnvironment 'Radius.Core/environments@2025-08-01-preview' = {
	// name: 'my-environment'
	// properties: {
	// providers: {
	// azure: {
	// subscriptionId: '00000000-0000-0000-0000-000000000000'
	// resourceGroupName: 'my-resource-group'
	// }
	// }
	// }
	// }
	// “`
	// The `providers` property selects the target account, but the credentials Radius uses to authenticate to AWS and Azure are
	// configured separately with the `rad credential register` command.
	// ## Recipe Packs
	// A Recipe Pack is a collection of Recipes, defined as a separate `Radius.Core/recipePacks` resource. A Recipe is an infrastructure-as-code
	// module, a Terraform module or Bicep template, that provisions the infrastructure backing an application resource. Reference
	// one or more Recipe Packs by their resource IDs in the `recipePacks` property to control which Recipes are used. See the
	// `Radius.Core/recipePacks` documentation for details.
	// Use `recipeParameters` to pass environment-specific parameters to the Recipes defined in the referenced Recipe Packs, for
	// example to standardize configuration such as SKUs or instance sizes across an Environment.
	// ## Advanced Terraform and Bicep settings
	// For advanced Terraform and Bicep settings, such as private module sources and registry authentication, reference a `Radius.Core/terraformSettings`
	// or `Radius.Core/bicepSettings` resource from the `terraformSettings` and `bicepSettings` properties.
	EnvironmentResource
}

type EnvironmentsClientListByScopeOptions struct {
}

type EnvironmentsClientListByScopeResponse struct {
	// The response of a EnvironmentResource list operation.
	EnvironmentResourceListResult
}

type EnvironmentsClientUpdateOptions struct {
}

type EnvironmentsClientUpdateResponse struct {
	// The `Radius.Core/environments` Resource Type represents a Radius Environment: the deployment target that platform engineers
	// configure for their developers. Every Radius Application is deployed to an Environment through its `environment` property.
	// An Environment defines three things for the Applications deployed to it:
	// - **Where resources are deployed**: the target compute platform and cloud provider accounts, set through the `providers`
	// property.
	// - **Which Recipes are used**: the Recipe Packs whose Recipes provision the infrastructure backing application resources,
	// set through the `recipePacks` property.
	// - **Advanced Terraform and Bicep settings**: environment-wide Recipe parameters and Terraform or Bicep engine configuration
	// applied when Recipes run.
	// ## Defining an Environment
	// The simplest Environment can be created directly with the `rad environment create` command, without a Bicep file:
	// “`bash
	// rad environment create my-environment
	// “`
	// For more advanced configurations, define an Environment as a `Radius.Core/environments` resource in a Bicep file. For example:
	// “`bicep
	// extension radius
	// resource myEnvironment 'Radius.Core/environments@2025-08-01-preview' = {
	// name: 'my-environment'
	// properties: {
	// recipePacks: [
	// myRecipePack.id
	// ]
	// providers: {
	// kubernetes: {
	// namespace: 'my-namespace'
	// }
	// }
	// }
	// }
	// resource myRecipePack 'Radius.Core/recipePacks@2025-08-01-preview' existing = {
	// name: 'my-recipe-pack'
	// }
	// “`
	// Both properties are optional. When you create an Environment with the Radius CLI, an omitted `providers` defaults to Kubernetes
	// in the `default` namespace, and an omitted `recipePacks` defaults to the `default` Recipe Pack in the `default` resource
	// group.
	// ## Deploying an Environment
	// Deploy a defined Environment with the `rad deploy` command:
	// “`bash
	// rad deploy ./environment.bicep
	// “`
	// ## Cloud providers
	// To use Recipes that provision resources in a cloud provider, you must configure that provider's account details on the
	// Environment by setting the `providers` property. For AWS, set the account ID and the region resources are deployed to:
	// “`bicep
	// extension radius
	// resource myEnvironment 'Radius.Core/environments@2025-08-01-preview' = {
	// name: 'my-environment'
	// properties: {
	// providers: {
	// aws: {
	// accountId: '123456789012'
	// region: 'us-west-2'
	// }
	// }
	// }
	// }
	// “`
	// For Azure, set the subscription ID and the name of the resource group that resources are deployed to:
	// “`bicep
	// extension radius
	// resource myEnvironment 'Radius.Core/environments@2025-08-01-preview' = {
	// name: 'my-environment'
	// properties: {
	// providers: {
	// azure: {
	// subscriptionId: '00000000-0000-0000-0000-000000000000'
	// resourceGroupName: 'my-resource-group'
	// }
	// }
	// }
	// }
	// “`
	// The `providers` property selects the target account, but the credentials Radius uses to authenticate to AWS and Azure are
	// configured separately with the `rad credential register` command.
	// ## Recipe Packs
	// A Recipe Pack is a collection of Recipes, defined as a separate `Radius.Core/recipePacks` resource. A Recipe is an infrastructure-as-code
	// module, a Terraform module or Bicep template, that provisions the infrastructure backing an application resource. Reference
	// one or more Recipe Packs by their resource IDs in the `recipePacks` property to control which Recipes are used. See the
	// `Radius.Core/recipePacks` documentation for details.
	// Use `recipeParameters` to pass environment-specific parameters to the Recipes defined in the referenced Recipe Packs, for
	// example to standardize configuration such as SKUs or instance sizes across an Environment.
	// ## Advanced Terraform and Bicep settings
	// For advanced Terraform and Bicep settings, such as private module sources and registry authentication, reference a `Radius.Core/terraformSettings`
	// or `Radius.Core/bicepSettings` resource from the `terraformSettings` and `bicepSettings` properties.
	EnvironmentResource
}

type GetGraphRequest struct {
	// Optional caller-supplied dependency edges, grouped by source resource ID. Each entry maps a source Radius resource ID to
	// the list of outbound Kind: Dependency edges leaving that source. Every entry MUST have direction: Outbound and kind: Dependency;
	// entries that don't are ignored. The server merges these onto the connection-only graph it computes from stored resources:
	// excluded types are dropped, unknown endpoints are dropped, and any pair already present as Kind: Connection wins over the
	// caller-supplied Dependency. Typically populated by `rad app graph -a <name> <app.bicep>` after compiling the Bicep template
	// locally.
	DependsOnEdges map[string][]*ApplicationGraphConnection

	// When true, `ApplicationGraphResponse.icons` is populated with the SVG bytes for every distinct `iconHash` referenced by
	// the response's resources. When false or omitted, only per-resource `iconHash` values are returned.
	IncludeIcons *bool
}

type IdentitySettingKind string

type IdentitySettings struct {
	// REQUIRED; kind of identity setting
	Kind *IdentitySettingKind

	// The list of user assigned managed identities
	ManagedIdentity []*string

	// The URI for your compute platform's OIDC issuer
	OidcIssuer *string

	// The resource ID of the provisioned identity
	Resource *string
}

type KubernetesCompute struct {
	// REQUIRED; The Kubernetes compute kind
	Kind *string

	// REQUIRED; The namespace to use for the environment.
	Namespace *string

	// Configuration for supported external identity providers
	Identity *IdentitySettings

	// The resource id of the compute resource for application environment.
	ResourceID *string
}

type Operation struct {
	// Localized display information for this particular operation.
	Display *OperationDisplay

	// READ-ONLY; Extensible enum. Indicates the action type. "Internal" refers to actions that are for internal only APIs.
	ActionType *ActionType

	// READ-ONLY; Whether the operation applies to data-plane. This is "true" for data-plane operations and "false" for Azure
	// Resource Manager/control-plane operations.
	IsDataAction *bool

	// READ-ONLY; The name of the operation, as per Resource-Based Access Control (RBAC). Examples: "Microsoft.Compute/virtualMachines/write",
	// "Microsoft.Compute/virtualMachines/capture/action"
	Name *string

	// READ-ONLY; The intended executor of the operation; as in Resource Based Access Control (RBAC) and audit logs UX. Default
	// value is "user,system"
	Origin *Origin
}

type OperationDisplay struct {
	// READ-ONLY; The short, localized friendly description of the operation; suitable for tool tips and detailed views.
	Description *string

	// READ-ONLY; The concise, localized friendly name for the operation; suitable for dropdowns. E.g. "Create or Update Virtual
	// Machine", "Restart Virtual Machine".
	Operation *string

	// READ-ONLY; The localized friendly form of the resource provider name, e.g. "Microsoft Monitoring Insights" or "Microsoft
	// Compute".
	Provider *string

	// READ-ONLY; The localized friendly name of the resource type related to this operation. E.g. "Virtual Machines" or "Job
	// Schedule Collections".
	Resource *string
}

type OperationListResult struct {
	// REQUIRED; The Operation items on this page
	Value []*Operation

	// The link to the next page of items
	NextLink *string
}

type OperationsClient struct {
	// contains filtered or unexported fields
}

type OperationsClientListOptions struct {
}

type OperationsClientListResponse struct {
	// A list of REST API operations supported by an Azure Resource Provider. It contains an URL link to get the next set of results.
	OperationListResult
}

type Origin string

type OutputResource struct {
	// The UCP resource ID of the underlying resource.
	ID *string

	// The logical identifier scoped to the owning Radius resource. This is only needed or used when a resource has a dependency
	// relationship. LocalIDs do not have any particular format or meaning beyond being compared to determine dependency relationships.
	LocalID *string

	// Determines whether Radius manages the lifecycle of the underlying resource.
	RadiusManaged *bool
}

type Providers struct {
	// (Optional) Configuration for deploying resources to AWS.
	Aws *ProvidersAws

	// (Optional) Configuration for deploying resources to Azure.
	Azure *ProvidersAzure

	// (Optional) Configuration for deploying resources to Kubernetes.
	Kubernetes *ProvidersKubernetes
}

type ProvidersAws struct {
	// REQUIRED; (Required) ID of the AWS account that resources are deployed into.
	AccountID *string

	// REQUIRED; (Required) AWS region that resources are deployed into.
	Region *string
}

type ProvidersAzure struct {
	// REQUIRED; (Required) ID of the Azure subscription that resources are deployed into.
	SubscriptionID *string

	// (Optional) Managed or workload identity Radius uses to authenticate to Azure when deploying resources.
	Identity *IdentitySettings

	// (Optional) Name of the Azure resource group that resources are deployed into. Most Bicep and Terraform Recipes expect a
	// resource group in the deployment context, so set this whenever deploying Azure resources.
	ResourceGroupName *string
}

type ProvidersKubernetes struct {
	// REQUIRED; (Required) Kubernetes namespace that workloads are deployed into.
	Namespace *string
}

type ProvisioningState string

type RecipeDefinition struct {
	// REQUIRED; (Required) The kind of Recipe, which determines how Radius runs it.
	Kind *RecipeKind

	// REQUIRED; (Required) Location of the Recipe. For Bicep Recipes this is an OCI registry reference. For Terraform Recipes
	// this is the module source such as a Git URL or a Terraform registry module.
	Source *string

	// (Optional) Maps the module outputs onto the resource type properties for recipes that point directly at a Bicep or Terraform
	// module. Each value is the module output name for a non-secret property. Under the reserved `secrets` key a nested object
	// maps secret property names to module output names and always routes those outputs to the resource secret outputs.
	Outputs map[string]any

	// (Optional) Default parameter values passed to the Recipe when it runs. An Environment can override these per resource type
	// through its `recipeParameters` property.
	Parameters map[string]any

	// (Optional) Connect to the source using HTTP instead of HTTPS. Use this only when the source does not support HTTPS such
	// as a locally hosted registry for Bicep recipes. Defaults to `false` if not specified.
	PlainHTTP *bool
}

type RecipeKind string

type RecipePackProperties struct {
	// REQUIRED; (Required) The Recipes in this pack, keyed by the resource type each Recipe provisions. Each key is a resource
	// type such as `Radius.Data/redisCaches`.
	Recipes map[string]*RecipeDefinition

	// READ-ONLY; (Read Only) The status of the Recipe Pack resource within the Radius control plane.
	ProvisioningState *ProvisioningState

	// READ-ONLY; (Read Only) Resource IDs of the Environments that reference this Recipe Pack.
	ReferencedBy []*string
}

type RecipePackResource struct {
	// REQUIRED; The geo-location where the resource lives
	Location *string

	// REQUIRED; The resource-specific properties for this resource.
	Properties *RecipePackProperties

	// Resource tags.
	Tags map[string]*string

	// READ-ONLY; Fully qualified resource ID for the resource. Ex - /subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/{resourceProviderNamespace}/{resourceType}/{resourceName}
	ID *string

	// READ-ONLY; The name of the resource
	Name *string

	// READ-ONLY; Azure Resource Manager metadata containing createdBy and modifiedBy information.
	SystemData *SystemData

	// READ-ONLY; The type of the resource. E.g. "Microsoft.Compute/virtualMachines" or "Microsoft.Storage/storageAccounts"
	Type *string
}

type RecipePackResourceListResult struct {
	// REQUIRED; The RecipePackResource items on this page
	Value []*RecipePackResource

	// The link to the next page of items
	NextLink *string
}

type RecipePacksClient struct {
	// contains filtered or unexported fields
}

type RecipePacksClientCreateOrUpdateOptions struct {
}

type RecipePacksClientCreateOrUpdateResponse struct {
	// The `Radius.Core/recipePacks` Resource Type represents a Recipe Pack: a named collection of Recipes that platform engineers
	// assign to an Environment. A Recipe maps a resource type (such as `Radius.Data/redisCaches`) to an infrastructure-as-code
	// module, a Terraform module or Bicep template, that provisions the infrastructure backing that resource when a developer
	// deploys it.
	// A Recipe Pack is defined as its own resource and referenced from an Environment's `recipePacks` property, so one Recipe
	// Pack can be shared across many Environments.
	// ## Defining a Recipe Pack
	// Each entry in the `recipes` map is keyed by resource type. Set the recipe `kind` (`bicep` or `terraform`) and its `source`
	// (an OCI registry reference for Bicep recipes, or a module source for Terraform recipes).
	// “`bicep
	// extension radius
	// resource dataRecipes 'Radius.Core/recipePacks@2025-08-01-preview' = {
	// name: 'data-recipes'
	// properties: {
	// recipes: {
	// 'Radius.Data/redisCaches': {
	// kind: 'bicep'
	// source: 'ghcr.io/my-org/recipes/redis:latest'
	// }
	// 'Radius.Data/postgreSqlDatabases': {
	// kind: 'terraform'
	// source: 'git::https://github.com/my-org/recipes//postgresql'
	// }
	// }
	// }
	// }
	// “`
	// ## Recipe parameters
	// Each Recipe can declare default `parameters` that are passed to its module. Platform engineers set baseline values here,
	// and developers get them automatically. An Environment can override these values per resource type through its `recipeParameters`
	// property.
	// “`bicep
	// resource dataRecipes 'Radius.Core/recipePacks@2025-08-01-preview' = {
	// name: 'data-recipes'
	// properties: {
	// recipes: {
	// 'Radius.Data/redisCaches': {
	// kind: 'bicep'
	// source: 'ghcr.io/my-org/recipes/redis:latest'
	// parameters: {
	// sku: 'Standard'
	// capacity: 1
	// }
	// }
	// }
	// }
	// }
	// “`
	// ## Deploying a Recipe Pack
	// Deploy the Bicep file with `rad deploy` to create the Recipe Pack resource. Once deployed, list and inspect Recipe Packs
	// with the `rad recipe-pack list` and `rad recipe-pack show` commands.
	// ## Referencing a Recipe Pack from an Environment
	// An Environment references a Recipe Pack through its `recipePacks` property. When the Recipe Pack and the Environment are
	// deployed to the same resource group, declare it as an `existing` resource and reference its `.id`:
	// “`bicep
	// extension radius
	// resource dataRecipes 'Radius.Core/recipePacks@2025-08-01-preview' existing = {
	// name: 'data-recipes'
	// }
	// resource myEnvironment 'Radius.Core/environments@2025-08-01-preview' = {
	// name: 'my-environment'
	// properties: {
	// recipePacks: [
	// dataRecipes.id
	// ]
	// }
	// }
	// “`
	// To reference a Recipe Pack in a different resource group, use its full resource ID instead:
	// “`bicep
	// recipePacks: [
	// '/planes/radius/local/resourceGroups/shared/providers/Radius.Core/recipePacks/data-recipes'
	// ]
	// “`
	// Radius is installed with a `default` Recipe Pack in the `default` resource group. When you create an Environment with the
	// Radius CLI and do not set `recipePacks`, the Environment uses this `default` Recipe Pack.
	// Prebuilt Recipe Packs and the Recipes they reference are published in the [resource-types-contrib](https://github.com/radius-project/resource-types-contrib)
	// repository.
	RecipePackResource
}

type RecipePacksClientDeleteOptions struct {
}

type RecipePacksClientDeleteResponse struct {
}

type RecipePacksClientGetOptions struct {
}

type RecipePacksClientGetResponse struct {
	// The `Radius.Core/recipePacks` Resource Type represents a Recipe Pack: a named collection of Recipes that platform engineers
	// assign to an Environment. A Recipe maps a resource type (such as `Radius.Data/redisCaches`) to an infrastructure-as-code
	// module, a Terraform module or Bicep template, that provisions the infrastructure backing that resource when a developer
	// deploys it.
	// A Recipe Pack is defined as its own resource and referenced from an Environment's `recipePacks` property, so one Recipe
	// Pack can be shared across many Environments.
	// ## Defining a Recipe Pack
	// Each entry in the `recipes` map is keyed by resource type. Set the recipe `kind` (`bicep` or `terraform`) and its `source`
	// (an OCI registry reference for Bicep recipes, or a module source for Terraform recipes).
	// “`bicep
	// extension radius
	// resource dataRecipes 'Radius.Core/recipePacks@2025-08-01-preview' = {
	// name: 'data-recipes'
	// properties: {
	// recipes: {
	// 'Radius.Data/redisCaches': {
	// kind: 'bicep'
	// source: 'ghcr.io/my-org/recipes/redis:latest'
	// }
	// 'Radius.Data/postgreSqlDatabases': {
	// kind: 'terraform'
	// source: 'git::https://github.com/my-org/recipes//postgresql'
	// }
	// }
	// }
	// }
	// “`
	// ## Recipe parameters
	// Each Recipe can declare default `parameters` that are passed to its module. Platform engineers set baseline values here,
	// and developers get them automatically. An Environment can override these values per resource type through its `recipeParameters`
	// property.
	// “`bicep
	// resource dataRecipes 'Radius.Core/recipePacks@2025-08-01-preview' = {
	// name: 'data-recipes'
	// properties: {
	// recipes: {
	// 'Radius.Data/redisCaches': {
	// kind: 'bicep'
	// source: 'ghcr.io/my-org/recipes/redis:latest'
	// parameters: {
	// sku: 'Standard'
	// capacity: 1
	// }
	// }
	// }
	// }
	// }
	// “`
	// ## Deploying a Recipe Pack
	// Deploy the Bicep file with `rad deploy` to create the Recipe Pack resource. Once deployed, list and inspect Recipe Packs
	// with the `rad recipe-pack list` and `rad recipe-pack show` commands.
	// ## Referencing a Recipe Pack from an Environment
	// An Environment references a Recipe Pack through its `recipePacks` property. When the Recipe Pack and the Environment are
	// deployed to the same resource group, declare it as an `existing` resource and reference its `.id`:
	// “`bicep
	// extension radius
	// resource dataRecipes 'Radius.Core/recipePacks@2025-08-01-preview' existing = {
	// name: 'data-recipes'
	// }
	// resource myEnvironment 'Radius.Core/environments@2025-08-01-preview' = {
	// name: 'my-environment'
	// properties: {
	// recipePacks: [
	// dataRecipes.id
	// ]
	// }
	// }
	// “`
	// To reference a Recipe Pack in a different resource group, use its full resource ID instead:
	// “`bicep
	// recipePacks: [
	// '/planes/radius/local/resourceGroups/shared/providers/Radius.Core/recipePacks/data-recipes'
	// ]
	// “`
	// Radius is installed with a `default` Recipe Pack in the `default` resource group. When you create an Environment with the
	// Radius CLI and do not set `recipePacks`, the Environment uses this `default` Recipe Pack.
	// Prebuilt Recipe Packs and the Recipes they reference are published in the [resource-types-contrib](https://github.com/radius-project/resource-types-contrib)
	// repository.
	RecipePackResource
}

type RecipePacksClientListByScopeOptions struct {
}

type RecipePacksClientListByScopeResponse struct {
	// The response of a RecipePackResource list operation.
	RecipePackResourceListResult
}

type RecipePacksClientUpdateOptions struct {
}

type RecipePacksClientUpdateResponse struct {
	// The `Radius.Core/recipePacks` Resource Type represents a Recipe Pack: a named collection of Recipes that platform engineers
	// assign to an Environment. A Recipe maps a resource type (such as `Radius.Data/redisCaches`) to an infrastructure-as-code
	// module, a Terraform module or Bicep template, that provisions the infrastructure backing that resource when a developer
	// deploys it.
	// A Recipe Pack is defined as its own resource and referenced from an Environment's `recipePacks` property, so one Recipe
	// Pack can be shared across many Environments.
	// ## Defining a Recipe Pack
	// Each entry in the `recipes` map is keyed by resource type. Set the recipe `kind` (`bicep` or `terraform`) and its `source`
	// (an OCI registry reference for Bicep recipes, or a module source for Terraform recipes).
	// “`bicep
	// extension radius
	// resource dataRecipes 'Radius.Core/recipePacks@2025-08-01-preview' = {
	// name: 'data-recipes'
	// properties: {
	// recipes: {
	// 'Radius.Data/redisCaches': {
	// kind: 'bicep'
	// source: 'ghcr.io/my-org/recipes/redis:latest'
	// }
	// 'Radius.Data/postgreSqlDatabases': {
	// kind: 'terraform'
	// source: 'git::https://github.com/my-org/recipes//postgresql'
	// }
	// }
	// }
	// }
	// “`
	// ## Recipe parameters
	// Each Recipe can declare default `parameters` that are passed to its module. Platform engineers set baseline values here,
	// and developers get them automatically. An Environment can override these values per resource type through its `recipeParameters`
	// property.
	// “`bicep
	// resource dataRecipes 'Radius.Core/recipePacks@2025-08-01-preview' = {
	// name: 'data-recipes'
	// properties: {
	// recipes: {
	// 'Radius.Data/redisCaches': {
	// kind: 'bicep'
	// source: 'ghcr.io/my-org/recipes/redis:latest'
	// parameters: {
	// sku: 'Standard'
	// capacity: 1
	// }
	// }
	// }
	// }
	// }
	// “`
	// ## Deploying a Recipe Pack
	// Deploy the Bicep file with `rad deploy` to create the Recipe Pack resource. Once deployed, list and inspect Recipe Packs
	// with the `rad recipe-pack list` and `rad recipe-pack show` commands.
	// ## Referencing a Recipe Pack from an Environment
	// An Environment references a Recipe Pack through its `recipePacks` property. When the Recipe Pack and the Environment are
	// deployed to the same resource group, declare it as an `existing` resource and reference its `.id`:
	// “`bicep
	// extension radius
	// resource dataRecipes 'Radius.Core/recipePacks@2025-08-01-preview' existing = {
	// name: 'data-recipes'
	// }
	// resource myEnvironment 'Radius.Core/environments@2025-08-01-preview' = {
	// name: 'my-environment'
	// properties: {
	// recipePacks: [
	// dataRecipes.id
	// ]
	// }
	// }
	// “`
	// To reference a Recipe Pack in a different resource group, use its full resource ID instead:
	// “`bicep
	// recipePacks: [
	// '/planes/radius/local/resourceGroups/shared/providers/Radius.Core/recipePacks/data-recipes'
	// ]
	// “`
	// Radius is installed with a `default` Recipe Pack in the `default` resource group. When you create an Environment with the
	// Radius CLI and do not set `recipePacks`, the Environment uses this `default` Recipe Pack.
	// Prebuilt Recipe Packs and the Recipes they reference are published in the [resource-types-contrib](https://github.com/radius-project/resource-types-contrib)
	// repository.
	RecipePackResource
}

type RecipeParameterValue struct {
	AdditionalProperties map[string]any
}

type RecipeStatus struct {
	// REQUIRED; TemplateKind is the kind of the recipe template used by the portable resource upon deployment.
	TemplateKind *string

	// REQUIRED; TemplatePath is the path of the recipe consumed by the portable resource upon deployment.
	TemplatePath *string

	// TemplateVersion is the version number of the template.
	TemplateVersion *string
}

type ResourceStatus struct {
	// The compute resource associated with the resource.
	Compute EnvironmentComputeClassification

	// Properties of an output resource
	OutputResources []*OutputResource

	// READ-ONLY; The recipe data at the time of deployment
	Recipe *RecipeStatus
}

type SystemData struct {
	// The timestamp of resource creation (UTC).
	CreatedAt *time.Time

	// The identity that created the resource.
	CreatedBy *string

	// The type of identity that created the resource.
	CreatedByType *CreatedByType

	// The timestamp of resource last modification (UTC)
	LastModifiedAt *time.Time

	// The identity that last modified the resource.
	LastModifiedBy *string

	// The type of identity that last modified the resource.
	LastModifiedByType *CreatedByType
}

type TerraformCredentialConfig struct {
	// (Optional) The ID of a `Radius.Security/secrets` resource containing the authentication token. The secret must have a key
	// named `token`.
	Secret *string
}

type TerraformProviderDirect struct {
	// (Optional) Provider address patterns to exclude from direct installation.
	Exclude []*string

	// (Optional) Provider address patterns to include for direct installation.
	Include []*string
}

type TerraformProviderInstallation struct {
	// (Optional) Providers to install directly from the public registry rather than a mirror.
	Direct *TerraformProviderDirect

	// (Optional) A network mirror to install providers from instead of the public registry.
	NetworkMirror *TerraformProviderMirror
}

type TerraformProviderMirror struct {
	// (Optional) Provider address patterns to exclude from this mirror.
	Exclude []*string

	// (Optional) Provider address patterns to include from this mirror.
	Include []*string

	// (Optional) The URL of the provider mirror.
	URL *string
}

type TerraformSettingsClient struct {
	// contains filtered or unexported fields
}

type TerraformSettingsClientCreateOrUpdateOptions struct {
}

type TerraformSettingsClientCreateOrUpdateResponse struct {
	// The `Radius.Core/terraformSettings` Resource Type holds reusable Terraform CLI settings that Environments apply when running
	// Terraform Recipes. Its primary use is authenticating to private Terraform registries that host the modules referenced by
	// a Recipe Pack, along with configuring provider installation and injecting environment variables during Recipe execution.
	// Platform engineers define a `Radius.Core/terraformSettings` resource once and reference it from any Environment whose Recipes
	// pull modules from a private registry.
	// ## Defining Terraform settings
	// Configure `terraformrc.credentials`, keyed by registry hostname, to authenticate to a private Terraform registry. Each
	// entry points to a secret whose `token` key holds the registry token:
	// “`bicep
	// extension radius
	// @description('The Radius Environment ID. Injected automatically by the rad CLI.')
	// param environment string
	// resource registrySecret 'Radius.Security/secrets@2025-08-01-preview' = {
	// name: 'terraform-registry-token'
	// properties: {
	// environment: environment
	// data: {
	// token: { value: 'my-registry-token' }
	// }
	// }
	// }
	// resource terraformRegistry 'Radius.Core/terraformSettings@2025-08-01-preview' = {
	// name: 'private-registry'
	// properties: {
	// terraformrc: {
	// credentials: {
	// 'app.terraform.io': {
	// secret: registrySecret.id
	// }
	// }
	// }
	// }
	// }
	// “`
	// Two other settings are available: provider installation and environment variables.
	// ### Provider installation
	// In air-gapped or internal environments, use `terraformrc.providerInstallation` to install providers from a network mirror
	// instead of the public registry. Set the mirror `url`, optionally narrow it with `include` or `exclude` provider address
	// patterns, and use `direct` to control which providers are still downloaded directly:
	// “`bicep
	// resource providerMirror 'Radius.Core/terraformSettings@2025-08-01-preview' = {
	// name: 'internal-mirror'
	// properties: {
	// terraformrc: {
	// providerInstallation: {
	// networkMirror: {
	// url: 'https://terraform.corp.example.com/providers/'
	// include: ['*']
	// }
	// direct: {
	// exclude: ['*']
	// }
	// }
	// }
	// }
	// }
	// “`
	// ### Environment variables
	// Use `env` to inject environment variables into every Terraform Recipe run, for example to raise the Terraform log level
	// for troubleshooting or to tune CLI behavior:
	// “`bicep
	// resource terraformLogging 'Radius.Core/terraformSettings@2025-08-01-preview' = {
	// name: 'terraform-logging'
	// properties: {
	// env: {
	// TF_LOG: 'TRACE'
	// TF_REGISTRY_CLIENT_TIMEOUT: '15'
	// }
	// }
	// }
	// “`
	// ## Deploying Terraform settings
	// Deploy the settings resource with the `rad deploy` command:
	// “`bash
	// rad deploy ./terraform-settings.bicep
	// “`
	// ## Referencing Terraform settings from an Environment
	// Reference the settings from an Environment by setting its `terraformSettings` property to the resource ID. Every Terraform
	// Recipe run in that Environment then uses the configured registry credentials:
	// “`bicep
	// extension radius
	// resource terraformRegistry 'Radius.Core/terraformSettings@2025-08-01-preview' existing = {
	// name: 'private-registry'
	// }
	// resource myEnvironment 'Radius.Core/environments@2025-08-01-preview' = {
	// name: 'my-environment'
	// properties: {
	// terraformSettings: terraformRegistry.id
	// }
	// }
	// “`
	TerraformSettingsResource
}

type TerraformSettingsClientDeleteOptions struct {
}

type TerraformSettingsClientDeleteResponse struct {
}

type TerraformSettingsClientGetOptions struct {
}

type TerraformSettingsClientGetResponse struct {
	// The `Radius.Core/terraformSettings` Resource Type holds reusable Terraform CLI settings that Environments apply when running
	// Terraform Recipes. Its primary use is authenticating to private Terraform registries that host the modules referenced by
	// a Recipe Pack, along with configuring provider installation and injecting environment variables during Recipe execution.
	// Platform engineers define a `Radius.Core/terraformSettings` resource once and reference it from any Environment whose Recipes
	// pull modules from a private registry.
	// ## Defining Terraform settings
	// Configure `terraformrc.credentials`, keyed by registry hostname, to authenticate to a private Terraform registry. Each
	// entry points to a secret whose `token` key holds the registry token:
	// “`bicep
	// extension radius
	// @description('The Radius Environment ID. Injected automatically by the rad CLI.')
	// param environment string
	// resource registrySecret 'Radius.Security/secrets@2025-08-01-preview' = {
	// name: 'terraform-registry-token'
	// properties: {
	// environment: environment
	// data: {
	// token: { value: 'my-registry-token' }
	// }
	// }
	// }
	// resource terraformRegistry 'Radius.Core/terraformSettings@2025-08-01-preview' = {
	// name: 'private-registry'
	// properties: {
	// terraformrc: {
	// credentials: {
	// 'app.terraform.io': {
	// secret: registrySecret.id
	// }
	// }
	// }
	// }
	// }
	// “`
	// Two other settings are available: provider installation and environment variables.
	// ### Provider installation
	// In air-gapped or internal environments, use `terraformrc.providerInstallation` to install providers from a network mirror
	// instead of the public registry. Set the mirror `url`, optionally narrow it with `include` or `exclude` provider address
	// patterns, and use `direct` to control which providers are still downloaded directly:
	// “`bicep
	// resource providerMirror 'Radius.Core/terraformSettings@2025-08-01-preview' = {
	// name: 'internal-mirror'
	// properties: {
	// terraformrc: {
	// providerInstallation: {
	// networkMirror: {
	// url: 'https://terraform.corp.example.com/providers/'
	// include: ['*']
	// }
	// direct: {
	// exclude: ['*']
	// }
	// }
	// }
	// }
	// }
	// “`
	// ### Environment variables
	// Use `env` to inject environment variables into every Terraform Recipe run, for example to raise the Terraform log level
	// for troubleshooting or to tune CLI behavior:
	// “`bicep
	// resource terraformLogging 'Radius.Core/terraformSettings@2025-08-01-preview' = {
	// name: 'terraform-logging'
	// properties: {
	// env: {
	// TF_LOG: 'TRACE'
	// TF_REGISTRY_CLIENT_TIMEOUT: '15'
	// }
	// }
	// }
	// “`
	// ## Deploying Terraform settings
	// Deploy the settings resource with the `rad deploy` command:
	// “`bash
	// rad deploy ./terraform-settings.bicep
	// “`
	// ## Referencing Terraform settings from an Environment
	// Reference the settings from an Environment by setting its `terraformSettings` property to the resource ID. Every Terraform
	// Recipe run in that Environment then uses the configured registry credentials:
	// “`bicep
	// extension radius
	// resource terraformRegistry 'Radius.Core/terraformSettings@2025-08-01-preview' existing = {
	// name: 'private-registry'
	// }
	// resource myEnvironment 'Radius.Core/environments@2025-08-01-preview' = {
	// name: 'my-environment'
	// properties: {
	// terraformSettings: terraformRegistry.id
	// }
	// }
	// “`
	TerraformSettingsResource
}

type TerraformSettingsClientListByScopeOptions struct {
}

type TerraformSettingsClientListByScopeResponse struct {
	// The response of a TerraformSettingsResource list operation.
	TerraformSettingsResourceListResult
}

type TerraformSettingsClientUpdateOptions struct {
}

type TerraformSettingsClientUpdateResponse struct {
	// The `Radius.Core/terraformSettings` Resource Type holds reusable Terraform CLI settings that Environments apply when running
	// Terraform Recipes. Its primary use is authenticating to private Terraform registries that host the modules referenced by
	// a Recipe Pack, along with configuring provider installation and injecting environment variables during Recipe execution.
	// Platform engineers define a `Radius.Core/terraformSettings` resource once and reference it from any Environment whose Recipes
	// pull modules from a private registry.
	// ## Defining Terraform settings
	// Configure `terraformrc.credentials`, keyed by registry hostname, to authenticate to a private Terraform registry. Each
	// entry points to a secret whose `token` key holds the registry token:
	// “`bicep
	// extension radius
	// @description('The Radius Environment ID. Injected automatically by the rad CLI.')
	// param environment string
	// resource registrySecret 'Radius.Security/secrets@2025-08-01-preview' = {
	// name: 'terraform-registry-token'
	// properties: {
	// environment: environment
	// data: {
	// token: { value: 'my-registry-token' }
	// }
	// }
	// }
	// resource terraformRegistry 'Radius.Core/terraformSettings@2025-08-01-preview' = {
	// name: 'private-registry'
	// properties: {
	// terraformrc: {
	// credentials: {
	// 'app.terraform.io': {
	// secret: registrySecret.id
	// }
	// }
	// }
	// }
	// }
	// “`
	// Two other settings are available: provider installation and environment variables.
	// ### Provider installation
	// In air-gapped or internal environments, use `terraformrc.providerInstallation` to install providers from a network mirror
	// instead of the public registry. Set the mirror `url`, optionally narrow it with `include` or `exclude` provider address
	// patterns, and use `direct` to control which providers are still downloaded directly:
	// “`bicep
	// resource providerMirror 'Radius.Core/terraformSettings@2025-08-01-preview' = {
	// name: 'internal-mirror'
	// properties: {
	// terraformrc: {
	// providerInstallation: {
	// networkMirror: {
	// url: 'https://terraform.corp.example.com/providers/'
	// include: ['*']
	// }
	// direct: {
	// exclude: ['*']
	// }
	// }
	// }
	// }
	// }
	// “`
	// ### Environment variables
	// Use `env` to inject environment variables into every Terraform Recipe run, for example to raise the Terraform log level
	// for troubleshooting or to tune CLI behavior:
	// “`bicep
	// resource terraformLogging 'Radius.Core/terraformSettings@2025-08-01-preview' = {
	// name: 'terraform-logging'
	// properties: {
	// env: {
	// TF_LOG: 'TRACE'
	// TF_REGISTRY_CLIENT_TIMEOUT: '15'
	// }
	// }
	// }
	// “`
	// ## Deploying Terraform settings
	// Deploy the settings resource with the `rad deploy` command:
	// “`bash
	// rad deploy ./terraform-settings.bicep
	// “`
	// ## Referencing Terraform settings from an Environment
	// Reference the settings from an Environment by setting its `terraformSettings` property to the resource ID. Every Terraform
	// Recipe run in that Environment then uses the configured registry credentials:
	// “`bicep
	// extension radius
	// resource terraformRegistry 'Radius.Core/terraformSettings@2025-08-01-preview' existing = {
	// name: 'private-registry'
	// }
	// resource myEnvironment 'Radius.Core/environments@2025-08-01-preview' = {
	// name: 'my-environment'
	// properties: {
	// terraformSettings: terraformRegistry.id
	// }
	// }
	// “`
	TerraformSettingsResource
}

type TerraformSettingsProperties struct {
	// (Optional) Environment variables injected into the Terraform process during Recipe execution.
	Env map[string]*string

	// (Optional) Settings for the Terraform CLI configuration file. Radius renders these into a `.terraformrc` file used when
	// running Terraform Recipes.
	Terraformrc *TerraformrcConfig

	// READ-ONLY; (Read Only) The status of the Terraform settings resource within the Radius control plane.
	ProvisioningState *ProvisioningState

	// READ-ONLY; (Read Only) Resource IDs of the Environments that reference this Terraform settings resource.
	ReferencedBy []*string
}

type TerraformSettingsResource struct {
	// REQUIRED; The geo-location where the resource lives
	Location *string

	// REQUIRED; The resource-specific properties for this resource.
	Properties *TerraformSettingsProperties

	// Resource tags.
	Tags map[string]*string

	// READ-ONLY; Fully qualified resource ID for the resource. Ex - /subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/{resourceProviderNamespace}/{resourceType}/{resourceName}
	ID *string

	// READ-ONLY; The name of the resource
	Name *string

	// READ-ONLY; Azure Resource Manager metadata containing createdBy and modifiedBy information.
	SystemData *SystemData

	// READ-ONLY; The type of the resource. E.g. "Microsoft.Compute/virtualMachines" or "Microsoft.Storage/storageAccounts"
	Type *string
}

type TerraformSettingsResourceListResult struct {
	// REQUIRED; The TerraformSettingsResource items on this page
	Value []*TerraformSettingsResource

	// The link to the next page of items
	NextLink *string
}

type TerraformrcConfig struct {
	// (Optional) Credentials for authenticating to private Terraform registries such as `app.terraform.io`. Maps a registry hostname
	// to its credential configuration. This authenticates to Terraform CLI registries over HTTP and does not authenticate Git-based
	// module sources, which use a separate mechanism.
	Credentials map[string]*TerraformCredentialConfig

	// (Optional) Controls where Terraform installs providers from, such as a network mirror instead of the public registry.
	ProviderInstallation *TerraformProviderInstallation
}