project

type AIModelProps struct {
	Model AIModelPropsModel `yaml:"model,omitempty"`
}

type AIModelPropsModel struct {
	Name    string `yaml:"name,omitempty"`
	Version string `yaml:"version,omitempty"`
}

type AiFoundryModelProps struct {
	Models []AiServicesModel `yaml:"models,omitempty"`
}

type AiHelper interface {
	// RequiredExternalTools returns the required external tools for the AiHelper
	RequiredExternalTools(ctx context.Context) []tools.ExternalTool
	// Initialize initializes the AiHelper
	Initialize(ctx context.Context) error
	// ValidateWorkspace ensures that the workspace exists
	ValidateWorkspace(ctx context.Context, scope *ai.Scope) error
	// CreateEnvironmentVersion creates a new environment version
	CreateEnvironmentVersion(
		ctx context.Context,
		scope *ai.Scope,
		serviceConfig *ServiceConfig,
		config *ai.ComponentConfig,
	) (*armmachinelearning.EnvironmentVersion, error)
	// CreateModelVersion creates a new model version
	CreateModelVersion(
		ctx context.Context,
		scope *ai.Scope,
		serviceConfig *ServiceConfig,
		config *ai.ComponentConfig,
	) (*armmachinelearning.ModelVersion, error)
	// GetEndpoint retrieves an online endpoint
	GetEndpoint(ctx context.Context, scope *ai.Scope, endpointName string) (*armmachinelearning.OnlineEndpoint, error)
	// DeployToEndpoint deploys a new online deployment to an online endpoint
	DeployToEndpoint(
		ctx context.Context,
		scope *ai.Scope,
		serviceConfig *ServiceConfig,
		endpointName string,
		config *ai.EndpointDeploymentConfig,
	) (*armmachinelearning.OnlineDeployment, error)
	// DeleteDeployments deletes all deployments of an online endpoint except the ones in filter
	DeleteDeployments(ctx context.Context, scope *ai.Scope, endpointName string, filter []string) error
	// UpdateTraffic updates the traffic distribution of an online endpoint for the specified deployment
	UpdateTraffic(
		ctx context.Context,
		scope *ai.Scope,
		endpointName string,
		deploymentName string,
	) (*armmachinelearning.OnlineEndpoint, error)
	// CreateFlow creates a new flow
	CreateFlow(
		ctx context.Context,
		scope *ai.Scope,
		serviceConfig *ServiceConfig,
		config *ai.ComponentConfig,
	) (*ai.Flow, error)
}

type AiServicesModel struct {
	Name    string             `yaml:"name,omitempty"`
	Version string             `yaml:"version,omitempty"`
	Format  string             `yaml:"format,omitempty"`
	Sku     AiServicesModelSku `yaml:"sku,omitempty"`
}

type AiServicesModelSku struct {
	Name      string `yaml:"name,omitempty"`
	UsageName string `yaml:"usageName,omitempty"`
	Capacity  int32  `yaml:"capacity,omitempty"`
}

type AksDeploymentOptions struct {
	Name string `yaml:"name"`
}

type AksIngressOptions struct {
	Name         string `yaml:"name"`
	RelativePath string `yaml:"relativePath"`
}

type AksOptions struct {
	// The namespace used for deploying k8s resources. Defaults to the project name
	Namespace string `yaml:"namespace"`
	// The relative folder path from the service that contains the k8s deployment manifests. Defaults to 'manifests'
	DeploymentPath string `yaml:"deploymentPath"`
	// The services ingress configuration options
	Ingress AksIngressOptions `yaml:"ingress"`
	// The services deployment configuration options
	Deployment AksDeploymentOptions `yaml:"deployment"`
	// The services service configuration options
	Service AksServiceOptions `yaml:"service"`
	// The helm configuration options
	Helm *helm.Config `yaml:"helm"`
	// The kustomize configuration options
	Kustomize *kustomize.Config `yaml:"kustomize"`
}

type AksServiceOptions struct {
	Name string `yaml:"name"`
}

