@azure/arm-frontdoor 5.1.1-alpha.20230511.1 → 5.2.0

package/src/models/mappers.ts

@@ -8,10 +8,10 @@
 
 import * as coreClient from "@azure/core-client";
 
-export const ProfileList: coreClient.CompositeMapper = {
+export const WebApplicationFirewallPolicyList: coreClient.CompositeMapper = {
   type: {
     name: "Composite",
-    className: "ProfileList",
+    className: "WebApplicationFirewallPolicyList",
     modelProperties: {
       value: {
         serializedName: "value",
@@ -21,7 +21,7 @@ export const ProfileList: coreClient.CompositeMapper = {
           element: {
             type: {
               name: "Composite",
-              className: "Profile"
+              className: "WebApplicationFirewallPolicy"
             }
           }
         }
@@ -36,114 +36,146 @@ export const ProfileList: coreClient.CompositeMapper = {
   }
 };
 
-export const Resource: coreClient.CompositeMapper = {
+export const PolicySettings: coreClient.CompositeMapper = {
   type: {
     name: "Composite",
-    className: "Resource",
+    className: "PolicySettings",
     modelProperties: {
-      id: {
-        serializedName: "id",
-        readOnly: true,
+      enabledState: {
+        serializedName: "enabledState",
         type: {
           name: "String"
         }
       },
-      name: {
-        serializedName: "name",
-        readOnly: true,
+      mode: {
+        serializedName: "mode",
         type: {
           name: "String"
         }
       },
-      type: {
-        serializedName: "type",
-        readOnly: true,
+      redirectUrl: {
+        serializedName: "redirectUrl",
         type: {
           name: "String"
         }
       },
-      location: {
-        serializedName: "location",
+      customBlockResponseStatusCode: {
+        serializedName: "customBlockResponseStatusCode",
+        type: {
+          name: "Number"
+        }
+      },
+      customBlockResponseBody: {
+        constraints: {
+          Pattern: new RegExp(
+            "^(?:[A-Za-z0-9+/]{4})*(?:[A-Za-z0-9+/]{2}==|[A-Za-z0-9+/]{3}=|[A-Za-z0-9+/]{4})$"
+          )
+        },
+        serializedName: "customBlockResponseBody",
         type: {
           name: "String"
         }
       },
-      tags: {
-        serializedName: "tags",
+      requestBodyCheck: {
+        serializedName: "requestBodyCheck",
         type: {
-          name: "Dictionary",
-          value: { type: { name: "String" } }
+          name: "String"
         }
       }
     }
   }
 };
 
-export const ErrorResponse: coreClient.CompositeMapper = {
+export const CustomRuleList: coreClient.CompositeMapper = {
   type: {
     name: "Composite",
-    className: "ErrorResponse",
+    className: "CustomRuleList",
     modelProperties: {
-      code: {
-        serializedName: "code",
-        readOnly: true,
-        type: {
-          name: "String"
-        }
-      },
-      message: {
-        serializedName: "message",
-        readOnly: true,
+      rules: {
+        serializedName: "rules",
         type: {
-          name: "String"
+          name: "Sequence",
+          element: {
+            type: {
+              name: "Composite",
+              className: "CustomRule"
+            }
+          }
         }
       }
     }
   }
 };
 
-export const ProfileUpdateModel: coreClient.CompositeMapper = {
+export const CustomRule: coreClient.CompositeMapper = {
   type: {
     name: "Composite",
-    className: "ProfileUpdateModel",
+    className: "CustomRule",
     modelProperties: {
-      tags: {
-        serializedName: "tags",
+      name: {
+        constraints: {
+          MaxLength: 128
+        },
+        serializedName: "name",
         type: {
-          name: "Dictionary",
-          value: { type: { name: "String" } }
+          name: "String"
+        }
+      },
+      priority: {
+        serializedName: "priority",
+        required: true,
+        type: {
+          name: "Number"
         }
       },
       enabledState: {
-        serializedName: "properties.enabledState",
+        serializedName: "enabledState",
         type: {
           name: "String"
         }
-      }
-    }
-  }
-};
-
-export const PreconfiguredEndpointList: coreClient.CompositeMapper = {
-  type: {
-    name: "Composite",
-    className: "PreconfiguredEndpointList",
-    modelProperties: {
-      value: {
-        serializedName: "value",
-        readOnly: true,
+      },
+      ruleType: {
+        serializedName: "ruleType",
+        required: true,
+        type: {
+          name: "String"
+        }
+      },
+      rateLimitDurationInMinutes: {
+        constraints: {
+          InclusiveMaximum: 5,
+          InclusiveMinimum: 0
+        },
+        serializedName: "rateLimitDurationInMinutes",
+        type: {
+          name: "Number"
+        }
+      },
+      rateLimitThreshold: {
+        constraints: {
+          InclusiveMinimum: 0
+        },
+        serializedName: "rateLimitThreshold",
+        type: {
+          name: "Number"
+        }
+      },
+      matchConditions: {
+        serializedName: "matchConditions",
+        required: true,
         type: {
           name: "Sequence",
           element: {
             type: {
               name: "Composite",
-              className: "PreconfiguredEndpoint"
+              className: "MatchCondition"
             }
           }
         }
       },
-      nextLink: {
-        serializedName: "nextLink",
+      action: {
+        serializedName: "action",
+        required: true,
         type: {
           name: "String"
         }
@@ -152,232 +184,285 @@ export const PreconfiguredEndpointList: coreClient.CompositeMapper = {
   }
 };
 
-export const ExperimentList: coreClient.CompositeMapper = {
+export const MatchCondition: coreClient.CompositeMapper = {
   type: {
     name: "Composite",
-    className: "ExperimentList",
+    className: "MatchCondition",
     modelProperties: {
-      value: {
-        serializedName: "value",
-        readOnly: true,
+      matchVariable: {
+        serializedName: "matchVariable",
+        required: true,
+        type: {
+          name: "String"
+        }
+      },
+      selector: {
+        serializedName: "selector",
+        type: {
+          name: "String"
+        }
+      },
+      operator: {
+        serializedName: "operator",
+        required: true,
+        type: {
+          name: "String"
+        }
+      },
+      negateCondition: {
+        serializedName: "negateCondition",
+        type: {
+          name: "Boolean"
+        }
+      },
+      matchValue: {
+        serializedName: "matchValue",
+        required: true,
         type: {
           name: "Sequence",
           element: {
             type: {
-              name: "Composite",
-              className: "Experiment"
+              name: "String"
             }
           }
         }
       },
-      nextLink: {
-        serializedName: "nextLink",
+      transforms: {
+        serializedName: "transforms",
         type: {
-          name: "String"
+          name: "Sequence",
+          element: {
+            type: {
+              name: "String"
+            }
+          }
         }
       }
     }
   }
 };
 
-export const Endpoint: coreClient.CompositeMapper = {
+export const ManagedRuleSetList: coreClient.CompositeMapper = {
   type: {
     name: "Composite",
-    className: "Endpoint",
+    className: "ManagedRuleSetList",
     modelProperties: {
-      name: {
-        serializedName: "name",
-        type: {
-          name: "String"
-        }
-      },
-      endpoint: {
-        serializedName: "endpoint",
+      managedRuleSets: {
+        serializedName: "managedRuleSets",
         type: {
-          name: "String"
+          name: "Sequence",
+          element: {
+            type: {
+              name: "Composite",
+              className: "ManagedRuleSet"
+            }
+          }
         }
       }
     }
   }
 };
 
-export const ExperimentUpdateModel: coreClient.CompositeMapper = {
+export const ManagedRuleSet: coreClient.CompositeMapper = {
   type: {
     name: "Composite",
-    className: "ExperimentUpdateModel",
+    className: "ManagedRuleSet",
     modelProperties: {
-      tags: {
-        serializedName: "tags",
-        type: {
-          name: "Dictionary",
-          value: { type: { name: "String" } }
-        }
-      },
-      description: {
-        serializedName: "properties.description",
+      ruleSetType: {
+        serializedName: "ruleSetType",
+        required: true,
         type: {
           name: "String"
         }
       },
-      enabledState: {
-        serializedName: "properties.enabledState",
+      ruleSetVersion: {
+        serializedName: "ruleSetVersion",
+        required: true,
         type: {
           name: "String"
         }
-      }
-    }
-  }
-};
-
-export const LatencyMetric: coreClient.CompositeMapper = {
-  type: {
-    name: "Composite",
-    className: "LatencyMetric",
-    modelProperties: {
-      name: {
-        serializedName: "name",
-        readOnly: true,
+      },
+      ruleSetAction: {
+        serializedName: "ruleSetAction",
         type: {
           name: "String"
         }
       },
-      endDateTimeUTC: {
-        serializedName: "endDateTimeUTC",
-        readOnly: true,
-        type: {
-          name: "String"
-        }
-      },
-      aValue: {
-        serializedName: "aValue",
-        readOnly: true,
+      exclusions: {
+        serializedName: "exclusions",
         type: {
-          name: "Number"
+          name: "Sequence",
+          element: {
+            type: {
+              name: "Composite",
+              className: "ManagedRuleExclusion"
+            }
+          }
         }
       },
-      bValue: {
-        serializedName: "bValue",
-        readOnly: true,
+      ruleGroupOverrides: {
+        serializedName: "ruleGroupOverrides",
         type: {
-          name: "Number"
+          name: "Sequence",
+          element: {
+            type: {
+              name: "Composite",
+              className: "ManagedRuleGroupOverride"
+            }
+          }
         }
-      },
-      delta: {
-        serializedName: "delta",
-        readOnly: true,
+      }
+    }
+  }
+};
+
+export const ManagedRuleExclusion: coreClient.CompositeMapper = {
+  type: {
+    name: "Composite",
+    className: "ManagedRuleExclusion",
+    modelProperties: {
+      matchVariable: {
+        serializedName: "matchVariable",
+        required: true,
         type: {
-          name: "Number"
+          name: "String"
         }
       },
-      deltaPercent: {
-        serializedName: "deltaPercent",
-        readOnly: true,
+      selectorMatchOperator: {
+        serializedName: "selectorMatchOperator",
+        required: true,
         type: {
-          name: "Number"
+          name: "String"
         }
       },
-      aCLower95CI: {
-        serializedName: "aCLower95CI",
-        readOnly: true,
+      selector: {
+        serializedName: "selector",
+        required: true,
         type: {
-          name: "Number"
+          name: "String"
         }
-      },
-      aHUpper95CI: {
-        serializedName: "aHUpper95CI",
-        readOnly: true,
+      }
+    }
+  }
+};
+
+export const ManagedRuleGroupOverride: coreClient.CompositeMapper = {
+  type: {
+    name: "Composite",
+    className: "ManagedRuleGroupOverride",
+    modelProperties: {
+      ruleGroupName: {
+        serializedName: "ruleGroupName",
+        required: true,
         type: {
-          name: "Number"
+          name: "String"
         }
       },
-      bCLower95CI: {
-        serializedName: "bCLower95CI",
-        readOnly: true,
+      exclusions: {
+        serializedName: "exclusions",
         type: {
-          name: "Number"
+          name: "Sequence",
+          element: {
+            type: {
+              name: "Composite",
+              className: "ManagedRuleExclusion"
+            }
+          }
         }
       },
-      bUpper95CI: {
-        serializedName: "bUpper95CI",
-        readOnly: true,
+      rules: {
+        serializedName: "rules",
         type: {
-          name: "Number"
+          name: "Sequence",
+          element: {
+            type: {
+              name: "Composite",
+              className: "ManagedRuleOverride"
+            }
+          }
         }
       }
     }
   }
 };
 
-export const TimeseriesDataPoint: coreClient.CompositeMapper = {
+export const ManagedRuleOverride: coreClient.CompositeMapper = {
   type: {
     name: "Composite",
-    className: "TimeseriesDataPoint",
+    className: "ManagedRuleOverride",
     modelProperties: {
-      dateTimeUTC: {
-        serializedName: "dateTimeUTC",
+      ruleId: {
+        serializedName: "ruleId",
+        required: true,
         type: {
           name: "String"
         }
       },
-      value: {
-        serializedName: "value",
+      enabledState: {
+        serializedName: "enabledState",
         type: {
-          name: "Number"
+          name: "String"
+        }
+      },
+      action: {
+        serializedName: "action",
+        type: {
+          name: "String"
+        }
+      },
+      exclusions: {
+        serializedName: "exclusions",
+        type: {
+          name: "Sequence",
+          element: {
+            type: {
+              name: "Composite",
+              className: "ManagedRuleExclusion"
+            }
+          }
         }
       }
     }
   }
 };
 
-export const CheckNameAvailabilityInput: coreClient.CompositeMapper = {
+export const FrontendEndpointLink: coreClient.CompositeMapper = {
   type: {
     name: "Composite",
-    className: "CheckNameAvailabilityInput",
+    className: "FrontendEndpointLink",
     modelProperties: {
-      name: {
-        serializedName: "name",
-        required: true,
+      id: {
+        serializedName: "id",
         type: {
           name: "String"
         }
-      },
-      type: {
-        serializedName: "type",
-        required: true,
-        type: {
-          name: "Enum",
-          allowedValues: [
-            "Microsoft.Network/frontDoors",
-            "Microsoft.Network/frontDoors/frontendEndpoints"
-          ]
-        }
       }
     }
   }
 };
 
-export const CheckNameAvailabilityOutput: coreClient.CompositeMapper = {
+export const RoutingRuleLink: coreClient.CompositeMapper = {
   type: {
     name: "Composite",
-    className: "CheckNameAvailabilityOutput",
+    className: "RoutingRuleLink",
     modelProperties: {
-      nameAvailability: {
-        serializedName: "nameAvailability",
-        readOnly: true,
-        type: {
-          name: "String"
-        }
-      },
-      reason: {
-        serializedName: "reason",
-        readOnly: true,
+      id: {
+        serializedName: "id",
         type: {
           name: "String"
         }
-      },
-      message: {
-        serializedName: "message",
-        readOnly: true,
+      }
+    }
+  }
+};
+
+export const SecurityPolicyLink: coreClient.CompositeMapper = {
+  type: {
+    name: "Composite",
+    className: "SecurityPolicyLink",
+    modelProperties: {
+      id: {
+        serializedName: "id",
         type: {
           name: "String"
         }
@@ -386,26 +471,13 @@ export const CheckNameAvailabilityOutput: coreClient.CompositeMapper = {
   }
 };
 
-export const FrontDoorListResult: coreClient.CompositeMapper = {
+export const Sku: coreClient.CompositeMapper = {
   type: {
     name: "Composite",
-    className: "FrontDoorListResult",
+    className: "Sku",
     modelProperties: {
-      value: {
-        serializedName: "value",
-        readOnly: true,
-        type: {
-          name: "Sequence",
-          element: {
-            type: {
-              name: "Composite",
-              className: "FrontDoor"
-            }
-          }
-        }
-      },
-      nextLink: {
-        serializedName: "nextLink",
+      name: {
+        serializedName: "name",
         type: {
           name: "String"
         }
@@ -414,116 +486,147 @@ export const FrontDoorListResult: coreClient.CompositeMapper = {
   }
 };
 
-export const RulesEngine: coreClient.CompositeMapper = {
+export const Resource: coreClient.CompositeMapper = {
   type: {
     name: "Composite",
-    className: "RulesEngine",
+    className: "Resource",
     modelProperties: {
-      name: {
-        serializedName: "name",
+      id: {
+        serializedName: "id",
         readOnly: true,
         type: {
           name: "String"
         }
       },
-      type: {
-        serializedName: "type",
+      name: {
+        serializedName: "name",
         readOnly: true,
         type: {
           name: "String"
         }
       },
-      id: {
-        serializedName: "id",
+      type: {
+        serializedName: "type",
         readOnly: true,
         type: {
           name: "String"
         }
       },
-      rules: {
-        serializedName: "properties.rules",
+      location: {
+        serializedName: "location",
         type: {
-          name: "Sequence",
-          element: {
-            type: {
-              name: "Composite",
-              className: "RulesEngineRule"
-            }
-          }
+          name: "String"
         }
       },
-      resourceState: {
-        serializedName: "properties.resourceState",
-        readOnly: true,
+      tags: {
+        serializedName: "tags",
         type: {
-          name: "String"
+          name: "Dictionary",
+          value: { type: { name: "String" } }
         }
       }
     }
   }
 };
 
-export const RulesEngineUpdateParameters: coreClient.CompositeMapper = {
+export const ErrorResponse: coreClient.CompositeMapper = {
   type: {
     name: "Composite",
-    className: "RulesEngineUpdateParameters",
+    className: "ErrorResponse",
     modelProperties: {
-      rules: {
-        serializedName: "rules",
+      code: {
+        serializedName: "code",
+        readOnly: true,
         type: {
-          name: "Sequence",
-          element: {
-            type: {
-              name: "Composite",
-              className: "RulesEngineRule"
-            }
-          }
+          name: "String"
+        }
+      },
+      message: {
+        serializedName: "message",
+        readOnly: true,
+        type: {
+          name: "String"
         }
       }
     }
   }
 };
 
-export const RulesEngineRule: coreClient.CompositeMapper = {
+export const DefaultErrorResponse: coreClient.CompositeMapper = {
   type: {
     name: "Composite",
-    className: "RulesEngineRule",
+    className: "DefaultErrorResponse",
     modelProperties: {
-      name: {
-        serializedName: "name",
-        required: true,
+      error: {
+        serializedName: "error",
+        type: {
+          name: "Composite",
+          className: "DefaultErrorResponseError"
+        }
+      }
+    }
+  }
+};
+
+export const DefaultErrorResponseError: coreClient.CompositeMapper = {
+  type: {
+    name: "Composite",
+    className: "DefaultErrorResponseError",
+    modelProperties: {
+      code: {
+        serializedName: "code",
+        readOnly: true,
         type: {
           name: "String"
         }
       },
-      priority: {
-        serializedName: "priority",
-        required: true,
+      message: {
+        serializedName: "message",
+        readOnly: true,
         type: {
-          name: "Number"
+          name: "String"
         }
-      },
-      action: {
-        serializedName: "action",
+      }
+    }
+  }
+};
+
+export const TagsObject: coreClient.CompositeMapper = {
+  type: {
+    name: "Composite",
+    className: "TagsObject",
+    modelProperties: {
+      tags: {
+        serializedName: "tags",
         type: {
-          name: "Composite",
-          className: "RulesEngineAction"
+          name: "Dictionary",
+          value: { type: { name: "String" } }
         }
-      },
-      matchConditions: {
-        serializedName: "matchConditions",
+      }
+    }
+  }
+};
+
+export const ManagedRuleSetDefinitionList: coreClient.CompositeMapper = {
+  type: {
+    name: "Composite",
+    className: "ManagedRuleSetDefinitionList",
+    modelProperties: {
+      value: {
+        serializedName: "value",
+        readOnly: true,
         type: {
           name: "Sequence",
           element: {
             type: {
               name: "Composite",
-              className: "RulesEngineMatchCondition"
+              className: "ManagedRuleSetDefinition"
             }
           }
         }
       },
-      matchProcessingBehavior: {
-        serializedName: "matchProcessingBehavior",
+      nextLink: {
+        serializedName: "nextLink",
         type: {
           name: "String"
         }
@@ -532,67 +635,71 @@ export const RulesEngineRule: coreClient.CompositeMapper = {
   }
 };
 
-export const RulesEngineAction: coreClient.CompositeMapper = {
+export const ManagedRuleGroupDefinition: coreClient.CompositeMapper = {
   type: {
     name: "Composite",
-    className: "RulesEngineAction",
+    className: "ManagedRuleGroupDefinition",
     modelProperties: {
-      requestHeaderActions: {
-        serializedName: "requestHeaderActions",
+      ruleGroupName: {
+        serializedName: "ruleGroupName",
+        readOnly: true,
         type: {
-          name: "Sequence",
-          element: {
-            type: {
-              name: "Composite",
-              className: "HeaderAction"
-            }
-          }
+          name: "String"
         }
       },
-      responseHeaderActions: {
-        serializedName: "responseHeaderActions",
+      description: {
+        serializedName: "description",
+        readOnly: true,
+        type: {
+          name: "String"
+        }
+      },
+      rules: {
+        serializedName: "rules",
+        readOnly: true,
         type: {
           name: "Sequence",
           element: {
             type: {
               name: "Composite",
-              className: "HeaderAction"
+              className: "ManagedRuleDefinition"
             }
           }
         }
-      },
-      routeConfigurationOverride: {
-        serializedName: "routeConfigurationOverride",
-        type: {
-          name: "Composite",
-          className: "RouteConfiguration"
-        }
       }
     }
   }
 };
 
-export const HeaderAction: coreClient.CompositeMapper = {
+export const ManagedRuleDefinition: coreClient.CompositeMapper = {
   type: {
     name: "Composite",
-    className: "HeaderAction",
+    className: "ManagedRuleDefinition",
     modelProperties: {
-      headerActionType: {
-        serializedName: "headerActionType",
-        required: true,
+      ruleId: {
+        serializedName: "ruleId",
+        readOnly: true,
         type: {
           name: "String"
         }
       },
-      headerName: {
-        serializedName: "headerName",
-        required: true,
+      defaultState: {
+        serializedName: "defaultState",
+        readOnly: true,
         type: {
           name: "String"
         }
       },
-      value: {
-        serializedName: "value",
+      defaultAction: {
+        serializedName: "defaultAction",
+        readOnly: true,
+        type: {
+          name: "String"
+        }
+      },
+      description: {
+        serializedName: "description",
+        readOnly: true,
         type: {
           name: "String"
         }
@@ -601,165 +708,132 @@ export const HeaderAction: coreClient.CompositeMapper = {
   }
 };
 
-export const RouteConfiguration: coreClient.CompositeMapper = {
+export const CheckNameAvailabilityInput: coreClient.CompositeMapper = {
   type: {
     name: "Composite",
-    className: "RouteConfiguration",
-    uberParent: "RouteConfiguration",
-    polymorphicDiscriminator: {
-      serializedName: "@odata\\.type",
-      clientName: "odataType"
-    },
+    className: "CheckNameAvailabilityInput",
     modelProperties: {
-      odataType: {
-        serializedName: "@odata\\.type",
+      name: {
+        serializedName: "name",
         required: true,
         type: {
           name: "String"
         }
+      },
+      type: {
+        serializedName: "type",
+        required: true,
+        type: {
+          name: "Enum",
+          allowedValues: [
+            "Microsoft.Network/frontDoors",
+            "Microsoft.Network/frontDoors/frontendEndpoints"
+          ]
+        }
       }
     }
   }
 };
 
-export const RulesEngineMatchCondition: coreClient.CompositeMapper = {
+export const CheckNameAvailabilityOutput: coreClient.CompositeMapper = {
   type: {
     name: "Composite",
-    className: "RulesEngineMatchCondition",
+    className: "CheckNameAvailabilityOutput",
     modelProperties: {
-      rulesEngineMatchVariable: {
-        serializedName: "rulesEngineMatchVariable",
-        required: true,
+      nameAvailability: {
+        serializedName: "nameAvailability",
+        readOnly: true,
         type: {
           name: "String"
         }
       },
-      selector: {
-        serializedName: "selector",
+      reason: {
+        serializedName: "reason",
+        readOnly: true,
         type: {
           name: "String"
         }
       },
-      rulesEngineOperator: {
-        serializedName: "rulesEngineOperator",
-        required: true,
+      message: {
+        serializedName: "message",
+        readOnly: true,
         type: {
           name: "String"
         }
-      },
-      negateCondition: {
-        serializedName: "negateCondition",
-        type: {
-          name: "Boolean"
-        }
-      },
-      rulesEngineMatchValue: {
-        serializedName: "rulesEngineMatchValue",
-        required: true,
+      }
+    }
+  }
+};
+
+export const FrontDoorListResult: coreClient.CompositeMapper = {
+  type: {
+    name: "Composite",
+    className: "FrontDoorListResult",
+    modelProperties: {
+      value: {
+        serializedName: "value",
+        readOnly: true,
         type: {
           name: "Sequence",
           element: {
             type: {
-              name: "String"
+              name: "Composite",
+              className: "FrontDoor"
             }
           }
         }
       },
-      transforms: {
-        serializedName: "transforms",
+      nextLink: {
+        serializedName: "nextLink",
         type: {
-          name: "Sequence",
-          element: {
-            type: {
-              name: "String"
-            }
-          }
+          name: "String"
         }
       }
     }
   }
 };
 
-export const FrontDoorUpdateParameters: coreClient.CompositeMapper = {
+export const RulesEngine: coreClient.CompositeMapper = {
   type: {
     name: "Composite",
-    className: "FrontDoorUpdateParameters",
+    className: "RulesEngine",
     modelProperties: {
-      friendlyName: {
-        serializedName: "friendlyName",
+      name: {
+        serializedName: "name",
+        readOnly: true,
         type: {
           name: "String"
         }
       },
-      routingRules: {
-        serializedName: "routingRules",
+      type: {
+        serializedName: "type",
+        readOnly: true,
         type: {
-          name: "Sequence",
-          element: {
-            type: {
-              name: "Composite",
-              className: "RoutingRule"
-            }
-          }
-        }
-      },
-      loadBalancingSettings: {
-        serializedName: "loadBalancingSettings",
-        type: {
-          name: "Sequence",
-          element: {
-            type: {
-              name: "Composite",
-              className: "LoadBalancingSettingsModel"
-            }
-          }
-        }
-      },
-      healthProbeSettings: {
-        serializedName: "healthProbeSettings",
-        type: {
-          name: "Sequence",
-          element: {
-            type: {
-              name: "Composite",
-              className: "HealthProbeSettingsModel"
-            }
-          }
+          name: "String"
         }
       },
-      backendPools: {
-        serializedName: "backendPools",
+      id: {
+        serializedName: "id",
+        readOnly: true,
         type: {
-          name: "Sequence",
-          element: {
-            type: {
-              name: "Composite",
-              className: "BackendPool"
-            }
-          }
+          name: "String"
         }
       },
-      frontendEndpoints: {
-        serializedName: "frontendEndpoints",
+      rules: {
+        serializedName: "properties.rules",
         type: {
           name: "Sequence",
           element: {
             type: {
               name: "Composite",
-              className: "FrontendEndpoint"
+              className: "RulesEngineRule"
             }
           }
         }
       },
-      backendPoolsSettings: {
-        serializedName: "backendPoolsSettings",
-        type: {
-          name: "Composite",
-          className: "BackendPoolsSettings"
-        }
-      },
-      enabledState: {
-        serializedName: "enabledState",
+      resourceState: {
+        serializedName: "properties.resourceState",
+        readOnly: true,
         type: {
           name: "String"
         }
@@ -768,166 +842,67 @@ export const FrontDoorUpdateParameters: coreClient.CompositeMapper = {
   }
 };
 
-export const RoutingRuleUpdateParameters: coreClient.CompositeMapper = {
+export const RulesEngineUpdateParameters: coreClient.CompositeMapper = {
   type: {
     name: "Composite",
-    className: "RoutingRuleUpdateParameters",
+    className: "RulesEngineUpdateParameters",
     modelProperties: {
-      frontendEndpoints: {
-        serializedName: "frontendEndpoints",
+      rules: {
+        serializedName: "rules",
         type: {
           name: "Sequence",
           element: {
             type: {
               name: "Composite",
-              className: "SubResource"
-            }
-          }
-        }
-      },
-      acceptedProtocols: {
-        serializedName: "acceptedProtocols",
-        type: {
-          name: "Sequence",
-          element: {
-            type: {
-              name: "String"
-            }
-          }
-        }
-      },
-      patternsToMatch: {
-        serializedName: "patternsToMatch",
-        type: {
-          name: "Sequence",
-          element: {
-            type: {
-              name: "String"
+              className: "RulesEngineRule"
             }
           }
         }
-      },
-      enabledState: {
-        serializedName: "enabledState",
-        type: {
-          name: "String"
-        }
-      },
-      routeConfiguration: {
-        serializedName: "routeConfiguration",
-        type: {
-          name: "Composite",
-          className: "RouteConfiguration"
-        }
-      },
-      rulesEngine: {
-        serializedName: "rulesEngine",
-        type: {
-          name: "Composite",
-          className: "SubResource"
-        }
-      },
-      webApplicationFirewallPolicyLink: {
-        serializedName: "webApplicationFirewallPolicyLink",
-        type: {
-          name: "Composite",
-          className:
-            "RoutingRuleUpdateParametersWebApplicationFirewallPolicyLink"
-        }
       }
     }
   }
 };
 
-export const SubResource: coreClient.CompositeMapper = {
-  type: {
-    name: "Composite",
-    className: "SubResource",
-    modelProperties: {
-      id: {
-        serializedName: "id",
-        type: {
-          name: "String"
-        }
-      }
-    }
-  }
-};
-
-export const RoutingRuleUpdateParametersWebApplicationFirewallPolicyLink: coreClient.CompositeMapper = {
+export const RulesEngineRule: coreClient.CompositeMapper = {
   type: {
     name: "Composite",
-    className: "RoutingRuleUpdateParametersWebApplicationFirewallPolicyLink",
+    className: "RulesEngineRule",
     modelProperties: {
-      id: {
-        serializedName: "id",
+      name: {
+        serializedName: "name",
+        required: true,
         type: {
           name: "String"
         }
-      }
-    }
-  }
-};
-
-export const LoadBalancingSettingsUpdateParameters: coreClient.CompositeMapper = {
-  type: {
-    name: "Composite",
-    className: "LoadBalancingSettingsUpdateParameters",
-    modelProperties: {
-      sampleSize: {
-        serializedName: "sampleSize",
-        type: {
-          name: "Number"
-        }
       },
-      successfulSamplesRequired: {
-        serializedName: "successfulSamplesRequired",
+      priority: {
+        serializedName: "priority",
+        required: true,
         type: {
           name: "Number"
         }
       },
-      additionalLatencyMilliseconds: {
-        serializedName: "additionalLatencyMilliseconds",
-        type: {
-          name: "Number"
-        }
-      }
-    }
-  }
-};
-
-export const HealthProbeSettingsUpdateParameters: coreClient.CompositeMapper = {
-  type: {
-    name: "Composite",
-    className: "HealthProbeSettingsUpdateParameters",
-    modelProperties: {
-      path: {
-        serializedName: "path",
-        type: {
-          name: "String"
-        }
-      },
-      protocol: {
-        serializedName: "protocol",
-        type: {
-          name: "String"
-        }
-      },
-      intervalInSeconds: {
-        serializedName: "intervalInSeconds",
+      action: {
+        serializedName: "action",
         type: {
-          name: "Number"
+          name: "Composite",
+          className: "RulesEngineAction"
         }
       },
-      healthProbeMethod: {
-        defaultValue: "HEAD",
-        serializedName: "healthProbeMethod",
+      matchConditions: {
+        serializedName: "matchConditions",
         type: {
-          name: "String"
+          name: "Sequence",
+          element: {
+            type: {
+              name: "Composite",
+              className: "RulesEngineMatchCondition"
+            }
+          }
         }
       },
-      enabledState: {
-        serializedName: "enabledState",
+      matchProcessingBehavior: {
+        serializedName: "matchProcessingBehavior",
         type: {
           name: "String"
         }
@@ -936,131 +911,67 @@ export const HealthProbeSettingsUpdateParameters: coreClient.CompositeMapper = {
   }
 };
 
-export const BackendPoolUpdateParameters: coreClient.CompositeMapper = {
+export const RulesEngineAction: coreClient.CompositeMapper = {
   type: {
     name: "Composite",
-    className: "BackendPoolUpdateParameters",
+    className: "RulesEngineAction",
     modelProperties: {
-      backends: {
-        serializedName: "backends",
+      requestHeaderActions: {
+        serializedName: "requestHeaderActions",
         type: {
           name: "Sequence",
           element: {
             type: {
               name: "Composite",
-              className: "Backend"
+              className: "HeaderAction"
             }
           }
         }
       },
-      loadBalancingSettings: {
-        serializedName: "loadBalancingSettings",
+      responseHeaderActions: {
+        serializedName: "responseHeaderActions",
         type: {
-          name: "Composite",
-          className: "SubResource"
+          name: "Sequence",
+          element: {
+            type: {
+              name: "Composite",
+              className: "HeaderAction"
+            }
+          }
         }
       },
-      healthProbeSettings: {
-        serializedName: "healthProbeSettings",
+      routeConfigurationOverride: {
+        serializedName: "routeConfigurationOverride",
         type: {
           name: "Composite",
-          className: "SubResource"
+          className: "RouteConfiguration"
         }
       }
     }
   }
 };
 
-export const Backend: coreClient.CompositeMapper = {
+export const HeaderAction: coreClient.CompositeMapper = {
   type: {
     name: "Composite",
-    className: "Backend",
+    className: "HeaderAction",
     modelProperties: {
-      address: {
-        serializedName: "address",
-        type: {
-          name: "String"
-        }
-      },
-      privateLinkAlias: {
-        serializedName: "privateLinkAlias",
-        type: {
-          name: "String"
-        }
-      },
-      privateLinkResourceId: {
-        serializedName: "privateLinkResourceId",
-        type: {
-          name: "String"
-        }
-      },
-      privateLinkLocation: {
-        serializedName: "privateLinkLocation",
-        type: {
-          name: "String"
-        }
-      },
-      privateEndpointStatus: {
-        serializedName: "privateEndpointStatus",
-        readOnly: true,
-        type: {
-          name: "String"
-        }
-      },
-      privateLinkApprovalMessage: {
-        serializedName: "privateLinkApprovalMessage",
+      headerActionType: {
+        serializedName: "headerActionType",
+        required: true,
         type: {
           name: "String"
         }
       },
-      httpPort: {
-        constraints: {
-          InclusiveMaximum: 65535,
-          InclusiveMinimum: 1
-        },
-        serializedName: "httpPort",
-        type: {
-          name: "Number"
-        }
-      },
-      httpsPort: {
-        constraints: {
-          InclusiveMaximum: 65535,
-          InclusiveMinimum: 1
-        },
-        serializedName: "httpsPort",
-        type: {
-          name: "Number"
-        }
-      },
-      enabledState: {
-        serializedName: "enabledState",
+      headerName: {
+        serializedName: "headerName",
+        required: true,
         type: {
           name: "String"
         }
       },
-      priority: {
-        constraints: {
-          InclusiveMaximum: 5,
-          InclusiveMinimum: 1
-        },
-        serializedName: "priority",
-        type: {
-          name: "Number"
-        }
-      },
-      weight: {
-        constraints: {
-          InclusiveMaximum: 1000,
-          InclusiveMinimum: 1
-        },
-        serializedName: "weight",
-        type: {
-          name: "Number"
-        }
-      },
-      backendHostHeader: {
-        serializedName: "backendHostHeader",
+      value: {
+        serializedName: "value",
         type: {
           name: "String"
         }
@@ -1069,188 +980,203 @@ export const Backend: coreClient.CompositeMapper = {
   }
 };
 
-export const CustomHttpsConfiguration: coreClient.CompositeMapper = {
+export const RouteConfiguration: coreClient.CompositeMapper = {
   type: {
     name: "Composite",
-    className: "CustomHttpsConfiguration",
+    className: "RouteConfiguration",
+    uberParent: "RouteConfiguration",
+    polymorphicDiscriminator: {
+      serializedName: "@odata\\.type",
+      clientName: "odataType"
+    },
     modelProperties: {
-      certificateSource: {
-        serializedName: "certificateSource",
+      odataType: {
+        serializedName: "@odata\\.type",
         required: true,
         type: {
           name: "String"
         }
-      },
-      protocolType: {
-        serializedName: "protocolType",
+      }
+    }
+  }
+};
+
+export const RulesEngineMatchCondition: coreClient.CompositeMapper = {
+  type: {
+    name: "Composite",
+    className: "RulesEngineMatchCondition",
+    modelProperties: {
+      rulesEngineMatchVariable: {
+        serializedName: "rulesEngineMatchVariable",
         required: true,
         type: {
           name: "String"
         }
       },
-      minimumTlsVersion: {
-        serializedName: "minimumTlsVersion",
-        required: true,
+      selector: {
+        serializedName: "selector",
         type: {
           name: "String"
         }
       },
-      certificateType: {
-        serializedName: "frontDoorCertificateSourceParameters.certificateType",
+      rulesEngineOperator: {
+        serializedName: "rulesEngineOperator",
+        required: true,
         type: {
           name: "String"
         }
       },
-      vault: {
-        serializedName: "keyVaultCertificateSourceParameters.vault",
+      negateCondition: {
+        serializedName: "negateCondition",
         type: {
-          name: "Composite",
-          className: "KeyVaultCertificateSourceParametersVault"
+          name: "Boolean"
         }
       },
-      secretName: {
-        serializedName: "keyVaultCertificateSourceParameters.secretName",
+      rulesEngineMatchValue: {
+        serializedName: "rulesEngineMatchValue",
+        required: true,
         type: {
-          name: "String"
+          name: "Sequence",
+          element: {
+            type: {
+              name: "String"
+            }
+          }
         }
       },
-      secretVersion: {
-        serializedName: "keyVaultCertificateSourceParameters.secretVersion",
+      transforms: {
+        serializedName: "transforms",
         type: {
-          name: "String"
+          name: "Sequence",
+          element: {
+            type: {
+              name: "String"
+            }
+          }
         }
       }
     }
   }
 };
 
-export const KeyVaultCertificateSourceParametersVault: coreClient.CompositeMapper = {
+export const FrontDoorUpdateParameters: coreClient.CompositeMapper = {
   type: {
     name: "Composite",
-    className: "KeyVaultCertificateSourceParametersVault",
+    className: "FrontDoorUpdateParameters",
     modelProperties: {
-      id: {
-        serializedName: "id",
+      friendlyName: {
+        serializedName: "friendlyName",
         type: {
           name: "String"
         }
-      }
-    }
-  }
-};
-
-export const FrontendEndpointUpdateParameters: coreClient.CompositeMapper = {
-  type: {
-    name: "Composite",
-    className: "FrontendEndpointUpdateParameters",
-    modelProperties: {
-      hostName: {
-        serializedName: "hostName",
+      },
+      routingRules: {
+        serializedName: "routingRules",
         type: {
-          name: "String"
+          name: "Sequence",
+          element: {
+            type: {
+              name: "Composite",
+              className: "RoutingRule"
+            }
+          }
         }
       },
-      sessionAffinityEnabledState: {
-        serializedName: "sessionAffinityEnabledState",
+      loadBalancingSettings: {
+        serializedName: "loadBalancingSettings",
         type: {
-          name: "String"
+          name: "Sequence",
+          element: {
+            type: {
+              name: "Composite",
+              className: "LoadBalancingSettingsModel"
+            }
+          }
         }
       },
-      sessionAffinityTtlSeconds: {
-        serializedName: "sessionAffinityTtlSeconds",
+      healthProbeSettings: {
+        serializedName: "healthProbeSettings",
         type: {
-          name: "Number"
+          name: "Sequence",
+          element: {
+            type: {
+              name: "Composite",
+              className: "HealthProbeSettingsModel"
+            }
+          }
         }
       },
-      webApplicationFirewallPolicyLink: {
-        serializedName: "webApplicationFirewallPolicyLink",
+      backendPools: {
+        serializedName: "backendPools",
         type: {
-          name: "Composite",
-          className:
-            "FrontendEndpointUpdateParametersWebApplicationFirewallPolicyLink"
+          name: "Sequence",
+          element: {
+            type: {
+              name: "Composite",
+              className: "BackendPool"
+            }
+          }
         }
-      }
-    }
-  }
-};
-
-export const FrontendEndpointUpdateParametersWebApplicationFirewallPolicyLink: coreClient.CompositeMapper = {
-  type: {
-    name: "Composite",
-    className:
-      "FrontendEndpointUpdateParametersWebApplicationFirewallPolicyLink",
-    modelProperties: {
-      id: {
-        serializedName: "id",
+      },
+      frontendEndpoints: {
+        serializedName: "frontendEndpoints",
         type: {
-          name: "String"
-        }
-      }
-    }
-  }
-};
-
-export const BackendPoolsSettings: coreClient.CompositeMapper = {
-  type: {
-    name: "Composite",
-    className: "BackendPoolsSettings",
-    modelProperties: {
-      enforceCertificateNameCheck: {
-        defaultValue: "Enabled",
-        serializedName: "enforceCertificateNameCheck",
+          name: "Sequence",
+          element: {
+            type: {
+              name: "Composite",
+              className: "FrontendEndpoint"
+            }
+          }
+        }
+      },
+      backendPoolsSettings: {
+        serializedName: "backendPoolsSettings",
         type: {
-          name: "String"
+          name: "Composite",
+          className: "BackendPoolsSettings"
         }
       },
-      sendRecvTimeoutSeconds: {
-        constraints: {
-          InclusiveMinimum: 16
-        },
-        serializedName: "sendRecvTimeoutSeconds",
+      enabledState: {
+        serializedName: "enabledState",
         type: {
-          name: "Number"
+          name: "String"
         }
       }
     }
   }
 };
 
-export const FrontendEndpointsListResult: coreClient.CompositeMapper = {
+export const RoutingRuleUpdateParameters: coreClient.CompositeMapper = {
   type: {
     name: "Composite",
-    className: "FrontendEndpointsListResult",
+    className: "RoutingRuleUpdateParameters",
     modelProperties: {
-      value: {
-        serializedName: "value",
-        readOnly: true,
+      frontendEndpoints: {
+        serializedName: "frontendEndpoints",
         type: {
           name: "Sequence",
           element: {
             type: {
               name: "Composite",
-              className: "FrontendEndpoint"
+              className: "SubResource"
             }
           }
         }
       },
-      nextLink: {
-        serializedName: "nextLink",
+      acceptedProtocols: {
+        serializedName: "acceptedProtocols",
         type: {
-          name: "String"
+          name: "Sequence",
+          element: {
+            type: {
+              name: "String"
+            }
+          }
         }
-      }
-    }
-  }
-};
-
-export const PurgeParameters: coreClient.CompositeMapper = {
-  type: {
-    name: "Composite",
-    className: "PurgeParameters",
-    modelProperties: {
-      contentPaths: {
-        serializedName: "contentPaths",
-        required: true,
+      },
+      patternsToMatch: {
+        serializedName: "patternsToMatch",
         type: {
           name: "Sequence",
           element: {
@@ -1259,49 +1185,46 @@ export const PurgeParameters: coreClient.CompositeMapper = {
             }
           }
         }
-      }
-    }
-  }
-};
-
-export const ValidateCustomDomainInput: coreClient.CompositeMapper = {
-  type: {
-    name: "Composite",
-    className: "ValidateCustomDomainInput",
-    modelProperties: {
-      hostName: {
-        serializedName: "hostName",
-        required: true,
+      },
+      enabledState: {
+        serializedName: "enabledState",
         type: {
           name: "String"
         }
+      },
+      routeConfiguration: {
+        serializedName: "routeConfiguration",
+        type: {
+          name: "Composite",
+          className: "RouteConfiguration"
+        }
+      },
+      rulesEngine: {
+        serializedName: "rulesEngine",
+        type: {
+          name: "Composite",
+          className: "SubResource"
+        }
+      },
+      webApplicationFirewallPolicyLink: {
+        serializedName: "webApplicationFirewallPolicyLink",
+        type: {
+          name: "Composite",
+          className:
+            "RoutingRuleUpdateParametersWebApplicationFirewallPolicyLink"
+        }
       }
     }
   }
 };
 
-export const ValidateCustomDomainOutput: coreClient.CompositeMapper = {
+export const SubResource: coreClient.CompositeMapper = {
   type: {
     name: "Composite",
-    className: "ValidateCustomDomainOutput",
+    className: "SubResource",
     modelProperties: {
-      customDomainValidated: {
-        serializedName: "customDomainValidated",
-        readOnly: true,
-        type: {
-          name: "Boolean"
-        }
-      },
-      reason: {
-        serializedName: "reason",
-        readOnly: true,
-        type: {
-          name: "String"
-        }
-      },
-      message: {
-        serializedName: "message",
-        readOnly: true,
+      id: {
+        serializedName: "id",
         type: {
           name: "String"
         }
@@ -1310,26 +1233,13 @@ export const ValidateCustomDomainOutput: coreClient.CompositeMapper = {
   }
 };
 
-export const RulesEngineListResult: coreClient.CompositeMapper = {
+export const RoutingRuleUpdateParametersWebApplicationFirewallPolicyLink: coreClient.CompositeMapper = {
   type: {
     name: "Composite",
-    className: "RulesEngineListResult",
+    className: "RoutingRuleUpdateParametersWebApplicationFirewallPolicyLink",
     modelProperties: {
-      value: {
-        serializedName: "value",
-        readOnly: true,
-        type: {
-          name: "Sequence",
-          element: {
-            type: {
-              name: "Composite",
-              className: "RulesEngine"
-            }
-          }
-        }
-      },
-      nextLink: {
-        serializedName: "nextLink",
+      id: {
+        serializedName: "id",
         type: {
           name: "String"
         }
@@ -1338,76 +1248,65 @@ export const RulesEngineListResult: coreClient.CompositeMapper = {
   }
 };
 
-export const WebApplicationFirewallPolicyList: coreClient.CompositeMapper = {
+export const LoadBalancingSettingsUpdateParameters: coreClient.CompositeMapper = {
   type: {
     name: "Composite",
-    className: "WebApplicationFirewallPolicyList",
+    className: "LoadBalancingSettingsUpdateParameters",
     modelProperties: {
-      value: {
-        serializedName: "value",
-        readOnly: true,
+      sampleSize: {
+        serializedName: "sampleSize",
         type: {
-          name: "Sequence",
-          element: {
-            type: {
-              name: "Composite",
-              className: "WebApplicationFirewallPolicy"
-            }
-          }
+          name: "Number"
         }
       },
-      nextLink: {
-        serializedName: "nextLink",
+      successfulSamplesRequired: {
+        serializedName: "successfulSamplesRequired",
         type: {
-          name: "String"
+          name: "Number"
+        }
+      },
+      additionalLatencyMilliseconds: {
+        serializedName: "additionalLatencyMilliseconds",
+        type: {
+          name: "Number"
         }
       }
     }
   }
 };
 
-export const PolicySettings: coreClient.CompositeMapper = {
+export const HealthProbeSettingsUpdateParameters: coreClient.CompositeMapper = {
   type: {
     name: "Composite",
-    className: "PolicySettings",
+    className: "HealthProbeSettingsUpdateParameters",
     modelProperties: {
-      enabledState: {
-        serializedName: "enabledState",
-        type: {
-          name: "String"
-        }
-      },
-      mode: {
-        serializedName: "mode",
+      path: {
+        serializedName: "path",
         type: {
           name: "String"
         }
       },
-      redirectUrl: {
-        serializedName: "redirectUrl",
+      protocol: {
+        serializedName: "protocol",
         type: {
           name: "String"
         }
       },
-      customBlockResponseStatusCode: {
-        serializedName: "customBlockResponseStatusCode",
+      intervalInSeconds: {
+        serializedName: "intervalInSeconds",
         type: {
           name: "Number"
         }
       },
-      customBlockResponseBody: {
-        constraints: {
-          Pattern: new RegExp(
-            "^(?:[A-Za-z0-9+/]{4})*(?:[A-Za-z0-9+/]{2}==|[A-Za-z0-9+/]{3}=|[A-Za-z0-9+/]{4})$"
-          )
-        },
-        serializedName: "customBlockResponseBody",
+      healthProbeMethod: {
+        defaultValue: "HEAD",
+        serializedName: "healthProbeMethod",
         type: {
           name: "String"
         }
       },
-      requestBodyCheck: {
-        serializedName: "requestBodyCheck",
+      enabledState: {
+        serializedName: "enabledState",
         type: {
           name: "String"
         }
@@ -1416,96 +1315,131 @@ export const PolicySettings: coreClient.CompositeMapper = {
   }
 };
 
-export const CustomRuleList: coreClient.CompositeMapper = {
+export const BackendPoolUpdateParameters: coreClient.CompositeMapper = {
   type: {
     name: "Composite",
-    className: "CustomRuleList",
+    className: "BackendPoolUpdateParameters",
     modelProperties: {
-      rules: {
-        serializedName: "rules",
+      backends: {
+        serializedName: "backends",
         type: {
           name: "Sequence",
           element: {
             type: {
               name: "Composite",
-              className: "CustomRule"
+              className: "Backend"
             }
           }
         }
+      },
+      loadBalancingSettings: {
+        serializedName: "loadBalancingSettings",
+        type: {
+          name: "Composite",
+          className: "SubResource"
+        }
+      },
+      healthProbeSettings: {
+        serializedName: "healthProbeSettings",
+        type: {
+          name: "Composite",
+          className: "SubResource"
+        }
       }
     }
   }
 };
 
-export const CustomRule: coreClient.CompositeMapper = {
+export const Backend: coreClient.CompositeMapper = {
   type: {
     name: "Composite",
-    className: "CustomRule",
+    className: "Backend",
     modelProperties: {
-      name: {
-        constraints: {
-          MaxLength: 128
-        },
-        serializedName: "name",
+      address: {
+        serializedName: "address",
+        type: {
+          name: "String"
+        }
+      },
+      privateLinkAlias: {
+        serializedName: "privateLinkAlias",
+        type: {
+          name: "String"
+        }
+      },
+      privateLinkResourceId: {
+        serializedName: "privateLinkResourceId",
+        type: {
+          name: "String"
+        }
+      },
+      privateLinkLocation: {
+        serializedName: "privateLinkLocation",
         type: {
           name: "String"
         }
       },
-      priority: {
-        serializedName: "priority",
-        required: true,
+      privateEndpointStatus: {
+        serializedName: "privateEndpointStatus",
+        readOnly: true,
         type: {
-          name: "Number"
+          name: "String"
         }
       },
-      enabledState: {
-        serializedName: "enabledState",
+      privateLinkApprovalMessage: {
+        serializedName: "privateLinkApprovalMessage",
         type: {
           name: "String"
         }
       },
-      ruleType: {
-        serializedName: "ruleType",
-        required: true,
+      httpPort: {
+        constraints: {
+          InclusiveMaximum: 65535,
+          InclusiveMinimum: 1
+        },
+        serializedName: "httpPort",
         type: {
-          name: "String"
+          name: "Number"
         }
       },
-      rateLimitDurationInMinutes: {
+      httpsPort: {
         constraints: {
-          InclusiveMaximum: 5,
-          InclusiveMinimum: 0
+          InclusiveMaximum: 65535,
+          InclusiveMinimum: 1
         },
-        serializedName: "rateLimitDurationInMinutes",
+        serializedName: "httpsPort",
         type: {
           name: "Number"
         }
       },
-      rateLimitThreshold: {
+      enabledState: {
+        serializedName: "enabledState",
+        type: {
+          name: "String"
+        }
+      },
+      priority: {
         constraints: {
-          InclusiveMinimum: 0
+          InclusiveMaximum: 5,
+          InclusiveMinimum: 1
         },
-        serializedName: "rateLimitThreshold",
+        serializedName: "priority",
         type: {
           name: "Number"
         }
       },
-      matchConditions: {
-        serializedName: "matchConditions",
-        required: true,
+      weight: {
+        constraints: {
+          InclusiveMaximum: 1000,
+          InclusiveMinimum: 1
+        },
+        serializedName: "weight",
         type: {
-          name: "Sequence",
-          element: {
-            type: {
-              name: "Composite",
-              className: "MatchCondition"
-            }
-          }
+          name: "Number"
         }
       },
-      action: {
-        serializedName: "action",
-        required: true,
+      backendHostHeader: {
+        serializedName: "backendHostHeader",
         type: {
           name: "String"
         }
@@ -1514,200 +1448,193 @@ export const CustomRule: coreClient.CompositeMapper = {
   }
 };
 
-export const MatchCondition: coreClient.CompositeMapper = {
+export const CustomHttpsConfiguration: coreClient.CompositeMapper = {
   type: {
     name: "Composite",
-    className: "MatchCondition",
+    className: "CustomHttpsConfiguration",
     modelProperties: {
-      matchVariable: {
-        serializedName: "matchVariable",
+      certificateSource: {
+        serializedName: "certificateSource",
         required: true,
         type: {
           name: "String"
         }
       },
-      selector: {
-        serializedName: "selector",
+      protocolType: {
+        serializedName: "protocolType",
+        required: true,
         type: {
           name: "String"
         }
       },
-      operator: {
-        serializedName: "operator",
+      minimumTlsVersion: {
+        serializedName: "minimumTlsVersion",
         required: true,
         type: {
           name: "String"
         }
       },
-      negateCondition: {
-        serializedName: "negateCondition",
+      certificateType: {
+        serializedName: "frontDoorCertificateSourceParameters.certificateType",
         type: {
-          name: "Boolean"
+          name: "String"
         }
       },
-      matchValue: {
-        serializedName: "matchValue",
-        required: true,
+      vault: {
+        serializedName: "keyVaultCertificateSourceParameters.vault",
         type: {
-          name: "Sequence",
-          element: {
-            type: {
-              name: "String"
-            }
-          }
+          name: "Composite",
+          className: "KeyVaultCertificateSourceParametersVault"
         }
       },
-      transforms: {
-        serializedName: "transforms",
+      secretName: {
+        serializedName: "keyVaultCertificateSourceParameters.secretName",
         type: {
-          name: "Sequence",
-          element: {
-            type: {
-              name: "String"
-            }
-          }
+          name: "String"
+        }
+      },
+      secretVersion: {
+        serializedName: "keyVaultCertificateSourceParameters.secretVersion",
+        type: {
+          name: "String"
         }
       }
     }
   }
 };
 
-export const ManagedRuleSetList: coreClient.CompositeMapper = {
+export const KeyVaultCertificateSourceParametersVault: coreClient.CompositeMapper = {
   type: {
     name: "Composite",
-    className: "ManagedRuleSetList",
+    className: "KeyVaultCertificateSourceParametersVault",
     modelProperties: {
-      managedRuleSets: {
-        serializedName: "managedRuleSets",
+      id: {
+        serializedName: "id",
         type: {
-          name: "Sequence",
-          element: {
-            type: {
-              name: "Composite",
-              className: "ManagedRuleSet"
-            }
-          }
+          name: "String"
         }
       }
     }
   }
 };
 
-export const ManagedRuleSet: coreClient.CompositeMapper = {
+export const FrontendEndpointUpdateParameters: coreClient.CompositeMapper = {
   type: {
     name: "Composite",
-    className: "ManagedRuleSet",
+    className: "FrontendEndpointUpdateParameters",
     modelProperties: {
-      ruleSetType: {
-        serializedName: "ruleSetType",
-        required: true,
-        type: {
-          name: "String"
-        }
-      },
-      ruleSetVersion: {
-        serializedName: "ruleSetVersion",
-        required: true,
+      hostName: {
+        serializedName: "hostName",
         type: {
           name: "String"
         }
       },
-      ruleSetAction: {
-        serializedName: "ruleSetAction",
+      sessionAffinityEnabledState: {
+        serializedName: "sessionAffinityEnabledState",
         type: {
           name: "String"
         }
       },
-      exclusions: {
-        serializedName: "exclusions",
+      sessionAffinityTtlSeconds: {
+        serializedName: "sessionAffinityTtlSeconds",
         type: {
-          name: "Sequence",
-          element: {
-            type: {
-              name: "Composite",
-              className: "ManagedRuleExclusion"
-            }
-          }
+          name: "Number"
         }
       },
-      ruleGroupOverrides: {
-        serializedName: "ruleGroupOverrides",
+      webApplicationFirewallPolicyLink: {
+        serializedName: "webApplicationFirewallPolicyLink",
         type: {
-          name: "Sequence",
-          element: {
-            type: {
-              name: "Composite",
-              className: "ManagedRuleGroupOverride"
-            }
-          }
+          name: "Composite",
+          className:
+            "FrontendEndpointUpdateParametersWebApplicationFirewallPolicyLink"
         }
       }
     }
   }
 };
 
-export const ManagedRuleExclusion: coreClient.CompositeMapper = {
+export const FrontendEndpointUpdateParametersWebApplicationFirewallPolicyLink: coreClient.CompositeMapper = {
   type: {
     name: "Composite",
-    className: "ManagedRuleExclusion",
+    className:
+      "FrontendEndpointUpdateParametersWebApplicationFirewallPolicyLink",
     modelProperties: {
-      matchVariable: {
-        serializedName: "matchVariable",
-        required: true,
+      id: {
+        serializedName: "id",
         type: {
           name: "String"
         }
-      },
-      selectorMatchOperator: {
-        serializedName: "selectorMatchOperator",
-        required: true,
+      }
+    }
+  }
+};
+
+export const BackendPoolsSettings: coreClient.CompositeMapper = {
+  type: {
+    name: "Composite",
+    className: "BackendPoolsSettings",
+    modelProperties: {
+      enforceCertificateNameCheck: {
+        defaultValue: "Enabled",
+        serializedName: "enforceCertificateNameCheck",
         type: {
           name: "String"
         }
       },
-      selector: {
-        serializedName: "selector",
-        required: true,
+      sendRecvTimeoutSeconds: {
+        constraints: {
+          InclusiveMinimum: 16
+        },
+        serializedName: "sendRecvTimeoutSeconds",
         type: {
-          name: "String"
+          name: "Number"
         }
       }
     }
   }
 };
 
-export const ManagedRuleGroupOverride: coreClient.CompositeMapper = {
+export const FrontendEndpointsListResult: coreClient.CompositeMapper = {
   type: {
     name: "Composite",
-    className: "ManagedRuleGroupOverride",
+    className: "FrontendEndpointsListResult",
     modelProperties: {
-      ruleGroupName: {
-        serializedName: "ruleGroupName",
-        required: true,
-        type: {
-          name: "String"
-        }
-      },
-      exclusions: {
-        serializedName: "exclusions",
+      value: {
+        serializedName: "value",
+        readOnly: true,
         type: {
           name: "Sequence",
           element: {
             type: {
               name: "Composite",
-              className: "ManagedRuleExclusion"
+              className: "FrontendEndpoint"
             }
           }
         }
       },
-      rules: {
-        serializedName: "rules",
+      nextLink: {
+        serializedName: "nextLink",
+        type: {
+          name: "String"
+        }
+      }
+    }
+  }
+};
+
+export const PurgeParameters: coreClient.CompositeMapper = {
+  type: {
+    name: "Composite",
+    className: "PurgeParameters",
+    modelProperties: {
+      contentPaths: {
+        serializedName: "contentPaths",
+        required: true,
         type: {
           name: "Sequence",
           element: {
             type: {
-              name: "Composite",
-              className: "ManagedRuleOverride"
+              name: "String"
             }
           }
         }
@@ -1716,53 +1643,72 @@ export const ManagedRuleGroupOverride: coreClient.CompositeMapper = {
   }
 };
 
-export const ManagedRuleOverride: coreClient.CompositeMapper = {
+export const ValidateCustomDomainInput: coreClient.CompositeMapper = {
   type: {
     name: "Composite",
-    className: "ManagedRuleOverride",
+    className: "ValidateCustomDomainInput",
     modelProperties: {
-      ruleId: {
-        serializedName: "ruleId",
+      hostName: {
+        serializedName: "hostName",
         required: true,
         type: {
           name: "String"
         }
-      },
-      enabledState: {
-        serializedName: "enabledState",
+      }
+    }
+  }
+};
+
+export const ValidateCustomDomainOutput: coreClient.CompositeMapper = {
+  type: {
+    name: "Composite",
+    className: "ValidateCustomDomainOutput",
+    modelProperties: {
+      customDomainValidated: {
+        serializedName: "customDomainValidated",
+        readOnly: true,
         type: {
-          name: "String"
+          name: "Boolean"
         }
       },
-      action: {
-        serializedName: "action",
+      reason: {
+        serializedName: "reason",
+        readOnly: true,
         type: {
           name: "String"
         }
       },
-      exclusions: {
-        serializedName: "exclusions",
+      message: {
+        serializedName: "message",
+        readOnly: true,
         type: {
-          name: "Sequence",
-          element: {
-            type: {
-              name: "Composite",
-              className: "ManagedRuleExclusion"
-            }
-          }
+          name: "String"
         }
       }
     }
   }
 };
 
-export const FrontendEndpointLink: coreClient.CompositeMapper = {
+export const RulesEngineListResult: coreClient.CompositeMapper = {
   type: {
     name: "Composite",
-    className: "FrontendEndpointLink",
+    className: "RulesEngineListResult",
     modelProperties: {
-      id: {
-        serializedName: "id",
+      value: {
+        serializedName: "value",
+        readOnly: true,
+        type: {
+          name: "Sequence",
+          element: {
+            type: {
+              name: "Composite",
+              className: "RulesEngine"
+            }
+          }
+        }
+      },
+      nextLink: {
+        serializedName: "nextLink",
         type: {
           name: "String"
         }
@@ -1771,13 +1717,26 @@ export const FrontendEndpointLink: coreClient.CompositeMapper = {
   }
 };
 
-export const RoutingRuleLink: coreClient.CompositeMapper = {
+export const ProfileList: coreClient.CompositeMapper = {
   type: {
     name: "Composite",
-    className: "RoutingRuleLink",
+    className: "ProfileList",
     modelProperties: {
-      id: {
-        serializedName: "id",
+      value: {
+        serializedName: "value",
+        readOnly: true,
+        type: {
+          name: "Sequence",
+          element: {
+            type: {
+              name: "Composite",
+              className: "Profile"
+            }
+          }
+        }
+      },
+      nextLink: {
+        serializedName: "nextLink",
         type: {
           name: "String"
         }
@@ -1786,13 +1745,20 @@ export const RoutingRuleLink: coreClient.CompositeMapper = {
   }
 };
 
-export const SecurityPolicyLink: coreClient.CompositeMapper = {
+export const ProfileUpdateModel: coreClient.CompositeMapper = {
   type: {
     name: "Composite",
-    className: "SecurityPolicyLink",
+    className: "ProfileUpdateModel",
     modelProperties: {
-      id: {
-        serializedName: "id",
+      tags: {
+        serializedName: "tags",
+        type: {
+          name: "Dictionary",
+          value: { type: { name: "String" } }
+        }
+      },
+      enabledState: {
+        serializedName: "properties.enabledState",
         type: {
           name: "String"
         }
@@ -1801,13 +1767,26 @@ export const SecurityPolicyLink: coreClient.CompositeMapper = {
   }
 };
 
-export const Sku: coreClient.CompositeMapper = {
+export const PreconfiguredEndpointList: coreClient.CompositeMapper = {
   type: {
     name: "Composite",
-    className: "Sku",
+    className: "PreconfiguredEndpointList",
     modelProperties: {
-      name: {
-        serializedName: "name",
+      value: {
+        serializedName: "value",
+        readOnly: true,
+        type: {
+          name: "Sequence",
+          element: {
+            type: {
+              name: "Composite",
+              className: "PreconfiguredEndpoint"
+            }
+          }
+        }
+      },
+      nextLink: {
+        serializedName: "nextLink",
         type: {
           name: "String"
         }
@@ -1816,10 +1795,10 @@ export const Sku: coreClient.CompositeMapper = {
   }
 };
 
-export const ManagedRuleSetDefinitionList: coreClient.CompositeMapper = {
+export const ExperimentList: coreClient.CompositeMapper = {
   type: {
     name: "Composite",
-    className: "ManagedRuleSetDefinitionList",
+    className: "ExperimentList",
     modelProperties: {
       value: {
         serializedName: "value",
@@ -1829,7 +1808,7 @@ export const ManagedRuleSetDefinitionList: coreClient.CompositeMapper = {
           element: {
             type: {
               name: "Composite",
-              className: "ManagedRuleSetDefinition"
+              className: "Experiment"
             }
           }
         }
@@ -1844,73 +1823,149 @@ export const ManagedRuleSetDefinitionList: coreClient.CompositeMapper = {
   }
 };
 
-export const ManagedRuleGroupDefinition: coreClient.CompositeMapper = {
+export const Endpoint: coreClient.CompositeMapper = {
   type: {
     name: "Composite",
-    className: "ManagedRuleGroupDefinition",
+    className: "Endpoint",
     modelProperties: {
-      ruleGroupName: {
-        serializedName: "ruleGroupName",
-        readOnly: true,
+      name: {
+        serializedName: "name",
+        type: {
+          name: "String"
+        }
+      },
+      endpoint: {
+        serializedName: "endpoint",
         type: {
           name: "String"
         }
+      }
+    }
+  }
+};
+
+export const ExperimentUpdateModel: coreClient.CompositeMapper = {
+  type: {
+    name: "Composite",
+    className: "ExperimentUpdateModel",
+    modelProperties: {
+      tags: {
+        serializedName: "tags",
+        type: {
+          name: "Dictionary",
+          value: { type: { name: "String" } }
+        }
       },
       description: {
-        serializedName: "description",
-        readOnly: true,
+        serializedName: "properties.description",
         type: {
           name: "String"
         }
       },
-      rules: {
-        serializedName: "rules",
-        readOnly: true,
+      enabledState: {
+        serializedName: "properties.enabledState",
         type: {
-          name: "Sequence",
-          element: {
-            type: {
-              name: "Composite",
-              className: "ManagedRuleDefinition"
-            }
-          }
+          name: "String"
         }
       }
     }
   }
 };
 
-export const ManagedRuleDefinition: coreClient.CompositeMapper = {
+export const LatencyMetric: coreClient.CompositeMapper = {
   type: {
     name: "Composite",
-    className: "ManagedRuleDefinition",
+    className: "LatencyMetric",
     modelProperties: {
-      ruleId: {
-        serializedName: "ruleId",
+      name: {
+        serializedName: "name",
         readOnly: true,
         type: {
           name: "String"
         }
       },
-      defaultState: {
-        serializedName: "defaultState",
+      endDateTimeUTC: {
+        serializedName: "endDateTimeUTC",
         readOnly: true,
         type: {
           name: "String"
         }
       },
-      defaultAction: {
-        serializedName: "defaultAction",
+      aValue: {
+        serializedName: "aValue",
+        readOnly: true,
+        type: {
+          name: "Number"
+        }
+      },
+      bValue: {
+        serializedName: "bValue",
+        readOnly: true,
+        type: {
+          name: "Number"
+        }
+      },
+      delta: {
+        serializedName: "delta",
+        readOnly: true,
+        type: {
+          name: "Number"
+        }
+      },
+      deltaPercent: {
+        serializedName: "deltaPercent",
+        readOnly: true,
+        type: {
+          name: "Number"
+        }
+      },
+      aCLower95CI: {
+        serializedName: "aCLower95CI",
+        readOnly: true,
+        type: {
+          name: "Number"
+        }
+      },
+      aHUpper95CI: {
+        serializedName: "aHUpper95CI",
+        readOnly: true,
+        type: {
+          name: "Number"
+        }
+      },
+      bCLower95CI: {
+        serializedName: "bCLower95CI",
+        readOnly: true,
+        type: {
+          name: "Number"
+        }
+      },
+      bUpper95CI: {
+        serializedName: "bUpper95CI",
         readOnly: true,
+        type: {
+          name: "Number"
+        }
+      }
+    }
+  }
+};
+
+export const TimeseriesDataPoint: coreClient.CompositeMapper = {
+  type: {
+    name: "Composite",
+    className: "TimeseriesDataPoint",
+    modelProperties: {
+      dateTimeUTC: {
+        serializedName: "dateTimeUTC",
         type: {
           name: "String"
         }
       },
-      description: {
-        serializedName: "description",
-        readOnly: true,
+      value: {
+        serializedName: "value",
         type: {
-          name: "String"
+          name: "Number"
         }
       }
     }
@@ -2011,22 +2066,6 @@ export const AzureAsyncOperationResult: coreClient.CompositeMapper = {
   }
 };
 
-export const TagsObject: coreClient.CompositeMapper = {
-  type: {
-    name: "Composite",
-    className: "TagsObject",
-    modelProperties: {
-      tags: {
-        serializedName: "tags",
-        type: {
-          name: "Dictionary",
-          value: { type: { name: "String" } }
-        }
-      }
-    }
-  }
-};
-
 export const RoutingRuleListResult: coreClient.CompositeMapper = {
   type: {
     name: "Composite",
@@ -2172,10 +2211,10 @@ export const BackendPoolListResult: coreClient.CompositeMapper = {
   }
 };
 
-export const Profile: coreClient.CompositeMapper = {
+export const WebApplicationFirewallPolicy: coreClient.CompositeMapper = {
   type: {
     name: "Composite",
-    className: "Profile",
+    className: "WebApplicationFirewallPolicy",
     modelProperties: {
       ...Resource.type.modelProperties,
       etag: {
@@ -2184,242 +2223,134 @@ export const Profile: coreClient.CompositeMapper = {
           name: "String"
         }
       },
-      resourceState: {
-        serializedName: "properties.resourceState",
-        readOnly: true,
-        type: {
-          name: "String"
-        }
-      },
-      enabledState: {
-        serializedName: "properties.enabledState",
-        type: {
-          name: "String"
-        }
-      }
-    }
-  }
-};
-
-export const PreconfiguredEndpoint: coreClient.CompositeMapper = {
-  type: {
-    name: "Composite",
-    className: "PreconfiguredEndpoint",
-    modelProperties: {
-      ...Resource.type.modelProperties,
-      description: {
-        serializedName: "properties.description",
-        type: {
-          name: "String"
-        }
-      },
-      endpoint: {
-        serializedName: "properties.endpoint",
-        type: {
-          name: "String"
-        }
-      },
-      endpointType: {
-        serializedName: "properties.endpointType",
-        type: {
-          name: "String"
-        }
-      },
-      backend: {
-        serializedName: "properties.backend",
-        type: {
-          name: "String"
-        }
-      }
-    }
-  }
-};
-
-export const Experiment: coreClient.CompositeMapper = {
-  type: {
-    name: "Composite",
-    className: "Experiment",
-    modelProperties: {
-      ...Resource.type.modelProperties,
-      description: {
-        serializedName: "properties.description",
-        type: {
-          name: "String"
-        }
-      },
-      endpointA: {
-        serializedName: "properties.endpointA",
+      sku: {
+        serializedName: "sku",
         type: {
           name: "Composite",
-          className: "Endpoint"
+          className: "Sku"
         }
       },
-      endpointB: {
-        serializedName: "properties.endpointB",
+      policySettings: {
+        serializedName: "properties.policySettings",
         type: {
           name: "Composite",
-          className: "Endpoint"
-        }
-      },
-      enabledState: {
-        serializedName: "properties.enabledState",
-        type: {
-          name: "String"
-        }
-      },
-      resourceState: {
-        serializedName: "properties.resourceState",
-        readOnly: true,
-        type: {
-          name: "String"
+          className: "PolicySettings"
         }
       },
-      status: {
-        serializedName: "properties.status",
-        readOnly: true,
+      customRules: {
+        serializedName: "properties.customRules",
         type: {
-          name: "String"
+          name: "Composite",
+          className: "CustomRuleList"
         }
       },
-      scriptFileUri: {
-        serializedName: "properties.scriptFileUri",
-        readOnly: true,
-        type: {
-          name: "String"
-        }
-      }
-    }
-  }
-};
-
-export const LatencyScorecard: coreClient.CompositeMapper = {
-  type: {
-    name: "Composite",
-    className: "LatencyScorecard",
-    modelProperties: {
-      ...Resource.type.modelProperties,
-      idPropertiesId: {
-        serializedName: "properties.id",
-        readOnly: true,
+      managedRules: {
+        serializedName: "properties.managedRules",
         type: {
-          name: "String"
+          name: "Composite",
+          className: "ManagedRuleSetList"
         }
       },
-      namePropertiesName: {
-        serializedName: "properties.name",
+      frontendEndpointLinks: {
+        serializedName: "properties.frontendEndpointLinks",
         readOnly: true,
         type: {
-          name: "String"
+          name: "Sequence",
+          element: {
+            type: {
+              name: "Composite",
+              className: "FrontendEndpointLink"
+            }
+          }
         }
       },
-      description: {
-        serializedName: "properties.description",
+      routingRuleLinks: {
+        serializedName: "properties.routingRuleLinks",
         readOnly: true,
         type: {
-          name: "String"
+          name: "Sequence",
+          element: {
+            type: {
+              name: "Composite",
+              className: "RoutingRuleLink"
+            }
+          }
         }
       },
-      endpointA: {
-        serializedName: "properties.endpointA",
+      securityPolicyLinks: {
+        serializedName: "properties.securityPolicyLinks",
         readOnly: true,
         type: {
-          name: "String"
+          name: "Sequence",
+          element: {
+            type: {
+              name: "Composite",
+              className: "SecurityPolicyLink"
+            }
+          }
         }
       },
-      endpointB: {
-        serializedName: "properties.endpointB",
+      provisioningState: {
+        serializedName: "properties.provisioningState",
         readOnly: true,
         type: {
           name: "String"
         }
       },
-      startDateTimeUTC: {
-        serializedName: "properties.startDateTimeUTC",
-        readOnly: true,
-        type: {
-          name: "DateTime"
-        }
-      },
-      endDateTimeUTC: {
-        serializedName: "properties.endDateTimeUTC",
-        readOnly: true,
-        type: {
-          name: "DateTime"
-        }
-      },
-      country: {
-        serializedName: "properties.country",
+      resourceState: {
+        serializedName: "properties.resourceState",
         readOnly: true,
         type: {
           name: "String"
         }
-      },
-      latencyMetrics: {
-        serializedName: "properties.latencyMetrics",
-        type: {
-          name: "Sequence",
-          element: {
-            type: {
-              name: "Composite",
-              className: "LatencyMetric"
-            }
-          }
-        }
       }
     }
   }
 };
 
-export const Timeseries: coreClient.CompositeMapper = {
+export const ManagedRuleSetDefinition: coreClient.CompositeMapper = {
   type: {
     name: "Composite",
-    className: "Timeseries",
+    className: "ManagedRuleSetDefinition",
     modelProperties: {
       ...Resource.type.modelProperties,
-      endpoint: {
-        serializedName: "properties.endpoint",
-        type: {
-          name: "String"
-        }
-      },
-      startDateTimeUTC: {
-        serializedName: "properties.startDateTimeUTC",
-        type: {
-          name: "String"
-        }
-      },
-      endDateTimeUTC: {
-        serializedName: "properties.endDateTimeUTC",
+      provisioningState: {
+        serializedName: "properties.provisioningState",
+        readOnly: true,
         type: {
           name: "String"
         }
       },
-      aggregationInterval: {
-        serializedName: "properties.aggregationInterval",
+      ruleSetId: {
+        serializedName: "properties.ruleSetId",
+        readOnly: true,
         type: {
           name: "String"
         }
       },
-      timeseriesType: {
-        serializedName: "properties.timeseriesType",
+      ruleSetType: {
+        serializedName: "properties.ruleSetType",
+        readOnly: true,
         type: {
           name: "String"
         }
       },
-      country: {
-        serializedName: "properties.country",
+      ruleSetVersion: {
+        serializedName: "properties.ruleSetVersion",
+        readOnly: true,
         type: {
           name: "String"
         }
       },
-      timeseriesData: {
-        serializedName: "properties.timeseriesData",
+      ruleGroups: {
+        serializedName: "properties.ruleGroups",
+        readOnly: true,
         type: {
           name: "Sequence",
           element: {
             type: {
               name: "Composite",
-              className: "TimeseriesDataPoint"
+              className: "ManagedRuleGroupDefinition"
             }
           }
         }
@@ -2553,15 +2484,23 @@ export const FrontDoor: coreClient.CompositeMapper = {
             }
           }
         }
+      },
+      extendedProperties: {
+        serializedName: "properties.extendedProperties",
+        readOnly: true,
+        type: {
+          name: "Dictionary",
+          value: { type: { name: "String" } }
+        }
       }
     }
   }
 };
 
-export const WebApplicationFirewallPolicy: coreClient.CompositeMapper = {
+export const Profile: coreClient.CompositeMapper = {
   type: {
     name: "Composite",
-    className: "WebApplicationFirewallPolicy",
+    className: "Profile",
     modelProperties: {
       ...Resource.type.modelProperties,
       etag: {
@@ -2570,82 +2509,105 @@ export const WebApplicationFirewallPolicy: coreClient.CompositeMapper = {
           name: "String"
         }
       },
-      sku: {
-        serializedName: "sku",
+      resourceState: {
+        serializedName: "properties.resourceState",
+        readOnly: true,
         type: {
-          name: "Composite",
-          className: "Sku"
+          name: "String"
         }
       },
-      policySettings: {
-        serializedName: "properties.policySettings",
+      enabledState: {
+        serializedName: "properties.enabledState",
         type: {
-          name: "Composite",
-          className: "PolicySettings"
+          name: "String"
+        }
+      }
+    }
+  }
+};
+
+export const PreconfiguredEndpoint: coreClient.CompositeMapper = {
+  type: {
+    name: "Composite",
+    className: "PreconfiguredEndpoint",
+    modelProperties: {
+      ...Resource.type.modelProperties,
+      description: {
+        serializedName: "properties.description",
+        type: {
+          name: "String"
         }
       },
-      customRules: {
-        serializedName: "properties.customRules",
+      endpoint: {
+        serializedName: "properties.endpoint",
         type: {
-          name: "Composite",
-          className: "CustomRuleList"
+          name: "String"
         }
       },
-      managedRules: {
-        serializedName: "properties.managedRules",
+      endpointType: {
+        serializedName: "properties.endpointType",
+        type: {
+          name: "String"
+        }
+      },
+      backend: {
+        serializedName: "properties.backend",
+        type: {
+          name: "String"
+        }
+      }
+    }
+  }
+};
+
+export const Experiment: coreClient.CompositeMapper = {
+  type: {
+    name: "Composite",
+    className: "Experiment",
+    modelProperties: {
+      ...Resource.type.modelProperties,
+      description: {
+        serializedName: "properties.description",
+        type: {
+          name: "String"
+        }
+      },
+      endpointA: {
+        serializedName: "properties.endpointA",
         type: {
           name: "Composite",
-          className: "ManagedRuleSetList"
+          className: "Endpoint"
         }
       },
-      frontendEndpointLinks: {
-        serializedName: "properties.frontendEndpointLinks",
-        readOnly: true,
+      endpointB: {
+        serializedName: "properties.endpointB",
         type: {
-          name: "Sequence",
-          element: {
-            type: {
-              name: "Composite",
-              className: "FrontendEndpointLink"
-            }
-          }
+          name: "Composite",
+          className: "Endpoint"
         }
       },
-      routingRuleLinks: {
-        serializedName: "properties.routingRuleLinks",
-        readOnly: true,
+      enabledState: {
+        serializedName: "properties.enabledState",
         type: {
-          name: "Sequence",
-          element: {
-            type: {
-              name: "Composite",
-              className: "RoutingRuleLink"
-            }
-          }
+          name: "String"
         }
       },
-      securityPolicyLinks: {
-        serializedName: "properties.securityPolicyLinks",
+      resourceState: {
+        serializedName: "properties.resourceState",
         readOnly: true,
         type: {
-          name: "Sequence",
-          element: {
-            type: {
-              name: "Composite",
-              className: "SecurityPolicyLink"
-            }
-          }
+          name: "String"
         }
       },
-      provisioningState: {
-        serializedName: "properties.provisioningState",
+      status: {
+        serializedName: "properties.status",
         readOnly: true,
         type: {
           name: "String"
         }
       },
-      resourceState: {
-        serializedName: "properties.resourceState",
+      scriptFileUri: {
+        serializedName: "properties.scriptFileUri",
         readOnly: true,
         type: {
           name: "String"
@@ -2655,49 +2617,134 @@ export const WebApplicationFirewallPolicy: coreClient.CompositeMapper = {
   }
 };
 
-export const ManagedRuleSetDefinition: coreClient.CompositeMapper = {
+export const LatencyScorecard: coreClient.CompositeMapper = {
   type: {
     name: "Composite",
-    className: "ManagedRuleSetDefinition",
+    className: "LatencyScorecard",
     modelProperties: {
       ...Resource.type.modelProperties,
-      provisioningState: {
-        serializedName: "properties.provisioningState",
+      idPropertiesId: {
+        serializedName: "properties.id",
         readOnly: true,
         type: {
           name: "String"
         }
       },
-      ruleSetId: {
-        serializedName: "properties.ruleSetId",
+      namePropertiesName: {
+        serializedName: "properties.name",
         readOnly: true,
         type: {
           name: "String"
         }
       },
-      ruleSetType: {
-        serializedName: "properties.ruleSetType",
+      description: {
+        serializedName: "properties.description",
         readOnly: true,
         type: {
           name: "String"
         }
       },
-      ruleSetVersion: {
-        serializedName: "properties.ruleSetVersion",
+      endpointA: {
+        serializedName: "properties.endpointA",
         readOnly: true,
         type: {
           name: "String"
         }
       },
-      ruleGroups: {
-        serializedName: "properties.ruleGroups",
+      endpointB: {
+        serializedName: "properties.endpointB",
+        readOnly: true,
+        type: {
+          name: "String"
+        }
+      },
+      startDateTimeUTC: {
+        serializedName: "properties.startDateTimeUTC",
+        readOnly: true,
+        type: {
+          name: "DateTime"
+        }
+      },
+      endDateTimeUTC: {
+        serializedName: "properties.endDateTimeUTC",
+        readOnly: true,
+        type: {
+          name: "DateTime"
+        }
+      },
+      country: {
+        serializedName: "properties.country",
         readOnly: true,
+        type: {
+          name: "String"
+        }
+      },
+      latencyMetrics: {
+        serializedName: "properties.latencyMetrics",
         type: {
           name: "Sequence",
           element: {
             type: {
               name: "Composite",
-              className: "ManagedRuleGroupDefinition"
+              className: "LatencyMetric"
+            }
+          }
+        }
+      }
+    }
+  }
+};
+
+export const Timeseries: coreClient.CompositeMapper = {
+  type: {
+    name: "Composite",
+    className: "Timeseries",
+    modelProperties: {
+      ...Resource.type.modelProperties,
+      endpoint: {
+        serializedName: "properties.endpoint",
+        type: {
+          name: "String"
+        }
+      },
+      startDateTimeUTC: {
+        serializedName: "properties.startDateTimeUTC",
+        type: {
+          name: "String"
+        }
+      },
+      endDateTimeUTC: {
+        serializedName: "properties.endDateTimeUTC",
+        type: {
+          name: "String"
+        }
+      },
+      aggregationInterval: {
+        serializedName: "properties.aggregationInterval",
+        type: {
+          name: "String"
+        }
+      },
+      timeseriesType: {
+        serializedName: "properties.timeseriesType",
+        type: {
+          name: "String"
+        }
+      },
+      country: {
+        serializedName: "properties.country",
+        type: {
+          name: "String"
+        }
+      },
+      timeseriesData: {
+        serializedName: "properties.timeseriesData",
+        type: {
+          name: "Sequence",
+          element: {
+            type: {
+              name: "Composite",
+              className: "TimeseriesDataPoint"
             }
           }
         }
@@ -2859,6 +2906,14 @@ export const FrontDoorProperties: coreClient.CompositeMapper = {
             }
           }
         }
+      },
+      extendedProperties: {
+        serializedName: "extendedProperties",
+        readOnly: true,
+        type: {
+          name: "Dictionary",
+          value: { type: { name: "String" } }
+        }
       }
     }
   }