diff --git a/sdk/data/azappconfig/internal/autorest.md b/sdk/data/azappconfig/internal/autorest.md
index f51b417b7daa..ab80e1f29d22 100644
--- a/sdk/data/azappconfig/internal/autorest.md
+++ b/sdk/data/azappconfig/internal/autorest.md
@@ -14,7 +14,7 @@ file-prefix: "zz_"
 output-folder: generated
 openapi-type: "data-plane"
 security: "AADToken"
-use: "@autorest/go@4.0.0-preview.59"
+use: "@autorest/go@4.0.0-preview.63"
 slice-elements-byval: true
 modelerfour:
   lenient-model-deduplication: true
diff --git a/sdk/data/azappconfig/internal/generated/zz_azureappconfiguration_client.go b/sdk/data/azappconfig/internal/generated/zz_azureappconfiguration_client.go
index c07a312396ed..cbe578e183e0 100644
--- a/sdk/data/azappconfig/internal/generated/zz_azureappconfiguration_client.go
+++ b/sdk/data/azappconfig/internal/generated/zz_azureappconfiguration_client.go
@@ -65,17 +65,14 @@ func (client *AzureAppConfigurationClient) checkKeyValueCreateRequest(ctx contex
 		return nil, err
 	}
 	reqQP := req.Raw().URL.Query()
-	if options != nil && options.Label != nil {
-		reqQP.Set("label", *options.Label)
-	}
-	reqQP.Set("api-version", "2023-10-01")
 	if options != nil && options.Select != nil {
 		reqQP.Set("$Select", strings.Join(strings.Fields(strings.Trim(fmt.Sprint(options.Select), "[]")), ","))
 	}