type AppServiceProps struct {
	Port           int               `yaml:"port,omitempty"`
	Env            []ServiceEnvVar   `yaml:"env,omitempty"`
	Runtime        AppServiceRuntime `yaml:"runtime,omitempty"`
	StartupCommand string            `yaml:"startupCommand,omitempty"`
}

type AppServiceRuntime struct {
	Stack   AppServiceRuntimeStack `yaml:"stack,omitempty"`
	Version string                 `yaml:"version,omitempty"`
}

type AppServiceRuntimeStack string

type Artifact struct {
	Kind         ArtifactKind      `json:"kind"`                   // Required: artifact type
	Location     string            `json:"location,omitempty"`     // Optional: location of the artifact
	LocationKind LocationKind      `json:"locationKind,omitempty"` // Optional: local, remote, or other
	Metadata     map[string]string `json:"metadata,omitempty"`     // Optional: arbitrary key/value pairs
}

type ArtifactCollection []*Artifact

type ArtifactKind string

type CompositeFrameworkService interface {
	FrameworkService
	SetSource(inner FrameworkService)
}

type ContainerAppProps struct {
	Port int             `yaml:"port,omitempty"`
	Env  []ServiceEnvVar `yaml:"env,omitempty"`
}

type ContainerFile struct {
	ServiceConfig *ServiceConfig
	Sources       []string
	Destination   string
}

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

type CosmosDBContainerProps struct {
	Name          string   `yaml:"name,omitempty"`
	PartitionKeys []string `yaml:"partitionKeys,omitempty"`
}

type CosmosDBProps struct {
	Containers []CosmosDBContainerProps `yaml:"containers,omitempty"`
}

type DockerProjectOptions struct {
	Path        string                    `yaml:"path,omitempty"        json:"path,omitempty"`
	Context     string                    `yaml:"context,omitempty"     json:"context,omitempty"`
	Platform    string                    `yaml:"platform,omitempty"    json:"platform,omitempty"`
	Target      string                    `yaml:"target,omitempty"      json:"target,omitempty"`
	Registry    osutil.ExpandableString   `yaml:"registry,omitempty"    json:"registry,omitempty"`
	Image       osutil.ExpandableString   `yaml:"image,omitempty"       json:"image,omitempty"`
	Tag         osutil.ExpandableString   `yaml:"tag,omitempty"         json:"tag,omitempty"`
	RemoteBuild bool                      `yaml:"remoteBuild,omitempty" json:"remoteBuild,omitempty"`
	BuildArgs   []osutil.ExpandableString `yaml:"buildArgs,omitempty"   json:"buildArgs,omitempty"`
	// not supported from azure.yaml directly yet. Adding it for Aspire to use it, initially.
	// Aspire would pass the secret keys, which are env vars that azd will set just to run docker build.
	BuildSecrets []string `yaml:"-"                     json:"-"`
	BuildEnv     []string `yaml:"-"                     json:"-"`
	//InMemDockerfile allow projects to specify a dockerfile contents directly instead of a path on disk.
	// This is not supported from azure.yaml.
	// This is used by projects like Aspire that can generate a dockerfile on the fly and don't want to write it to disk.
	// When this is set, whatever value in Path is ignored and the dockerfile contents in this property is used instead.
	InMemDockerfile []byte `yaml:"-"                     json:"-"`
}

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

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

type DotNetContainerAppOptions struct {
	Manifest    *apphost.Manifest
	AppHostPath string
	ProjectName string
	// ContainerImage is non-empty when a prebuilt container image is being used.
	ContainerImage string
	// ContainerFiles is a list of files to include in the container image.
	ContainerFiles map[string]ContainerFile
}

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

type EmitEnv struct {
	// The function map to use for evaluating expressions.
	FuncMap scaffold.FuncMap

	// ResourceVarName is the name of Bicep symbol to assign property expressions.
	ResourceVarName string
}

type EventHubsProps struct {
	Hubs []string `yaml:"hubs,omitempty"`
}

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

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

type FindOpts func(*findFilter)

type FrameworkPackageRequirements struct {
	RequireRestore bool
	RequireBuild   bool
}

type FrameworkRequirements struct {
	Package FrameworkPackageRequirements
}

