@azure/arm-containerservicefleet 2.1.0-beta.1 → 2.1.0-beta.3

package/dist/esm/models/models.d.ts

@@ -1,3 +1,7 @@
+/**
+ * This file contains only generated model types and their (de)serializers.
+ * Disable the following rules for internal models with '_' prefix and deserializers which require 'any' for raw JSON input.
+ */
 /** A list of REST API operations supported by an Azure Resource Provider. It contains an URL link to get the next set of results. */
 export interface _OperationListResult {
     /** The Operation items on this page */
@@ -21,7 +25,7 @@ export interface Operation {
     readonly actionType?: ActionType;
 }
 export declare function operationDeserializer(item: any): Operation;
-/** Localized display information for and operation. */
+/** Localized display information for an operation. */
 export interface OperationDisplay {
     /** The localized friendly form of the resource provider name, e.g. "Microsoft Monitoring Insights" or "Microsoft Compute". */
     readonly provider?: string;
@@ -287,7 +291,7 @@ export declare enum KnownCreatedByType {
 }
 /**
  * The kind of entity that created the resource. \
- * {@link KnowncreatedByType} can be used interchangeably with createdByType,
+ * {@link KnownCreatedByType} can be used interchangeably with CreatedByType,
  *  this enum contains the known values that the service supports.
  * ### Known values supported by the service
  * **User**: The entity was created by a user. \
@@ -418,6 +422,420 @@ export interface _FleetMemberListResult {
 export declare function _fleetMemberListResultDeserializer(item: any): _FleetMemberListResult;
 export declare function fleetMemberArraySerializer(result: Array<FleetMember>): any[];
 export declare function fleetMemberArrayDeserializer(result: Array<FleetMember>): any[];
+/** A fleet managed namespace. */
+export interface FleetManagedNamespace extends TrackedResource {
+    /** If eTag is provided in the response body, it may also be provided as a header per the normal etag convention.  Entity tags are used for comparing two or more entities from the same requested resource. HTTP/1.1 uses entity tags in the etag (section 14.19), If-Match (section 14.24), If-None-Match (section 14.26), and If-Range (section 14.27) header fields. */
+    readonly eTag?: string;
+    /** The status of the last operation. */
+    readonly provisioningState?: FleetManagedNamespaceProvisioningState;
+    /** The namespace properties for the fleet managed namespace. */
+    managedNamespaceProperties?: ManagedNamespaceProperties;
+    /** Action if the managed namespace with the same name already exists. Default is Never. */
+    adoptionPolicy?: AdoptionPolicy;
+    /** Delete options of a fleet managed namespace. Default is Keep. */
+    deletePolicy?: DeletePolicy;
+    /** The profile of the propagation to create the namespace. */
+    propagationPolicy?: PropagationPolicy;
+    /** Status information of the last operation for fleet managed namespace. */
+    readonly status?: FleetManagedNamespaceStatus;
+    /** The Azure Portal FQDN of the Fleet hub. */
+    readonly portalFqdn?: string;
+}
+export declare function fleetManagedNamespaceSerializer(item: FleetManagedNamespace): any;
+export declare function fleetManagedNamespaceDeserializer(item: any): FleetManagedNamespace;
+/** The properties of a fleet managed namespace. */
+export interface FleetManagedNamespaceProperties {
+    /** The status of the last operation. */
+    readonly provisioningState?: FleetManagedNamespaceProvisioningState;
+    /** The namespace properties for the fleet managed namespace. */
+    managedNamespaceProperties?: ManagedNamespaceProperties;
+    /** Action if the managed namespace with the same name already exists. Default is Never. */
+    adoptionPolicy: AdoptionPolicy;
+    /** Delete options of a fleet managed namespace. Default is Keep. */
+    deletePolicy: DeletePolicy;
+    /** The profile of the propagation to create the namespace. */
+    propagationPolicy?: PropagationPolicy;
+    /** Status information of the last operation for fleet managed namespace. */
+    readonly status?: FleetManagedNamespaceStatus;
+    /** The Azure Portal FQDN of the Fleet hub. */
+    readonly portalFqdn?: string;
+}
+export declare function fleetManagedNamespacePropertiesSerializer(item: FleetManagedNamespaceProperties): any;
+export declare function fleetManagedNamespacePropertiesDeserializer(item: any): FleetManagedNamespaceProperties;
+/** The provisioning state of the fleet managed namespace resource */
+export declare enum KnownFleetManagedNamespaceProvisioningState {
+    /** Resource has been created. */
+    Succeeded = "Succeeded",
+    /** Resource creation failed. */
+    Failed = "Failed",
+    /** Resource creation was canceled. */
+    Canceled = "Canceled",
+    /** The provisioning state of a fleet managed namespace being created. */
+    Creating = "Creating",
+    /** The provisioning state of a fleet managed namespace being updated. */
+    Updating = "Updating",
+    /** The provisioning state of a fleet managed namespace being deleted. */
+    Deleting = "Deleting"
+}
+/**
+ * The provisioning state of the fleet managed namespace resource \
+ * {@link KnownFleetManagedNamespaceProvisioningState} can be used interchangeably with FleetManagedNamespaceProvisioningState,
+ *  this enum contains the known values that the service supports.
+ * ### Known values supported by the service
+ * **Succeeded**: Resource has been created. \
+ * **Failed**: Resource creation failed. \
+ * **Canceled**: Resource creation was canceled. \
+ * **Creating**: The provisioning state of a fleet managed namespace being created. \
+ * **Updating**: The provisioning state of a fleet managed namespace being updated. \
+ * **Deleting**: The provisioning state of a fleet managed namespace being deleted.
+ */
+export type FleetManagedNamespaceProvisioningState = string;
+/** The namespace properties for the fleet managed namespace. */
+export interface ManagedNamespaceProperties {
+    /** The labels for the fleet managed namespace. */
+    labels?: Record<string, string>;
+    /** The annotations for the fleet managed namespace. */
+    annotations?: Record<string, string>;
+    /** The default resource quota for the fleet managed namespace. */
+    defaultResourceQuota?: ResourceQuota;
+    /** The default network policy for the fleet managed namespace. */
+    defaultNetworkPolicy?: NetworkPolicy;
+}
+export declare function managedNamespacePropertiesSerializer(item: ManagedNamespaceProperties): any;
+export declare function managedNamespacePropertiesDeserializer(item: any): ManagedNamespaceProperties;
+/** The resource quota for the managed namespace. */
+export interface ResourceQuota {
+    /** The CPU request for the managed namespace. See more at https://kubernetes.io/docs/concepts/configuration/manage-resources-containers/#meaning-of-cpu */
+    cpuRequest?: string;
+    /** The CPU limit for the managed namespace. See more at https://kubernetes.io/docs/concepts/configuration/manage-resources-containers/#meaning-of-cpu */
+    cpuLimit?: string;
+    /** The memory request for the managed namespace. See more at https://kubernetes.io/docs/concepts/configuration/manage-resources-containers/#meaning-of-memory */
+    memoryRequest?: string;
+    /** The memory limit for the managed namespace. See more at https://kubernetes.io/docs/concepts/configuration/manage-resources-containers/#meaning-of-memory */
+    memoryLimit?: string;
+}
+export declare function resourceQuotaSerializer(item: ResourceQuota): any;
+export declare function resourceQuotaDeserializer(item: any): ResourceQuota;
+/** The network policy for the managed namespace. */
+export interface NetworkPolicy {
+    /** The ingress policy for the managed namespace. */
+    ingress?: PolicyRule;
+    /** The egress policy for the managed namespace. */
+    egress?: PolicyRule;
+}
+export declare function networkPolicySerializer(item: NetworkPolicy): any;
+export declare function networkPolicyDeserializer(item: any): NetworkPolicy;
+/** The possible values representing different network policy rules. */
+export declare enum KnownPolicyRule {
+    /** Allow all network traffic. */
+    AllowAll = "AllowAll",
+    /** Deny all network traffic. */
+    DenyAll = "DenyAll",
+    /** Allow traffic within the same namespace. */
+    AllowSameNamespace = "AllowSameNamespace"
+}
+/**
+ * The possible values representing different network policy rules. \
+ * {@link KnownPolicyRule} can be used interchangeably with PolicyRule,
+ *  this enum contains the known values that the service supports.
+ * ### Known values supported by the service
+ * **AllowAll**: Allow all network traffic. \
+ * **DenyAll**: Deny all network traffic. \
+ * **AllowSameNamespace**: Allow traffic within the same namespace.
+ */
+export type PolicyRule = string;
+/** Action if the Namespace with the same name already exists. */
+export declare enum KnownAdoptionPolicy {
+    /** If the Namespace already exists, do not take over the existing Namespace to be managed by ARM. */
+    Never = "Never",
+    /** If there is an identical Namespace, take over the existing Namespace to be managed by ARM. */
+    IfIdentical = "IfIdentical",
+    /** Always take over the existing Namespace to be managed by ARM, even if it is not identical. */
+    Always = "Always"
+}
+/**
+ * Action if the Namespace with the same name already exists. \
+ * {@link KnownAdoptionPolicy} can be used interchangeably with AdoptionPolicy,
+ *  this enum contains the known values that the service supports.
+ * ### Known values supported by the service
+ * **Never**: If the Namespace already exists, do not take over the existing Namespace to be managed by ARM. \
+ * **IfIdentical**: If there is an identical Namespace, take over the existing Namespace to be managed by ARM. \
+ * **Always**: Always take over the existing Namespace to be managed by ARM, even if it is not identical.
+ */
+export type AdoptionPolicy = string;
+/** Delete options for the ARM managed namespace. */
+export declare enum KnownDeletePolicy {
+    /** Delete the ARM resource but keep the Namespace. */
+    Keep = "Keep",
+    /** Delete both ARM resource and Namespace. */
+    Delete = "Delete"
+}
+/**
+ * Delete options for the ARM managed namespace. \
+ * {@link KnownDeletePolicy} can be used interchangeably with DeletePolicy,
+ *  this enum contains the known values that the service supports.
+ * ### Known values supported by the service
+ * **Keep**: Delete the ARM resource but keep the Namespace. \
+ * **Delete**: Delete both ARM resource and Namespace.
+ */
+export type DeletePolicy = string;
+/** The propagation to be used for provisioning the namespace among the fleet. */
+export interface PropagationPolicy {
+    /** The type of the policy to be used. Default is Placement. */
+    type: PropagationType;
+    /** The profile to be used for propagation via placement. */
+    placementProfile?: PlacementProfile;
+}
+export declare function propagationPolicySerializer(item: PropagationPolicy): any;
+export declare function propagationPolicyDeserializer(item: any): PropagationPolicy;
+/** How the namespace will be provisioned among the fleet members. */
+export declare enum KnownPropagationType {
+    /** Using ClusterResourcePlacement. */
+    Placement = "Placement"
+}
+/**
+ * How the namespace will be provisioned among the fleet members. \
+ * {@link KnownPropagationType} can be used interchangeably with PropagationType,
+ *  this enum contains the known values that the service supports.
+ * ### Known values supported by the service
+ * **Placement**: Using ClusterResourcePlacement.
+ */
+export type PropagationType = string;
+/** The configuration profile for default ClusterResourcePlacement for placement. */
+export interface PlacementProfile {
+    /** The default ClusterResourcePlacement policy configuration. */
+    defaultClusterResourcePlacement?: ClusterResourcePlacementSpec;
+}
+export declare function placementProfileSerializer(item: PlacementProfile): any;
+export declare function placementProfileDeserializer(item: any): PlacementProfile;
+/** ClusterResourcePlacementSpec defines the desired state of ClusterResourcePlacement. */
+export interface ClusterResourcePlacementSpec {
+    /** Policy defines how to select member clusters to place the selected resources. If unspecified, all the joined member clusters are selected. */
+    policy?: PlacementPolicy;
+}
+export declare function clusterResourcePlacementSpecSerializer(item: ClusterResourcePlacementSpec): any;
+export declare function clusterResourcePlacementSpecDeserializer(item: any): ClusterResourcePlacementSpec;
+/** PlacementPolicy contains the rules to select target member clusters to place the selected resources. Note that only clusters that are both joined and satisfying the rules will be selected. You can only specify at most one of the two fields: ClusterNames and Affinity. If none is specified, all the joined clusters are selected. */
+export interface PlacementPolicy {
+    /** Type of placement. Can be "PickAll", "PickN" or "PickFixed". Default is PickAll. */
+    placementType?: PlacementType;
+    /** ClusterNames contains a list of names of MemberCluster to place the selected resources. Only valid if the placement type is "PickFixed" */
+    clusterNames?: string[];
+    /** Affinity contains cluster affinity scheduling rules. Defines which member clusters to place the selected resources. Only valid if the placement type is "PickAll" or "PickN". */
+    affinity?: Affinity;
+    /** If specified, the ClusterResourcePlacement's Tolerations. Tolerations cannot be updated or deleted. This field is beta-level and is for the taints and tolerations feature. */
+    tolerations?: Toleration[];
+}
+export declare function placementPolicySerializer(item: PlacementPolicy): any;
+export declare function placementPolicyDeserializer(item: any): PlacementPolicy;
+/** PlacementType identifies the type of placement. */
+export declare enum KnownPlacementType {
+    /** PickAll picks all clusters that satisfy the rules. */
+    PickAll = "PickAll",
+    /** PickFixed picks a fixed set of clusters. */
+    PickFixed = "PickFixed"
+}
+/**
+ * PlacementType identifies the type of placement. \
+ * {@link KnownPlacementType} can be used interchangeably with PlacementType,
+ *  this enum contains the known values that the service supports.
+ * ### Known values supported by the service
+ * **PickAll**: PickAll picks all clusters that satisfy the rules. \
+ * **PickFixed**: PickFixed picks a fixed set of clusters.
+ */
+export type PlacementType = string;
+/** Affinity is a group of cluster affinity scheduling rules. More to be added. */
+export interface Affinity {
+    /** ClusterAffinity contains cluster affinity scheduling rules for the selected resources. */
+    clusterAffinity?: ClusterAffinity;
+}
+export declare function affinitySerializer(item: Affinity): any;
+export declare function affinityDeserializer(item: any): Affinity;
+/** ClusterAffinity contains cluster affinity scheduling rules for the selected resources. */
+export interface ClusterAffinity {
+    /** If the affinity requirements specified by this field are not met at scheduling time, the resource will not be scheduled onto the cluster. If the affinity requirements specified by this field cease to be met at some point after the placement (e.g. due to an update), the system may or may not try to eventually remove the resource from the cluster. */
+    requiredDuringSchedulingIgnoredDuringExecution?: ClusterSelector;
+}
+export declare function clusterAffinitySerializer(item: ClusterAffinity): any;
+export declare function clusterAffinityDeserializer(item: any): ClusterAffinity;
+/** ClusterSelector */
+export interface ClusterSelector {
+    /** ClusterSelectorTerms is a list of cluster selector terms. The terms are `ORed`. */
+    clusterSelectorTerms: ClusterSelectorTerm[];
+}
+export declare function clusterSelectorSerializer(item: ClusterSelector): any;
+export declare function clusterSelectorDeserializer(item: any): ClusterSelector;
+export declare function clusterSelectorTermArraySerializer(result: Array<ClusterSelectorTerm>): any[];
+export declare function clusterSelectorTermArrayDeserializer(result: Array<ClusterSelectorTerm>): any[];
+/** ClusterSelectorTerm */
+export interface ClusterSelectorTerm {
+    /** LabelSelector is a label query over all the joined member clusters. Clusters matching the query are selected. If you specify both label and property selectors in the same term, the results are AND'd. */
+    labelSelector?: LabelSelector;
+    /** PropertySelector is a property query over all joined member clusters. Clusters matching the query are selected. If you specify both label and property selectors in the same term, the results are AND'd. At this moment, PropertySelector can only be used with `RequiredDuringSchedulingIgnoredDuringExecution` affinity terms. This field is beta-level; it is for the property-based scheduling feature and is only functional when a property provider is enabled in the deployment. */
+    propertySelector?: PropertySelector;
+}
+export declare function clusterSelectorTermSerializer(item: ClusterSelectorTerm): any;
+export declare function clusterSelectorTermDeserializer(item: any): ClusterSelectorTerm;
+/** A label selector is a label query over a set of resources. The result of matchLabels and matchExpressions are ANDed. An empty label selector matches all objects. A null label selector matches no objects. */
+export interface LabelSelector {
+    /** matchLabels is a map of {key,value} pairs. A single {key,value} in the matchLabels map is equivalent to an element of matchExpressions, whose key field is "key", the operator is "In", and the values array contains only "value". The requirements are ANDed. */
+    matchLabels?: Record<string, string>;
+    /** matchExpressions is a list of label selector requirements. The requirements are ANDed. */
+    matchExpressions?: LabelSelectorRequirement[];
+}
+export declare function labelSelectorSerializer(item: LabelSelector): any;
+export declare function labelSelectorDeserializer(item: any): LabelSelector;
+export declare function labelSelectorRequirementArraySerializer(result: Array<LabelSelectorRequirement>): any[];
+export declare function labelSelectorRequirementArrayDeserializer(result: Array<LabelSelectorRequirement>): any[];
+/** A label selector requirement is a selector that contains values, a key, and an operator that relates the key and values. */
+export interface LabelSelectorRequirement {
+    /** key is the label key that the selector applies to. */
+    key: string;
+    /** operator represents a key's relationship to a set of values. Valid operators are In, NotIn, Exists and DoesNotExist. */
+    operator: LabelSelectorOperator;
+    /** values is an array of string values. If the operator is In or NotIn, the values array must be non-empty. If the operator is Exists or DoesNotExist, the values array must be empty. This array is replaced during a strategic merge patch. */
+    values?: string[];
+}
+export declare function labelSelectorRequirementSerializer(item: LabelSelectorRequirement): any;
+export declare function labelSelectorRequirementDeserializer(item: any): LabelSelectorRequirement;
+/** A label selector operator is the set of operators that can be used in a selector requirement. */
+export declare enum KnownLabelSelectorOperator {
+    /** Label Selector Operator In */
+    In = "In",
+    /** Label Selector Operator NotIn */
+    NotIn = "NotIn",
+    /** Label Selector Operator Exists */
+    Exists = "Exists",
+    /** Label Selector Operator DoesNotExist */
+    DoesNotExist = "DoesNotExist"
+}
+/**
+ * A label selector operator is the set of operators that can be used in a selector requirement. \
+ * {@link KnownLabelSelectorOperator} can be used interchangeably with LabelSelectorOperator,
+ *  this enum contains the known values that the service supports.
+ * ### Known values supported by the service
+ * **In**: Label Selector Operator In \
+ * **NotIn**: Label Selector Operator NotIn \
+ * **Exists**: Label Selector Operator Exists \
+ * **DoesNotExist**: Label Selector Operator DoesNotExist
+ */
+export type LabelSelectorOperator = string;
+/** PropertySelector helps user specify property requirements when picking clusters for resource placement. */
+export interface PropertySelector {
+    /** MatchExpressions is an array of PropertySelectorRequirements. The requirements are AND'd. */
+    matchExpressions: PropertySelectorRequirement[];
+}
+export declare function propertySelectorSerializer(item: PropertySelector): any;
+export declare function propertySelectorDeserializer(item: any): PropertySelector;
+export declare function propertySelectorRequirementArraySerializer(result: Array<PropertySelectorRequirement>): any[];
+export declare function propertySelectorRequirementArrayDeserializer(result: Array<PropertySelectorRequirement>): any[];
+/** PropertySelectorRequirement is a specific property requirement when picking clusters for resource placement. */
+export interface PropertySelectorRequirement {
+    /** Name is the name of the property; it should be a Kubernetes label name. */
+    name: string;
+    /** Operator specifies the relationship between a cluster's observed value of the specified property and the values given in the requirement. */
+    operator: PropertySelectorOperator;
+    /** Values are a list of values of the specified property which Fleet will compare against the observed values of individual member clusters in accordance with the given operator. At this moment, each value should be a Kubernetes quantity. For more information, see https://pkg.go.dev/k8s.io/apimachinery/pkg/api/resource#Quantity. If the operator is Gt (greater than), Ge (greater than or equal to), Lt (less than), or `Le` (less than or equal to), Eq (equal to), or Ne (ne), exactly one value must be specified in the list. */
+    values: string[];
+}
+export declare function propertySelectorRequirementSerializer(item: PropertySelectorRequirement): any;
+export declare function propertySelectorRequirementDeserializer(item: any): PropertySelectorRequirement;
+/** PropertySelectorOperator is the operator that can be used with PropertySelectorRequirements. */
+export declare enum KnownPropertySelectorOperator {
+    /** Gt dictates Fleet to select cluster if its observed value of a given property is greater than the value specified in the requirement. */
+    Gt = "Gt",
+    /** Ge dictates Fleet to select cluster if its observed value of a given property is greater than or equal to the value specified in the requirement. */
+    Ge = "Ge",
+    /** Eq dictates Fleet to select cluster if its observed value of a given property is equal to the values specified in the requirement. */
+    Eq = "Eq",
+    /** Ne dictates Fleet to select cluster if its observed value of a given property is not equal to the values specified in the requirement. */
+    Ne = "Ne",
+    /** Lt dictates Fleet to select cluster if its observed value of a given property is less than the value specified in the requirement. */
+    Lt = "Lt",
+    /** Le dictates Fleet to select cluster if its observed value of a given property is less than or equal to the value specified in the requirement. */
+    Le = "Le"
+}
+/**
+ * PropertySelectorOperator is the operator that can be used with PropertySelectorRequirements. \
+ * {@link KnownPropertySelectorOperator} can be used interchangeably with PropertySelectorOperator,
+ *  this enum contains the known values that the service supports.
+ * ### Known values supported by the service
+ * **Gt**: Gt dictates Fleet to select cluster if its observed value of a given property is greater than the value specified in the requirement. \
+ * **Ge**: Ge dictates Fleet to select cluster if its observed value of a given property is greater than or equal to the value specified in the requirement. \
+ * **Eq**: Eq dictates Fleet to select cluster if its observed value of a given property is equal to the values specified in the requirement. \
+ * **Ne**: Ne dictates Fleet to select cluster if its observed value of a given property is not equal to the values specified in the requirement. \
+ * **Lt**: Lt dictates Fleet to select cluster if its observed value of a given property is less than the value specified in the requirement. \
+ * **Le**: Le dictates Fleet to select cluster if its observed value of a given property is less than or equal to the value specified in the requirement.
+ */
+export type PropertySelectorOperator = string;
+export declare function tolerationArraySerializer(result: Array<Toleration>): any[];
+export declare function tolerationArrayDeserializer(result: Array<Toleration>): any[];
+/** Toleration allows ClusterResourcePlacement to tolerate any taint that matches the triple <key,value,effect> using the matching operator <operator>. */
+export interface Toleration {
+    /** Key is the taint key that the toleration applies to. Empty means match all taint keys. If the key is empty, operator must be Exists; this combination means to match all values and all keys. */
+    key?: string;
+    /** Operator represents a key's relationship to the value. Valid operators are Exists and Equal. Defaults to Equal. Exists is equivalent to wildcard for value, so that a ClusterResourcePlacement can tolerate all taints of a particular category. */
+    operator?: TolerationOperator;
+    /** Value is the taint value the toleration matches to. If the operator is Exists, the value should be empty, otherwise just a regular string. */
+    value?: string;
+    /** Effect indicates the taint effect to match. Empty means match all taint effects. When specified, only allowed value is NoSchedule. */
+    effect?: TaintEffect;
+}
+export declare function tolerationSerializer(item: Toleration): any;
+export declare function tolerationDeserializer(item: any): Toleration;
+/** A toleration operator is the set of operators that can be used in a toleration. */
+export declare enum KnownTolerationOperator {
+    /** Toleration Operator Exists */
+    Exists = "Exists",
+    /** Toleration Operator Equal */
+    Equal = "Equal"
+}
+/**
+ * A toleration operator is the set of operators that can be used in a toleration. \
+ * {@link KnownTolerationOperator} can be used interchangeably with TolerationOperator,
+ *  this enum contains the known values that the service supports.
+ * ### Known values supported by the service
+ * **Exists**: Toleration Operator Exists \
+ * **Equal**: Toleration Operator Equal
+ */
+export type TolerationOperator = string;
+/** TaintEffect */
+export declare enum KnownTaintEffect {
+    /** Do not allow new pods to schedule onto the node unless they tolerate the taint, but allow all pods submitted to Kubelet without going through the scheduler to start, and allow all already-running pods to continue running. Enforced by the scheduler. */
+    NoSchedule = "NoSchedule"
+}
+/**
+ * TaintEffect \
+ * {@link KnownTaintEffect} can be used interchangeably with TaintEffect,
+ *  this enum contains the known values that the service supports.
+ * ### Known values supported by the service
+ * **NoSchedule**: Do not allow new pods to schedule onto the node unless they tolerate the taint, but allow all pods submitted to Kubelet without going through the scheduler to start, and allow all already-running pods to continue running. Enforced by the scheduler.
+ */
+export type TaintEffect = string;
+/** Status information for the fleet managed namespace. */
+export interface FleetManagedNamespaceStatus {
+    /** The last operation ID for the fleet managed namespace */
+    readonly lastOperationId?: string;
+    /** The last operation error of the fleet managed namespace */
+    readonly lastOperationError?: ErrorDetail;
+}
+export declare function fleetManagedNamespaceStatusDeserializer(item: any): FleetManagedNamespaceStatus;
+/** The response of a FleetManagedNamespace list operation. */
+export interface _FleetManagedNamespaceListResult {
+    /** The FleetManagedNamespace items on this page */
+    value: FleetManagedNamespace[];
+    /** The link to the next page of items */
+    nextLink?: string;
+}
+export declare function _fleetManagedNamespaceListResultDeserializer(item: any): _FleetManagedNamespaceListResult;
+export declare function fleetManagedNamespaceArraySerializer(result: Array<FleetManagedNamespace>): any[];
+export declare function fleetManagedNamespaceArrayDeserializer(result: Array<FleetManagedNamespace>): any[];
+/** The properties of a fleet managed namespace that can be patched. */
+export interface FleetManagedNamespacePatch {
+    /** Resource tags. */
+    tags?: Record<string, string>;
+}
+export declare function fleetManagedNamespacePatchSerializer(item: FleetManagedNamespacePatch): any;
 /** A Gate controls the progression during a staged rollout, e.g. in an Update Run. */
 export interface Gate extends ProxyResource {
     /** The resource-specific properties for this resource. */
@@ -635,6 +1053,21 @@ export interface UpdateStage {
     groups?: UpdateGroup[];
     /** The time in seconds to wait at the end of this stage before starting the next one. Defaults to 0 seconds if unspecified. */
     afterStageWaitInSeconds?: number;
+    /**
+     * The max number of upgrades that can run concurrently across all groups in this stage.
+     * Acts as a ceiling (and not a quota) for the number of concurrent upgrades within the stage you want to tolerate at a time.
+     * Actual concurrency may be lower depending on group-level concurrency limits or individual member conditions.
+     * Stage maxConcurrency has a min value of "1".
+     * Accepts either:
+     *     • A fixed count, e.g., "3"
+     *     • A percentage, e.g., "25%" (range 1–100). Percentage is of the total number of clusters across all groups in the stage.
+     *       Fractional results are rounded down. A minimum of 1 upgrade is enforced.
+     * Examples:
+     *     • "3"     --> up to 3 clusters from this stage upgrade at once (across all groups).
+     *     • "100%"  --> “all at once”; up to all clusters in this stage upgrade at the same time.
+     *     • "25%"   --> up to 25% of the stage’s total clusters upgrade at the same time.
+     */
+    maxConcurrency?: string;
     /** A list of Gates that will be created before this Stage is executed. */
     beforeGates?: GateConfiguration[];
     /** A list of Gates that will be created after this Stage is executed. */
@@ -651,6 +1084,22 @@ export interface UpdateGroup {
      * It must match a group name of an existing fleet member.
      */
     name: string;
+    /**
+     * The max number of upgrades that can run concurrently in this specific group.
+     * Acts as a ceiling (and not a quota) for the number of concurrent upgrades within the group you want to tolerate at a time.
+     * Actual concurrency may be lower depending on stage-level concurrency limits or individual member conditions.
+     * Group maxConcurrency has a min value of "1". The max value is min(number of clusters in the group, the stage maxConcurrency).
+     * If no value is provided, defaults to 1.
+     * Accepts either:
+     *     • A fixed count, e.g. "3"
+     *     • A percentage, e.g. "25%" (range 1–100). Percentage is of the number of clusters in the group.
+     *       Fractional results are rounded down. A minimum of 1 upgrade is enforced.
+     * Examples:
+     *     • "3" --> up to 3 members from this group upgrade at once.
+     *     • "100%" --> “all at once”, up to all members for this group upgrade at the same time.
+     *     • "25%" --> up to 25% of the members in the group will be upgraded at the same time.
+     */
+    maxConcurrency?: string;
     /** A list of Gates that will be created before this Group is executed. */
     beforeGates?: GateConfiguration[];
     /** A list of Gates that will be created after this Group is executed. */
@@ -806,6 +1255,8 @@ export interface UpdateStageStatus {
     readonly status?: UpdateStatus;
     /** The name of the UpdateStage. */
     readonly name?: string;
+    /** The max number of upgrades that can run concurrently across all groups in this stage, resolved from the UpdateStrategy.UpdateStage.maxConcurrency value. */
+    readonly maxConcurrency?: number;
     /** The list of groups to be updated as part of this UpdateStage. */
     readonly groups?: UpdateGroupStatus[];
     /** The list of Gates that will run before this UpdateStage. */
@@ -823,6 +1274,8 @@ export interface UpdateGroupStatus {
     readonly status?: UpdateStatus;
     /** The name of the UpdateGroup. */
     readonly name?: string;
+    /**   The max number of upgrades that can run concurrently in this group, resolved from the UpdateStrategy.UpdateGroup.maxConcurrency value. If no value was provided, this value defaults to "1". */
+    readonly maxConcurrency?: number;
     /** The list of member this UpdateGroup updates. */
     readonly members?: MemberUpdateStatus[];
     /** The list of Gates that will run before this UpdateGroup. */
@@ -1155,6 +1608,20 @@ export declare enum KnownVersions {
     /** Azure Kubernetes Fleet Manager api version 2025-03-01. */
     V20250301 = "2025-03-01",
     /** Azure Kubernetes Fleet Manager api version 2025-04-01-preview. */
-    V20250401Preview = "2025-04-01-preview"
-}
+    V20250401Preview = "2025-04-01-preview",
+    /** Azure Kubernetes Fleet Manager api version 2025-08-01-preview. */
+    V20250801Preview = "2025-08-01-preview",
+    /** Azure Kubernetes Fleet Manager api version 2026-02-01-preview. */
+    V20260201Preview = "2026-02-01-preview"
+}
+export declare function _fleetManagedNamespacePropertiesSerializer(item: FleetManagedNamespace): any;
+export declare function _fleetManagedNamespacePropertiesDeserializer(item: any): {
+    provisioningState: any;
+    managedNamespaceProperties: any;
+    adoptionPolicy: any;
+    deletePolicy: any;
+    propagationPolicy: any;
+    status: any;
+    portalFqdn: any;
+};
 //# sourceMappingURL=models.d.ts.map