-	req.Raw().URL.RawQuery = reqQP.Encode()
-	if client.syncToken != nil {
-		req.Raw().Header["Sync-Token"] = []string{*client.syncToken}
+	reqQP.Set("api-version", "2023-10-01")
+	if options != nil && options.Label != nil {
+		reqQP.Set("label", *options.Label)
 	}
+	req.Raw().URL.RawQuery = reqQP.Encode()
 	if options != nil && options.AcceptDatetime != nil {
 		req.Raw().Header["Accept-Datetime"] = []string{*options.AcceptDatetime}
 	}
@@ -85,6 +82,9 @@ func (client *AzureAppConfigurationClient) checkKeyValueCreateRequest(ctx contex
 	if options != nil && options.IfNoneMatch != nil {
 		req.Raw().Header["If-None-Match"] = []string{*options.IfNoneMatch}
 	}
+	if client.syncToken != nil {
+		req.Raw().Header["Sync-Token"] = []string{*client.syncToken}
+	}
 	return req, nil
 }
 
@@ -132,26 +132,23 @@ func (client *AzureAppConfigurationClient) checkKeyValuesCreateRequest(ctx conte
 		return nil, err
 	}
 	reqQP := req.Raw().URL.Query()
+	if options != nil && options.Select != nil {
+		reqQP.Set("$Select", strings.Join(strings.Fields(strings.Trim(fmt.Sprint(options.Select), "[]")), ","))
+	}
+	if options != nil && options.After != nil {
+		reqQP.Set("After", *options.After)
+	}
+	reqQP.Set("api-version", "2023-10-01")
 	if options != nil && options.Key != nil {
 		reqQP.Set("key", *options.Key)
 	}
 	if options != nil && options.Label != nil {
 		reqQP.Set("label", *options.Label)
 	}
-	reqQP.Set("api-version", "2023-10-01")
-	if options != nil && options.After != nil {
-		reqQP.Set("After", *options.After)
-	}
-	if options != nil && options.Select != nil {
-		reqQP.Set("$Select", strings.Join(strings.Fields(strings.Trim(fmt.Sprint(options.Select), "[]")), ","))
-	}
 	if options != nil && options.Snapshot != nil {
 		reqQP.Set("snapshot", *options.Snapshot)
 	}
 	req.Raw().URL.RawQuery = reqQP.Encode()
-	if client.syncToken != nil {
-		req.Raw().Header["Sync-Token"] = []string{*client.syncToken}
-	}
 	if options != nil && options.AcceptDatetime != nil {
 		req.Raw().Header["Accept-Datetime"] = []string{*options.AcceptDatetime}
 	}
@@ -161,6 +158,9 @@ func (client *AzureAppConfigurationClient) checkKeyValuesCreateRequest(ctx conte
 	if options != nil && options.IfNoneMatch != nil {
 		req.Raw().Header["If-None-Match"] = []string{*options.IfNoneMatch}
 	}
+	if client.syncToken != nil {
+		req.Raw().Header["Sync-Token"] = []string{*client.syncToken}
+	}
 	return req, nil
 }
 
@@ -208,20 +208,20 @@ func (client *AzureAppConfigurationClient) checkKeysCreateRequest(ctx context.Co
 		return nil, err
 	}
 	reqQP := req.Raw().URL.Query()
-	if options != nil && options.Name != nil {
-		reqQP.Set("name", *options.Name)
-	}
-	reqQP.Set("api-version", "2023-10-01")
 	if options != nil && options.After != nil {
 		reqQP.Set("After", *options.After)
 	}
-	req.Raw().URL.RawQuery = reqQP.Encode()
-	if client.syncToken != nil {
-		req.Raw().Header["Sync-Token"] = []string{*client.syncToken}
+	reqQP.Set("api-version", "2023-10-01")
+	if options != nil && options.Name != nil {
+		reqQP.Set("name", *options.Name)
 	}
+	req.Raw().URL.RawQuery = reqQP.Encode()
 	if options != nil && options.AcceptDatetime != nil {
 		req.Raw().Header["Accept-Datetime"] = []string{*options.AcceptDatetime}
 	}
+	if client.syncToken != nil {
+		req.Raw().Header["Sync-Token"] = []string{*client.syncToken}
+	}
 	return req, nil
 }
 
@@ -266,23 +266,23 @@ func (client *AzureAppConfigurationClient) checkLabelsCreateRequest(ctx context.
 		return nil, err
 	}
 	reqQP := req.Raw().URL.Query()
-	if options != nil && options.Name != nil {
-		reqQP.Set("name", *options.Name)
+	if options != nil && options.Select != nil {
+		reqQP.Set("$Select", strings.Join(strings.Fields(strings.Trim(fmt.Sprint(options.Select), "[]")), ","))
 	}
-	reqQP.Set("api-version", "2023-10-01")
 	if options != nil && options.After != nil {
 		reqQP.Set("After", *options.After)
 	}
-	if options != nil && options.Select != nil {
-		reqQP.Set("$Select", strings.Join(strings.Fields(strings.Trim(fmt.Sprint(options.Select), "[]")), ","))
+	reqQP.Set("api-version", "2023-10-01")
+	if options != nil && options.Name != nil {
+		reqQP.Set("name", *options.Name)
 	}
 	req.Raw().URL.RawQuery = reqQP.Encode()
-	if client.syncToken != nil {
-		req.Raw().Header["Sync-Token"] = []string{*client.syncToken}
-	}
 	if options != nil && options.AcceptDatetime != nil {
 		req.Raw().Header["Accept-Datetime"] = []string{*options.AcceptDatetime}
 	}
+	if client.syncToken != nil {
+		req.Raw().Header["Sync-Token"] = []string{*client.syncToken}
+	}
 	return req, nil
 }
 
@@ -327,26 +327,26 @@ func (client *AzureAppConfigurationClient) checkRevisionsCreateRequest(ctx conte
 		return nil, err
 	}
 	reqQP := req.Raw().URL.Query()
+	if options != nil && options.Select != nil {
+		reqQP.Set("$Select", strings.Join(strings.Fields(strings.Trim(fmt.Sprint(options.Select), "[]")), ","))
+	}
+	if options != nil && options.After != nil {
+		reqQP.Set("After", *options.After)
+	}
+	reqQP.Set("api-version", "2023-10-01")
 	if options != nil && options.Key != nil {
 		reqQP.Set("key", *options.Key)
 	}
 	if options != nil && options.Label != nil {
 		reqQP.Set("label", *options.Label)
 	}
-	reqQP.Set("api-version", "2023-10-01")
-	if options != nil && options.After != nil {
-		reqQP.Set("After", *options.After)
-	}
-	if options != nil && options.Select != nil {
-		reqQP.Set("$Select", strings.Join(strings.Fields(strings.Trim(fmt.Sprint(options.Select), "[]")), ","))
-	}
 	req.Raw().URL.RawQuery = reqQP.Encode()
-	if client.syncToken != nil {
-		req.Raw().Header["Sync-Token"] = []string{*client.syncToken}
-	}
 	if options != nil && options.AcceptDatetime != nil {
 		req.Raw().Header["Accept-Datetime"] = []string{*options.AcceptDatetime}
 	}
+	if client.syncToken != nil {
+		req.Raw().Header["Sync-Token"] = []string{*client.syncToken}
+	}
 	return req, nil
 }
 
@@ -401,15 +401,15 @@ func (client *AzureAppConfigurationClient) checkSnapshotCreateRequest(ctx contex
 	reqQP := req.Raw().URL.Query()
 	reqQP.Set("api-version", "2023-10-01")
 	req.Raw().URL.RawQuery = reqQP.Encode()
-	if client.syncToken != nil {
-		req.Raw().Header["Sync-Token"] = []string{*client.syncToken}
-	}
 	if options != nil && options.IfMatch != nil {
 		req.Raw().Header["If-Match"] = []string{*options.IfMatch}
 	}
 	if options != nil && options.IfNoneMatch != nil {
 		req.Raw().Header["If-None-Match"] = []string{*options.IfNoneMatch}
 	}
+	if client.syncToken != nil {
+		req.Raw().Header["Sync-Token"] = []string{*client.syncToken}
+	}
 	return req, nil
 }
 
@@ -460,10 +460,10 @@ func (client *AzureAppConfigurationClient) checkSnapshotsCreateRequest(ctx conte
 		return nil, err
 	}
 	reqQP := req.Raw().URL.Query()
-	reqQP.Set("api-version", "2023-10-01")
 	if options != nil && options.After != nil {
 		reqQP.Set("After", *options.After)
 	}
+	reqQP.Set("api-version", "2023-10-01")
 	req.Raw().URL.RawQuery = reqQP.Encode()
 	if client.syncToken != nil {
 		req.Raw().Header["Sync-Token"] = []string{*client.syncToken}
@@ -536,10 +536,10 @@ func (client *AzureAppConfigurationClient) createSnapshotCreateRequest(ctx conte
 	reqQP := req.Raw().URL.Query()
 	reqQP.Set("api-version", "2023-10-01")
 	req.Raw().URL.RawQuery = reqQP.Encode()
+	req.Raw().Header["Accept"] = []string{"application/vnd.microsoft.appconfig.snapshot+json, application/problem+json"}
 	if client.syncToken != nil {
 		req.Raw().Header["Sync-Token"] = []string{*client.syncToken}
 	}
-	req.Raw().Header["Accept"] = []string{"application/vnd.microsoft.appconfig.snapshot+json, application/problem+json"}
 	if err := runtime.MarshalAsJSON(req, entity); err != nil {
 		return nil, err
 	}
@@ -583,18 +583,18 @@ func (client *AzureAppConfigurationClient) deleteKeyValueCreateRequest(ctx conte
 		return nil, err
 	}
 	reqQP := req.Raw().URL.Query()
+	reqQP.Set("api-version", "2023-10-01")
 	if options != nil && options.Label != nil {
 		reqQP.Set("label", *options.Label)
 	}
-	reqQP.Set("api-version", "2023-10-01")
 	req.Raw().URL.RawQuery = reqQP.Encode()
-	if client.syncToken != nil {
-		req.Raw().Header["Sync-Token"] = []string{*client.syncToken}
-	}
+	req.Raw().Header["Accept"] = []string{"application/vnd.microsoft.appconfig.kv+json, application/problem+json"}
 	if options != nil && options.IfMatch != nil {
 		req.Raw().Header["If-Match"] = []string{*options.IfMatch}
 	}
-	req.Raw().Header["Accept"] = []string{"application/vnd.microsoft.appconfig.kv+json, application/problem+json"}
+	if client.syncToken != nil {
+		req.Raw().Header["Sync-Token"] = []string{*client.syncToken}
+	}
 	return req, nil
 }
 
@@ -650,21 +650,21 @@ func (client *AzureAppConfigurationClient) deleteLockCreateRequest(ctx context.C
 		return nil, err
 	}
 	reqQP := req.Raw().URL.Query()
+	reqQP.Set("api-version", "2023-10-01")
 	if options != nil && options.Label != nil {
 		reqQP.Set("label", *options.Label)
 	}
-	reqQP.Set("api-version", "2023-10-01")
 	req.Raw().URL.RawQuery = reqQP.Encode()
-	if client.syncToken != nil {
-		req.Raw().Header["Sync-Token"] = []string{*client.syncToken}
-	}
+	req.Raw().Header["Accept"] = []string{"application/vnd.microsoft.appconfig.kv+json, application/problem+json"}
 	if options != nil && options.IfMatch != nil {
 		req.Raw().Header["If-Match"] = []string{*options.IfMatch}
 	}
 	if options != nil && options.IfNoneMatch != nil {
 		req.Raw().Header["If-None-Match"] = []string{*options.IfNoneMatch}
 	}
-	req.Raw().Header["Accept"] = []string{"application/vnd.microsoft.appconfig.kv+json, application/problem+json"}
+	if client.syncToken != nil {
+		req.Raw().Header["Sync-Token"] = []string{*client.syncToken}
+	}
 	return req, nil
 }
 
@@ -720,17 +720,15 @@ func (client *AzureAppConfigurationClient) getKeyValueCreateRequest(ctx context.
 		return nil, err
 	}
 	reqQP := req.Raw().URL.Query()
-	if options != nil && options.Label != nil {
-		reqQP.Set("label", *options.Label)
-	}
-	reqQP.Set("api-version", "2023-10-01")
 	if options != nil && options.Select != nil {
 		reqQP.Set("$Select", strings.Join(strings.Fields(strings.Trim(fmt.Sprint(options.Select), "[]")), ","))
 	}
-	req.Raw().URL.RawQuery = reqQP.Encode()
-	if client.syncToken != nil {
-		req.Raw().Header["Sync-Token"] = []string{*client.syncToken}
+	reqQP.Set("api-version", "2023-10-01")
+	if options != nil && options.Label != nil {
+		reqQP.Set("label", *options.Label)
 	}
+	req.Raw().URL.RawQuery = reqQP.Encode()
+	req.Raw().Header["Accept"] = []string{"application/vnd.microsoft.appconfig.kv+json, application/problem+json"}
 	if options != nil && options.AcceptDatetime != nil {
 		req.Raw().Header["Accept-Datetime"] = []string{*options.AcceptDatetime}
 	}
@@ -740,7 +738,9 @@ func (client *AzureAppConfigurationClient) getKeyValueCreateRequest(ctx context.
 	if options != nil && options.IfNoneMatch != nil {
 		req.Raw().Header["If-None-Match"] = []string{*options.IfNoneMatch}
 	}
-	req.Raw().Header["Accept"] = []string{"application/vnd.microsoft.appconfig.kv+json, application/problem+json"}
+	if client.syncToken != nil {
+		req.Raw().Header["Sync-Token"] = []string{*client.syncToken}
+	}
 	return req, nil
 }
 
@@ -797,26 +797,24 @@ func (client *AzureAppConfigurationClient) getKeyValuesCreateRequest(ctx context
 		return nil, err
 	}
 	reqQP := req.Raw().URL.Query()
+	if options != nil && options.Select != nil {
+		reqQP.Set("$Select", strings.Join(strings.Fields(strings.Trim(fmt.Sprint(options.Select), "[]")), ","))
+	}
+	if options != nil && options.After != nil {
+		reqQP.Set("After", *options.After)
+	}
+	reqQP.Set("api-version", "2023-10-01")
 	if options != nil && options.Key != nil {
 		reqQP.Set("key", *options.Key)
 	}
 	if options != nil && options.Label != nil {
 		reqQP.Set("label", *options.Label)
 	}
-	reqQP.Set("api-version", "2023-10-01")
-	if options != nil && options.After != nil {
-		reqQP.Set("After", *options.After)
-	}
-	if options != nil && options.Select != nil {
-		reqQP.Set("$Select", strings.Join(strings.Fields(strings.Trim(fmt.Sprint(options.Select), "[]")), ","))
-	}
 	if options != nil && options.Snapshot != nil {
 		reqQP.Set("snapshot", *options.Snapshot)
 	}
 	req.Raw().URL.RawQuery = reqQP.Encode()
-	if client.syncToken != nil {
-		req.Raw().Header["Sync-Token"] = []string{*client.syncToken}
-	}
+	req.Raw().Header["Accept"] = []string{"application/vnd.microsoft.appconfig.kvset+json, application/problem+json"}
 	if options != nil && options.AcceptDatetime != nil {
 		req.Raw().Header["Accept-Datetime"] = []string{*options.AcceptDatetime}
 	}
@@ -826,7 +824,9 @@ func (client *AzureAppConfigurationClient) getKeyValuesCreateRequest(ctx context
 	if options != nil && options.IfNoneMatch != nil {
 		req.Raw().Header["If-None-Match"] = []string{*options.IfNoneMatch}
 	}
-	req.Raw().Header["Accept"] = []string{"application/vnd.microsoft.appconfig.kvset+json, application/problem+json"}
+	if client.syncToken != nil {
+		req.Raw().Header["Sync-Token"] = []string{*client.syncToken}
+	}
 	return req, nil
 }
 
@@ -883,21 +883,21 @@ func (client *AzureAppConfigurationClient) getKeysCreateRequest(ctx context.Cont
 		return nil, err
 	}
 	reqQP := req.Raw().URL.Query()
-	if options != nil && options.Name != nil {
-		reqQP.Set("name", *options.Name)
-	}
-	reqQP.Set("api-version", "2023-10-01")
 	if options != nil && options.After != nil {
 		reqQP.Set("After", *options.After)
 	}
-	req.Raw().URL.RawQuery = reqQP.Encode()
-	if client.syncToken != nil {
-		req.Raw().Header["Sync-Token"] = []string{*client.syncToken}
+	reqQP.Set("api-version", "2023-10-01")
+	if options != nil && options.Name != nil {
+		reqQP.Set("name", *options.Name)
 	}
+	req.Raw().URL.RawQuery = reqQP.Encode()
+	req.Raw().Header["Accept"] = []string{"application/vnd.microsoft.appconfig.keyset+json, application/problem+json"}
 	if options != nil && options.AcceptDatetime != nil {
 		req.Raw().Header["Accept-Datetime"] = []string{*options.AcceptDatetime}
 	}
-	req.Raw().Header["Accept"] = []string{"application/vnd.microsoft.appconfig.keyset+json, application/problem+json"}
+	if client.syncToken != nil {
+		req.Raw().Header["Sync-Token"] = []string{*client.syncToken}
+	}
 	return req, nil
 }
 
@@ -951,24 +951,24 @@ func (client *AzureAppConfigurationClient) getLabelsCreateRequest(ctx context.Co
 		return nil, err
 	}
 	reqQP := req.Raw().URL.Query()
-	if options != nil && options.Name != nil {
-		reqQP.Set("name", *options.Name)
+	if options != nil && options.Select != nil {
+		reqQP.Set("$Select", strings.Join(strings.Fields(strings.Trim(fmt.Sprint(options.Select), "[]")), ","))
 	}
-	reqQP.Set("api-version", "2023-10-01")
 	if options != nil && options.After != nil {
 		reqQP.Set("After", *options.After)
 	}
-	if options != nil && options.Select != nil {
-		reqQP.Set("$Select", strings.Join(strings.Fields(strings.Trim(fmt.Sprint(options.Select), "[]")), ","))
+	reqQP.Set("api-version", "2023-10-01")
+	if options != nil && options.Name != nil {
+		reqQP.Set("name", *options.Name)
 	}
 	req.Raw().URL.RawQuery = reqQP.Encode()
-	if client.syncToken != nil {
-		req.Raw().Header["Sync-Token"] = []string{*client.syncToken}
-	}
+	req.Raw().Header["Accept"] = []string{"application/vnd.microsoft.appconfig.labelset+json, application/problem+json"}
 	if options != nil && options.AcceptDatetime != nil {
 		req.Raw().Header["Accept-Datetime"] = []string{*options.AcceptDatetime}
 	}
-	req.Raw().Header["Accept"] = []string{"application/vnd.microsoft.appconfig.labelset+json, application/problem+json"}
+	if client.syncToken != nil {
+		req.Raw().Header["Sync-Token"] = []string{*client.syncToken}
+	}
 	return req, nil
 }
 
@@ -1071,27 +1071,27 @@ func (client *AzureAppConfigurationClient) getRevisionsCreateRequest(ctx context
 		return nil, err
 	}
 	reqQP := req.Raw().URL.Query()
+	if options != nil && options.Select != nil {
+		reqQP.Set("$Select", strings.Join(strings.Fields(strings.Trim(fmt.Sprint(options.Select), "[]")), ","))
+	}
+	if options != nil && options.After != nil {
+		reqQP.Set("After", *options.After)
+	}
+	reqQP.Set("api-version", "2023-10-01")
 	if options != nil && options.Key != nil {
 		reqQP.Set("key", *options.Key)
 	}
 	if options != nil && options.Label != nil {
 		reqQP.Set("label", *options.Label)
 	}
-	reqQP.Set("api-version", "2023-10-01")
-	if options != nil && options.After != nil {
-		reqQP.Set("After", *options.After)
-	}
-	if options != nil && options.Select != nil {
-		reqQP.Set("$Select", strings.Join(strings.Fields(strings.Trim(fmt.Sprint(options.Select), "[]")), ","))
-	}
 	req.Raw().URL.RawQuery = reqQP.Encode()
-	if client.syncToken != nil {
-		req.Raw().Header["Sync-Token"] = []string{*client.syncToken}
-	}
+	req.Raw().Header["Accept"] = []string{"application/vnd.microsoft.appconfig.kvset+json, application/problem+json"}
 	if options != nil && options.AcceptDatetime != nil {
 		req.Raw().Header["Accept-Datetime"] = []string{*options.AcceptDatetime}
 	}
-	req.Raw().Header["Accept"] = []string{"application/vnd.microsoft.appconfig.kvset+json, application/problem+json"}
+	if client.syncToken != nil {
+		req.Raw().Header["Sync-Token"] = []string{*client.syncToken}
+	}
 	return req, nil
 }
 
@@ -1147,21 +1147,21 @@ func (client *AzureAppConfigurationClient) getSnapshotCreateRequest(ctx context.
 		return nil, err
 	}
 	reqQP := req.Raw().URL.Query()
-	reqQP.Set("api-version", "2023-10-01")
 	if options != nil && options.Select != nil {
 		reqQP.Set("$Select", strings.Join(strings.Fields(strings.Trim(fmt.Sprint(options.Select), "[]")), ","))
 	}
+	reqQP.Set("api-version", "2023-10-01")
 	req.Raw().URL.RawQuery = reqQP.Encode()
-	if client.syncToken != nil {
-		req.Raw().Header["Sync-Token"] = []string{*client.syncToken}
-	}
+	req.Raw().Header["Accept"] = []string{"application/vnd.microsoft.appconfig.snapshot+json, application/problem+json"}
 	if options != nil && options.IfMatch != nil {
 		req.Raw().Header["If-Match"] = []string{*options.IfMatch}
 	}
 	if options != nil && options.IfNoneMatch != nil {
 		req.Raw().Header["If-None-Match"] = []string{*options.IfNoneMatch}
 	}
-	req.Raw().Header["Accept"] = []string{"application/vnd.microsoft.appconfig.snapshot+json, application/problem+json"}
+	if client.syncToken != nil {
+		req.Raw().Header["Sync-Token"] = []string{*client.syncToken}
+	}
 	return req, nil
 }
 
@@ -1221,24 +1221,24 @@ func (client *AzureAppConfigurationClient) getSnapshotsCreateRequest(ctx context
 		return nil, err
 	}
 	reqQP := req.Raw().URL.Query()
-	if options != nil && options.Name != nil {
-		reqQP.Set("name", *options.Name)
+	if options != nil && options.Select != nil {
+		reqQP.Set("$Select", strings.Join(strings.Fields(strings.Trim(fmt.Sprint(options.Select), "[]")), ","))
 	}
-	reqQP.Set("api-version", "2023-10-01")
 	if options != nil && options.After != nil {
 		reqQP.Set("After", *options.After)
 	}
-	if options != nil && options.Select != nil {
-		reqQP.Set("$Select", strings.Join(strings.Fields(strings.Trim(fmt.Sprint(options.Select), "[]")), ","))
+	reqQP.Set("api-version", "2023-10-01")
+	if options != nil && options.Name != nil {
+		reqQP.Set("name", *options.Name)
 	}
 	if options != nil && options.Status != nil {
 		reqQP.Set("status", strings.Join(strings.Fields(strings.Trim(fmt.Sprint(options.Status), "[]")), ","))
 	}
 	req.Raw().URL.RawQuery = reqQP.Encode()
+	req.Raw().Header["Accept"] = []string{"application/vnd.microsoft.appconfig.snapshotset+json, application/problem+json"}
 	if client.syncToken != nil {
 		req.Raw().Header["Sync-Token"] = []string{*client.syncToken}
 	}
-	req.Raw().Header["Accept"] = []string{"application/vnd.microsoft.appconfig.snapshotset+json, application/problem+json"}
 	return req, nil
 }
 
@@ -1292,21 +1292,21 @@ func (client *AzureAppConfigurationClient) putKeyValueCreateRequest(ctx context.
 		return nil, err
 	}
 	reqQP := req.Raw().URL.Query()
+	reqQP.Set("api-version", "2023-10-01")
 	if options != nil && options.Label != nil {
 		reqQP.Set("label", *options.Label)
 	}
-	reqQP.Set("api-version", "2023-10-01")
 	req.Raw().URL.RawQuery = reqQP.Encode()
-	if client.syncToken != nil {
-		req.Raw().Header["Sync-Token"] = []string{*client.syncToken}
-	}
+	req.Raw().Header["Accept"] = []string{"application/vnd.microsoft.appconfig.kv+json, application/problem+json"}
 	if options != nil && options.IfMatch != nil {
 		req.Raw().Header["If-Match"] = []string{*options.IfMatch}
 	}
 	if options != nil && options.IfNoneMatch != nil {
 		req.Raw().Header["If-None-Match"] = []string{*options.IfNoneMatch}
 	}
-	req.Raw().Header["Accept"] = []string{"application/vnd.microsoft.appconfig.kv+json, application/problem+json"}
+	if client.syncToken != nil {
+		req.Raw().Header["Sync-Token"] = []string{*client.syncToken}
+	}
 	if err := runtime.MarshalAsJSON(req, entity); err != nil {
 		return nil, err
 	}
@@ -1365,21 +1365,21 @@ func (client *AzureAppConfigurationClient) putLockCreateRequest(ctx context.Cont
 		return nil, err
 	}
 	reqQP := req.Raw().URL.Query()
+	reqQP.Set("api-version", "2023-10-01")
 	if options != nil && options.Label != nil {
 		reqQP.Set("label", *options.Label)
 	}
-	reqQP.Set("api-version", "2023-10-01")
 	req.Raw().URL.RawQuery = reqQP.Encode()
-	if client.syncToken != nil {
-		req.Raw().Header["Sync-Token"] = []string{*client.syncToken}
-	}
+	req.Raw().Header["Accept"] = []string{"application/vnd.microsoft.appconfig.kv+json, application/problem+json"}
 	if options != nil && options.IfMatch != nil {
 		req.Raw().Header["If-Match"] = []string{*options.IfMatch}
 	}
 	if options != nil && options.IfNoneMatch != nil {
 		req.Raw().Header["If-None-Match"] = []string{*options.IfNoneMatch}
 	}
-	req.Raw().Header["Accept"] = []string{"application/vnd.microsoft.appconfig.kv+json, application/problem+json"}
+	if client.syncToken != nil {
+		req.Raw().Header["Sync-Token"] = []string{*client.syncToken}
+	}
 	return req, nil
 }
 
@@ -1438,16 +1438,16 @@ func (client *AzureAppConfigurationClient) updateSnapshotCreateRequest(ctx conte
 	reqQP := req.Raw().URL.Query()
 	reqQP.Set("api-version", "2023-10-01")
 	req.Raw().URL.RawQuery = reqQP.Encode()
-	if client.syncToken != nil {
-		req.Raw().Header["Sync-Token"] = []string{*client.syncToken}
-	}
+	req.Raw().Header["Accept"] = []string{"application/vnd.microsoft.appconfig.snapshot+json, application/problem+json"}
 	if options != nil && options.IfMatch != nil {
 		req.Raw().Header["If-Match"] = []string{*options.IfMatch}
 	}
 	if options != nil && options.IfNoneMatch != nil {
 		req.Raw().Header["If-None-Match"] = []string{*options.IfNoneMatch}
 	}
-	req.Raw().Header["Accept"] = []string{"application/vnd.microsoft.appconfig.snapshot+json, application/problem+json"}
+	if client.syncToken != nil {
+		req.Raw().Header["Sync-Token"] = []string{*client.syncToken}
+	}
 	if err := runtime.MarshalAsJSON(req, entity); err != nil {
 		return nil, err
 	}
diff --git a/sdk/data/azappconfig/internal/generated/zz_models_serde.go b/sdk/data/azappconfig/internal/generated/zz_models_serde.go
index 25b4a5e7ca72..3baf26974550 100644
--- a/sdk/data/azappconfig/internal/generated/zz_models_serde.go
+++ b/sdk/data/azappconfig/internal/generated/zz_models_serde.go
@@ -536,7 +536,7 @@ func populate(m map[string]any, k string, v any) {
 }
 
 func unpopulate(data json.RawMessage, fn string, v any) error {
-	if data == nil {
+	if data == nil || string(data) == "null" {
 		return nil
 	}
 	if err := json.Unmarshal(data, v); err != nil {
diff --git a/sdk/data/azappconfig/internal/generated/zz_response_types.go b/sdk/data/azappconfig/internal/generated/zz_responses.go
similarity index 100%
rename from sdk/data/azappconfig/internal/generated/zz_response_types.go
rename to sdk/data/azappconfig/internal/generated/zz_responses.go
diff --git a/sdk/data/azappconfig/internal/generated/zz_time_rfc3339.go b/sdk/data/azappconfig/internal/generated/zz_time_rfc3339.go
index f7ee07918fbb..c47ca575c64c 100644
--- a/sdk/data/azappconfig/internal/generated/zz_time_rfc3339.go
+++ b/sdk/data/azappconfig/internal/generated/zz_time_rfc3339.go
@@ -19,12 +19,16 @@ import (
 )
 
 // Azure reports time in UTC but it doesn't include the 'Z' time zone suffix in some cases.
-var tzOffsetRegex = regexp.MustCompile(`(Z|z|\+|-)(\d+:\d+)*"*$`)
+var tzOffsetRegex = regexp.MustCompile(`(?:Z|z|\+|-)(?:\d+:\d+)*"*$`)
 
 const (
-	utcDateTimeJSON = `"2006-01-02T15:04:05.999999999"`
-	utcDateTime     = "2006-01-02T15:04:05.999999999"
-	dateTimeJSON    = `"` + time.RFC3339Nano + `"`
+	utcDateTime        = "2006-01-02T15:04:05.999999999"
+	utcDateTimeJSON    = `"` + utcDateTime + `"`
+	utcDateTimeNoT     = "2006-01-02 15:04:05.999999999"
+	utcDateTimeJSONNoT = `"` + utcDateTimeNoT + `"`
+	dateTimeNoT        = `2006-01-02 15:04:05.999999999Z07:00`
+	dateTimeJSON       = `"` + time.RFC3339Nano + `"`
+	dateTimeJSONNoT    = `"` + dateTimeNoT + `"`
 )
 
 type dateTimeRFC3339 time.Time
@@ -40,17 +44,33 @@ func (t dateTimeRFC3339) MarshalText() ([]byte, error) {
 }
 
 func (t *dateTimeRFC3339) UnmarshalJSON(data []byte) error {
-	layout := utcDateTimeJSON
-	if tzOffsetRegex.Match(data) {
+	tzOffset := tzOffsetRegex.Match(data)
+	hasT := strings.Contains(string(data), "T") || strings.Contains(string(data), "t")
+	var layout string
+	if tzOffset && hasT {
 		layout = dateTimeJSON
+	} else if tzOffset {
+		layout = dateTimeJSONNoT
+	} else if hasT {
+		layout = utcDateTimeJSON
+	} else {
+		layout = utcDateTimeJSONNoT
 	}
 	return t.Parse(layout, string(data))
 }
 
 func (t *dateTimeRFC3339) UnmarshalText(data []byte) error {
-	layout := utcDateTime
-	if tzOffsetRegex.Match(data) {
+	tzOffset := tzOffsetRegex.Match(data)
+	hasT := strings.Contains(string(data), "T") || strings.Contains(string(data), "t")
+	var layout string
+	if tzOffset && hasT {
 		layout = time.RFC3339Nano
+	} else if tzOffset {
+		layout = dateTimeNoT
+	} else if hasT {
+		layout = utcDateTime
+	} else {
+		layout = utcDateTimeNoT
 	}
 	return t.Parse(layout, string(data))
 }
@@ -61,6 +81,10 @@ func (t *dateTimeRFC3339) Parse(layout, value string) error {
 	return err
 }
 
+func (t dateTimeRFC3339) String() string {
+	return time.Time(t).Format(time.RFC3339Nano)
+}
+
 func populateDateTimeRFC3339(m map[string]any, k string, t *time.Time) {
 	if t == nil {
 		return
@@ -74,7 +98,7 @@ func populateDateTimeRFC3339(m map[string]any, k string, t *time.Time) {
 }
 
 func unpopulateDateTimeRFC3339(data json.RawMessage, fn string, t **time.Time) error {
-	if data == nil || strings.EqualFold(string(data), "null") {
+	if data == nil || string(data) == "null" {
 		return nil
 	}
 	var aux dateTimeRFC3339