type FrameworkService interface {
	// Gets a list of the required external tools for the framework service
	RequiredExternalTools(ctx context.Context, serviceConfig *ServiceConfig) []tools.ExternalTool

	// Initializes the framework service for the specified service configuration
	// This is useful if the framework needs to subscribe to any service events
	Initialize(ctx context.Context, serviceConfig *ServiceConfig) error

	// Gets the requirements for the language or framework service.
	// This enables more fine grain control on whether the language / framework
	// supports or requires lifecycle commands such as restore, build, and package
	Requirements() FrameworkRequirements

	// Restores dependencies for the framework service
	Restore(
		ctx context.Context,
		serviceConfig *ServiceConfig,
		serviceContext *ServiceContext,
		progress *async.Progress[ServiceProgress],
	) (*ServiceRestoreResult, error)

	// Builds the source for the framework service
	Build(
		ctx context.Context,
		serviceConfig *ServiceConfig,
		serviceContext *ServiceContext,
		progress *async.Progress[ServiceProgress],
	) (*ServiceBuildResult, error)

	// Packages the source suitable for deployment
	// This may optionally perform a rebuild internally depending on the language/framework requirements
	Package(
		ctx context.Context,
		serviceConfig *ServiceConfig,
		serviceContext *ServiceContext,
		progress *async.Progress[ServiceProgress],
	) (*ServicePackageResult, error)
}

type HooksConfig map[string][]*ext.HookConfig

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

type Infra struct {
	Options provisioning.Options

	IsCompose bool
	// contains filtered or unexported fields
}

type LocationKind string

type PackageOptions struct {
	OutputPath string
}

type PipelineOptions struct {
	Provider  string   `yaml:"provider"`
	Variables []string `yaml:"variables"`
	Secrets   []string `yaml:"secrets"`
}

type ProjectConfig struct {
	// Metadata that specifies the schema version.
	//
	// This is currently only used during [Save] to write the file schema annotation for intellisense.
	// This should include the "v" prefix used in official version numbers.
	MetaSchemaVersion string `yaml:"-"`

	RequiredVersions  *RequiredVersions          `yaml:"requiredVersions,omitempty"`
	Name              string                     `yaml:"name"`
	ResourceGroupName osutil.ExpandableString    `yaml:"resourceGroup,omitempty"`
	Path              string                     `yaml:"-"`
	Metadata          *ProjectMetadata           `yaml:"metadata,omitempty"`
	Services          map[string]*ServiceConfig  `yaml:"services,omitempty"`
	Infra             provisioning.Options       `yaml:"infra,omitempty"`
	Pipeline          PipelineOptions            `yaml:"pipeline,omitempty"`
	Hooks             HooksConfig                `yaml:"hooks,omitempty"`
	State             *state.Config              `yaml:"state,omitempty"`
	Platform          *platform.Config           `yaml:"platform,omitempty"`
	Workflows         workflow.WorkflowMap       `yaml:"workflows,omitempty"`
	Cloud             *cloud.Config              `yaml:"cloud,omitempty"`
	Resources         map[string]*ResourceConfig `yaml:"resources,omitempty"`

	// AdditionalProperties captures any unknown YAML fields for extension support
	AdditionalProperties map[string]interface{} `yaml:",inline"`

	*ext.EventDispatcher[ProjectLifecycleEventArgs] `yaml:"-"`
}

type ProjectLifecycleEventArgs struct {
	Project *ProjectConfig
	Args    map[string]any
}

type ProjectLifecycleEventHandlerFn func(ctx context.Context, args ProjectLifecycleEventArgs) error

