@azure/arm-cognitiveservices 9.0.0-beta.1 → 9.0.0-beta.3

package/dist/commonjs/models/models.d.ts

@@ -1208,6 +1208,101 @@ export declare enum KnownModelLifecycleStatus {
  * **Legacy**: Model is a legacy version that is no longer recommended for use. Customers should migrate to newer models. Check replacementConfig for upgrade information.
  */
 export type ModelLifecycleStatus = string;
+/** Request body for the evaluateDeploymentPolicies action. */
+export interface EvaluateDeploymentPoliciesRequest {
+    /** The list of hypothetical deployments to evaluate against Azure Policy. */
+    deployments: EvaluateDeploymentPoliciesDeployment[];
+}
+export declare function evaluateDeploymentPoliciesRequestSerializer(item: EvaluateDeploymentPoliciesRequest): any;
+export declare function evaluateDeploymentPoliciesDeploymentArraySerializer(result: Array<EvaluateDeploymentPoliciesDeployment>): any[];
+/** A hypothetical deployment definition used for policy dry-run evaluation. */
+export interface EvaluateDeploymentPoliciesDeployment {
+    /** The name of the hypothetical deployment. */
+    name: string;
+    /** Properties of the hypothetical deployment. */
+    properties: EvaluateDeploymentPoliciesDeploymentProperties;
+}
+export declare function evaluateDeploymentPoliciesDeploymentSerializer(item: EvaluateDeploymentPoliciesDeployment): any;
+/** Properties of a hypothetical deployment for policy evaluation. */
+export interface EvaluateDeploymentPoliciesDeploymentProperties {
+    /** The model to evaluate. */
+    model: DeploymentModel;
+    /** The name of the RAI policy to evaluate. */
+    raiPolicyName?: string;
+}
+export declare function evaluateDeploymentPoliciesDeploymentPropertiesSerializer(item: EvaluateDeploymentPoliciesDeploymentProperties): any;
+/** Response body for the evaluateDeploymentPolicies action. */
+export interface EvaluateDeploymentPoliciesResponse {
+    /** Per-deployment policy evaluation results, keyed by deployment name. */
+    results?: Record<string, DeploymentPolicyEvaluationResult>;
+}
+export declare function evaluateDeploymentPoliciesResponseDeserializer(item: any): EvaluateDeploymentPoliciesResponse;
+export declare function deploymentPolicyEvaluationResultRecordDeserializer(item: Record<string, any>): Record<string, DeploymentPolicyEvaluationResult>;
+/** Policy evaluation result for a single deployment. */
+export interface DeploymentPolicyEvaluationResult {
+    /** The evaluation outcome. */
+    evaluationOutcome?: PolicyEvaluationOutcome;
+    /** Error message if the evaluation outcome is Error. */
+    errorMessage?: string;
+    /** Details of non-compliant policy assignments. */
+    nonCompliantAssignments?: PolicyAssignmentEvaluationDetails[];
+}
+export declare function deploymentPolicyEvaluationResultDeserializer(item: any): DeploymentPolicyEvaluationResult;
+/** The outcome of a policy evaluation. */
+export declare enum KnownPolicyEvaluationOutcome {
+    /** The deployment is compliant with all policies. */
+    Compliant = "Compliant",
+    /** The deployment violates one or more policies. */
+    NonCompliant = "NonCompliant",
+    /** An error occurred during evaluation. */
+    Error = "Error"
+}
+/**
+ * The outcome of a policy evaluation. \
+ * {@link KnownPolicyEvaluationOutcome} can be used interchangeably with PolicyEvaluationOutcome,
+ *  this enum contains the known values that the service supports.
+ * ### Known values supported by the service
+ * **Compliant**: The deployment is compliant with all policies. \
+ * **NonCompliant**: The deployment violates one or more policies. \
+ * **Error**: An error occurred during evaluation.
+ */
+export type PolicyEvaluationOutcome = string;
+export declare function policyAssignmentEvaluationDetailsArrayDeserializer(result: Array<PolicyAssignmentEvaluationDetails>): any[];
+/** Details of a non-compliant policy assignment. */
+export interface PolicyAssignmentEvaluationDetails {
+    /** The policy assignment ID. */
+    assignmentId?: string;
+    /** The policy definition ID. */
+    policyDefinitionId?: string;
+    /** The policy set definition ID. */
+    policySetDefinitionId?: string;
+    /** The evaluation outcome for this assignment. */
+    evaluationOutcome?: PolicyEvaluationOutcome;
+    /** The reason for non-compliance. */
+    nonComplianceReason?: string;
+    /** The policy effect (e.g., Deny, Audit). */
+    effect?: string;
+    /** Expression-level evaluation details. */
+    expressionEvaluations?: PolicyExpressionEvaluationDetails[];
+}
+export declare function policyAssignmentEvaluationDetailsDeserializer(item: any): PolicyAssignmentEvaluationDetails;
+export declare function policyExpressionEvaluationDetailsArrayDeserializer(result: Array<PolicyExpressionEvaluationDetails>): any[];
+/** Details of a policy expression evaluation. */
+export interface PolicyExpressionEvaluationDetails {
+    /** The policy expression. */
+    expression?: string;
+    /** The kind of expression. */
+    expressionKind?: string;
+    /** The operator used in evaluation. */
+    operator?: string;
+    /** The evaluation result. */
+    result?: string;
+    /** The target value of the expression. */
+    targetValue?: string;
+    /** The actual value of the expression. */
+    expressionValue?: string;
+}
+export declare function policyExpressionEvaluationDetailsDeserializer(item: any): PolicyExpressionEvaluationDetails;
 /** A list of private endpoint connections */
 export interface PrivateEndpointConnectionListResult {
     /** Array of private endpoint connections */
@@ -1233,6 +1328,8 @@ export interface DeploymentProperties {
     readonly provisioningState?: DeploymentProvisioningState;
     /** Properties of Cognitive Services account deployment model. */
     model?: DeploymentModel;
+    /** Speculative decoding settings for the deployment. This configuration applies to Fireworks model formats. */
+    speculativeDecoding?: DeploymentSpeculativeDecoding;
     /** Properties of Cognitive Services account deployment model. (Deprecated, please use Deployment.sku instead.) */
     scaleSettings?: DeploymentScaleSettings;
     /** The capabilities. */
@@ -1297,6 +1394,15 @@ export declare enum KnownDeploymentProvisioningState {
  * **Canceled**
  */
 export type DeploymentProvisioningState = string;
+/** Speculative decoding settings for a deployment. */
+export interface DeploymentSpeculativeDecoding {
+    /** Draft model used to generate speculative decoding tokens. */
+    draftModel: DeploymentModel;
+    /** The number of draft tokens attempted per speculation step. */
+    draftTokenCount?: number;
+}
+export declare function deploymentSpeculativeDecodingSerializer(item: DeploymentSpeculativeDecoding): any;
+export declare function deploymentSpeculativeDecodingDeserializer(item: any): DeploymentSpeculativeDecoding;
 /** Properties of Cognitive Services account deployment model. (Deprecated, please use Deployment.sku instead.) */
 export interface DeploymentScaleSettings {
     /** Deployment scale type. */
@@ -1711,6 +1817,11 @@ export interface RaiPolicyProperties {
     customBlocklists?: CustomBlocklistConfig[];
     /** The list of Safety Providers. */
     safetyProviders?: SafetyProviderConfig[];
+    /**
+     * Egress (outbound network) policy controlling which external endpoints sandboxed
+     * agents can reach. Includes rules with Allow/Deny/Transform/Rewrite actions.
+     */
+    egressPolicy?: RaiEgressPolicyConfig;
 }
 export declare function raiPolicyPropertiesSerializer(item: RaiPolicyProperties): any;
 export declare function raiPolicyPropertiesDeserializer(item: any): RaiPolicyProperties;
@@ -1861,6 +1972,277 @@ export interface SafetyProviderConfig extends RaiSafetyProviderConfig {
 }
 export declare function safetyProviderConfigSerializer(item: SafetyProviderConfig): any;
 export declare function safetyProviderConfigDeserializer(item: any): SafetyProviderConfig;
+/**
+ * Egress (outbound network) policy configuration nested within an RAI policy.
+ * Controls which external endpoints sandboxed agents can reach and what
+ * transformations (header injection, URL rewrite) are applied to matching traffic.
+ */
+export interface RaiEgressPolicyConfig {
+    /**
+     * The enforcement mode for egress rules.
+     * If omitted on create, the server defaults to Enforced. On subsequent GET
+     * requests, the server always returns the effective mode.
+     */
+    mode?: RaiEgressMode;
+    /**
+     * The default action when no user-defined rules match.
+     * Deny blocks unmatched traffic; Allow permits it. Transform and Rewrite rules
+     * are always applied to their matched traffic regardless of this setting —
+     * defaultAction only governs traffic that does not match any rule.
+     * If omitted on create, the server defaults to Deny (fail-closed). On subsequent
+     * GET requests, the server always returns the effective value.
+     */
+    defaultAction?: RaiEgressDefaultAction;
+    /** Description of the egress policy. */
+    description?: string;
+    /**
+     * Ordered list of egress rules. First matching rule wins.
+     * Rules are evaluated in declaration order; the first rule whose match criteria
+     * are satisfied determines the action taken on the request.
+     */
+    rules?: RaiEgressRule[];
+}
+export declare function raiEgressPolicyConfigSerializer(item: RaiEgressPolicyConfig): any;
+export declare function raiEgressPolicyConfigDeserializer(item: any): RaiEgressPolicyConfig;
+/**
+ * The enforcement mode for egress rules.
+ * If omitted on create, the server defaults to Enforced.
+ */
+export declare enum KnownRaiEgressMode {
+    /** Rules are enforced. Matching traffic is allowed or denied per rule actions. */
+    Enforced = "Enforced",
+    /**
+     * Rules are evaluated and logged but not enforced. Traffic is always forwarded regardless of
+     * rule action. A would-be Deny is logged but not applied. Transform and Rewrite actions are
+     * still applied to matching traffic (only Deny enforcement is suppressed).
+     */
+    Audit = "Audit"
+}
+/**
+ * The enforcement mode for egress rules.
+ * If omitted on create, the server defaults to Enforced. \
+ * {@link KnownRaiEgressMode} can be used interchangeably with RaiEgressMode,
+ *  this enum contains the known values that the service supports.
+ * ### Known values supported by the service
+ * **Enforced**: Rules are enforced. Matching traffic is allowed or denied per rule actions. \
+ * **Audit**: Rules are evaluated and logged but not enforced. Traffic is always forwarded regardless of
+ * rule action. A would-be Deny is logged but not applied. Transform and Rewrite actions are
+ * still applied to matching traffic (only Deny enforcement is suppressed).
+ */
+export type RaiEgressMode = string;
+/** The default action when no user-defined egress rules match. */
+export declare enum KnownRaiEgressDefaultAction {
+    /** Allow traffic by default when no rules match. */
+    Allow = "Allow",
+    /** Deny traffic by default when no rules match. */
+    Deny = "Deny"
+}
+/**
+ * The default action when no user-defined egress rules match. \
+ * {@link KnownRaiEgressDefaultAction} can be used interchangeably with RaiEgressDefaultAction,
+ *  this enum contains the known values that the service supports.
+ * ### Known values supported by the service
+ * **Allow**: Allow traffic by default when no rules match. \
+ * **Deny**: Deny traffic by default when no rules match.
+ */
+export type RaiEgressDefaultAction = string;
+export declare function raiEgressRuleArraySerializer(result: Array<RaiEgressRule>): any[];
+export declare function raiEgressRuleArrayDeserializer(result: Array<RaiEgressRule>): any[];
+/** A single egress rule. Rules are evaluated in order; first match wins. */
+export interface RaiEgressRule {
+    /** Name of the rule. Must be unique within the policy. */
+    name: string;
+    /** Description of the rule. */
+    description?: string;
+    /** The type of rule (e.g., Fqdn). Determines how match criteria are interpreted. */
+    ruleType: RaiEgressRuleType;
+    /** The match criteria for this rule. */
+    match?: RaiEgressRuleMatch;
+    /**
+     * The action to take when this rule matches, including the action type and any
+     * type-specific configuration (headers for Transform, rewrite target for Rewrite).
+     */
+    action: RaiEgressRuleAction;
+}
+export declare function raiEgressRuleSerializer(item: RaiEgressRule): any;
+export declare function raiEgressRuleDeserializer(item: any): RaiEgressRule;
+/** The type of an egress rule, determining what kind of traffic matching it performs. */
+export declare enum KnownRaiEgressRuleType {
+    /** Fully qualified domain name (FQDN) based rule matching on host and path patterns. */
+    Fqdn = "Fqdn"
+}
+/**
+ * The type of an egress rule, determining what kind of traffic matching it performs. \
+ * {@link KnownRaiEgressRuleType} can be used interchangeably with RaiEgressRuleType,
+ *  this enum contains the known values that the service supports.
+ * ### Known values supported by the service
+ * **Fqdn**: Fully qualified domain name (FQDN) based rule matching on host and path patterns.
+ */
+export type RaiEgressRuleType = string;
+/**
+ * The match criteria for an egress rule.
+ * If both host and path are omitted, the rule matches all traffic.
+ * Host uses DNS wildcard syntax (e.g., "*.openai.com" matches "api.openai.com").
+ * Path uses URI prefix matching with '*' as a single-segment wildcard (e.g., "/v1/*" matches "/v1/chat").
+ */
+export interface RaiEgressRuleMatch {
+    /**
+     * Host pattern to match using DNS wildcard syntax (e.g., "*.openai.com").
+     * A leading "*." matches any subdomain. Omit to match all hosts.
+     */
+    host?: string;
+    /**
+     * Path pattern to match using URI prefix with '*' wildcard (e.g., "/v1/*").
+     * Omit to match all paths.
+     */
+    path?: string;
+}
+export declare function raiEgressRuleMatchSerializer(item: RaiEgressRuleMatch): any;
+export declare function raiEgressRuleMatchDeserializer(item: any): RaiEgressRuleMatch;
+/**
+ * The action an egress rule takes when it matches.
+ * - Allow/Deny: no additional fields needed; headers and rewrite must not be set.
+ * - Transform: headers is required with at least one entry; rewrite must not be set.
+ * - Rewrite: rewrite is required with at least one of scheme/host/path;
+ * headers is optional for injecting headers alongside the redirect.
+ */
+export interface RaiEgressRuleAction {
+    /** The kind of action. */
+    actionType: RaiEgressRuleActionType;
+    /**
+     * Header transforms to apply. Required for Transform; optional for Rewrite;
+     * not allowed for Allow or Deny.
+     */
+    headers?: RaiEgressHeaderTransform[];
+    /** Destination override. Required for Rewrite; not allowed otherwise. */
+    rewrite?: RaiEgressRewriteTarget;
+}
+export declare function raiEgressRuleActionSerializer(item: RaiEgressRuleAction): any;
+export declare function raiEgressRuleActionDeserializer(item: any): RaiEgressRuleAction;
+/** The kind of action an egress rule takes when it matches. */
+export declare enum KnownRaiEgressRuleActionType {
+    /** Allow the matched traffic. */
+    Allow = "Allow",
+    /** Deny the matched traffic. */
+    Deny = "Deny",
+    /** Forward the matched traffic after applying header transforms. Requires at least one header. */
+    Transform = "Transform",
+    /** Redirect the matched traffic to a new destination, optionally applying header transforms. Requires a rewrite target. */
+    Rewrite = "Rewrite"
+}
+/**
+ * The kind of action an egress rule takes when it matches. \
+ * {@link KnownRaiEgressRuleActionType} can be used interchangeably with RaiEgressRuleActionType,
+ *  this enum contains the known values that the service supports.
+ * ### Known values supported by the service
+ * **Allow**: Allow the matched traffic. \
+ * **Deny**: Deny the matched traffic. \
+ * **Transform**: Forward the matched traffic after applying header transforms. Requires at least one header. \
+ * **Rewrite**: Redirect the matched traffic to a new destination, optionally applying header transforms. Requires a rewrite target.
+ */
+export type RaiEgressRuleActionType = string;
+export declare function raiEgressHeaderTransformArraySerializer(result: Array<RaiEgressHeaderTransform>): any[];
+export declare function raiEgressHeaderTransformArrayDeserializer(result: Array<RaiEgressHeaderTransform>): any[];
+/**
+ * A header transformation applied to matched traffic.
+ * For Set or Insert operations, exactly one of value or valueRef must be provided.
+ * For Remove operations, neither value nor valueRef should be set.
+ */
+export interface RaiEgressHeaderTransform {
+    /** The operation to perform on this header. */
+    operation: RaiEgressHeaderOperation;
+    /** The HTTP header name (e.g., "Authorization", "X-Custom-Auth"). */
+    name: string;
+    /**
+     * A static header value. Write-only: accepted on create/update, never returned on read.
+     * If omitted on update, the existing value is preserved. Use this for non-sensitive values;
+     * for credentials, use valueRef instead.
+     */
+    value?: string;
+    /** A dynamic header value resolved at request time from a secret or managed identity. */
+    valueRef?: RaiEgressHeaderValueRef;
+}
+export declare function raiEgressHeaderTransformSerializer(item: RaiEgressHeaderTransform): any;
+export declare function raiEgressHeaderTransformDeserializer(item: any): RaiEgressHeaderTransform;
+/** The operation to apply to a header in a Transform or Rewrite action. */
+export declare enum KnownRaiEgressHeaderOperation {
+    /** Set or overwrite the header value, creating it if it does not exist. */
+    Set = "Set",
+    /** Add the header only if it is not already present. */
+    Insert = "Insert",
+    /** Remove the header if present. */
+    Remove = "Remove"
+}
+/**
+ * The operation to apply to a header in a Transform or Rewrite action. \
+ * {@link KnownRaiEgressHeaderOperation} can be used interchangeably with RaiEgressHeaderOperation,
+ *  this enum contains the known values that the service supports.
+ * ### Known values supported by the service
+ * **Set**: Set or overwrite the header value, creating it if it does not exist. \
+ * **Insert**: Add the header only if it is not already present. \
+ * **Remove**: Remove the header if present.
+ */
+export type RaiEgressHeaderOperation = string;
+/** A dynamic source for a header value. Exactly one of secretRef or managedIdentityRef must be set. */
+export interface RaiEgressHeaderValueRef {
+    /** Resolve the value from a stored secret. */
+    secretRef?: RaiEgressSecretRef;
+    /** Resolve the value from a managed-identity token. */
+    managedIdentityRef?: RaiEgressManagedIdentityRef;
+}
+export declare function raiEgressHeaderValueRefSerializer(item: RaiEgressHeaderValueRef): any;
+export declare function raiEgressHeaderValueRefDeserializer(item: any): RaiEgressHeaderValueRef;
+/** A reference to a stored secret used as a header value. */
+export interface RaiEgressSecretRef {
+    /** Identifier of the secret to inject. */
+    secretId: string;
+    /** Optional key within the secret. */
+    secretKey?: string;
+    /** Optional format for the resolved value; "{value}" is the placeholder, e.g. "Bearer {value}". */
+    format?: string;
+}
+export declare function raiEgressSecretRefSerializer(item: RaiEgressSecretRef): any;
+export declare function raiEgressSecretRefDeserializer(item: any): RaiEgressSecretRef;
+/** A reference to a managed-identity token used as a header value. */
+export interface RaiEgressManagedIdentityRef {
+    /** The resource/audience the token is requested for. */
+    resource: string;
+    /** Optional format for the resolved token; "{value}" is the placeholder, e.g. "Bearer {value}". */
+    format?: string;
+}
+export declare function raiEgressManagedIdentityRefSerializer(item: RaiEgressManagedIdentityRef): any;
+export declare function raiEgressManagedIdentityRefDeserializer(item: any): RaiEgressManagedIdentityRef;
+/**
+ * Where a Rewrite action sends matched traffic. At least one field must be set;
+ * omitted fields retain the original request values. This constraint is enforced
+ * by the server (400 Bad Request if all fields are omitted).
+ */
+export interface RaiEgressRewriteTarget {
+    /** Target scheme. Original scheme is kept if omitted. */
+    scheme?: RaiEgressScheme;
+    /** Target host. Original host is kept if omitted. */
+    host?: string;
+    /** Target path (literal string). Original path (and query) is kept if omitted. */
+    path?: string;
+}
+export declare function raiEgressRewriteTargetSerializer(item: RaiEgressRewriteTarget): any;
+export declare function raiEgressRewriteTargetDeserializer(item: any): RaiEgressRewriteTarget;
+/** URL scheme for rewrite targets. Only HTTP and HTTPS are supported. */
+export declare enum KnownRaiEgressScheme {
+    /** HTTP scheme. */
+    Http = "http",
+    /** HTTPS scheme. */
+    Https = "https"
+}
+/**
+ * URL scheme for rewrite targets. Only HTTP and HTTPS are supported. \
+ * {@link KnownRaiEgressScheme} can be used interchangeably with RaiEgressScheme,
+ *  this enum contains the known values that the service supports.
+ * ### Known values supported by the service
+ * **http**: HTTP scheme. \
+ * **https**: HTTPS scheme.
+ */
+export type RaiEgressScheme = string;
 /** Azure OpenAI blocklist config. */
 export interface RaiBlocklistConfig {
     /** Name of ContentFilter. */
@@ -3465,6 +3847,93 @@ export interface AgentReference extends ProxyResource {
     properties: AgentReferenceProperties;
 }
 export declare function agentReferenceDeserializer(item: any): AgentReference;
+/** Cognitive Services account managed compute deployment, backed by managed compute (GPU) resources. */
+export interface ManagedComputeDeployment extends ProxyResource {
+    /** Properties of the Cognitive Services managed compute deployment. */
+    properties?: ManagedComputeDeploymentProperties;
+    /** The resource model definition representing SKU */
+    sku?: Sku;
+    /** Resource Etag. */
+    readonly etag?: string;
+}
+export declare function managedComputeDeploymentSerializer(item: ManagedComputeDeployment): any;
+export declare function managedComputeDeploymentDeserializer(item: any): ManagedComputeDeployment;
+/** Properties of a Cognitive Services managed compute deployment. */
+export interface ManagedComputeDeploymentProperties {
+    /**
+     * AzureML Registry model asset URI. Required on creation; immutable after creation.
+     * Example: azureml://registries/{registry}/models/{model}/versions/{version}
+     */
+    model: string;
+    /**
+     * Deployment template identifier. Optional on creation.
+     * Accepts an AzureML Registry deployment template URI or a project-scoped deployment template path for VmManagedCompute.
+     * Examples: azureml://registries/{registry}/deploymenttemplates/{template}/versions/{version}, projects/{project}/deploymentTemplates/{template}/versions/{version}
+     */
+    deploymentTemplate?: string;
+    /** Accelerator type (e.g., H100_80GB). Optional on creation; immutable after creation. */
+    acceleratorType?: string;
+    /** Template auto-upgrade policy. Defaults to OnceNewDefaultVersionAvailable. */
+    versionUpgradeOption?: DeploymentModelVersionUpgradeOption;
+    /**
+     * Deployment capabilities represented as key-value pairs.
+     * Example: { assetsV2: "true" }.
+     */
+    readonly capabilities?: Record<string, string>;
+    /** Foundry compute ARM resource ID for VM-backed managed compute deployments. Required when sku.name is VmManagedCompute; immutable after creation. */
+    computeId?: string;
+    /** Scheduling priority for VM-backed managed compute deployments. Immutable after creation. */
+    priority?: string;
+    /** Read-only. Number of accelerators (GPUs) consumed by each model instance, sourced from the deployment template. */
+    readonly acceleratorsPerInstance?: number;
+    /** Read-only. Total accelerators allocated: sku.capacity (instances) x acceleratorsPerInstance. */
+    readonly totalAccelerators?: number;
+    /** Read-only. Current provisioning state. */
+    readonly provisioningState?: ProvisioningState;
+    /** Read-only. Status message and timestamp from the last provisioning operation. */
+    readonly provisioningDetails?: ManagedComputeDeploymentProvisioningDetails;
+    /** Read-only. Inference route paths relative to the account endpoint. Populated when provisioningState is Succeeded. */
+    readonly routes?: ManagedComputeDeploymentRoutes;
+}
+export declare function managedComputeDeploymentPropertiesSerializer(item: ManagedComputeDeploymentProperties): any;
+export declare function managedComputeDeploymentPropertiesDeserializer(item: any): ManagedComputeDeploymentProperties;
+/** Provisioning status details for a managed compute deployment. */
+export interface ManagedComputeDeploymentProvisioningDetails {
+    /** A human-readable status message from the last provisioning operation. */
+    message?: string;
+    /** Timestamp of the last provisioning operation. */
+    lastOperationTimestamp?: Date;
+}
+export declare function managedComputeDeploymentProvisioningDetailsDeserializer(item: any): ManagedComputeDeploymentProvisioningDetails;
+/**
+ * Inference route paths for a managed compute deployment, relative to the account endpoint.
+ * Populated when provisioningState is Succeeded.
+ */
+export interface ManagedComputeDeploymentRoutes {
+    /** Relative path to the chat completions scoring endpoint. */
+    chatCompletionsScoringPath?: string;
+    /** Relative path to the Swagger/OpenAPI endpoint. */
+    swagger?: string;
+    /** Relative path to the messages API scoring endpoint. */
+    messagesApiScoringPath?: string;
+}
+export declare function managedComputeDeploymentRoutesDeserializer(item: any): ManagedComputeDeploymentRoutes;
+/** The object being used to update sku of a resource, in general used for PATCH operations. */
+export interface PatchResourceSku {
+    /** The resource model definition representing SKU */
+    sku?: Sku;
+}
+export declare function patchResourceSkuSerializer(item: PatchResourceSku): any;
+/** The list of managed compute deployments. */
+export interface _ManagedComputeDeploymentListResult {
+    /** The link used to get the next page of managed compute deployments. */
+    nextLink?: string;
+    /** Gets the list of managed compute deployments and their properties. */
+    readonly value?: ManagedComputeDeployment[];
+}
+export declare function _managedComputeDeploymentListResultDeserializer(item: any): _ManagedComputeDeploymentListResult;
+export declare function managedComputeDeploymentArraySerializer(result: Array<ManagedComputeDeployment>): any[];
+export declare function managedComputeDeploymentArrayDeserializer(result: Array<ManagedComputeDeployment>): any[];
 /** The status of an async compute operation. */
 export interface ComputeOperationStatus extends ProxyResource {
     /** The properties of the compute operation status. */
@@ -3505,6 +3974,328 @@ export declare enum KnownComputeOperationStatusType {
  * **Canceled**: The operation has been canceled.
  */
 export type ComputeOperationStatusType = string;
+/** List of managed compute quota entries. */
+export interface _ManagedComputeUsageListResult {
+    /** The link used to get the next page of managed compute usages. */
+    nextLink?: string;
+    /** Per-SKU managed compute quota usage entries. */
+    value?: ManagedComputeUsage[];
+}
+export declare function _managedComputeUsageListResultDeserializer(item: any): _ManagedComputeUsageListResult;
+export declare function managedComputeUsageArrayDeserializer(result: Array<ManagedComputeUsage>): any[];
+/** Managed compute quota usage for a specific SKU. */
+export interface ManagedComputeUsage {
+    /** Fully qualified resource ID for the managed compute usage. */
+    readonly id?: string;
+    /** The name information for the metric. */
+    readonly name?: MetricName;
+    /** The resource type. */
+    readonly type?: string;
+    /** The unit of the metric. */
+    unit?: UnitType;
+    /** Maximum value for this metric. */
+    limit?: number;
+    /** Current value for this metric. */
+    currentValue?: number;
+    /** Offer scope (e.g., 'Global', 'Datazone-US'). */
+    offerScope?: string;
+    /** Deployments consuming this managed compute quota. */
+    deployments?: ManagedComputeDeploymentInfo[];
+}
+export declare function managedComputeUsageDeserializer(item: any): ManagedComputeUsage;
+export declare function managedComputeDeploymentInfoArrayDeserializer(result: Array<ManagedComputeDeploymentInfo>): any[];
+/** Deployment detail within a managed compute usage entry. */
+export interface ManagedComputeDeploymentInfo {
+    /** Full ARM resource ID of the deployment. */
+    deploymentId?: string;
+    /** Full ARM resource ID of the account/project. */
+    projectId?: string;
+    /** Model name (e.g., 'azureml://registries//models//versions/gpt-4o'). */
+    modelId?: string;
+    /** Number of GPUs consumed by this deployment. */
+    acceleratorCount?: number;
+    /** Number of instances for this deployment. */
+    instanceCount?: number;
+}
+export declare function managedComputeDeploymentInfoDeserializer(item: any): ManagedComputeDeploymentInfo;
+/**
+ * Cognitive Services compute resource. Supports polymorphic compute types
+ * (Cluster, ContainerInstance) via the computeType discriminator in properties.
+ */
+export interface Compute extends ProxyResource {
+    /** Polymorphic properties of the compute resource. Use computeType to select Cluster or ContainerInstance. */
+    properties: ComputePropertiesUnion;
+    /** Resource Etag. */
+    readonly etag?: string;
+    /** The location of the compute resource. */
+    location?: string;
+    /** Resource tags. */
+    tags?: Record<string, string>;
+    /** The kind (type) of compute resource. */
+    kind?: string;
+    /** Identity for the resource. */
+    identity?: Identity;
+}
+export declare function computeSerializer(item: Compute): any;
+export declare function computeDeserializer(item: any): Compute;
+/**
+ * Base properties for all compute resource types.
+ * The computeType discriminator determines the concrete property shape.
+ */
+export interface ComputeProperties {
+    /** The type of compute resource. */
+    /** The discriminator possible values: Cluster, ContainerInstance */
+    computeType: ComputeType;
+    /** Provisioning state of the compute resource. */
+    readonly provisioningState?: ComputeProvisioningState;
+    /** Error details for the compute resource. */
+    readonly errors?: ErrorDetail[];
+    /** Creation time of the compute resource. */
+    readonly creationTime?: Date;
+}
+export declare function computePropertiesSerializer(item: ComputeProperties): any;
+export declare function computePropertiesDeserializer(item: any): ComputeProperties;
+/** Alias for ComputePropertiesUnion */
+export type ComputePropertiesUnion = ClusterComputeProperties | ContainerInstanceComputeProperties | ComputeProperties;
+export declare function computePropertiesUnionSerializer(item: ComputePropertiesUnion): any;
+export declare function computePropertiesUnionDeserializer(item: any): ComputePropertiesUnion;
+/** The type of compute resource. */
+export declare enum KnownComputeType {
+    /** Cluster (AKS-backed) compute type. */
+    Cluster = "Cluster",
+    /** Container Instance compute type. */
+    ContainerInstance = "ContainerInstance"
+}
+/**
+ * The type of compute resource. \
+ * {@link KnownComputeType} can be used interchangeably with ComputeType,
+ *  this enum contains the known values that the service supports.
+ * ### Known values supported by the service
+ * **Cluster**: Cluster (AKS-backed) compute type. \
+ * **ContainerInstance**: Container Instance compute type.
+ */
+export type ComputeType = string;
+/** The provisioning state of a compute resource. */
+export declare enum KnownComputeProvisioningState {
+    /** The resource provisioning request has been accepted. */
+    Accepted = "Accepted",
+    /** The resource has been fully provisioned. */
+    Succeeded = "Succeeded",
+    /** The resource provisioning has failed. */
+    Failed = "Failed",
+    /** The resource provisioning was canceled. */
+    Canceled = "Canceled",
+    /** The resource is being deleted. */
+    Deleting = "Deleting",
+    /** The resource is scaling. */
+    Scaling = "Scaling",
+    /** The resource is disabled. */
+    Disabled = "Disabled",
+    /** The compute resource is starting. */
+    Starting = "Starting",
+    /** The compute resource is stopping. */
+    Stopping = "Stopping",
+    /** The compute resource is restarting. */
+    Restarting = "Restarting",
+    /** The compute resource is stopped. */
+    Stopped = "Stopped"
+}
+/**
+ * The provisioning state of a compute resource. \
+ * {@link KnownComputeProvisioningState} can be used interchangeably with ComputeProvisioningState,
+ *  this enum contains the known values that the service supports.
+ * ### Known values supported by the service
+ * **Accepted**: The resource provisioning request has been accepted. \
+ * **Succeeded**: The resource has been fully provisioned. \
+ * **Failed**: The resource provisioning has failed. \
+ * **Canceled**: The resource provisioning was canceled. \
+ * **Deleting**: The resource is being deleted. \
+ * **Scaling**: The resource is scaling. \
+ * **Disabled**: The resource is disabled. \
+ * **Starting**: The compute resource is starting. \
+ * **Stopping**: The compute resource is stopping. \
+ * **Restarting**: The compute resource is restarting. \
+ * **Stopped**: The compute resource is stopped.
+ */
+export type ComputeProvisioningState = string;
+/** Properties for a Cluster (AKS-backed) compute resource. */
+export interface ClusterComputeProperties extends ComputeProperties {
+    /** The type of compute resource. */
+    computeType: "Cluster";
+    /** Pools attached to this compute cluster. */
+    pools: Pool[];
+    /** ARM ID of the subnet used for compute. */
+    subnetArmId?: string;
+}
+export declare function clusterComputePropertiesSerializer(item: ClusterComputeProperties): any;
+export declare function clusterComputePropertiesDeserializer(item: any): ClusterComputeProperties;
+export declare function poolArraySerializer(result: Array<Pool>): any[];
+export declare function poolArrayDeserializer(result: Array<Pool>): any[];
+/** A compute pool configuration. */
+export interface Pool {
+    /** The name of the pool. */
+    name: string;
+    /** The VM priority of the pool. */
+    vmPriority: VmPriority;
+    /** The instance type (VM SKU) used in the pool. */
+    instanceType: string;
+    /** The number of nodes in the pool. */
+    nodeCount: number;
+}
+export declare function poolSerializer(item: Pool): any;
+export declare function poolDeserializer(item: any): Pool;
+/** VM priority for a compute pool. */
+export declare enum KnownVmPriority {
+    /** Regular VM priority. */
+    Regular = "Regular",
+    /** Low-priority VM. */
+    LowPriority = "LowPriority"
+}
+/**
+ * VM priority for a compute pool. \
+ * {@link KnownVmPriority} can be used interchangeably with VmPriority,
+ *  this enum contains the known values that the service supports.
+ * ### Known values supported by the service
+ * **Regular**: Regular VM priority. \
+ * **LowPriority**: Low-priority VM.
+ */
+export type VmPriority = string;
+/** Properties for a Container Instance compute resource. */
+export interface ContainerInstanceComputeProperties extends ComputeProperties {
+    /** The type of compute resource. */
+    computeType: "ContainerInstance";
+    /** ARM resource ID of the parent cluster that hosts this container instance. */
+    targetClusterId: string;
+    /** Container image URI (e.g., MCR or ACR image path) for the container instance. */
+    imageLink: string;
+    /** ISO 8601 duration before the idle instance is automatically shut down (e.g., 'PT30M'). */
+    idleTimeBeforeShutdown?: string;
+    /** SSH configuration for remote access to the container instance. */
+    sshSettings?: SshSettings;
+    /** Network connectivity endpoints assigned to the container instance. */
+    readonly connectivityEndpoints?: ConnectivityEndpoints;
+}
+export declare function containerInstanceComputePropertiesSerializer(item: ContainerInstanceComputeProperties): any;
+export declare function containerInstanceComputePropertiesDeserializer(item: any): ContainerInstanceComputeProperties;
+/** SSH configuration for a Container Instance compute. */
+export interface SshSettings {
+    /** The SSH public key for authenticating to the compute instance. */
+    sshPublicKey?: string;
+    /** Whether SSH admin access is enabled. */
+    adminEnabled?: boolean;
+}
+export declare function sshSettingsSerializer(item: SshSettings): any;
+export declare function sshSettingsDeserializer(item: any): SshSettings;
+/** Network connectivity endpoints for a Container Instance compute. */
+export interface ConnectivityEndpoints {
+    /** The public IP address of the compute instance. */
+    readonly publicIpAddress?: string;
+    /** The SSH port for the compute instance. */
+    readonly sshPort?: number;
+}
+export declare function connectivityEndpointsDeserializer(item: any): ConnectivityEndpoints;
+/** The list of cognitive services computes operation response. */
+export interface _ComputeListResult {
+    /** The link used to get the next page of compute list. */
+    nextLink?: string;
+    /** Gets the list of computes. */
+    value?: Compute[];
+}
+export declare function _computeListResultDeserializer(item: any): _ComputeListResult;
+export declare function computeArraySerializer(result: Array<Compute>): any[];
+export declare function computeArrayDeserializer(result: Array<Compute>): any[];
+/**
+ * Workbench resource under a Cognitive Services project.
+ * Provides interactive compute with data access for AI development.
+ */
+export interface Workbench extends ProxyResource {
+    /** Properties of the workbench resource. */
+    properties: WorkbenchProperties;
+    /** Resource Etag. */
+    readonly etag?: string;
+    /** The location of the workbench resource. */
+    location?: string;
+    /** Resource tags. */
+    tags?: Record<string, string>;
+    /** Identity for the resource. */
+    identity?: Identity;
+}
+export declare function workbenchSerializer(item: Workbench): any;
+export declare function workbenchDeserializer(item: any): Workbench;
+/** Properties for a Workbench resource. */
+export interface WorkbenchProperties {
+    /** ARM resource ID of the parent cluster that hosts this workbench. */
+    targetClusterId: string;
+    /** Container image URI (e.g., MCR or ACR image path) for the workbench. */
+    imageLink: string;
+    /** ISO 8601 duration before the idle workbench is automatically shut down (e.g., 'PT30M'). */
+    idleTimeBeforeShutdown?: string;
+    /** The dataset ID to mount for the workbench. */
+    datasetId?: string;
+    /** SSH configuration for remote access to the workbench. */
+    sshSettings?: SshSettings;
+    /** Network connectivity endpoints assigned to the workbench. */
+    readonly connectivityEndpoints?: ConnectivityEndpoints;
+    /** The web endpoint URL for accessing the workbench. */
+    readonly webEndpoint?: string;
+    /** Provisioning state of the workbench resource. */
+    readonly provisioningState?: ComputeProvisioningState;
+    /** Error details for the workbench resource. */
+    readonly errors?: ErrorDetail[];
+    /** Creation time of the workbench resource. */
+    readonly creationTime?: Date;
+}
+export declare function workbenchPropertiesSerializer(item: WorkbenchProperties): any;
+export declare function workbenchPropertiesDeserializer(item: any): WorkbenchProperties;
+/** The list of workbenches operation response. */
+export interface _WorkbenchListResult {
+    /** The link used to get the next page of workbench list. */
+    nextLink?: string;
+    /** Gets the list of workbenches. */
+    value?: Workbench[];
+}
+export declare function _workbenchListResultDeserializer(item: any): _WorkbenchListResult;
+export declare function workbenchArraySerializer(result: Array<Workbench>): any[];
+export declare function workbenchArrayDeserializer(result: Array<Workbench>): any[];
+/** The list of managed compute capacities response. */
+export interface _ManagedComputeCapacityListResult {
+    /** The link used to get the next page of managed compute capacities. */
+    nextLink?: string;
+    /** Gets the list of managed compute capacities. */
+    readonly value?: ManagedComputeCapacity[];
+}
+export declare function _managedComputeCapacityListResultDeserializer(item: any): _ManagedComputeCapacityListResult;
+export declare function managedComputeCapacityArrayDeserializer(result: Array<ManagedComputeCapacity>): any[];
+/**
+ * Managed compute capacity information for Cognitive Services managed compute deployments.
+ * Provides available accelerator capacity per type and region at the subscription level.
+ */
+export interface ManagedComputeCapacity extends ProxyResource {
+    /** Properties of the managed compute capacity resource. */
+    properties?: ManagedComputeCapacityProperties;
+}
+export declare function managedComputeCapacityDeserializer(item: any): ManagedComputeCapacity;
+/** Properties of a managed compute capacity resource. */
+export interface ManagedComputeCapacityProperties {
+    /** The type of accelerator (e.g., Azure.A100, Azure.H100). */
+    readonly acceleratorType?: string;
+    /** The number of available accelerators in the region. */
+    readonly availableAccelerators?: number;
+    /** Capacity information broken down by deployment size. */
+    readonly deploymentSizeCapacities?: DeploymentSizeCapacity[];
+}
+export declare function managedComputeCapacityPropertiesDeserializer(item: any): ManagedComputeCapacityProperties;
+export declare function deploymentSizeCapacityArrayDeserializer(result: Array<DeploymentSizeCapacity>): any[];
+/** Capacity information for a specific deployment size. */
+export interface DeploymentSizeCapacity {
+    /** The number of accelerators required per model instance. */
+    readonly modelInstanceAcceleratorCount?: number;
+    /** The total available capacity for this deployment size. */
+    readonly totalAvailableCapacity?: number;
+    /** The largest contiguous deployment capacity available for this deployment size. */
+    readonly largestDeploymentCapacity?: number;
+}
+export declare function deploymentSizeCapacityDeserializer(item: any): DeploymentSizeCapacity;
 /** A list of private link resources */
 export interface PrivateLinkResourceListResult {
     /** Array of private link resources */
@@ -4284,7 +5075,15 @@ export declare enum KnownVersions {
     /** The 2025-12-01 API version. */
     V20251201 = "2025-12-01",
     /** The 2026-01-15-preview API version. */
-    V20260115Preview = "2026-01-15-preview"
+    V20260115Preview = "2026-01-15-preview",
+    /** The 2026-03-01 API version. */
+    V20260301 = "2026-03-01",
+    /** The 2026-03-15-preview API version. */
+    V20260315Preview = "2026-03-15-preview",
+    /** The 2026-05-01 API version. */
+    V20260501 = "2026-05-01",
+    /** The 2026-05-15-preview API version. */
+    V20260515Preview = "2026-05-15-preview"
 }
 export declare function raiBlocklistItemBulkRequestArraySerializer(result: Array<RaiBlocklistItemBulkRequest>): any[];
 export declare function _commitmentPlanAccountAssociationPropertiesSerializer(item: CommitmentPlanAccountAssociation): any;