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

package/dist/browser/models/models.js

@@ -1357,6 +1357,9 @@ export function deploymentDeserializer(item) {
 export function deploymentPropertiesSerializer(item) {
     return {
         model: !item["model"] ? item["model"] : deploymentModelSerializer(item["model"]),
+        speculativeDecoding: !item["speculativeDecoding"]
+            ? item["speculativeDecoding"]
+            : deploymentSpeculativeDecodingSerializer(item["speculativeDecoding"]),
         scaleSettings: !item["scaleSettings"]
             ? item["scaleSettings"]
             : deploymentScaleSettingsSerializer(item["scaleSettings"]),
@@ -1377,6 +1380,9 @@ export function deploymentPropertiesDeserializer(item) {
     return {
         provisioningState: item["provisioningState"],
         model: !item["model"] ? item["model"] : deploymentModelDeserializer(item["model"]),
+        speculativeDecoding: !item["speculativeDecoding"]
+            ? item["speculativeDecoding"]
+            : deploymentSpeculativeDecodingDeserializer(item["speculativeDecoding"]),
         scaleSettings: !item["scaleSettings"]
             ? item["scaleSettings"]
             : deploymentScaleSettingsDeserializer(item["scaleSettings"]),
@@ -1423,6 +1429,18 @@ export var KnownDeploymentProvisioningState;
     /** Canceled */
     KnownDeploymentProvisioningState["Canceled"] = "Canceled";
 })(KnownDeploymentProvisioningState || (KnownDeploymentProvisioningState = {}));
+export function deploymentSpeculativeDecodingSerializer(item) {
+    return {
+        draftModel: deploymentModelSerializer(item["draftModel"]),
+        draftTokenCount: item["draftTokenCount"],
+    };
+}
+export function deploymentSpeculativeDecodingDeserializer(item) {
+    return {
+        draftModel: deploymentModelDeserializer(item["draftModel"]),
+        draftTokenCount: item["draftTokenCount"],
+    };
+}
 export function deploymentScaleSettingsSerializer(item) {
     return { scaleType: item["scaleType"], capacity: item["capacity"] };
 }
@@ -1845,6 +1863,9 @@ export function raiPolicyPropertiesSerializer(item) {
         safetyProviders: !item["safetyProviders"]
             ? item["safetyProviders"]
             : safetyProviderConfigArraySerializer(item["safetyProviders"]),
+        egressPolicy: !item["egressPolicy"]
+            ? item["egressPolicy"]
+            : raiEgressPolicyConfigSerializer(item["egressPolicy"]),
     };
 }
 export function raiPolicyPropertiesDeserializer(item) {
@@ -1861,6 +1882,9 @@ export function raiPolicyPropertiesDeserializer(item) {
         safetyProviders: !item["safetyProviders"]
             ? item["safetyProviders"]
             : safetyProviderConfigArrayDeserializer(item["safetyProviders"]),
+        egressPolicy: !item["egressPolicy"]
+            ? item["egressPolicy"]
+            : raiEgressPolicyConfigDeserializer(item["egressPolicy"]),
     };
 }
 /** Content Filters policy type. */
@@ -2001,6 +2025,217 @@ export function safetyProviderConfigDeserializer(item) {
         source: item["source"],
     };
 }
+export function raiEgressPolicyConfigSerializer(item) {
+    return {
+        mode: item["mode"],
+        defaultAction: item["defaultAction"],
+        description: item["description"],
+        rules: !item["rules"] ? item["rules"] : raiEgressRuleArraySerializer(item["rules"]),
+    };
+}
+export function raiEgressPolicyConfigDeserializer(item) {
+    return {
+        mode: item["mode"],
+        defaultAction: item["defaultAction"],
+        description: item["description"],
+        rules: !item["rules"] ? item["rules"] : raiEgressRuleArrayDeserializer(item["rules"]),
+    };
+}
+/**
+ * The enforcement mode for egress rules.
+ * If omitted on create, the server defaults to Enforced.
+ */
+export var KnownRaiEgressMode;
+(function (KnownRaiEgressMode) {
+    /** Rules are enforced. Matching traffic is allowed or denied per rule actions. */
+    KnownRaiEgressMode["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).
+     */
+    KnownRaiEgressMode["Audit"] = "Audit";
+})(KnownRaiEgressMode || (KnownRaiEgressMode = {}));
+/** The default action when no user-defined egress rules match. */
+export var KnownRaiEgressDefaultAction;
+(function (KnownRaiEgressDefaultAction) {
+    /** Allow traffic by default when no rules match. */
+    KnownRaiEgressDefaultAction["Allow"] = "Allow";
+    /** Deny traffic by default when no rules match. */
+    KnownRaiEgressDefaultAction["Deny"] = "Deny";
+})(KnownRaiEgressDefaultAction || (KnownRaiEgressDefaultAction = {}));
+export function raiEgressRuleArraySerializer(result) {
+    return result.map((item) => {
+        return raiEgressRuleSerializer(item);
+    });
+}
+export function raiEgressRuleArrayDeserializer(result) {
+    return result.map((item) => {
+        return raiEgressRuleDeserializer(item);
+    });
+}
+export function raiEgressRuleSerializer(item) {
+    return {
+        name: item["name"],
+        description: item["description"],
+        ruleType: item["ruleType"],
+        match: !item["match"] ? item["match"] : raiEgressRuleMatchSerializer(item["match"]),
+        action: raiEgressRuleActionSerializer(item["action"]),
+    };
+}
+export function raiEgressRuleDeserializer(item) {
+    return {
+        name: item["name"],
+        description: item["description"],
+        ruleType: item["ruleType"],
+        match: !item["match"] ? item["match"] : raiEgressRuleMatchDeserializer(item["match"]),
+        action: raiEgressRuleActionDeserializer(item["action"]),
+    };
+}
+/** The type of an egress rule, determining what kind of traffic matching it performs. */
+export var KnownRaiEgressRuleType;
+(function (KnownRaiEgressRuleType) {
+    /** Fully qualified domain name (FQDN) based rule matching on host and path patterns. */
+    KnownRaiEgressRuleType["Fqdn"] = "Fqdn";
+})(KnownRaiEgressRuleType || (KnownRaiEgressRuleType = {}));
+export function raiEgressRuleMatchSerializer(item) {
+    return { host: item["host"], path: item["path"] };
+}
+export function raiEgressRuleMatchDeserializer(item) {
+    return {
+        host: item["host"],
+        path: item["path"],
+    };
+}
+export function raiEgressRuleActionSerializer(item) {
+    return {
+        actionType: item["actionType"],
+        headers: !item["headers"]
+            ? item["headers"]
+            : raiEgressHeaderTransformArraySerializer(item["headers"]),
+        rewrite: !item["rewrite"] ? item["rewrite"] : raiEgressRewriteTargetSerializer(item["rewrite"]),
+    };
+}
+export function raiEgressRuleActionDeserializer(item) {
+    return {
+        actionType: item["actionType"],
+        headers: !item["headers"]
+            ? item["headers"]
+            : raiEgressHeaderTransformArrayDeserializer(item["headers"]),
+        rewrite: !item["rewrite"]
+            ? item["rewrite"]
+            : raiEgressRewriteTargetDeserializer(item["rewrite"]),
+    };
+}
+/** The kind of action an egress rule takes when it matches. */
+export var KnownRaiEgressRuleActionType;
+(function (KnownRaiEgressRuleActionType) {
+    /** Allow the matched traffic. */
+    KnownRaiEgressRuleActionType["Allow"] = "Allow";
+    /** Deny the matched traffic. */
+    KnownRaiEgressRuleActionType["Deny"] = "Deny";
+    /** Forward the matched traffic after applying header transforms. Requires at least one header. */
+    KnownRaiEgressRuleActionType["Transform"] = "Transform";
+    /** Redirect the matched traffic to a new destination, optionally applying header transforms. Requires a rewrite target. */
+    KnownRaiEgressRuleActionType["Rewrite"] = "Rewrite";
+})(KnownRaiEgressRuleActionType || (KnownRaiEgressRuleActionType = {}));
+export function raiEgressHeaderTransformArraySerializer(result) {
+    return result.map((item) => {
+        return raiEgressHeaderTransformSerializer(item);
+    });
+}
+export function raiEgressHeaderTransformArrayDeserializer(result) {
+    return result.map((item) => {
+        return raiEgressHeaderTransformDeserializer(item);
+    });
+}
+export function raiEgressHeaderTransformSerializer(item) {
+    return {
+        operation: item["operation"],
+        name: item["name"],
+        value: item["value"],
+        valueRef: !item["valueRef"]
+            ? item["valueRef"]
+            : raiEgressHeaderValueRefSerializer(item["valueRef"]),
+    };
+}
+export function raiEgressHeaderTransformDeserializer(item) {
+    return {
+        operation: item["operation"],
+        name: item["name"],
+        value: item["value"],
+        valueRef: !item["valueRef"]
+            ? item["valueRef"]
+            : raiEgressHeaderValueRefDeserializer(item["valueRef"]),
+    };
+}
+/** The operation to apply to a header in a Transform or Rewrite action. */
+export var KnownRaiEgressHeaderOperation;
+(function (KnownRaiEgressHeaderOperation) {
+    /** Set or overwrite the header value, creating it if it does not exist. */
+    KnownRaiEgressHeaderOperation["Set"] = "Set";
+    /** Add the header only if it is not already present. */
+    KnownRaiEgressHeaderOperation["Insert"] = "Insert";
+    /** Remove the header if present. */
+    KnownRaiEgressHeaderOperation["Remove"] = "Remove";
+})(KnownRaiEgressHeaderOperation || (KnownRaiEgressHeaderOperation = {}));
+export function raiEgressHeaderValueRefSerializer(item) {
+    return {
+        secretRef: !item["secretRef"]
+            ? item["secretRef"]
+            : raiEgressSecretRefSerializer(item["secretRef"]),
+        managedIdentityRef: !item["managedIdentityRef"]
+            ? item["managedIdentityRef"]
+            : raiEgressManagedIdentityRefSerializer(item["managedIdentityRef"]),
+    };
+}
+export function raiEgressHeaderValueRefDeserializer(item) {
+    return {
+        secretRef: !item["secretRef"]
+            ? item["secretRef"]
+            : raiEgressSecretRefDeserializer(item["secretRef"]),
+        managedIdentityRef: !item["managedIdentityRef"]
+            ? item["managedIdentityRef"]
+            : raiEgressManagedIdentityRefDeserializer(item["managedIdentityRef"]),
+    };
+}
+export function raiEgressSecretRefSerializer(item) {
+    return { secretId: item["secretId"], secretKey: item["secretKey"], format: item["format"] };
+}
+export function raiEgressSecretRefDeserializer(item) {
+    return {
+        secretId: item["secretId"],
+        secretKey: item["secretKey"],
+        format: item["format"],
+    };
+}
+export function raiEgressManagedIdentityRefSerializer(item) {
+    return { resource: item["resource"], format: item["format"] };
+}
+export function raiEgressManagedIdentityRefDeserializer(item) {
+    return {
+        resource: item["resource"],
+        format: item["format"],
+    };
+}
+export function raiEgressRewriteTargetSerializer(item) {
+    return { scheme: item["scheme"], host: item["host"], path: item["path"] };
+}
+export function raiEgressRewriteTargetDeserializer(item) {
+    return {
+        scheme: item["scheme"],
+        host: item["host"],
+        path: item["path"],
+    };
+}
+/** URL scheme for rewrite targets. Only HTTP and HTTPS are supported. */
+export var KnownRaiEgressScheme;
+(function (KnownRaiEgressScheme) {
+    /** HTTP scheme. */
+    KnownRaiEgressScheme["Http"] = "http";
+    /** HTTPS scheme. */
+    KnownRaiEgressScheme["Https"] = "https";
+})(KnownRaiEgressScheme || (KnownRaiEgressScheme = {}));
 export function raiBlocklistConfigSerializer(item) {
     return { blocklistName: item["blocklistName"], blocking: item["blocking"] };
 }
@@ -4279,6 +4514,9 @@ export function managedComputeDeploymentPropertiesDeserializer(item) {
         deploymentTemplate: item["deploymentTemplate"],
         acceleratorType: item["acceleratorType"],
         versionUpgradeOption: item["versionUpgradeOption"],
+        capabilities: !item["capabilities"]
+            ? item["capabilities"]
+            : Object.fromEntries(Object.entries(item["capabilities"]).map(([k, p]) => [k, p])),
         computeId: item["computeId"],
         priority: item["priority"],
         acceleratorsPerInstance: item["acceleratorsPerInstance"],
@@ -4699,7 +4937,6 @@ export function managedComputeCapacityDeserializer(item) {
 export function managedComputeCapacityPropertiesDeserializer(item) {
     return {
         acceleratorType: item["acceleratorType"],
-        location: item["location"],
         availableAccelerators: item["availableAccelerators"],
         deploymentSizeCapacities: !item["deploymentSizeCapacities"]
             ? item["deploymentSizeCapacities"]
@@ -5782,6 +6019,10 @@ export var KnownVersions;
     KnownVersions["V20260301"] = "2026-03-01";
     /** The 2026-03-15-preview API version. */
     KnownVersions["V20260315Preview"] = "2026-03-15-preview";
+    /** The 2026-05-01 API version. */
+    KnownVersions["V20260501"] = "2026-05-01";
+    /** The 2026-05-15-preview API version. */
+    KnownVersions["V20260515Preview"] = "2026-05-15-preview";
 })(KnownVersions || (KnownVersions = {}));
 export function raiBlocklistItemBulkRequestArraySerializer(result) {
     return result.map((item) => {