type ProjectManager interface {
	// Initializes the project and all child services defined within the project configuration
	//
	// The initialization process will instantiate the framework & service target associated
	// with the service config that enables the scenario for these components to add event
	// handlers to participate in the lifecycle of an azd project
	Initialize(ctx context.Context, projectConfig *ProjectConfig) error

	// Returns the default service name to target based on the current working directory.
	//
	//   - If the working directory is the project directory, then an empty string is returned to indicate all services.
	//   - If the working directory is a service directory, then the name of the service is returned.
	//   - If the working directory is neither the project directory nor a service directory, then
	//     ErrNoDefaultService is returned.
	DefaultServiceFromWd(ctx context.Context, projectConfig *ProjectConfig) (serviceConfig *ServiceConfig, err error)

	// Ensures that all required tools are installed for the project and all child services
	// This includes tools required by the framework and tools required by the service target
	EnsureAllTools(ctx context.Context, projectConfig *ProjectConfig, serviceFilterFn ServiceFilterPredicate) error

	// Ensures that all required framework tools are installed for the project and all child services
	EnsureFrameworkTools(ctx context.Context, projectConfig *ProjectConfig, serviceFilterFn ServiceFilterPredicate) error

	// Ensures that all required service target tools are installed for the project and all child services
	EnsureServiceTargetTools(ctx context.Context, projectConfig *ProjectConfig, serviceFilterFn ServiceFilterPredicate) error

	// Ensures that all required tools for restore are installed for the project and all child services. This is like
	// EnsureFrameworkTools but treats docker projects differently - it requires the tools for the inner project (i.e. npm)
	// instead of needing docker tools themselves, since when doing a project restore, docker is not invoked.
	EnsureRestoreTools(ctx context.Context, projectConfig *ProjectConfig, serviceFilterFn ServiceFilterPredicate) error
}

type ProjectMetadata struct {
	// Template is a slug that identifies the template and a version. This attribute should be
	// in every template that we ship.
	// ex: todo-python-mongo@version
	Template string
}

type PublishOptions struct {
	// Image specifies the target image in the form '[registry/]repository[:tag]'
	Image string
}

type RequiredVersions struct {
	// When non nil, a semver range (in the format expected by semver.ParseRange).
	Azd        *string            `yaml:"azd,omitempty"`
	Extensions map[string]*string `yaml:"extensions,omitempty"`
}

type ResourceConfig struct {
	// Reference to the parent project configuration
	Project *ProjectConfig `yaml:"-"`
	// Type of resource
	Type ResourceType `yaml:"type"`
	// The name of the resource
	Name string `yaml:"name,omitempty"`
	// The properties for the resource
	RawProps map[string]yaml.Node `yaml:",inline"`
	Props    interface{}          `yaml:"-"`
	// Relationships to other resources
	Uses []string `yaml:"uses,omitempty"`
	// Existing indicates whether the resource is an existing resource.
	Existing bool `yaml:"existing,omitempty"`
	// Resource ID in the project.
	// This is a virtual field. It is stored as environment state.
	ResourceId string `yaml:"-"`

	// IncludeName indicates whether the `name` field should be included upon serialization.
	IncludeName bool `yaml:"-"`
}

type ResourceManager interface {
	GetResourceGroupName(
		ctx context.Context,
		subscriptionId string,
		resourceGroupTemplate osutil.ExpandableString,
	) (string, error)
	GetServiceResources(
		ctx context.Context,
		subscriptionId string,
		resourceGroupName string,
		serviceConfig *ServiceConfig,
	) ([]*azapi.ResourceExtended, error)
	GetServiceResource(
		ctx context.Context,
		subscriptionId string,
		resourceGroupName string,
		serviceConfig *ServiceConfig,
		rerunCommand string,
	) (*azapi.ResourceExtended, error)
	GetTargetResource(
		ctx context.Context,
		subscriptionId string,
		serviceConfig *ServiceConfig,
	) (*environment.TargetResource, error)
}

type ResourceType string

type ServiceBuildResult struct {
	Artifacts ArtifactCollection `json:"artifacts"`
}

type ServiceBusProps struct {
	Queues []string `yaml:"queues,omitempty"`
	Topics []string `yaml:"topics,omitempty"`
}

type ServiceConfig struct {
	// Reference to the parent project configuration
	Project *ProjectConfig `yaml:"-"`
	// The friendly name/key of the project from the azure.yaml file
	Name string `yaml:"-"`
	// The azure resource group to deploy the service to
	ResourceGroupName osutil.ExpandableString `yaml:"resourceGroup,omitempty"`
	// The name used to override the default azure resource name
	ResourceName osutil.ExpandableString `yaml:"resourceName,omitempty"`
	// The ARM api version to use for the service. If not specified, the latest version is used.
	ApiVersion string `yaml:"apiVersion,omitempty"`
	// The relative path to the project folder from the project root
	RelativePath string `yaml:"project"`
	// The azure hosting model to use, ex) appservice, function, containerapp
	Host ServiceTargetKind `yaml:"host"`
	// The programming language of the project
	Language ServiceLanguageKind `yaml:"language"`
	// The output path for build artifacts
	OutputPath string `yaml:"dist,omitempty"`
	// The source image to use for container based applications
	Image osutil.ExpandableString `yaml:"image,omitempty"`
	// The optional docker options for configuring the output image
	Docker DockerProjectOptions `yaml:"docker,omitempty"`
	// The optional K8S / AKS options
	K8s AksOptions `yaml:"k8s,omitempty"`
	// Infrastructure module path relative to the root infra folder
	Module string `yaml:"module,omitempty"`
	// The infrastructure provisioning configuration
	Infra provisioning.Options `yaml:"infra,omitempty"`
	// Hook configuration for service
	Hooks HooksConfig `yaml:"hooks,omitempty"`
	// Dependencies on other services and resources
	Uses []string `yaml:"uses,omitempty"`
	// Options specific to the DotNetContainerApp target. These are set by the importer and
	// can not be controlled via the project file today.
	DotNetContainerApp *DotNetContainerAppOptions `yaml:"-,omitempty"`
	// Custom configuration for the service target
	Config map[string]any `yaml:"config,omitempty"`

	// Environment variables to set for the service
	Environment osutil.ExpandableMap `yaml:"env,omitempty"`

	// AdditionalProperties captures any unknown YAML fields for extension support
	AdditionalProperties map[string]interface{} `yaml:",inline"`

	*ext.EventDispatcher[ServiceLifecycleEventArgs] `yaml:"-"`

	// Turns service into a service that is only to be built but not deployed.
	// This is currently used by Aspire.
	BuildOnly bool `yaml:"-"`
	// contains filtered or unexported fields
}

type ServiceContext struct {
	Restore ArtifactCollection `json:"restore"`
	Build   ArtifactCollection `json:"build"`
	Package ArtifactCollection `json:"package"`
	Publish ArtifactCollection `json:"publish"`
	Deploy  ArtifactCollection `json:"deploy"`
}

type ServiceDeployResult struct {
	Artifacts ArtifactCollection `json:"artifacts"`
}

type ServiceEnvVar struct {
	Name string `yaml:"name,omitempty"`

	// either Value or Secret can be set, but not both
	Value  string `yaml:"value,omitempty"`
	Secret string `yaml:"secret,omitempty"`
}

type ServiceFilterPredicate func(svc *ServiceConfig) bool

type ServiceLanguageKind string

type ServiceLifecycleEventArgs struct {
	Project        *ProjectConfig
	Service        *ServiceConfig
	ServiceContext *ServiceContext
	Args           map[string]any
}

type ServiceManager interface {
	// Gets all of the required framework/service target tools for the specified service config
	GetRequiredTools(ctx context.Context, serviceConfig *ServiceConfig) ([]tools.ExternalTool, error)

	// Initializes the service configuration and dependent framework & service target
	// This allows frameworks & service targets to hook into a services lifecycle events
	Initialize(ctx context.Context, serviceConfig *ServiceConfig) error

	// Restores the code dependencies for the specified service config
	Restore(
		ctx context.Context,
		serviceConfig *ServiceConfig,
		serviceContext *ServiceContext,
		progress *async.Progress[ServiceProgress],
	) (*ServiceRestoreResult, error)

	// Builds the code for the specified service config
	// Will call the language compile for compiled languages or
	// may copy build artifacts to a configured output folder
	Build(
		ctx context.Context,
		serviceConfig *ServiceConfig,
		serviceContext *ServiceContext,
		progress *async.Progress[ServiceProgress],
	) (*ServiceBuildResult, error)

	// Packages the code for the specified service config
	// Depending on the service configuration this will generate an artifact
	// that can be consumed by the hosting Azure service.
	// Common examples could be a zip archive for app service or
	// Docker images for container apps and AKS
	Package(
		ctx context.Context,
		serviceConfig *ServiceConfig,
		serviceContext *ServiceContext,
		progress *async.Progress[ServiceProgress],
		options *PackageOptions,
	) (*ServicePackageResult, error)

	// Publishes the service to make it available to other services
	// A common example would be pushing container images to a container registry.
	Publish(
		ctx context.Context,
		serviceConfig *ServiceConfig,
		serviceContext *ServiceContext,
		progress *async.Progress[ServiceProgress],
		publishOptions *PublishOptions,
	) (*ServicePublishResult, error)

	// Deploys the generated artifacts to the Azure resource that will
	// host the service application
	// Common examples would be uploading zip archive using ZipDeploy deployment or
	// pushing container images to a container registry and creating a revision.
	Deploy(
		ctx context.Context,
		serviceConfig *ServiceConfig,
		serviceContext *ServiceContext,
		progress *async.Progress[ServiceProgress],
	) (*ServiceDeployResult, error)

	/// GetTargetResource finds and resolves the target Azure resource for the specified service configuration and host
	GetTargetResource(
		ctx context.Context,
		serviceConfig *ServiceConfig,
		serviceTarget ServiceTarget,
	) (*environment.TargetResource, error)

	// Gets the framework service for the specified service config
	// The framework service performs the restoration and building of the service app code
	GetFrameworkService(ctx context.Context, serviceConfig *ServiceConfig) (FrameworkService, error)

	// Gets the service target service for the specified service config
	// The service target is responsible for packaging & deploying the service app code
	// to the destination Azure resource
	GetServiceTarget(ctx context.Context, serviceConfig *ServiceConfig) (ServiceTarget, error)
}

type ServiceOperationCache map[string]any

type ServicePackageResult struct {
	Artifacts ArtifactCollection `json:"artifacts"`
}

type ServiceProgress struct {
	Message   string
	Timestamp time.Time
}

type ServicePublishResult struct {
	Artifacts ArtifactCollection `json:"artifacts"`
}

type ServiceRestoreResult struct {
	Artifacts ArtifactCollection `json:"artifacts"`
}

type ServiceTarget interface {
	// Initializes the service target for the specified service configuration.
	// This allows service targets to opt-in to service lifecycle events
	Initialize(ctx context.Context, serviceConfig *ServiceConfig) error

	// RequiredExternalTools are the tools needed to run the deploy operation for this
	// target.
	RequiredExternalTools(ctx context.Context, serviceConfig *ServiceConfig) []tools.ExternalTool

	// Package prepares artifacts for deployment
	Package(
		ctx context.Context,
		serviceConfig *ServiceConfig,
		serviceContext *ServiceContext,
		progress *async.Progress[ServiceProgress],
	) (*ServicePackageResult, error)

	// Publish pushes the prepared artifacts without performing deployment.
	Publish(
		ctx context.Context,
		serviceConfig *ServiceConfig,
		serviceContext *ServiceContext,
		targetResource *environment.TargetResource,
		progress *async.Progress[ServiceProgress],
		publishOptions *PublishOptions,
	) (*ServicePublishResult, error)

	// Deploys the given deployment artifact to the target resource
	Deploy(
		ctx context.Context,
		serviceConfig *ServiceConfig,
		serviceContext *ServiceContext,
		targetResource *environment.TargetResource,
		progress *async.Progress[ServiceProgress],
	) (*ServiceDeployResult, error)

	// Endpoints gets the endpoints a service exposes.
	Endpoints(
		ctx context.Context,
		serviceConfig *ServiceConfig,
		targetResource *environment.TargetResource,
	) ([]string, error)
}

type ServiceTargetKind string

type StorageProps struct {
	Containers []string `yaml:"containers,omitempty"`
}

type TargetResourceResolver interface {
	ResolveTargetResource(
		ctx context.Context,
		subscriptionId string,
		serviceConfig *ServiceConfig,
		defaultResolver func() (*environment.TargetResource, error),
	) (*environment.TargetResource, error)
}

type UnsupportedServiceHostError struct {
	Host         string
	ServiceName  string
	ErrorMessage string
}