Repository: Azure/azure-sdk-for-go
Pull request #20015 (2023-02-15 02:32:05)

[azeventhubs] Fix credit requesting errors
The current go-amqp can have issues if your active credits are greater than the session window size. We have a blocking-release bug here: https://github.com/Azure/go-amqp/issues/240.

I've also added validation to prevent asking for <= 0 credits as well, which isn't supported.

azure-pipelines[bot]: <samp>
Azure Pipelines successfully started running 1 pipeline(s).<br>

</samp>

Patch:
diff --git a/eng/common/pipelines/templates/jobs/perf.yml b/eng/common/pipelines/templates/jobs/perf.yml
index ff2d531625..073e5de641 100644
--- a/eng/common/pipelines/templates/jobs/perf.yml
+++ b/eng/common/pipelines/templates/jobs/perf.yml
@@ -2,18 +2,15 @@ parameters:
 - name: JobName
   type: string
   default: 'Perf'
+- name: TimeoutInMinutes
+  type: number
+  default: '360'
 - name: LinuxPool
   type: string
-  default: 'azsdk-pool-mms-ubuntu-2004-perf'
-- name: LinuxVmImage
-  type: string
-  default: 'MMSUbuntu20.04'
+  default: 'azsdk-pool-mms-ubuntu-2204-perf'
 - name: WindowsPool
   type: string
-  default: 'azsdk-pool-mms-win-2019-perf'
-- name: WindowsVmImage
-  type: string
-  default: 'MMS2019'
+  default: 'azsdk-pool-mms-win-2022-perf'
 - name: Language
   type: string
   default: ''
@@ -65,18 +62,16 @@ parameters:
 
 jobs:
 - job: ${{ parameters.JobName }}
-  timeoutInMinutes: 360
+  timeoutInMinutes: ${{ parameters.TimeoutInMinutes }}
   strategy:
     matrix:
       ${{ if contains(parameters.OperatingSystems, 'Linux') }}:
         Linux:
           Pool: ${{ parameters.LinuxPool }}
-          OsVmImage: ${{ parameters.LinuxVmImage }}
           MatrixName: 'Linux'
       ${{ if contains(parameters.OperatingSystems, 'Windows') }}:
         Windows:
           Pool: ${{ parameters.WindowsPool }}
-          OsVmImage: ${{ parameters.WindowsVmImage }}
           MatrixName: 'Windows'
   variables:
   - ${{ parameters.Variables }}
@@ -87,7 +82,6 @@ jobs:
       value: ''
   pool:
     name: $(Pool)
-    vmImage: $(OSVmImage)
   steps:
 
   - template: /eng/common/pipelines/templates/steps/sparse-checkout.yml
@@ -106,10 +100,6 @@ jobs:
         Commitish: ${{ parameters.ToolsRepoCommitish }}
         WorkingDirectory: $(System.DefaultWorkingDirectory)/azure-sdk-tools
 
-  - template: /eng/common/pipelines/templates/steps/verify-agent-os.yml
-    parameters:
-      AgentImage: $(OSVmImage)
-
   - ${{ parameters.InstallLanguageSteps }}
 
   - template: /eng/common/TestResources/deploy-test-resources.yml
diff --git a/sdk/data/azcosmos/CHANGELOG.md b/sdk/data/azcosmos/CHANGELOG.md
index e110a9000a..b95809c018 100644
--- a/sdk/data/azcosmos/CHANGELOG.md
+++ b/sdk/data/azcosmos/CHANGELOG.md
@@ -3,6 +3,7 @@
 ## 0.3.4 (Unreleased)
 
 ### Features Added
+* Added `NullPartitionKey` variable to create and query documents with null partition key in CosmosDB
 
 ### Breaking Changes
 
diff --git a/sdk/data/azcosmos/partition_key.go b/sdk/data/azcosmos/partition_key.go
index da0ac27763..ca61aec87a 100644
--- a/sdk/data/azcosmos/partition_key.go
+++ b/sdk/data/azcosmos/partition_key.go
@@ -14,6 +14,11 @@ type PartitionKey struct {
 	values []interface{}
 }
 
+// NullPartitionKey represents a partition key with a null value.
+var NullPartitionKey PartitionKey = PartitionKey{
+	values: []interface{}{nil},
+}
+
 // NewPartitionKeyString creates a partition key with a string value.
 func NewPartitionKeyString(value string) PartitionKey {
 	components := []interface{}{value}
diff --git a/sdk/messaging/azeventhubs/internal/eh/stress/Dockerfile b/sdk/messaging/azeventhubs/internal/eh/stress/Dockerfile
index 39f0df1368..10cf2a3ef8 100644
--- a/sdk/messaging/azeventhubs/internal/eh/stress/Dockerfile
+++ b/sdk/messaging/azeventhubs/internal/eh/stress/Dockerfile
@@ -1,4 +1,4 @@
-FROM mcr.microsoft.com/oss/go/microsoft/golang:1.18 as build
+FROM mcr.microsoft.com/oss/go/microsoft/golang:1.20 as build
 # you'll need to run this build from the root of the azeventhubs module
 ENV GOOS=linux 
 ENV GOARCH=amd64 
diff --git a/sdk/messaging/azeventhubs/internal/eh/stress/stress.go b/sdk/messaging/azeventhubs/internal/eh/stress/stress.go
index eab8fda442..81ab35a939 100644
--- a/sdk/messaging/azeventhubs/internal/eh/stress/stress.go
+++ b/sdk/messaging/azeventhubs/internal/eh/stress/stress.go
@@ -5,10 +5,8 @@ package main
 import (
 	"context"
 	"fmt"
-	"math/rand"
 	"os"
 	"sort"
-	"time"
 
 	"github.com/Azure/azure-sdk-for-go/sdk/messaging/azeventhubs/internal/eh/stress/tests"
 )
@@ -42,8 +40,6 @@ func main() {
 
 	for _, test := range tests {
 		if test.name == testName {
-			rand.Seed(time.Now().UnixNano())
-
 			if err := test.fn(context.Background()); err != nil {
 				fmt.Printf("ERROR: %s\n", err)
 				os.Exit(1)
diff --git a/sdk/messaging/azeventhubs/partition_client.go b/sdk/messaging/azeventhubs/partition_client.go
index eec90d5615..8640a2a781 100644
--- a/sdk/messaging/azeventhubs/partition_client.go
+++ b/sdk/messaging/azeventhubs/partition_client.go
@@ -21,7 +21,11 @@ import (
 const DefaultConsumerGroup = "$Default"
 
 const defaultPrefetchSize = uint32(300)
-const defaultMaxCreditSize = uint32(2048)
+
+// defaultLinkRxBuffer is the maximum number of transfer frames we can handle
+// on the Receiver. This matches the current default window size that go-amqp
+// uses for sessions.
+const defaultMaxCreditSize = uint32(5000)
 
 // StartPosition indicates the position to start receiving events within a partition.
 // The default position is Latest.
@@ -100,6 +104,14 @@ func (pc *PartitionClient) ReceiveEvents(ctx context.Context, count int, options
 
 	prefetchDisabled := pc.prefetch < 0
 
+	if count <= 0 {
+		return nil, internal.NewErrNonRetriable("count should be greater than 0")
+	}
+
+	if prefetchDisabled && count > int(defaultMaxCreditSize) {
+		return nil, internal.NewErrNonRetriable(fmt.Sprintf("count cannot exceed %d", defaultMaxCreditSize))
+	}
+
 	err := pc.links.Retry(ctx, EventConsumer, "ReceiveEvents", pc.partitionID, pc.retryOptions, func(ctx context.Context, lwid internal.LinkWithID[amqpwrap.AMQPReceiverCloser]) error {
 		events = nil
 
@@ -259,6 +271,11 @@ func newPartitionClient(args partitionClientArgs, options *PartitionClientOption
 		return nil, err
 	}
 
+	if options.Prefetch > int32(defaultMaxCreditSize) {
+		// don't allow them to set the prefetch above the session window size.
+		return nil, internal.NewErrNonRetriable(fmt.Sprintf("options.Prefetch cannot exceed %d", defaultMaxCreditSize))
+	}
+
 	client := &PartitionClient{
 		eventHub:         args.eventHub,
 		partitionID:      args.partitionID,
diff --git a/sdk/resourcemanager/liftrqumulo/armqumulo/CHANGELOG.md b/sdk/resourcemanager/liftrqumulo/armqumulo/CHANGELOG.md
new file mode 100644
index 0000000000..4de3835267
--- /dev/null
+++ b/sdk/resourcemanager/liftrqumulo/armqumulo/CHANGELOG.md
@@ -0,0 +1,7 @@
+# Release History
+
+## 0.1.0 (2023-02-15)
+
+The package of `github.com/Azure/azure-sdk-for-go/sdk/resourcemanager/liftrqumulo/armqumulo` is using our [next generation design principles](https://azure.github.io/azure-sdk/general_introduction.html).
+
+To learn more, please refer to our documentation [Quick Start](https://aka.ms/azsdk/go/mgmt).
diff --git a/sdk/resourcemanager/liftrqumulo/armqumulo/LICENSE.txt b/sdk/resourcemanager/liftrqumulo/armqumulo/LICENSE.txt
new file mode 100644
index 0000000000..dc0c2ffb3d
--- /dev/null
+++ b/sdk/resourcemanager/liftrqumulo/armqumulo/LICENSE.txt
@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) Microsoft Corporation. All rights reserved.
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.
\ No newline at end of file
diff --git a/sdk/resourcemanager/liftrqumulo/armqumulo/README.md b/sdk/resourcemanager/liftrqumulo/armqumulo/README.md
new file mode 100644
index 0000000000..7b36d022cb
--- /dev/null
+++ b/sdk/resourcemanager/liftrqumulo/armqumulo/README.md
@@ -0,0 +1,77 @@
+# Azure Liftr Qumulo Module for Go
+
+[![PkgGoDev](https://pkg.go.dev/badge/github.com/Azure/azure-sdk-for-go/sdk/resourcemanager/liftrqumulo/armqumulo)](https://pkg.go.dev/github.com/Azure/azure-sdk-for-go/sdk/resourcemanager/liftrqumulo/armqumulo)
+
+The `armqumulo` module provides operations for working with Azure Liftr Qumulo.
+
+[Source code](https://github.com/Azure/azure-sdk-for-go/tree/main/sdk/resourcemanager/liftrqumulo/armqumulo)
+
+# Getting started
+
+## Prerequisites
+
+- an [Azure subscription](https://azure.microsoft.com/free/)
+- Go 1.18 or above (You could download and install the latest version of Go from [here](https://go.dev/doc/install). It will replace the existing Go on your machine. If you want to install multiple Go versions on the same machine, you could refer this [doc](https://go.dev/doc/manage-install).)
+
+## Install the package
+
+This project uses [Go modules](https://github.com/golang/go/wiki/Modules) for versioning and dependency management.
+
+Install the Azure Liftr Qumulo module:
+
+```sh
+go get github.com/Azure/azure-sdk-for-go/sdk/resourcemanager/liftrqumulo/armqumulo
+```
+
+## Authorization
+
+When creating a client, you will need to provide a credential for authenticating with Azure Liftr Qumulo.  The `azidentity` module provides facilities for various ways of authenticating with Azure including client/secret, certificate, managed identity, and more.
+
+```go
+cred, err := azidentity.NewDefaultAzureCredential(nil)
+```
+
+For more information on authentication, please see the documentation for `azidentity` at [pkg.go.dev/github.com/Azure/azure-sdk-for-go/sdk/azidentity](https://pkg.go.dev/github.com/Azure/azure-sdk-for-go/sdk/azidentity).
+
+## Clients
+
+Azure Liftr Qumulo modules consist of one or more clients.  A client groups a set of related APIs, providing access to its functionality within the specified subscription.  Create one or more clients to access the APIs you require using your credential.
+
+```go
+client, err := armqumulo.NewFileSystemsClient(<subscription ID>, cred, nil)
+```
+
+You can use `ClientOptions` in package `github.com/Azure/azure-sdk-for-go/sdk/azcore/arm` to set endpoint to connect with public and sovereign clouds as well as Azure Stack. For more information, please see the documentation for `azcore` at [pkg.go.dev/github.com/Azure/azure-sdk-for-go/sdk/azcore](https://pkg.go.dev/github.com/Azure/azure-sdk-for-go/sdk/azcore).
+
+```go
+options := arm.ClientOptions{
+    ClientOptions: azcore.ClientOptions {
+        Cloud: cloud.AzureChina,
+    },
+}
+client, err := armqumulo.NewFileSystemsClient(<subscription ID>, cred, &options)
+```
+
+## Provide Feedback
+
+If you encounter bugs or have suggestions, please
+[open an issue](https://github.com/Azure/azure-sdk-for-go/issues) and assign the `Liftr Qumulo` label.
+
+# Contributing
+
+This project welcomes contributions and suggestions. Most contributions require
+you to agree to a Contributor License Agreement (CLA) declaring that you have
+the right to, and actually do, grant us the rights to use your contribution.
+For details, visit [https://cla.microsoft.com](https://cla.microsoft.com).
+
+When you submit a pull request, a CLA-bot will automatically determine whether
+you need to provide a CLA and decorate the PR appropriately (e.g., label,
+comment). Simply follow the instructions provided by the bot. You will only
+need to do this once across all repos using our CLA.
+
+This project has adopted the
+[Microsoft Open Source Code of Conduct](https://opensource.microsoft.com/codeofconduct/).
+For more information, see the
+[Code of Conduct FAQ](https://opensource.microsoft.com/codeofconduct/faq/)
+or contact [opencode@microsoft.com](mailto:opencode@microsoft.com) with any
+additional questions or comments.
\ No newline at end of file
diff --git a/sdk/resourcemanager/liftrqumulo/armqumulo/autorest.md b/sdk/resourcemanager/liftrqumulo/armqumulo/autorest.md
new file mode 100644
index 0000000000..e4929ac8d3
--- /dev/null
+++ b/sdk/resourcemanager/liftrqumulo/armqumulo/autorest.md
@@ -0,0 +1,13 @@
+### AutoRest Configuration
+
+> see https://aka.ms/autorest
+
+``` yaml
+azure-arm: true
+require:
+- https://github.com/Azure/azure-rest-api-specs/blob/9918780b4dc4bdc111cf3facc11561904d609ad7/specification/liftrqumulo/resource-manager/readme.md
+- https://github.com/Azure/azure-rest-api-specs/blob/9918780b4dc4bdc111cf3facc11561904d609ad7/specification/liftrqumulo/resource-manager/readme.go.md
+license-header: MICROSOFT_MIT_NO_VERSION
+module-version: 0.1.0
+
+```
\ No newline at end of file
diff --git a/sdk/resourcemanager/liftrqumulo/armqumulo/build.go b/sdk/resourcemanager/liftrqumulo/armqumulo/build.go
new file mode 100644
index 0000000000..f5cf562c55
--- /dev/null
+++ b/sdk/resourcemanager/liftrqumulo/armqumulo/build.go
@@ -0,0 +1,7 @@
+// Copyright (c) Microsoft Corporation. All rights reserved.
+// Licensed under the MIT License. See License.txt in the project root for license information.
+
+// This file enables 'go generate' to regenerate this specific SDK
+//go:generate pwsh ../../../../eng/scripts/build.ps1 -skipBuild -cleanGenerated -format -tidy -generate -alwaysSetBodyParamRequired -removeUnreferencedTypes resourcemanager/liftrqumulo/armqumulo
+
+package armqumulo
diff --git a/sdk/resourcemanager/liftrqumulo/armqumulo/ci.yml b/sdk/resourcemanager/liftrqumulo/armqumulo/ci.yml
new file mode 100644
index 0000000000..d81835cea2
--- /dev/null
+++ b/sdk/resourcemanager/liftrqumulo/armqumulo/ci.yml
@@ -0,0 +1,28 @@
+# NOTE: Please refer to https://aka.ms/azsdk/engsys/ci-yaml before editing this file.
+trigger:
+  branches:
+    include:
+      - main
+      - feature/*
+      - hotfix/*
+      - release/*
+  paths:
+    include:
+    - sdk/resourcemanager/liftrqumulo/armqumulo/
+
+pr:
+  branches:
+    include:
+      - main
+      - feature/*
+      - hotfix/*
+      - release/*
+  paths:
+    include:
+    - sdk/resourcemanager/liftrqumulo/armqumulo/
+
+stages:
+- template: /eng/pipelines/templates/jobs/archetype-sdk-client.yml
+  parameters:
+    IncludeRelease: true
+    ServiceDirectory: 'resourcemanager/liftrqumulo/armqumulo'
diff --git a/sdk/resourcemanager/liftrqumulo/armqumulo/constants.go b/sdk/resourcemanager/liftrqumulo/armqumulo/constants.go
new file mode 100644
index 0000000000..8a23223b37
--- /dev/null
+++ b/sdk/resourcemanager/liftrqumulo/armqumulo/constants.go
@@ -0,0 +1,169 @@
+//go:build go1.18
+// +build go1.18
+
+// Copyright (c) Microsoft Corporation. All rights reserved.
+// Licensed under the MIT License. See License.txt in the project root for license information.
+// Code generated by Microsoft (R) AutoRest Code Generator.
+// Changes may cause incorrect behavior and will be lost if the code is regenerated.
+// DO NOT EDIT.
+
+package armqumulo
+
+const (
+	moduleName    = "armqumulo"
+	moduleVersion = "v0.1.0"
+)
+
+// ActionType - Enum. Indicates the action type. "Internal" refers to actions that are for internal only APIs.
+type ActionType string
+
+const (
+	ActionTypeInternal ActionType = "Internal"
+)
+
+// PossibleActionTypeValues returns the possible values for the ActionType const type.
+func PossibleActionTypeValues() []ActionType {
+	return []ActionType{
+		ActionTypeInternal,
+	}
+}
+
+// CreatedByType - The type of identity that created the resource.
+type CreatedByType string
+
+const (
+	CreatedByTypeApplication     CreatedByType = "Application"
+	CreatedByTypeKey             CreatedByType = "Key"
+	CreatedByTypeManagedIdentity CreatedByType = "ManagedIdentity"
+	CreatedByTypeUser            CreatedByType = "User"
+)
+
+// PossibleCreatedByTypeValues returns the possible values for the CreatedByType const type.
+func PossibleCreatedByTypeValues() []CreatedByType {
+	return []CreatedByType{
+		CreatedByTypeApplication,
+		CreatedByTypeKey,
+		CreatedByTypeManagedIdentity,
+		CreatedByTypeUser,
+	}
+}
+
+// ManagedServiceIdentityType - Type of managed service identity (where both SystemAssigned and UserAssigned types are allowed).
+type ManagedServiceIdentityType string
+
+const (
+	ManagedServiceIdentityTypeNone                       ManagedServiceIdentityType = "None"
+	ManagedServiceIdentityTypeSystemAssigned             ManagedServiceIdentityType = "SystemAssigned"
+	ManagedServiceIdentityTypeSystemAssignedUserAssigned ManagedServiceIdentityType = "SystemAssigned, UserAssigned"
+	ManagedServiceIdentityTypeUserAssigned               ManagedServiceIdentityType = "UserAssigned"
+)
+
+// PossibleManagedServiceIdentityTypeValues returns the possible values for the ManagedServiceIdentityType const type.
+func PossibleManagedServiceIdentityTypeValues() []ManagedServiceIdentityType {
+	return []ManagedServiceIdentityType{
+		ManagedServiceIdentityTypeNone,
+		ManagedServiceIdentityTypeSystemAssigned,
+		ManagedServiceIdentityTypeSystemAssignedUserAssigned,
+		ManagedServiceIdentityTypeUserAssigned,
+	}
+}
+
+// MarketplaceSubscriptionStatus - Marketplace subscription status of the file system resource
+type MarketplaceSubscriptionStatus string
+
+const (
+	// MarketplaceSubscriptionStatusPendingFulfillmentStart - Fulfillment has not started
+	MarketplaceSubscriptionStatusPendingFulfillmentStart MarketplaceSubscriptionStatus = "PendingFulfillmentStart"
+	// MarketplaceSubscriptionStatusSubscribed - Marketplace offer is subscribed
+	MarketplaceSubscriptionStatusSubscribed MarketplaceSubscriptionStatus = "Subscribed"
+	// MarketplaceSubscriptionStatusSuspended - Marketplace offer is suspended because of non payment
+	MarketplaceSubscriptionStatusSuspended MarketplaceSubscriptionStatus = "Suspended"
+	// MarketplaceSubscriptionStatusUnsubscribed - Marketplace offer is unsubscribed
+	MarketplaceSubscriptionStatusUnsubscribed MarketplaceSubscriptionStatus = "Unsubscribed"
+)
+
+// PossibleMarketplaceSubscriptionStatusValues returns the possible values for the MarketplaceSubscriptionStatus const type.
+func PossibleMarketplaceSubscriptionStatusValues() []MarketplaceSubscriptionStatus {
+	return []MarketplaceSubscriptionStatus{
+		MarketplaceSubscriptionStatusPendingFulfillmentStart,
+		MarketplaceSubscriptionStatusSubscribed,
+		MarketplaceSubscriptionStatusSuspended,
+		MarketplaceSubscriptionStatusUnsubscribed,
+	}
+}
+
+// Origin - The intended executor of the operation; as in Resource Based Access Control (RBAC) and audit logs UX. Default
+// value is "user,system"
+type Origin string
+
+const (
+	OriginSystem     Origin = "system"
+	OriginUser       Origin = "user"
+	OriginUserSystem Origin = "user,system"
+)
+
+// PossibleOriginValues returns the possible values for the Origin const type.
+func PossibleOriginValues() []Origin {
+	return []Origin{
+		OriginSystem,
+		OriginUser,
+		OriginUserSystem,
+	}
+}
+
+// ProvisioningState - Provisioning State of the File system resource
+type ProvisioningState string
+
+const (
+	// ProvisioningStateAccepted - File system resource creation request accepted
+	ProvisioningStateAccepted ProvisioningState = "Accepted"
+	// ProvisioningStateCreating - File system resource creation started
+	ProvisioningStateCreating ProvisioningState = "Creating"
+	// ProvisioningStateUpdating - File system resource is being updated
+	ProvisioningStateUpdating ProvisioningState = "Updating"
+	// ProvisioningStateDeleting - File system resource deletion started
+	ProvisioningStateDeleting ProvisioningState = "Deleting"
+	// ProvisioningStateSucceeded - File system resource creation successful
+	ProvisioningStateSucceeded ProvisioningState = "Succeeded"
+	// ProvisioningStateFailed - File system resource creation failed
+	ProvisioningStateFailed ProvisioningState = "Failed"
+	// ProvisioningStateCanceled - File system resource creation canceled
+	ProvisioningStateCanceled ProvisioningState = "Canceled"
+	// ProvisioningStateDeleted - File system resource is deleted
+	ProvisioningStateDeleted ProvisioningState = "Deleted"
+	// ProvisioningStateNotSpecified - File system resource state is unknown
+	ProvisioningStateNotSpecified ProvisioningState = "NotSpecified"
+)
+
+// PossibleProvisioningStateValues returns the possible values for the ProvisioningState const type.
+func PossibleProvisioningStateValues() []ProvisioningState {
+	return []ProvisioningState{
+		ProvisioningStateAccepted,
+		ProvisioningStateCreating,
+		ProvisioningStateUpdating,
+		ProvisioningStateDeleting,
+		ProvisioningStateSucceeded,
+		ProvisioningStateFailed,
+		ProvisioningStateCanceled,
+		ProvisioningStateDeleted,
+		ProvisioningStateNotSpecified,
+	}
+}
+
+// StorageSKU - Storage Sku
+type StorageSKU string
+
+const (
+	// StorageSKUStandard - Standard Storage Sku
+	StorageSKUStandard StorageSKU = "Standard"
+	// StorageSKUPerformance - Performance Storage Sku
+	StorageSKUPerformance StorageSKU = "Performance"
+)
+
+// PossibleStorageSKUValues returns the possible values for the StorageSKU const type.
+func PossibleStorageSKUValues() []StorageSKU {
+	return []StorageSKU{
+		StorageSKUStandard,
+		StorageSKUPerformance,
+	}
+}
diff --git a/sdk/resourcemanager/liftrqumulo/armqumulo/filesystems_client.go b/sdk/resourcemanager/liftrqumulo/armqumulo/filesystems_client.go
new file mode 100644
index 0000000000..ab98a02ffe
--- /dev/null
+++ b/sdk/resourcemanager/liftrqumulo/armqumulo/filesystems_client.go
@@ -0,0 +1,430 @@
+//go:build go1.18
+// +build go1.18
+
+// Copyright (c) Microsoft Corporation. All rights reserved.
+// Licensed under the MIT License. See License.txt in the project root for license information.
+// Code generated by Microsoft (R) AutoRest Code Generator.
+// Changes may cause incorrect behavior and will be lost if the code is regenerated.
+// DO NOT EDIT.
+
+package armqumulo
+
+import (
+	"context"
+	"errors"
+	"github.com/Azure/azure-sdk-for-go/sdk/azcore"
+	"github.com/Azure/azure-sdk-for-go/sdk/azcore/arm"
+	armruntime "github.com/Azure/azure-sdk-for-go/sdk/azcore/arm/runtime"
+	"github.com/Azure/azure-sdk-for-go/sdk/azcore/cloud"
+	"github.com/Azure/azure-sdk-for-go/sdk/azcore/policy"
+	"github.com/Azure/azure-sdk-for-go/sdk/azcore/runtime"
+	"net/http"
+	"net/url"
+	"strings"
+)
+
+// FileSystemsClient contains the methods for the FileSystems group.
+// Don't use this type directly, use NewFileSystemsClient() instead.
+type FileSystemsClient struct {
+	host           string
+	subscriptionID string
+	pl             runtime.Pipeline
+}
+
+// NewFileSystemsClient creates a new instance of FileSystemsClient with the specified values.
+//   - subscriptionID - The ID of the target subscription.
+//   - credential - used to authorize requests. Usually a credential from azidentity.
+//   - options - pass nil to accept the default values.
+func NewFileSystemsClient(subscriptionID string, credential azcore.TokenCredential, options *arm.ClientOptions) (*FileSystemsClient, error) {
+	if options == nil {
+		options = &arm.ClientOptions{}
+	}
+	ep := cloud.AzurePublic.Services[cloud.ResourceManager].Endpoint
+	if c, ok := options.Cloud.Services[cloud.ResourceManager]; ok {
+		ep = c.Endpoint
+	}
+	pl, err := armruntime.NewPipeline(moduleName, moduleVersion, credential, runtime.PipelineOptions{}, options)
+	if err != nil {
+		return nil, err
+	}
+	client := &FileSystemsClient{
+		subscriptionID: subscriptionID,
+		host:           ep,
+		pl:             pl,
+	}
+	return client, nil
+}
+
+// BeginCreateOrUpdate - Create a FileSystemResource
+// If the operation fails it returns an *azcore.ResponseError type.
+//
+// Generated from API version 2022-10-12-preview
+//   - resourceGroupName - The name of the resource group. The name is case insensitive.
+//   - fileSystemName - Name of the File System resource
+//   - resource - Resource create parameters.
+//   - options - FileSystemsClientBeginCreateOrUpdateOptions contains the optional parameters for the FileSystemsClient.BeginCreateOrUpdate
+//     method.
+func (client *FileSystemsClient) BeginCreateOrUpdate(ctx context.Context, resourceGroupName string, fileSystemName string, resource FileSystemResource, options *FileSystemsClientBeginCreateOrUpdateOptions) (*runtime.Poller[FileSystemsClientCreateOrUpdateResponse], error) {
+	if options == nil || options.ResumeToken == "" {
+		resp, err := client.createOrUpdate(ctx, resourceGroupName, fileSystemName, resource, options)
+		if err != nil {
+			return nil, err
+		}
+		return runtime.NewPoller(resp, client.pl, &runtime.NewPollerOptions[FileSystemsClientCreateOrUpdateResponse]{
+			FinalStateVia: runtime.FinalStateViaAzureAsyncOp,
+		})
+	} else {
+		return runtime.NewPollerFromResumeToken[FileSystemsClientCreateOrUpdateResponse](options.ResumeToken, client.pl, nil)
+	}
+}
+
+// CreateOrUpdate - Create a FileSystemResource
+// If the operation fails it returns an *azcore.ResponseError type.
+//
+// Generated from API version 2022-10-12-preview
+func (client *FileSystemsClient) createOrUpdate(ctx context.Context, resourceGroupName string, fileSystemName string, resource FileSystemResource, options *FileSystemsClientBeginCreateOrUpdateOptions) (*http.Response, error) {
+	req, err := client.createOrUpdateCreateRequest(ctx, resourceGroupName, fileSystemName, resource, options)
+	if err != nil {
+		return nil, err
+	}
+	resp, err := client.pl.Do(req)
+	if err != nil {
+		return nil, err
+	}
+	if !runtime.HasStatusCode(resp, http.StatusOK, http.StatusCreated) {
+		return nil, runtime.NewResponseError(resp)
+	}
+	return resp, nil
+}
+
+// createOrUpdateCreateRequest creates the CreateOrUpdate request.
+func (client *FileSystemsClient) createOrUpdateCreateRequest(ctx context.Context, resourceGroupName string, fileSystemName string, resource FileSystemResource, options *FileSystemsClientBeginCreateOrUpdateOptions) (*policy.Request, error) {
+	urlPath := "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Qumulo.Storage/fileSystems/{fileSystemName}"
+	if client.subscriptionID == "" {
+		return nil, errors.New("parameter client.subscriptionID cannot be empty")
+	}
+	urlPath = strings.ReplaceAll(urlPath, "{subscriptionId}", url.PathEscape(client.subscriptionID))
+	if resourceGroupName == "" {
+		return nil, errors.New("parameter resourceGroupName cannot be empty")
+	}
+	urlPath = strings.ReplaceAll(urlPath, "{resourceGroupName}", url.PathEscape(resourceGroupName))
+	if fileSystemName == "" {
+		return nil, errors.New("parameter fileSystemName cannot be empty")
+	}
+	urlPath = strings.ReplaceAll(urlPath, "{fileSystemName}", url.PathEscape(fileSystemName))
+	req, err := runtime.NewRequest(ctx, http.MethodPut, runtime.JoinPaths(client.host, urlPath))
+	if err != nil {
+		return nil, err
+	}
+	reqQP := req.Raw().URL.Query()
+	reqQP.Set("api-version", "2022-10-12-preview")
+	req.Raw().URL.RawQuery = reqQP.Encode()
+	req.Raw().Header["Accept"] = []string{"application/json"}
+	return req, runtime.MarshalAsJSON(req, resource)
+}
+
+// BeginDelete - Delete a FileSystemResource
+// If the operation fails it returns an *azcore.ResponseError type.
+//
+// Generated from API version 2022-10-12-preview
+//   - resourceGroupName - The name of the resource group. The name is case insensitive.
+//   - fileSystemName - Name of the File System resource
+//   - options - FileSystemsClientBeginDeleteOptions contains the optional parameters for the FileSystemsClient.BeginDelete method.
+func (client *FileSystemsClient) BeginDelete(ctx context.Context, resourceGroupName string, fileSystemName string, options *FileSystemsClientBeginDeleteOptions) (*runtime.Poller[FileSystemsClientDeleteResponse], error) {
+	if options == nil || options.ResumeToken == "" {
+		resp, err := client.deleteOperation(ctx, resourceGroupName, fileSystemName, options)
+		if err != nil {
+			return nil, err
+		}
+		return runtime.NewPoller(resp, client.pl, &runtime.NewPollerOptions[FileSystemsClientDeleteResponse]{
+			FinalStateVia: runtime.FinalStateViaAzureAsyncOp,
+		})
+	} else {
+		return runtime.NewPollerFromResumeToken[FileSystemsClientDeleteResponse](options.ResumeToken, client.pl, nil)
+	}
+}
+
+// Delete - Delete a FileSystemResource
+// If the operation fails it returns an *azcore.ResponseError type.
+//
+// Generated from API version 2022-10-12-preview
+func (client *FileSystemsClient) deleteOperation(ctx context.Context, resourceGroupName string, fileSystemName string, options *FileSystemsClientBeginDeleteOptions) (*http.Response, error) {
+	req, err := client.deleteCreateRequest(ctx, resourceGroupName, fileSystemName, options)
+	if err != nil {
+		return nil, err
+	}
+	resp, err := client.pl.Do(req)
+	if err != nil {
+		return nil, err
+	}
+	if !runtime.HasStatusCode(resp, http.StatusOK, http.StatusAccepted, http.StatusNoContent) {
+		return nil, runtime.NewResponseError(resp)
+	}
+	return resp, nil
+}
+
+// deleteCreateRequest creates the Delete request.
+func (client *FileSystemsClient) deleteCreateRequest(ctx context.Context, resourceGroupName string, fileSystemName string, options *FileSystemsClientBeginDeleteOptions) (*policy.Request, error) {
+	urlPath := "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Qumulo.Storage/fileSystems/{fileSystemName}"
+	if client.subscriptionID == "" {
+		return nil, errors.New("parameter client.subscriptionID cannot be empty")
+	}
+	urlPath = strings.ReplaceAll(urlPath, "{subscriptionId}", url.PathEscape(client.subscriptionID))
+	if resourceGroupName == "" {
+		return nil, errors.New("parameter resourceGroupName cannot be empty")
+	}
+	urlPath = strings.ReplaceAll(urlPath, "{resourceGroupName}", url.PathEscape(resourceGroupName))
+	if fileSystemName == "" {
+		return nil, errors.New("parameter fileSystemName cannot be empty")
+	}
+	urlPath = strings.ReplaceAll(urlPath, "{fileSystemName}", url.PathEscape(fileSystemName))
+	req, err := runtime.NewRequest(ctx, http.MethodDelete, runtime.JoinPaths(client.host, urlPath))
+	if err != nil {
+		return nil, err
+	}
+	reqQP := req.Raw().URL.Query()
+	reqQP.Set("api-version", "2022-10-12-preview")
+	req.Raw().URL.RawQuery = reqQP.Encode()
+	req.Raw().Header["Accept"] = []string{"application/json"}
+	return req, nil
+}
+
+// Get - Get a FileSystemResource
+// If the operation fails it returns an *azcore.ResponseError type.
+//
+// Generated from API version 2022-10-12-preview
+//   - resourceGroupName - The name of the resource group. The name is case insensitive.
+//   - fileSystemName - Name of the File System resource
+//   - options - FileSystemsClientGetOptions contains the optional parameters for the FileSystemsClient.Get method.
+func (client *FileSystemsClient) Get(ctx context.Context, resourceGroupName string, fileSystemName string, options *FileSystemsClientGetOptions) (FileSystemsClientGetResponse, error) {
+	req, err := client.getCreateRequest(ctx, resourceGroupName, fileSystemName, options)
+	if err != nil {
+		return FileSystemsClientGetResponse{}, err
+	}
+	resp, err := client.pl.Do(req)
+	if err != nil {
+		return FileSystemsClientGetResponse{}, err
+	}
+	if !runtime.HasStatusCode(resp, http.StatusOK) {
+		return FileSystemsClientGetResponse{}, runtime.NewResponseError(resp)
+	}
+	return client.getHandleResponse(resp)
+}
+
+// getCreateRequest creates the Get request.
+func (client *FileSystemsClient) getCreateRequest(ctx context.Context, resourceGroupName string, fileSystemName string, options *FileSystemsClientGetOptions) (*policy.Request, error) {
+	urlPath := "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Qumulo.Storage/fileSystems/{fileSystemName}"
+	if client.subscriptionID == "" {
+		return nil, errors.New("parameter client.subscriptionID cannot be empty")
+	}
+	urlPath = strings.ReplaceAll(urlPath, "{subscriptionId}", url.PathEscape(client.subscriptionID))
+	if resourceGroupName == "" {
+		return nil, errors.New("parameter resourceGroupName cannot be empty")
+	}
+	urlPath = strings.ReplaceAll(urlPath, "{resourceGroupName}", url.PathEscape(resourceGroupName))
+	if fileSystemName == "" {
+		return nil, errors.New("parameter fileSystemName cannot be empty")
+	}
+	urlPath = strings.ReplaceAll(urlPath, "{fileSystemName}", url.PathEscape(fileSystemName))
+	req, err := runtime.NewRequest(ctx, http.MethodGet, runtime.JoinPaths(client.host, urlPath))
+	if err != nil {
+		return nil, err
+	}
+	reqQP := req.Raw().URL.Query()
+	reqQP.Set("api-version", "2022-10-12-preview")
+	req.Raw().URL.RawQuery = reqQP.Encode()
+	req.Raw().Header["Accept"] = []string{"application/json"}
+	return req, nil
+}
+
+// getHandleResponse handles the Get response.
+func (client *FileSystemsClient) getHandleResponse(resp *http.Response) (FileSystemsClientGetResponse, error) {
+	result := FileSystemsClientGetResponse{}
+	if err := runtime.UnmarshalAsJSON(resp, &result.FileSystemResource); err != nil {
+		return FileSystemsClientGetResponse{}, err
+	}
+	return result, nil
+}
+
+// NewListByResourceGroupPager - List FileSystemResource resources by resource group
+//
+// Generated from API version 2022-10-12-preview
+//   - resourceGroupName - The name of the resource group. The name is case insensitive.
+//   - options - FileSystemsClientListByResourceGroupOptions contains the optional parameters for the FileSystemsClient.NewListByResourceGroupPager
+//     method.
+func (client *FileSystemsClient) NewListByResourceGroupPager(resourceGroupName string, options *FileSystemsClientListByResourceGroupOptions) *runtime.Pager[FileSystemsClientListByResourceGroupResponse] {
+	return runtime.NewPager(runtime.PagingHandler[FileSystemsClientListByResourceGroupResponse]{
+		More: func(page FileSystemsClientListByResourceGroupResponse) bool {
+			return page.NextLink != nil && len(*page.NextLink) > 0
+		},
+		Fetcher: func(ctx context.Context, page *FileSystemsClientListByResourceGroupResponse) (FileSystemsClientListByResourceGroupResponse, error) {
+			var req *policy.Request
+			var err error
+			if page == nil {
+				req, err = client.listByResourceGroupCreateRequest(ctx, resourceGroupName, options)
+			} else {
+				req, err = runtime.NewRequest(ctx, http.MethodGet, *page.NextLink)
+			}
+			if err != nil {
+				return FileSystemsClientListByResourceGroupResponse{}, err
+			}
+			resp, err := client.pl.Do(req)
+			if err != nil {
+				return FileSystemsClientListByResourceGroupResponse{}, err
+			}
+			if !runtime.HasStatusCode(resp, http.StatusOK) {
+				return FileSystemsClientListByResourceGroupResponse{}, runtime.NewResponseError(resp)
+			}
+			return client.listByResourceGroupHandleResponse(resp)
+		},
+	})
+}
+
+// listByResourceGroupCreateRequest creates the ListByResourceGroup request.
+func (client *FileSystemsClient) listByResourceGroupCreateRequest(ctx context.Context, resourceGroupName string, options *FileSystemsClientListByResourceGroupOptions) (*policy.Request, error) {
+	urlPath := "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Qumulo.Storage/fileSystems"
+	if client.subscriptionID == "" {
+		return nil, errors.New("parameter client.subscriptionID cannot be empty")
+	}
+	urlPath = strings.ReplaceAll(urlPath, "{subscriptionId}", url.PathEscape(client.subscriptionID))
+	if resourceGroupName == "" {
+		return nil, errors.New("parameter resourceGroupName cannot be empty")
+	}
+	urlPath = strings.ReplaceAll(urlPath, "{resourceGroupName}", url.PathEscape(resourceGroupName))
+	req, err := runtime.NewRequest(ctx, http.MethodGet, runtime.JoinPaths(client.host, urlPath))
+	if err != nil {
+		return nil, err
+	}
+	reqQP := req.Raw().URL.Query()
+	reqQP.Set("api-version", "2022-10-12-preview")
+	req.Raw().URL.RawQuery = reqQP.Encode()
+	req.Raw().Header["Accept"] = []string{"application/json"}
+	return req, nil
+}
+
+// listByResourceGroupHandleResponse handles the ListByResourceGroup response.
+func (client *FileSystemsClient) listByResourceGroupHandleResponse(resp *http.Response) (FileSystemsClientListByResourceGroupResponse, error) {
+	result := FileSystemsClientListByResourceGroupResponse{}
+	if err := runtime.UnmarshalAsJSON(resp, &result.FileSystemResourceListResult); err != nil {
+		return FileSystemsClientListByResourceGroupResponse{}, err
+	}
+	return result, nil
+}
+
+// NewListBySubscriptionPager - List FileSystemResource resources by subscription ID
+//
+// Generated from API version 2022-10-12-preview
+//   - options - FileSystemsClientListBySubscriptionOptions contains the optional parameters for the FileSystemsClient.NewListBySubscriptionPager
+//     method.
+func (client *FileSystemsClient) NewListBySubscriptionPager(options *FileSystemsClientListBySubscriptionOptions) *runtime.Pager[FileSystemsClientListBySubscriptionResponse] {
+	return runtime.NewPager(runtime.PagingHandler[FileSystemsClientListBySubscriptionResponse]{
+		More: func(page FileSystemsClientListBySubscriptionResponse) bool {
+			return page.NextLink != nil && len(*page.NextLink) > 0
+		},
+		Fetcher: func(ctx context.Context, page *FileSystemsClientListBySubscriptionResponse) (FileSystemsClientListBySubscriptionResponse, error) {
+			var req *policy.Request
+			var err error
+			if page == nil {
+				req, err = client.listBySubscriptionCreateRequest(ctx, options)
+			} else {
+				req, err = runtime.NewRequest(ctx, http.MethodGet, *page.NextLink)
+			}
+			if err != nil {
+				return FileSystemsClientListBySubscriptionResponse{}, err
+			}
+			resp, err := client.pl.Do(req)
+			if err != nil {
+				return FileSystemsClientListBySubscriptionResponse{}, err
+			}
+			if !runtime.HasStatusCode(resp, http.StatusOK) {
+				return FileSystemsClientListBySubscriptionResponse{}, runtime.NewResponseError(resp)
+			}
+			return client.listBySubscriptionHandleResponse(resp)
+		},
+	})
+}
+
+// listBySubscriptionCreateRequest creates the ListBySubscription request.
+func (client *FileSystemsClient) listBySubscriptionCreateRequest(ctx context.Context, options *FileSystemsClientListBySubscriptionOptions) (*policy.Request, error) {
+	urlPath := "/subscriptions/{subscriptionId}/providers/Qumulo.Storage/fileSystems"
+	if client.subscriptionID == "" {
+		return nil, errors.New("parameter client.subscriptionID cannot be empty")
+	}
+	urlPath = strings.ReplaceAll(urlPath, "{subscriptionId}", url.PathEscape(client.subscriptionID))
+	req, err := runtime.NewRequest(ctx, http.MethodGet, runtime.JoinPaths(client.host, urlPath))
+	if err != nil {
+		return nil, err
+	}
+	reqQP := req.Raw().URL.Query()
+	reqQP.Set("api-version", "2022-10-12-preview")
+	req.Raw().URL.RawQuery = reqQP.Encode()
+	req.Raw().Header["Accept"] = []string{"application/json"}
+	return req, nil
+}
+
+// listBySubscriptionHandleResponse handles the ListBySubscription response.
+func (client *FileSystemsClient) listBySubscriptionHandleResponse(resp *http.Response) (FileSystemsClientListBySubscriptionResponse, error) {
+	result := FileSystemsClientListBySubscriptionResponse{}
+	if err := runtime.UnmarshalAsJSON(resp, &result.FileSystemResourceListResult); err != nil {
+		return FileSystemsClientListBySubscriptionResponse{}, err
+	}
+	return result, nil
+}
+
+// Update - Update a FileSystemResource
+// If the operation fails it returns an *azcore.ResponseError type.
+//
+// Generated from API version 2022-10-12-preview
+//   - resourceGroupName - The name of the resource group. The name is case insensitive.
+//   - fileSystemName - Name of the File System resource
+//   - properties - The resource properties to be updated.
+//   - options - FileSystemsClientUpdateOptions contains the optional parameters for the FileSystemsClient.Update method.
+func (client *FileSystemsClient) Update(ctx context.Context, resourceGroupName string, fileSystemName string, properties FileSystemResourceUpdate, options *FileSystemsClientUpdateOptions) (FileSystemsClientUpdateResponse, error) {
+	req, err := client.updateCreateRequest(ctx, resourceGroupName, fileSystemName, properties, options)
+	if err != nil {
+		return FileSystemsClientUpdateResponse{}, err
+	}
+	resp, err := client.pl.Do(req)
+	if err != nil {
+		return FileSystemsClientUpdateResponse{}, err
+	}
+	if !runtime.HasStatusCode(resp, http.StatusOK) {
+		return FileSystemsClientUpdateResponse{}, runtime.NewResponseError(resp)
+	}
+	return client.updateHandleResponse(resp)
+}
+
+// updateCreateRequest creates the Update request.
+func (client *FileSystemsClient) updateCreateRequest(ctx context.Context, resourceGroupName string, fileSystemName string, properties FileSystemResourceUpdate, options *FileSystemsClientUpdateOptions) (*policy.Request, error) {
+	urlPath := "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Qumulo.Storage/fileSystems/{fileSystemName}"
+	if client.subscriptionID == "" {
+		return nil, errors.New("parameter client.subscriptionID cannot be empty")
+	}
+	urlPath = strings.ReplaceAll(urlPath, "{subscriptionId}", url.PathEscape(client.subscriptionID))
+	if resourceGroupName == "" {
+		return nil, errors.New("parameter resourceGroupName cannot be empty")
+	}
+	urlPath = strings.ReplaceAll(urlPath, "{resourceGroupName}", url.PathEscape(resourceGroupName))
+	if fileSystemName == "" {
+		return nil, errors.New("parameter fileSystemName cannot be empty")
+	}
+	urlPath = strings.ReplaceAll(urlPath, "{fileSystemName}", url.PathEscape(fileSystemName))
+	req, err := runtime.NewRequest(ctx, http.MethodPatch, runtime.JoinPaths(client.host, urlPath))
+	if err != nil {
+		return nil, err
+	}
+	reqQP := req.Raw().URL.Query()
+	reqQP.Set("api-version", "2022-10-12-preview")
+	req.Raw().URL.RawQuery = reqQP.Encode()
+	req.Raw().Header["Accept"] = []string{"application/json"}
+	return req, runtime.MarshalAsJSON(req, properties)
+}
+
+// updateHandleResponse handles the Update response.
+func (client *FileSystemsClient) updateHandleResponse(resp *http.Response) (FileSystemsClientUpdateResponse, error) {
+	result := FileSystemsClientUpdateResponse{}
+	if err := runtime.UnmarshalAsJSON(resp, &result.FileSystemResource); err != nil {
+		return FileSystemsClientUpdateResponse{}, err
+	}
+	return result, nil
+}
diff --git a/sdk/resourcemanager/liftrqumulo/armqumulo/go.mod b/sdk/resourcemanager/liftrqumulo/armqumulo/go.mod
new file mode 100644
index 0000000000..eea3396f19
--- /dev/null
+++ b/sdk/resourcemanager/liftrqumulo/armqumulo/go.mod
@@ -0,0 +1,21 @@
+module github.com/Azure/azure-sdk-for-go/sdk/resourcemanager/liftrqumulo/armqumulo
+
+go 1.18
+
+require (
+	github.com/Azure/azure-sdk-for-go/sdk/azcore v1.0.0
+	github.com/Azure/azure-sdk-for-go/sdk/azidentity v1.2.1
+)
+
+require (
+	github.com/Azure/azure-sdk-for-go/sdk/internal v1.0.0 // indirect
+	github.com/AzureAD/microsoft-authentication-library-for-go v0.8.1 // indirect
+	github.com/golang-jwt/jwt/v4 v4.4.2 // indirect
+	github.com/google/uuid v1.1.1 // indirect
+	github.com/kylelemons/godebug v1.1.0 // indirect
+	github.com/pkg/browser v0.0.0-20210115035449-ce105d075bb4 // indirect
+	golang.org/x/crypto v0.0.0-20220511200225-c6db032c6c88 // indirect
+	golang.org/x/net v0.0.0-20220425223048-2871e0cb64e4 // indirect
+	golang.org/x/sys v0.0.0-20211216021012-1d35b9e2eb4e // indirect
+	golang.org/x/text v0.3.7 // indirect
+)
diff --git a/sdk/resourcemanager/liftrqumulo/armqumulo/go.sum b/sdk/resourcemanager/liftrqumulo/armqumulo/go.sum
new file mode 100644
index 0000000000..67cfef6bdf
--- /dev/null
+++ b/sdk/resourcemanager/liftrqumulo/armqumulo/go.sum
@@ -0,0 +1,30 @@
+github.com/Azure/azure-sdk-for-go/sdk/azcore v1.0.0 h1:sVPhtT2qjO86rTUaWMr4WoES4TkjGnzcioXcnHV9s5k=
+github.com/Azure/azure-sdk-for-go/sdk/azcore v1.0.0/go.mod h1:uGG2W01BaETf0Ozp+QxxKJdMBNRWPdstHG0Fmdwn1/U=
+github.com/Azure/azure-sdk-for-go/sdk/azidentity v1.2.1 h1:T8quHYlUGyb/oqtSTwqlCr1ilJHrDv+ZtpSfo+hm1BU=
+github.com/Azure/azure-sdk-for-go/sdk/azidentity v1.2.1/go.mod h1:gLa1CL2RNE4s7M3yopJ/p0iq5DdY6Yv5ZUt9MTRZOQM=
+github.com/Azure/azure-sdk-for-go/sdk/internal v1.0.0 h1:jp0dGvZ7ZK0mgqnTSClMxa5xuRL7NZgHameVYF6BurY=
+github.com/Azure/azure-sdk-for-go/sdk/internal v1.0.0/go.mod h1:eWRD7oawr1Mu1sLCawqVc0CUiF43ia3qQMxLscsKQ9w=
+github.com/AzureAD/microsoft-authentication-library-for-go v0.8.1 h1:oPdPEZFSbl7oSPEAIPMPBMUmiL+mqgzBJwM/9qYcwNg=
+github.com/AzureAD/microsoft-authentication-library-for-go v0.8.1/go.mod h1:4qFor3D/HDsvBME35Xy9rwW9DecL+M2sNw1ybjPtwA0=
+github.com/davecgh/go-spew v1.1.1 h1:vj9j/u1bqnvCEfJOwUhtlOARqs3+rkHYY13jYWTU97c=
+github.com/dnaeon/go-vcr v1.1.0 h1:ReYa/UBrRyQdant9B4fNHGoCNKw6qh6P0fsdGmZpR7c=
+github.com/golang-jwt/jwt/v4 v4.4.2 h1:rcc4lwaZgFMCZ5jxF9ABolDcIHdBytAFgqFPbSJQAYs=
+github.com/golang-jwt/jwt/v4 v4.4.2/go.mod h1:m21LjoU+eqJr34lmDMbreY2eSTRJ1cv77w39/MY0Ch0=
+github.com/google/uuid v1.1.1 h1:Gkbcsh/GbpXz7lPftLA3P6TYMwjCLYm83jiFQZF/3gY=
+github.com/google/uuid v1.1.1/go.mod h1:TIyPZe4MgqvfeYDBFedMoGGpEw/LqOeaOT+nhxU+yHo=
+github.com/kylelemons/godebug v1.1.0 h1:RPNrshWIDI6G2gRW9EHilWtl7Z6Sb1BR0xunSBf0SNc=
+github.com/kylelemons/godebug v1.1.0/go.mod h1:9/0rRGxNHcop5bhtWyNeEfOS8JIWk580+fNqagV/RAw=
+github.com/pkg/browser v0.0.0-20210115035449-ce105d075bb4 h1:Qj1ukM4GlMWXNdMBuXcXfz/Kw9s1qm0CLY32QxuSImI=
+github.com/pkg/browser v0.0.0-20210115035449-ce105d075bb4/go.mod h1:N6UoU20jOqggOuDwUaBQpluzLNDqif3kq9z2wpdYEfQ=
+github.com/pmezard/go-difflib v1.0.0 h1:4DBwDE0NGyQoBHbLQYPwSUPoCMWR5BEzIk/f1lZbAQM=
+github.com/stretchr/testify v1.7.0 h1:nwc3DEeHmmLAfoZucVR881uASk0Mfjw8xYJ99tb5CcY=
+golang.org/x/crypto v0.0.0-20220511200225-c6db032c6c88 h1:Tgea0cVUD0ivh5ADBX4WwuI12DUd2to3nCYe2eayMIw=
+golang.org/x/crypto v0.0.0-20220511200225-c6db032c6c88/go.mod h1:IxCIyHEi3zRg3s0A5j5BB6A9Jmi73HwBIUl50j+osU4=
+golang.org/x/net v0.0.0-20220425223048-2871e0cb64e4 h1:HVyaeDAYux4pnY+D/SiwmLOR36ewZ4iGQIIrtnuCjFA=
+golang.org/x/net v0.0.0-20220425223048-2871e0cb64e4/go.mod h1:CfG3xpIq0wQ8r1q4Su4UZFWDARRcnwPjda9FqA0JpMk=
+golang.org/x/sys v0.0.0-20211216021012-1d35b9e2eb4e h1:fLOSk5Q00efkSvAm+4xcoXD+RRmLmmulPn5I3Y9F2EM=
+golang.org/x/sys v0.0.0-20211216021012-1d35b9e2eb4e/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
+golang.org/x/text v0.3.7 h1:olpwvP2KacW1ZWvsR7uQhoyTYvKAupfQrRGBFM352Gk=
+golang.org/x/text v0.3.7/go.mod h1:u+2+/6zg+i71rQMx5EYifcz6MCKuco9NR6JIITiCfzQ=
+gopkg.in/yaml.v2 v2.4.0 h1:D8xgwECY7CYvx+Y2n4sBz93Jn9JRvxdiyyo8CTfuKaY=
+gopkg.in/yaml.v3 v3.0.0-20210107192922-496545a6307b h1:h8qDotaEPuJATrMmW04NCwg7v22aHH28wwpauUhK9Oo=
diff --git a/sdk/resourcemanager/liftrqumulo/armqumulo/models.go b/sdk/resourcemanager/liftrqumulo/armqumulo/models.go
new file mode 100644
index 0000000000..3b9921489f
--- /dev/null
+++ b/sdk/resourcemanager/liftrqumulo/armqumulo/models.go
@@ -0,0 +1,274 @@
+//go:build go1.18
+// +build go1.18
+
+// Copyright (c) Microsoft Corporation. All rights reserved.
+// Licensed under the MIT License. See License.txt in the project root for license information.
+// Code generated by Microsoft (R) AutoRest Code Generator.
+// Changes may cause incorrect behavior and will be lost if the code is regenerated.
+// DO NOT EDIT.
+
+package armqumulo
+
+import "time"
+
+// FileSystemResource - A FileSystem Resource by Qumulo
+type FileSystemResource struct {
+	// REQUIRED; The geo-location where the resource lives
+	Location *string `json:"location,omitempty"`
+
+	// REQUIRED; The resource-specific properties for this resource.
+	Properties *FileSystemResourceProperties `json:"properties,omitempty"`
+
+	// The managed service identities assigned to this resource.
+	Identity *ManagedServiceIdentity `json:"identity,omitempty"`
+
+	// Resource tags.
+	Tags map[string]*string `json:"tags,omitempty"`
+
+	// READ-ONLY; Fully qualified resource ID for the resource. Ex - /subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/{resourceProviderNamespace}/{resourceType}/{resourceName}
+	ID *string `json:"id,omitempty" azure:"ro"`
+
+	// READ-ONLY; The name of the resource
+	Name *string `json:"name,omitempty" azure:"ro"`
+
+	// READ-ONLY; Azure Resource Manager metadata containing createdBy and modifiedBy information.
+	SystemData *SystemData `json:"systemData,omitempty" azure:"ro"`
+
+	// READ-ONLY; The type of the resource. E.g. "Microsoft.Compute/virtualMachines" or "Microsoft.Storage/storageAccounts"
+	Type *string `json:"type,omitempty" azure:"ro"`
+}
+
+// FileSystemResourceListResult - The response of a FileSystemResource list operation.
+type FileSystemResourceListResult struct {
+	// REQUIRED; The FileSystemResource items on this page
+	Value []*FileSystemResource `json:"value,omitempty"`
+
+	// The link to the next page of items
+	NextLink *string `json:"nextLink,omitempty"`
+}
+
+// FileSystemResourceProperties - Properties specific to the Qumulo File System resource
+type FileSystemResourceProperties struct {
+	// REQUIRED; Initial administrator password of the resource
+	AdminPassword *string `json:"adminPassword,omitempty"`
+
+	// REQUIRED; Delegated subnet id for Vnet injection
+	DelegatedSubnetID *string `json:"delegatedSubnetId,omitempty"`
+
+	// REQUIRED; Storage capacity in TB
+	InitialCapacity *int32 `json:"initialCapacity,omitempty"`
+
+	// REQUIRED; Marketplace details
+	MarketplaceDetails *MarketplaceDetails `json:"marketplaceDetails,omitempty"`
+
+	// REQUIRED; Storage Sku
+	StorageSKU *StorageSKU `json:"storageSku,omitempty"`
+
+	// REQUIRED; User Details
+	UserDetails *UserDetails `json:"userDetails,omitempty"`
+
+	// Availability zone
+	AvailabilityZone *string `json:"availabilityZone,omitempty"`
+
+	// File system Id of the resource
+	ClusterLoginURL *string `json:"clusterLoginUrl,omitempty"`
+
+	// Private IPs of the resource
+	PrivateIPs []*string `json:"privateIPs,omitempty"`
+
+	// READ-ONLY; Provisioning State of the resource
+	ProvisioningState *ProvisioningState `json:"provisioningState,omitempty" azure:"ro"`
+}
+
+// FileSystemResourceUpdate - The type used for update operations of the FileSystemResource.
+type FileSystemResourceUpdate struct {
+	// The managed service identities assigned to this resource.
+	Identity *ManagedServiceIdentity `json:"identity,omitempty"`
+
+	// The updatable properties of the FileSystemResource.
+	Properties *FileSystemResourceUpdateProperties `json:"properties,omitempty"`
+
+	// Resource tags.
+	Tags map[string]*string `json:"tags,omitempty"`
+}
+
+// FileSystemResourceUpdateProperties - The updatable properties of the FileSystemResource.
+type FileSystemResourceUpdateProperties struct {
+	// File system Id of the resource
+	ClusterLoginURL *string `json:"clusterLoginUrl,omitempty"`
+
+	// Delegated subnet id for Vnet injection
+	DelegatedSubnetID *string `json:"delegatedSubnetId,omitempty"`
+
+	// Marketplace details
+	MarketplaceDetails *MarketplaceDetails `json:"marketplaceDetails,omitempty"`
+
+	// Private IPs of the resource
+	PrivateIPs []*string `json:"privateIPs,omitempty"`
+
+	// User Details
+	UserDetails *UserDetails `json:"userDetails,omitempty"`
+}
+
+// FileSystemsClientBeginCreateOrUpdateOptions contains the optional parameters for the FileSystemsClient.BeginCreateOrUpdate
+// method.
+type FileSystemsClientBeginCreateOrUpdateOptions struct {
+	// Resumes the LRO from the provided token.
+	ResumeToken string
+}
+
+// FileSystemsClientBeginDeleteOptions contains the optional parameters for the FileSystemsClient.BeginDelete method.
+type FileSystemsClientBeginDeleteOptions struct {
+	// Resumes the LRO from the provided token.
+	ResumeToken string
+}
+
+// FileSystemsClientGetOptions contains the optional parameters for the FileSystemsClient.Get method.
+type FileSystemsClientGetOptions struct {
+	// placeholder for future optional parameters
+}
+
+// FileSystemsClientListByResourceGroupOptions contains the optional parameters for the FileSystemsClient.NewListByResourceGroupPager
+// method.
+type FileSystemsClientListByResourceGroupOptions struct {
+	// placeholder for future optional parameters
+}
+
+// FileSystemsClientListBySubscriptionOptions contains the optional parameters for the FileSystemsClient.NewListBySubscriptionPager
+// method.
+type FileSystemsClientListBySubscriptionOptions struct {
+	// placeholder for future optional parameters
+}
+
+// FileSystemsClientUpdateOptions contains the optional parameters for the FileSystemsClient.Update method.
+type FileSystemsClientUpdateOptions struct {
+	// placeholder for future optional parameters
+}
+
+// ManagedServiceIdentity - Managed service identity (system assigned and/or user assigned identities)
+type ManagedServiceIdentity struct {
+	// REQUIRED; Type of managed service identity (where both SystemAssigned and UserAssigned types are allowed).
+	Type *ManagedServiceIdentityType `json:"type,omitempty"`
+
+	// The set of user assigned identities associated with the resource. The userAssignedIdentities dictionary keys will be ARM
+	// resource ids in the form:
+	// '/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.ManagedIdentity/userAssignedIdentities/{identityName}.
+	// The dictionary values can be empty objects ({}) in
+	// requests.
+	UserAssignedIdentities map[string]*UserAssignedIdentity `json:"userAssignedIdentities,omitempty"`
+
+	// READ-ONLY; The service principal ID of the system assigned identity. This property will only be provided for a system assigned
+	// identity.
+	PrincipalID *string `json:"principalId,omitempty" azure:"ro"`
+
+	// READ-ONLY; The tenant ID of the system assigned identity. This property will only be provided for a system assigned identity.
+	TenantID *string `json:"tenantId,omitempty" azure:"ro"`
+}
+
+// MarketplaceDetails of Qumulo FileSystem resource
+type MarketplaceDetails struct {
+	// REQUIRED; Offer Id
+	OfferID *string `json:"offerId,omitempty"`
+
+	// REQUIRED; Plan Id
+	PlanID *string `json:"planId,omitempty"`
+
+	// REQUIRED; Publisher Id
+	PublisherID *string `json:"publisherId,omitempty"`
+
+	// Marketplace Subscription Id
+	MarketplaceSubscriptionID *string `json:"marketplaceSubscriptionId,omitempty"`
+
+	// READ-ONLY; Marketplace subscription status
+	MarketplaceSubscriptionStatus *MarketplaceSubscriptionStatus `json:"marketplaceSubscriptionStatus,omitempty" azure:"ro"`
+}
+
+// Operation - Details of a REST API operation, returned from the Resource Provider Operations API
+type Operation struct {
+	// Localized display information for this particular operation.
+	Display *OperationDisplay `json:"display,omitempty"`
+
+	// READ-ONLY; Enum. Indicates the action type. "Internal" refers to actions that are for internal only APIs.
+	ActionType *ActionType `json:"actionType,omitempty" azure:"ro"`
+
+	// READ-ONLY; Whether the operation applies to data-plane. This is "true" for data-plane operations and "false" for ARM/control-plane
+	// operations.
+	IsDataAction *bool `json:"isDataAction,omitempty" azure:"ro"`
+
+	// READ-ONLY; The name of the operation, as per Resource-Based Access Control (RBAC). Examples: "Microsoft.Compute/virtualMachines/write",
+	// "Microsoft.Compute/virtualMachines/capture/action"
+	Name *string `json:"name,omitempty" azure:"ro"`
+
+	// READ-ONLY; The intended executor of the operation; as in Resource Based Access Control (RBAC) and audit logs UX. Default
+	// value is "user,system"
+	Origin *Origin `json:"origin,omitempty" azure:"ro"`
+}
+
+// OperationDisplay - Localized display information for this particular operation.
+type OperationDisplay struct {
+	// READ-ONLY; The short, localized friendly description of the operation; suitable for tool tips and detailed views.
+	Description *string `json:"description,omitempty" azure:"ro"`
+
+	// READ-ONLY; The concise, localized friendly name for the operation; suitable for dropdowns. E.g. "Create or Update Virtual
+	// Machine", "Restart Virtual Machine".
+	Operation *string `json:"operation,omitempty" azure:"ro"`
+
+	// READ-ONLY; The localized friendly form of the resource provider name, e.g. "Microsoft Monitoring Insights" or "Microsoft
+	// Compute".
+	Provider *string `json:"provider,omitempty" azure:"ro"`
+
+	// READ-ONLY; The localized friendly name of the resource type related to this operation. E.g. "Virtual Machines" or "Job
+	// Schedule Collections".
+	Resource *string `json:"resource,omitempty" azure:"ro"`
+}
+
+// OperationListResult - A list of REST API operations supported by an Azure Resource Provider. It contains an URL link to
+// get the next set of results.
+type OperationListResult struct {
+	// READ-ONLY; URL to get the next set of operation list results (if there are any).
+	NextLink *string `json:"nextLink,omitempty" azure:"ro"`
+
+	// READ-ONLY; List of operations supported by the resource provider
+	Value []*Operation `json:"value,omitempty" azure:"ro"`
+}
+
+// OperationsClientListOptions contains the optional parameters for the OperationsClient.NewListPager method.
+type OperationsClientListOptions struct {
+	// placeholder for future optional parameters
+}
+
+// SystemData - Metadata pertaining to creation and last modification of the resource.
+type SystemData struct {
+	// The timestamp of resource creation (UTC).
+	CreatedAt *time.Time `json:"createdAt,omitempty"`
+
+	// The identity that created the resource.
+	CreatedBy *string `json:"createdBy,omitempty"`
+
+	// The type of identity that created the resource.
+	CreatedByType *CreatedByType `json:"createdByType,omitempty"`
+
+	// The timestamp of resource last modification (UTC)
+	LastModifiedAt *time.Time `json:"lastModifiedAt,omitempty"`
+
+	// The identity that last modified the resource.
+	LastModifiedBy *string `json:"lastModifiedBy,omitempty"`
+
+	// The type of identity that last modified the resource.
+	LastModifiedByType *CreatedByType `json:"lastModifiedByType,omitempty"`
+}
+
+// UserAssignedIdentity - User assigned identity properties
+type UserAssignedIdentity struct {
+	// READ-ONLY; The client ID of the assigned identity.
+	ClientID *string `json:"clientId,omitempty" azure:"ro"`
+
+	// READ-ONLY; The principal ID of the assigned identity.
+	PrincipalID *string `json:"principalId,omitempty" azure:"ro"`
+}
+
+// UserDetails - User Details of Qumulo FileSystem resource
+type UserDetails struct {
+	// REQUIRED; User Email
+	Email *string `json:"email,omitempty"`
+}
diff --git a/sdk/resourcemanager/liftrqumulo/armqumulo/models_serde.go b/sdk/resourcemanager/liftrqumulo/armqumulo/models_serde.go
new file mode 100644
index 0000000000..2c4444ff8e
--- /dev/null
+++ b/sdk/resourcemanager/liftrqumulo/armqumulo/models_serde.go
@@ -0,0 +1,564 @@
+//go:build go1.18
+// +build go1.18
+
+// Copyright (c) Microsoft Corporation. All rights reserved.
+// Licensed under the MIT License. See License.txt in the project root for license information.
+// Code generated by Microsoft (R) AutoRest Code Generator.
+// Changes may cause incorrect behavior and will be lost if the code is regenerated.
+// DO NOT EDIT.
+
+package armqumulo
+
+import (
+	"encoding/json"
+	"fmt"
+	"github.com/Azure/azure-sdk-for-go/sdk/azcore"
+	"reflect"
+)
+
+// MarshalJSON implements the json.Marshaller interface for type FileSystemResource.
+func (f FileSystemResource) MarshalJSON() ([]byte, error) {
+	objectMap := make(map[string]any)
+	populate(objectMap, "id", f.ID)
+	populate(objectMap, "identity", f.Identity)
+	populate(objectMap, "location", f.Location)
+	populate(objectMap, "name", f.Name)
+	populate(objectMap, "properties", f.Properties)
+	populate(objectMap, "systemData", f.SystemData)
+	populate(objectMap, "tags", f.Tags)
+	populate(objectMap, "type", f.Type)
+	return json.Marshal(objectMap)
+}
+
+// UnmarshalJSON implements the json.Unmarshaller interface for type FileSystemResource.
+func (f *FileSystemResource) UnmarshalJSON(data []byte) error {
+	var rawMsg map[string]json.RawMessage
+	if err := json.Unmarshal(data, &rawMsg); err != nil {
+		return fmt.Errorf("unmarshalling type %T: %v", f, err)
+	}
+	for key, val := range rawMsg {
+		var err error
+		switch key {
+		case "id":
+			err = unpopulate(val, "ID", &f.ID)
+			delete(rawMsg, key)
+		case "identity":
+			err = unpopulate(val, "Identity", &f.Identity)
+			delete(rawMsg, key)
+		case "location":
+			err = unpopulate(val, "Location", &f.Location)
+			delete(rawMsg, key)
+		case "name":
+			err = unpopulate(val, "Name", &f.Name)
+			delete(rawMsg, key)
+		case "properties":
+			err = unpopulate(val, "Properties", &f.Properties)
+			delete(rawMsg, key)
+		case "systemData":
+			err = unpopulate(val, "SystemData", &f.SystemData)
+			delete(rawMsg, key)
+		case "tags":
+			err = unpopulate(val, "Tags", &f.Tags)
+			delete(rawMsg, key)
+		case "type":
+			err = unpopulate(val, "Type", &f.Type)
+			delete(rawMsg, key)
+		}
+		if err != nil {
+			return fmt.Errorf("unmarshalling type %T: %v", f, err)
+		}
+	}
+	return nil
+}
+
+// MarshalJSON implements the json.Marshaller interface for type FileSystemResourceListResult.
+func (f FileSystemResourceListResult) MarshalJSON() ([]byte, error) {
+	objectMap := make(map[string]any)
+	populate(objectMap, "nextLink", f.NextLink)
+	populate(objectMap, "value", f.Value)
+	return json.Marshal(objectMap)
+}
+
+// UnmarshalJSON implements the json.Unmarshaller interface for type FileSystemResourceListResult.
+func (f *FileSystemResourceListResult) UnmarshalJSON(data []byte) error {
+	var rawMsg map[string]json.RawMessage
+	if err := json.Unmarshal(data, &rawMsg); err != nil {
+		return fmt.Errorf("unmarshalling type %T: %v", f, err)
+	}
+	for key, val := range rawMsg {
+		var err error
+		switch key {
+		case "nextLink":
+			err = unpopulate(val, "NextLink", &f.NextLink)
+			delete(rawMsg, key)
+		case "value":
+			err = unpopulate(val, "Value", &f.Value)
+			delete(rawMsg, key)
+		}
+		if err != nil {
+			return fmt.Errorf("unmarshalling type %T: %v", f, err)
+		}
+	}
+	return nil
+}
+
+// MarshalJSON implements the json.Marshaller interface for type FileSystemResourceProperties.
+func (f FileSystemResourceProperties) MarshalJSON() ([]byte, error) {
+	objectMap := make(map[string]any)
+	populate(objectMap, "adminPassword", f.AdminPassword)
+	populate(objectMap, "availabilityZone", f.AvailabilityZone)
+	populate(objectMap, "clusterLoginUrl", f.ClusterLoginURL)
+	populate(objectMap, "delegatedSubnetId", f.DelegatedSubnetID)
+	populate(objectMap, "initialCapacity", f.InitialCapacity)
+	populate(objectMap, "marketplaceDetails", f.MarketplaceDetails)
+	populate(objectMap, "privateIPs", f.PrivateIPs)
+	populate(objectMap, "provisioningState", f.ProvisioningState)
+	populate(objectMap, "storageSku", f.StorageSKU)
+	populate(objectMap, "userDetails", f.UserDetails)
+	return json.Marshal(objectMap)
+}
+
+// UnmarshalJSON implements the json.Unmarshaller interface for type FileSystemResourceProperties.
+func (f *FileSystemResourceProperties) UnmarshalJSON(data []byte) error {
+	var rawMsg map[string]json.RawMessage
+	if err := json.Unmarshal(data, &rawMsg); err != nil {
+		return fmt.Errorf("unmarshalling type %T: %v", f, err)
+	}
+	for key, val := range rawMsg {
+		var err error
+		switch key {
+		case "adminPassword":
+			err = unpopulate(val, "AdminPassword", &f.AdminPassword)
+			delete(rawMsg, key)
+		case "availabilityZone":
+			err = unpopulate(val, "AvailabilityZone", &f.AvailabilityZone)
+			delete(rawMsg, key)
+		case "clusterLoginUrl":
+			err = unpopulate(val, "ClusterLoginURL", &f.ClusterLoginURL)
+			delete(rawMsg, key)
+		case "delegatedSubnetId":
+			err = unpopulate(val, "DelegatedSubnetID", &f.DelegatedSubnetID)
+			delete(rawMsg, key)
+		case "initialCapacity":
+			err = unpopulate(val, "InitialCapacity", &f.InitialCapacity)
+			delete(rawMsg, key)
+		case "marketplaceDetails":
+			err = unpopulate(val, "MarketplaceDetails", &f.MarketplaceDetails)
+			delete(rawMsg, key)
+		case "privateIPs":
+			err = unpopulate(val, "PrivateIPs", &f.PrivateIPs)
+			delete(rawMsg, key)
+		case "provisioningState":
+			err = unpopulate(val, "ProvisioningState", &f.ProvisioningState)
+			delete(rawMsg, key)
+		case "storageSku":
+			err = unpopulate(val, "StorageSKU", &f.StorageSKU)
+			delete(rawMsg, key)
+		case "userDetails":
+			err = unpopulate(val, "UserDetails", &f.UserDetails)
+			delete(rawMsg, key)
+		}
+		if err != nil {
+			return fmt.Errorf("unmarshalling type %T: %v", f, err)
+		}
+	}
+	return nil
+}
+
+// MarshalJSON implements the json.Marshaller interface for type FileSystemResourceUpdate.
+func (f FileSystemResourceUpdate) MarshalJSON() ([]byte, error) {
+	objectMap := make(map[string]any)
+	populate(objectMap, "identity", f.Identity)
+	populate(objectMap, "properties", f.Properties)
+	populate(objectMap, "tags", f.Tags)
+	return json.Marshal(objectMap)
+}
+
+// UnmarshalJSON implements the json.Unmarshaller interface for type FileSystemResourceUpdate.
+func (f *FileSystemResourceUpdate) UnmarshalJSON(data []byte) error {
+	var rawMsg map[string]json.RawMessage
+	if err := json.Unmarshal(data, &rawMsg); err != nil {
+		return fmt.Errorf("unmarshalling type %T: %v", f, err)
+	}
+	for key, val := range rawMsg {
+		var err error
+		switch key {
+		case "identity":
+			err = unpopulate(val, "Identity", &f.Identity)
+			delete(rawMsg, key)
+		case "properties":
+			err = unpopulate(val, "Properties", &f.Properties)
+			delete(rawMsg, key)
+		case "tags":
+			err = unpopulate(val, "Tags", &f.Tags)
+			delete(rawMsg, key)
+		}
+		if err != nil {
+			return fmt.Errorf("unmarshalling type %T: %v", f, err)
+		}
+	}
+	return nil
+}
+
+// MarshalJSON implements the json.Marshaller interface for type FileSystemResourceUpdateProperties.
+func (f FileSystemResourceUpdateProperties) MarshalJSON() ([]byte, error) {
+	objectMap := make(map[string]any)
+	populate(objectMap, "clusterLoginUrl", f.ClusterLoginURL)
+	populate(objectMap, "delegatedSubnetId", f.DelegatedSubnetID)
+	populate(objectMap, "marketplaceDetails", f.MarketplaceDetails)
+	populate(objectMap, "privateIPs", f.PrivateIPs)
+	populate(objectMap, "userDetails", f.UserDetails)
+	return json.Marshal(objectMap)
+}
+
+// UnmarshalJSON implements the json.Unmarshaller interface for type FileSystemResourceUpdateProperties.
+func (f *FileSystemResourceUpdateProperties) UnmarshalJSON(data []byte) error {
+	var rawMsg map[string]json.RawMessage
+	if err := json.Unmarshal(data, &rawMsg); err != nil {
+		return fmt.Errorf("unmarshalling type %T: %v", f, err)
+	}
+	for key, val := range rawMsg {
+		var err error
+		switch key {
+		case "clusterLoginUrl":
+			err = unpopulate(val, "ClusterLoginURL", &f.ClusterLoginURL)
+			delete(rawMsg, key)
+		case "delegatedSubnetId":
+			err = unpopulate(val, "DelegatedSubnetID", &f.DelegatedSubnetID)
+			delete(rawMsg, key)
+		case "marketplaceDetails":
+			err = unpopulate(val, "MarketplaceDetails", &f.MarketplaceDetails)
+			delete(rawMsg, key)
+		case "privateIPs":
+			err = unpopulate(val, "PrivateIPs", &f.PrivateIPs)
+			delete(rawMsg, key)
+		case "userDetails":
+			err = unpopulate(val, "UserDetails", &f.UserDetails)
+			delete(rawMsg, key)
+		}
+		if err != nil {
+			return fmt.Errorf("unmarshalling type %T: %v", f, err)
+		}
+	}
+	return nil
+}
+
+// MarshalJSON implements the json.Marshaller interface for type ManagedServiceIdentity.
+func (m ManagedServiceIdentity) MarshalJSON() ([]byte, error) {
+	objectMap := make(map[string]any)
+	populate(objectMap, "principalId", m.PrincipalID)
+	populate(objectMap, "tenantId", m.TenantID)
+	populate(objectMap, "type", m.Type)
+	populate(objectMap, "userAssignedIdentities", m.UserAssignedIdentities)
+	return json.Marshal(objectMap)
+}
+
+// UnmarshalJSON implements the json.Unmarshaller interface for type ManagedServiceIdentity.
+func (m *ManagedServiceIdentity) UnmarshalJSON(data []byte) error {
+	var rawMsg map[string]json.RawMessage
+	if err := json.Unmarshal(data, &rawMsg); err != nil {
+		return fmt.Errorf("unmarshalling type %T: %v", m, err)
+	}
+	for key, val := range rawMsg {
+		var err error
+		switch key {
+		case "principalId":
+			err = unpopulate(val, "PrincipalID", &m.PrincipalID)
+			delete(rawMsg, key)
+		case "tenantId":
+			err = unpopulate(val, "TenantID", &m.TenantID)
+			delete(rawMsg, key)
+		case "type":
+			err = unpopulate(val, "Type", &m.Type)
+			delete(rawMsg, key)
+		case "userAssignedIdentities":
+			err = unpopulate(val, "UserAssignedIdentities", &m.UserAssignedIdentities)
+			delete(rawMsg, key)
+		}
+		if err != nil {
+			return fmt.Errorf("unmarshalling type %T: %v", m, err)
+		}
+	}
+	return nil
+}
+
+// MarshalJSON implements the json.Marshaller interface for type MarketplaceDetails.
+func (m MarketplaceDetails) MarshalJSON() ([]byte, error) {
+	objectMap := make(map[string]any)
+	populate(objectMap, "marketplaceSubscriptionId", m.MarketplaceSubscriptionID)
+	populate(objectMap, "marketplaceSubscriptionStatus", m.MarketplaceSubscriptionStatus)
+	populate(objectMap, "offerId", m.OfferID)
+	populate(objectMap, "planId", m.PlanID)
+	populate(objectMap, "publisherId", m.PublisherID)
+	return json.Marshal(objectMap)
+}
+
+// UnmarshalJSON implements the json.Unmarshaller interface for type MarketplaceDetails.
+func (m *MarketplaceDetails) UnmarshalJSON(data []byte) error {
+	var rawMsg map[string]json.RawMessage
+	if err := json.Unmarshal(data, &rawMsg); err != nil {
+		return fmt.Errorf("unmarshalling type %T: %v", m, err)
+	}
+	for key, val := range rawMsg {
+		var err error
+		switch key {
+		case "marketplaceSubscriptionId":
+			err = unpopulate(val, "MarketplaceSubscriptionID", &m.MarketplaceSubscriptionID)
+			delete(rawMsg, key)
+		case "marketplaceSubscriptionStatus":
+			err = unpopulate(val, "MarketplaceSubscriptionStatus", &m.MarketplaceSubscriptionStatus)
+			delete(rawMsg, key)
+		case "offerId":
+			err = unpopulate(val, "OfferID", &m.OfferID)
+			delete(rawMsg, key)
+		case "planId":
+			err = unpopulate(val, "PlanID", &m.PlanID)
+			delete(rawMsg, key)
+		case "publisherId":
+			err = unpopulate(val, "PublisherID", &m.PublisherID)
+			delete(rawMsg, key)
+		}
+		if err != nil {
+			return fmt.Errorf("unmarshalling type %T: %v", m, err)
+		}
+	}
+	return nil
+}
+
+// MarshalJSON implements the json.Marshaller interface for type Operation.
+func (o Operation) MarshalJSON() ([]byte, error) {
+	objectMap := make(map[string]any)
+	populate(objectMap, "actionType", o.ActionType)
+	populate(objectMap, "display", o.Display)
+	populate(objectMap, "isDataAction", o.IsDataAction)
+	populate(objectMap, "name", o.Name)
+	populate(objectMap, "origin", o.Origin)
+	return json.Marshal(objectMap)
+}
+
+// UnmarshalJSON implements the json.Unmarshaller interface for type Operation.
+func (o *Operation) UnmarshalJSON(data []byte) error {
+	var rawMsg map[string]json.RawMessage
+	if err := json.Unmarshal(data, &rawMsg); err != nil {
+		return fmt.Errorf("unmarshalling type %T: %v", o, err)
+	}
+	for key, val := range rawMsg {
+		var err error
+		switch key {
+		case "actionType":
+			err = unpopulate(val, "ActionType", &o.ActionType)
+			delete(rawMsg, key)
+		case "display":
+			err = unpopulate(val, "Display", &o.Display)
+			delete(rawMsg, key)
+		case "isDataAction":
+			err = unpopulate(val, "IsDataAction", &o.IsDataAction)
+			delete(rawMsg, key)
+		case "name":
+			err = unpopulate(val, "Name", &o.Name)
+			delete(rawMsg, key)
+		case "origin":
+			err = unpopulate(val, "Origin", &o.Origin)
+			delete(rawMsg, key)
+		}
+		if err != nil {
+			return fmt.Errorf("unmarshalling type %T: %v", o, err)
+		}
+	}
+	return nil
+}
+
+// MarshalJSON implements the json.Marshaller interface for type OperationDisplay.
+func (o OperationDisplay) MarshalJSON() ([]byte, error) {
+	objectMap := make(map[string]any)
+	populate(objectMap, "description", o.Description)
+	populate(objectMap, "operation", o.Operation)
+	populate(objectMap, "provider", o.Provider)
+	populate(objectMap, "resource", o.Resource)
+	return json.Marshal(objectMap)
+}
+
+// UnmarshalJSON implements the json.Unmarshaller interface for type OperationDisplay.
+func (o *OperationDisplay) UnmarshalJSON(data []byte) error {
+	var rawMsg map[string]json.RawMessage
+	if err := json.Unmarshal(data, &rawMsg); err != nil {
+		return fmt.Errorf("unmarshalling type %T: %v", o, err)
+	}
+	for key, val := range rawMsg {
+		var err error
+		switch key {
+		case "description":
+			err = unpopulate(val, "Description", &o.Description)
+			delete(rawMsg, key)
+		case "operation":
+			err = unpopulate(val, "Operation", &o.Operation)
+			delete(rawMsg, key)
+		case "provider":
+			err = unpopulate(val, "Provider", &o.Provider)
+			delete(rawMsg, key)
+		case "resource":
+			err = unpopulate(val, "Resource", &o.Resource)
+			delete(rawMsg, key)
+		}
+		if err != nil {
+			return fmt.Errorf("unmarshalling type %T: %v", o, err)
+		}
+	}
+	return nil
+}
+
+// MarshalJSON implements the json.Marshaller interface for type OperationListResult.
+func (o OperationListResult) MarshalJSON() ([]byte, error) {
+	objectMap := make(map[string]any)
+	populate(objectMap, "nextLink", o.NextLink)
+	populate(objectMap, "value", o.Value)
+	return json.Marshal(objectMap)
+}
+
+// UnmarshalJSON implements the json.Unmarshaller interface for type OperationListResult.
+func (o *OperationListResult) UnmarshalJSON(data []byte) error {
+	var rawMsg map[string]json.RawMessage
+	if err := json.Unmarshal(data, &rawMsg); err != nil {
+		return fmt.Errorf("unmarshalling type %T: %v", o, err)
+	}
+	for key, val := range rawMsg {
+		var err error
+		switch key {
+		case "nextLink":
+			err = unpopulate(val, "NextLink", &o.NextLink)
+			delete(rawMsg, key)
+		case "value":
+			err = unpopulate(val, "Value", &o.Value)
+			delete(rawMsg, key)
+		}
+		if err != nil {
+			return fmt.Errorf("unmarshalling type %T: %v", o, err)
+		}
+	}
+	return nil
+}
+
+// MarshalJSON implements the json.Marshaller interface for type SystemData.
+func (s SystemData) MarshalJSON() ([]byte, error) {
+	objectMap := make(map[string]any)
+	populateTimeRFC3339(objectMap, "createdAt", s.CreatedAt)
+	populate(objectMap, "createdBy", s.CreatedBy)
+	populate(objectMap, "createdByType", s.CreatedByType)
+	populateTimeRFC3339(objectMap, "lastModifiedAt", s.LastModifiedAt)
+	populate(objectMap, "lastModifiedBy", s.LastModifiedBy)
+	populate(objectMap, "lastModifiedByType", s.LastModifiedByType)
+	return json.Marshal(objectMap)
+}
+
+// UnmarshalJSON implements the json.Unmarshaller interface for type SystemData.
+func (s *SystemData) UnmarshalJSON(data []byte) error {
+	var rawMsg map[string]json.RawMessage
+	if err := json.Unmarshal(data, &rawMsg); err != nil {
+		return fmt.Errorf("unmarshalling type %T: %v", s, err)
+	}
+	for key, val := range rawMsg {
+		var err error
+		switch key {
+		case "createdAt":
+			err = unpopulateTimeRFC3339(val, "CreatedAt", &s.CreatedAt)
+			delete(rawMsg, key)
+		case "createdBy":
+			err = unpopulate(val, "CreatedBy", &s.CreatedBy)
+			delete(rawMsg, key)
+		case "createdByType":
+			err = unpopulate(val, "CreatedByType", &s.CreatedByType)
+			delete(rawMsg, key)
+		case "lastModifiedAt":
+			err = unpopulateTimeRFC3339(val, "LastModifiedAt", &s.LastModifiedAt)
+			delete(rawMsg, key)
+		case "lastModifiedBy":
+			err = unpopulate(val, "LastModifiedBy", &s.LastModifiedBy)
+			delete(rawMsg, key)
+		case "lastModifiedByType":
+			err = unpopulate(val, "LastModifiedByType", &s.LastModifiedByType)
+			delete(rawMsg, key)
+		}
+		if err != nil {
+			return fmt.Errorf("unmarshalling type %T: %v", s, err)
+		}
+	}
+	return nil
+}
+
+// MarshalJSON implements the json.Marshaller interface for type UserAssignedIdentity.
+func (u UserAssignedIdentity) MarshalJSON() ([]byte, error) {
+	objectMap := make(map[string]any)
+	populate(objectMap, "clientId", u.ClientID)
+	populate(objectMap, "principalId", u.PrincipalID)
+	return json.Marshal(objectMap)
+}
+
+// UnmarshalJSON implements the json.Unmarshaller interface for type UserAssignedIdentity.
+func (u *UserAssignedIdentity) UnmarshalJSON(data []byte) error {
+	var rawMsg map[string]json.RawMessage
+	if err := json.Unmarshal(data, &rawMsg); err != nil {
+		return fmt.Errorf("unmarshalling type %T: %v", u, err)
+	}
+	for key, val := range rawMsg {
+		var err error
+		switch key {
+		case "clientId":
+			err = unpopulate(val, "ClientID", &u.ClientID)
+			delete(rawMsg, key)
+		case "principalId":
+			err = unpopulate(val, "PrincipalID", &u.PrincipalID)
+			delete(rawMsg, key)
+		}
+		if err != nil {
+			return fmt.Errorf("unmarshalling type %T: %v", u, err)
+		}
+	}
+	return nil
+}
+
+// MarshalJSON implements the json.Marshaller interface for type UserDetails.
+func (u UserDetails) MarshalJSON() ([]byte, error) {
+	objectMap := make(map[string]any)
+	populate(objectMap, "email", u.Email)
+	return json.Marshal(objectMap)
+}
+
+// UnmarshalJSON implements the json.Unmarshaller interface for type UserDetails.
+func (u *UserDetails) UnmarshalJSON(data []byte) error {
+	var rawMsg map[string]json.RawMessage
+	if err := json.Unmarshal(data, &rawMsg); err != nil {
+		return fmt.Errorf("unmarshalling type %T: %v", u, err)
+	}
+	for key, val := range rawMsg {
+		var err error
+		switch key {
+		case "email":
+			err = unpopulate(val, "Email", &u.Email)
+			delete(rawMsg, key)
+		}
+		if err != nil {
+			return fmt.Errorf("unmarshalling type %T: %v", u, err)
+		}
+	}
+	return nil
+}
+
+func populate(m map[string]any, k string, v any) {
+	if v == nil {
+		return
+	} else if azcore.IsNullValue(v) {
+		m[k] = nil
+	} else if !reflect.ValueOf(v).IsNil() {
+		m[k] = v
+	}
+}
+
+func unpopulate(data json.RawMessage, fn string, v any) error {
+	if data == nil {
+		return nil
+	}
+	if err := json.Unmarshal(data, v); err != nil {
+		return fmt.Errorf("struct field %s: %v", fn, err)
+	}
+	return nil
+}
diff --git a/sdk/resourcemanager/liftrqumulo/armqumulo/operations_client.go b/sdk/resourcemanager/liftrqumulo/armqumulo/operations_client.go
new file mode 100644
index 0000000000..b56594574a
--- /dev/null
+++ b/sdk/resourcemanager/liftrqumulo/armqumulo/operations_client.go
@@ -0,0 +1,105 @@
+//go:build go1.18
+// +build go1.18
+
+// Copyright (c) Microsoft Corporation. All rights reserved.
+// Licensed under the MIT License. See License.txt in the project root for license information.
+// Code generated by Microsoft (R) AutoRest Code Generator.
+// Changes may cause incorrect behavior and will be lost if the code is regenerated.
+// DO NOT EDIT.
+
+package armqumulo
+
+import (
+	"context"
+	"github.com/Azure/azure-sdk-for-go/sdk/azcore"
+	"github.com/Azure/azure-sdk-for-go/sdk/azcore/arm"
+	armruntime "github.com/Azure/azure-sdk-for-go/sdk/azcore/arm/runtime"
+	"github.com/Azure/azure-sdk-for-go/sdk/azcore/cloud"
+	"github.com/Azure/azure-sdk-for-go/sdk/azcore/policy"
+	"github.com/Azure/azure-sdk-for-go/sdk/azcore/runtime"
+	"net/http"
+)
+
+// OperationsClient contains the methods for the Operations group.
+// Don't use this type directly, use NewOperationsClient() instead.
+type OperationsClient struct {
+	host string
+	pl   runtime.Pipeline
+}
+
+// NewOperationsClient creates a new instance of OperationsClient with the specified values.
+//   - credential - used to authorize requests. Usually a credential from azidentity.
+//   - options - pass nil to accept the default values.
+func NewOperationsClient(credential azcore.TokenCredential, options *arm.ClientOptions) (*OperationsClient, error) {
+	if options == nil {
+		options = &arm.ClientOptions{}
+	}
+	ep := cloud.AzurePublic.Services[cloud.ResourceManager].Endpoint
+	if c, ok := options.Cloud.Services[cloud.ResourceManager]; ok {
+		ep = c.Endpoint
+	}
+	pl, err := armruntime.NewPipeline(moduleName, moduleVersion, credential, runtime.PipelineOptions{}, options)
+	if err != nil {
+		return nil, err
+	}
+	client := &OperationsClient{
+		host: ep,
+		pl:   pl,
+	}
+	return client, nil
+}
+
+// NewListPager - List the operations for the provider
+//
+// Generated from API version 2022-10-12-preview
+//   - options - OperationsClientListOptions contains the optional parameters for the OperationsClient.NewListPager method.
+func (client *OperationsClient) NewListPager(options *OperationsClientListOptions) *runtime.Pager[OperationsClientListResponse] {
+	return runtime.NewPager(runtime.PagingHandler[OperationsClientListResponse]{
+		More: func(page OperationsClientListResponse) bool {
+			return page.NextLink != nil && len(*page.NextLink) > 0
+		},
+		Fetcher: func(ctx context.Context, page *OperationsClientListResponse) (OperationsClientListResponse, error) {
+			var req *policy.Request
+			var err error
+			if page == nil {
+				req, err = client.listCreateRequest(ctx, options)
+			} else {
+				req, err = runtime.NewRequest(ctx, http.MethodGet, *page.NextLink)
+			}
+			if err != nil {
+				return OperationsClientListResponse{}, err
+			}
+			resp, err := client.pl.Do(req)
+			if err != nil {
+				return OperationsClientListResponse{}, err
+			}
+			if !runtime.HasStatusCode(resp, http.StatusOK) {
+				return OperationsClientListResponse{}, runtime.NewResponseError(resp)
+			}
+			return client.listHandleResponse(resp)
+		},
+	})
+}
+
+// listCreateRequest creates the List request.
+func (client *OperationsClient) listCreateRequest(ctx context.Context, options *OperationsClientListOptions) (*policy.Request, error) {
+	urlPath := "/providers/Qumulo.Storage/operations"
+	req, err := runtime.NewRequest(ctx, http.MethodGet, runtime.JoinPaths(client.host, urlPath))
+	if err != nil {
+		return nil, err
+	}
+	reqQP := req.Raw().URL.Query()
+	reqQP.Set("api-version", "2022-10-12-preview")
+	req.Raw().URL.RawQuery = reqQP.Encode()
+	req.Raw().Header["Accept"] = []string{"application/json"}
+	return req, nil
+}
+
+// listHandleResponse handles the List response.
+func (client *OperationsClient) listHandleResponse(resp *http.Response) (OperationsClientListResponse, error) {
+	result := OperationsClientListResponse{}
+	if err := runtime.UnmarshalAsJSON(resp, &result.OperationListResult); err != nil {
+		return OperationsClientListResponse{}, err
+	}
+	return result, nil
+}
diff --git a/sdk/resourcemanager/liftrqumulo/armqumulo/response_types.go b/sdk/resourcemanager/liftrqumulo/armqumulo/response_types.go
new file mode 100644
index 0000000000..6dacad3ea3
--- /dev/null
+++ b/sdk/resourcemanager/liftrqumulo/armqumulo/response_types.go
@@ -0,0 +1,45 @@
+//go:build go1.18
+// +build go1.18
+
+// Copyright (c) Microsoft Corporation. All rights reserved.
+// Licensed under the MIT License. See License.txt in the project root for license information.
+// Code generated by Microsoft (R) AutoRest Code Generator.
+// Changes may cause incorrect behavior and will be lost if the code is regenerated.
+// DO NOT EDIT.
+
+package armqumulo
+
+// FileSystemsClientCreateOrUpdateResponse contains the response from method FileSystemsClient.BeginCreateOrUpdate.
+type FileSystemsClientCreateOrUpdateResponse struct {
+	FileSystemResource
+}
+
+// FileSystemsClientDeleteResponse contains the response from method FileSystemsClient.BeginDelete.
+type FileSystemsClientDeleteResponse struct {
+	// placeholder for future response values
+}
+
+// FileSystemsClientGetResponse contains the response from method FileSystemsClient.Get.
+type FileSystemsClientGetResponse struct {
+	FileSystemResource
+}
+
+// FileSystemsClientListByResourceGroupResponse contains the response from method FileSystemsClient.NewListByResourceGroupPager.
+type FileSystemsClientListByResourceGroupResponse struct {
+	FileSystemResourceListResult
+}
+
+// FileSystemsClientListBySubscriptionResponse contains the response from method FileSystemsClient.NewListBySubscriptionPager.
+type FileSystemsClientListBySubscriptionResponse struct {
+	FileSystemResourceListResult
+}
+
+// FileSystemsClientUpdateResponse contains the response from method FileSystemsClient.Update.
+type FileSystemsClientUpdateResponse struct {
+	FileSystemResource
+}
+
+// OperationsClientListResponse contains the response from method OperationsClient.NewListPager.
+type OperationsClientListResponse struct {
+	OperationListResult
+}
diff --git a/sdk/resourcemanager/liftrqumulo/armqumulo/time_rfc3339.go b/sdk/resourcemanager/liftrqumulo/armqumulo/time_rfc3339.go
new file mode 100644
index 0000000000..921c908026
--- /dev/null
+++ b/sdk/resourcemanager/liftrqumulo/armqumulo/time_rfc3339.go
@@ -0,0 +1,87 @@
+//go:build go1.18
+// +build go1.18
+
+// Copyright (c) Microsoft Corporation. All rights reserved.
+// Licensed under the MIT License. See License.txt in the project root for license information.
+// Code generated by Microsoft (R) AutoRest Code Generator.
+// Changes may cause incorrect behavior and will be lost if the code is regenerated.
+// DO NOT EDIT.
+
+package armqumulo
+
+import (
+	"encoding/json"
+	"fmt"
+	"github.com/Azure/azure-sdk-for-go/sdk/azcore"
+	"reflect"
+	"regexp"
+	"strings"
+	"time"
+)
+
+const (
+	utcLayoutJSON = `"2006-01-02T15:04:05.999999999"`
+	utcLayout     = "2006-01-02T15:04:05.999999999"
+	rfc3339JSON   = `"` + time.RFC3339Nano + `"`
+)
+
+// 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+)*"*$`)
+
+type timeRFC3339 time.Time
+
+func (t timeRFC3339) MarshalJSON() (json []byte, err error) {
+	tt := time.Time(t)
+	return tt.MarshalJSON()
+}
+
+func (t timeRFC3339) MarshalText() (text []byte, err error) {
+	tt := time.Time(t)
+	return tt.MarshalText()
+}
+
+func (t *timeRFC3339) UnmarshalJSON(data []byte) error {
+	layout := utcLayoutJSON
+	if tzOffsetRegex.Match(data) {
+		layout = rfc3339JSON
+	}
+	return t.Parse(layout, string(data))
+}
+
+func (t *timeRFC3339) UnmarshalText(data []byte) (err error) {
+	layout := utcLayout
+	if tzOffsetRegex.Match(data) {
+		layout = time.RFC3339Nano
+	}
+	return t.Parse(layout, string(data))
+}
+
+func (t *timeRFC3339) Parse(layout, value string) error {
+	p, err := time.Parse(layout, strings.ToUpper(value))
+	*t = timeRFC3339(p)
+	return err
+}
+
+func populateTimeRFC3339(m map[string]any, k string, t *time.Time) {
+	if t == nil {
+		return
+	} else if azcore.IsNullValue(t) {
+		m[k] = nil
+		return
+	} else if reflect.ValueOf(t).IsNil() {
+		return
+	}
+	m[k] = (*timeRFC3339)(t)
+}
+
+func unpopulateTimeRFC3339(data json.RawMessage, fn string, t **time.Time) error {
+	if data == nil || strings.EqualFold(string(data), "null") {
+		return nil
+	}
+	var aux timeRFC3339
+	if err := json.Unmarshal(data, &aux); err != nil {
+		return fmt.Errorf("struct field %s: %v", fn, err)
+	}
+	*t = (*time.Time)(&aux)
+	return nil
+}
diff --git a/sdk/storage/azqueue/CHANGELOG.md b/sdk/storage/azqueue/CHANGELOG.md
index e540248798..81127f99b8 100644
--- a/sdk/storage/azqueue/CHANGELOG.md
+++ b/sdk/storage/azqueue/CHANGELOG.md
@@ -1,4 +1,16 @@
-## 0.1.0 (2023-02-15)
+## Release History
+
+### 0.1.1 (Unreleased)
+
+#### Features Added
+
+#### Breaking Changes
+
+#### Bugs Fixed
+
+#### Other Changes
+
+### 0.1.0 (2023-02-15)
 
 ### Features Added
 
diff --git a/sdk/storage/azqueue/internal/exported/version.go b/sdk/storage/azqueue/internal/exported/version.go
index cfbc93f4ea..9ad8cee51f 100644
--- a/sdk/storage/azqueue/internal/exported/version.go
+++ b/sdk/storage/azqueue/internal/exported/version.go
@@ -8,5 +8,5 @@ package exported
 
 const (
 	ModuleName    = "azqueue"
-	ModuleVersion = "v0.1.0"
+	ModuleVersion = "v0.1.1"
 )


Test patch:
diff --git a/sdk/data/azcosmos/emulator_cosmos_item_test.go b/sdk/data/azcosmos/emulator_cosmos_item_test.go
index 3a402efc0c..1086f62d73 100644
--- a/sdk/data/azcosmos/emulator_cosmos_item_test.go
+++ b/sdk/data/azcosmos/emulator_cosmos_item_test.go
@@ -188,6 +188,181 @@ func TestItemCRUD(t *testing.T) {
 	}
 }
 
+func TestItemCRUDforNullPartitionKey(t *testing.T) {
+	emulatorTests := newEmulatorTests(t)
+	client := emulatorTests.getClient(t)
+
+	database := emulatorTests.createDatabase(t, context.TODO(), client, "itemCRUD")
+	defer emulatorTests.deleteDatabase(t, context.TODO(), database)
+	properties := ContainerProperties{
+		ID: "aContainer",
+		PartitionKeyDefinition: PartitionKeyDefinition{
+			Paths: []string{"/partitionKey"},
+		},
+	}
+
+	_, err := database.CreateContainer(context.TODO(), properties, nil)
+	if err != nil {
+		t.Fatalf("Failed to create container: %v", err)
+	}
+
+	item := map[string]interface{}{
+		"partitionKey": nil,
+		"id":           "1",
+		"value":        "2",
+		"count":        3,
+		"description":  "4",
+	}
+
+	container, _ := database.NewContainer("aContainer")
+	pk := NullPartitionKey
+
+	marshalled, err := json.Marshal(item)
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	itemResponse, err := container.CreateItem(context.TODO(), pk, marshalled, nil)
+	if err != nil {
+		t.Fatalf("Failed to create item: %v", err)
+	}
+
+	if itemResponse.SessionToken == "" {
+		t.Fatalf("Session token is empty")
+	}
+
+	// No content on write by default
+	if len(itemResponse.Value) != 0 {
+		t.Fatalf("Expected empty response, got %v", itemResponse.Value)
+	}
+
+	itemResponse, err = container.ReadItem(context.TODO(), pk, "1", nil)
+	if err != nil {
+		t.Fatalf("Failed to read item: %v", err)
+	}
+
+	if len(itemResponse.Value) == 0 {
+		t.Fatalf("Expected non-empty response, got %v", itemResponse.Value)
+	}
+
+	var itemResponseBody map[string]interface{}
+	err = json.Unmarshal(itemResponse.Value, &itemResponseBody)
+	if err != nil {
+		t.Fatalf("Failed to unmarshal item response: %v", err)
+	}
+	if itemResponseBody["id"] != "1" {
+		t.Fatalf("Expected id to be 1, got %v", itemResponseBody["id"])
+	}
+	if itemResponseBody["value"] != "2" {
+		t.Fatalf("Expected value to be 2, got %v", itemResponseBody["value"])
+	}
+
+	item["value"] = "3"
+	marshalled, err = json.Marshal(item)
+	if err != nil {
+		t.Fatal(err)
+	}
+	itemResponse, err = container.ReplaceItem(context.TODO(), pk, "1", marshalled, &ItemOptions{EnableContentResponseOnWrite: true})
+	if err != nil {
+		t.Fatalf("Failed to replace item: %v", err)
+	}
+
+	// Explicitly requesting body on write
+	if len(itemResponse.Value) == 0 {
+		t.Fatalf("Expected non-empty response, got %v", itemResponse.Value)
+	}
+
+	err = json.Unmarshal(itemResponse.Value, &itemResponseBody)
+	if err != nil {
+		t.Fatalf("Failed to unmarshal item response: %v", err)
+	}
+	if itemResponseBody["id"] != "1" {
+		t.Fatalf("Expected id to be 1, got %v", itemResponseBody["id"])
+	}
+	if itemResponseBody["value"] != "3" {
+		t.Fatalf("Expected value to be 3, got %v", itemResponseBody["value"])
+	}
+
+	item["value"] = "4"
+	marshalled, err = json.Marshal(item)
+	if err != nil {
+		t.Fatal(err)
+	}
+	itemResponse, err = container.UpsertItem(context.TODO(), pk, marshalled, &ItemOptions{EnableContentResponseOnWrite: true})
+	if err != nil {
+		t.Fatalf("Failed to upsert item: %v", err)
+	}
+
+	// Explicitly requesting body on write
+	if len(itemResponse.Value) == 0 {
+		t.Fatalf("Expected non-empty response, got %v", itemResponse.Value)
+	}
+
+	err = json.Unmarshal(itemResponse.Value, &itemResponseBody)
+	if err != nil {
+		t.Fatalf("Failed to unmarshal item response: %v", err)
+	}
+	if itemResponseBody["id"] != "1" {
+		t.Fatalf("Expected id to be 1, got %v", itemResponseBody["id"])
+	}
+	if itemResponseBody["value"] != "4" {
+		t.Fatalf("Expected value to be 4, got %v", itemResponseBody["value"])
+	}
+
+	patchItem := PatchOperations{}
+	patchItem.AppendReplace("/value", "5")
+	patchItem.AppendSet("/hello", "world")
+	patchItem.AppendAdd("/foo", "bar")
+	patchItem.AppendRemove("/description")
+	patchItem.AppendIncrement("/count", 1)
+
+	itemResponse, err = container.PatchItem(context.TODO(), pk, "1", patchItem, nil)
+	if err != nil {
+		t.Fatalf("Failed to patch item: %v", err)
+	}
+
+	// No content on write by default
+	if len(itemResponse.Value) != 0 {
+		t.Fatalf("Expected empty response, got %v", itemResponse.Value)
+	}
+
+	itemResponse, _ = container.ReadItem(context.TODO(), pk, "1", nil)
+
+	err = json.Unmarshal(itemResponse.Value, &itemResponseBody)
+	if err != nil {
+		t.Fatalf("Failed to unmarshal item response: %v", err)
+	}
+
+	if itemResponseBody["value"] != "5" {
+		t.Fatalf("Expected value to be 5, got %v", itemResponseBody["id"])
+	}
+
+	if itemResponseBody["hello"] != "world" {
+		t.Fatalf("Expected hello to be world, got %v", itemResponseBody["hello"])
+	}
+
+	if itemResponseBody["foo"] != "bar" {
+		t.Fatalf("Expected foo to be bar, got %v", itemResponseBody["foo"])
+	}
+
+	if itemResponseBody["count"].(float64) != float64(4) {
+		t.Fatalf("Expected count to be 4, got %v", itemResponseBody["count"])
+	}
+
+	if itemResponseBody["toremove"] != nil {
+		t.Fatalf("Expected toremove to be nil, got %v", itemResponseBody)
+	}
+
+	itemResponse, err = container.DeleteItem(context.TODO(), pk, "1", nil)
+	if err != nil {
+		t.Fatalf("Failed to replace item: %v", err)
+	}
+
+	if len(itemResponse.Value) != 0 {
+		t.Fatalf("Expected empty response, got %v", itemResponse.Value)
+	}
+}
+
 func TestItemIdEncodingRoutingGW(t *testing.T) {
 	emulatorTests := newEmulatorTests(t)
 	client := emulatorTests.getClient(t)
diff --git a/sdk/data/azcosmos/partition_key_test.go b/sdk/data/azcosmos/partition_key_test.go
index 44096f5444..bd7e651aba 100644
--- a/sdk/data/azcosmos/partition_key_test.go
+++ b/sdk/data/azcosmos/partition_key_test.go
@@ -15,6 +15,7 @@ func TestSerialization(t *testing.T) {
 		"[\"some string\"]": NewPartitionKeyString("some string"),
 		"[true]":            NewPartitionKeyBool(true),
 		"[false]":           NewPartitionKeyBool(false),
+		"[null]":            NullPartitionKey,
 	}
 
 	for expectedSerialization, pk := range validTypes {
@@ -68,4 +69,10 @@ func TestPartitionKeyEquality(t *testing.T) {
 	if !reflect.DeepEqual(pk, pk2) {
 		t.Errorf("Expected %v to equal %v", pk, pk2)
 	}
+
+	pk = NullPartitionKey
+	pk2 = NullPartitionKey
+	if !reflect.DeepEqual(pk, pk2) {
+		t.Errorf("Expected %v to equal %v", pk, pk2)
+	}
 }
diff --git a/sdk/messaging/azeventhubs/partition_client_unit_test.go b/sdk/messaging/azeventhubs/partition_client_unit_test.go
index bf18e3e57f..e03eb2d5eb 100644
--- a/sdk/messaging/azeventhubs/partition_client_unit_test.go
+++ b/sdk/messaging/azeventhubs/partition_client_unit_test.go
@@ -5,11 +5,13 @@ package azeventhubs
 
 import (
 	"context"
+	"fmt"
 	"testing"
 	"time"
 
 	"github.com/Azure/azure-sdk-for-go/sdk/messaging/azeventhubs/internal"
 	"github.com/Azure/azure-sdk-for-go/sdk/messaging/azeventhubs/internal/go-amqp"
+	"github.com/Azure/azure-sdk-for-go/sdk/messaging/azeventhubs/internal/test"
 	"github.com/stretchr/testify/require"
 )
 
@@ -41,6 +43,43 @@ func TestUnit_PartitionClient_PrefetchOff(t *testing.T) {
 	require.True(t, ns.Receiver.ManualCreditsSetFromOptions)
 }
 
+func TestUnit_PartitionClient_PrefetchOff_CreditLimits(t *testing.T) {
+	ns := &internal.FakeNSForPartClient{
+		Receiver: &internal.FakeAMQPReceiver{
+			Messages: fakeMessages(int(defaultMaxCreditSize)),
+		},
+	}
+
+	client, err := newPartitionClient(partitionClientArgs{
+		namespace: ns,
+	}, &PartitionClientOptions{
+		Prefetch: -1,
+	})
+	require.NoError(t, err)
+
+	ctx, cancel := context.WithTimeout(context.Background(), time.Second)
+	defer cancel()
+
+	// can't request over the max
+	events, err := client.ReceiveEvents(ctx, int(defaultMaxCreditSize+1), nil)
+	require.EqualError(t, err, "count cannot exceed 5000")
+	require.Empty(t, events)
+
+	// can't request negative/0 credits
+	events, err = client.ReceiveEvents(ctx, 0, nil)
+	require.EqualError(t, err, "count should be greater than 0")
+	require.Empty(t, events)
+
+	events, err = client.ReceiveEvents(ctx, -1, nil)
+	require.EqualError(t, err, "count should be greater than 0")
+	require.Empty(t, events)
+
+	// can request the max
+	events, err = client.ReceiveEvents(ctx, int(defaultMaxCreditSize), nil)
+	require.NoError(t, err)
+	require.NotEmpty(t, events)
+}
+
 func TestUnit_PartitionClient_PrefetchOffOnlyBackfillsCredits(t *testing.T) {
 	testData := []struct {
 		Name    string
@@ -116,3 +155,77 @@ func TestUnit_PartitionClient_PrefetchOn(t *testing.T) {
 		require.Equal(t, uint32(td.initialCredits-3), ns.Receiver.ActiveCredits, "All messages should have been received")
 	}
 }
+
+func TestUnit_PartitionClient_PrefetchLimit(t *testing.T) {
+	newPartitionClient := func(prefetch int32) (*PartitionClient, error) {
+		ns := &internal.FakeNSForPartClient{
+			Receiver: &internal.FakeAMQPReceiver{
+				Messages: fakeMessages(int(defaultMaxCreditSize) + 1),
+			},
+		}
+
+		client, err := newPartitionClient(partitionClientArgs{namespace: ns}, &PartitionClientOptions{
+			Prefetch: prefetch,
+		})
+
+		return client, err
+	}
+
+	t.Run("max allowed credits is defaultMaxCreditSize", func(t *testing.T) {
+		client, err := newPartitionClient(int32(defaultMaxCreditSize))
+		require.NoError(t, err)
+		require.NotNil(t, client)
+
+		test.RequireClose(t, client)
+	})
+
+	t.Run("can't request zero or negative credits", func(t *testing.T) {
+		client, err := newPartitionClient(int32(defaultMaxCreditSize))
+		require.NoError(t, err)
+		require.NotNil(t, client)
+
+		events, err := client.ReceiveEvents(context.Background(), 0, nil)
+		require.EqualError(t, err, "count should be greater than 0")
+		require.Empty(t, events)
+
+		events, err = client.ReceiveEvents(context.Background(), -1, nil)
+		require.EqualError(t, err, "count should be greater than 0")
+		require.Empty(t, events)
+
+		test.RequireClose(t, client)
+	})
+
+	t.Run("can receive more than defaultMaxCreditSize in prefetch mode", func(t *testing.T) {
+		client, err := newPartitionClient(0)
+		require.NoError(t, err)
+		require.NotNil(t, client)
+
+		// if you're using prefetch it's fine to ask for more than the `defaultMaxCreditSize`
+		// since it doesn't actually cause to request more credits than is allowed.
+		ctx, cancel := context.WithTimeout(context.Background(), time.Second)
+		defer cancel()
+
+		events, err := client.ReceiveEvents(ctx, int(defaultMaxCreditSize+1), nil)
+		require.NoError(t, err)
+		require.NotEmpty(t, events)
+
+		test.RequireClose(t, client)
+	})
+
+	t.Run("can't set a option.Prefetch > defaultMaxCreditSize", func(t *testing.T) {
+		// and you can't create a PartitionClient that uses more credits than allowed.
+		client, err := newPartitionClient(int32(defaultMaxCreditSize) + 1)
+		require.EqualError(t, err, fmt.Sprintf("options.Prefetch cannot exceed %d", defaultMaxCreditSize))
+		require.Nil(t, client)
+	})
+}
+
+func fakeMessages(count int) []*amqp.Message {
+	var messages []*amqp.Message
+
+	for i := 0; i < count; i++ {
+		messages = append(messages, &amqp.Message{})
+	}
+
+	return messages
+}
diff --git a/sdk/resourcemanager/liftrqumulo/armqumulo/filesystems_client_example_test.go b/sdk/resourcemanager/liftrqumulo/armqumulo/filesystems_client_example_test.go
new file mode 100644
index 0000000000..fdafeb7edb
--- /dev/null
+++ b/sdk/resourcemanager/liftrqumulo/armqumulo/filesystems_client_example_test.go
@@ -0,0 +1,711 @@
+//go:build go1.18
+// +build go1.18
+
+// Copyright (c) Microsoft Corporation. All rights reserved.
+// Licensed under the MIT License. See License.txt in the project root for license information.
+// Code generated by Microsoft (R) AutoRest Code Generator.
+// Changes may cause incorrect behavior and will be lost if the code is regenerated.
+// DO NOT EDIT.
+
+package armqumulo_test
+
+import (
+	"context"
+	"log"
+
+	"github.com/Azure/azure-sdk-for-go/sdk/azcore/to"
+	"github.com/Azure/azure-sdk-for-go/sdk/azidentity"
+	"github.com/Azure/azure-sdk-for-go/sdk/resourcemanager/liftrqumulo/armqumulo"
+)
+
+// Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/9918780b4dc4bdc111cf3facc11561904d609ad7/specification/liftrqumulo/resource-manager/Qumulo.Storage/preview/2022-10-12-preview/examples/FileSystems_ListBySubscription_MaximumSet_Gen.json
+func ExampleFileSystemsClient_NewListBySubscriptionPager_fileSystemsListBySubscriptionMaximumSetGen() {
+	cred, err := azidentity.NewDefaultAzureCredential(nil)
+	if err != nil {
+		log.Fatalf("failed to obtain a credential: %v", err)
+	}
+	ctx := context.Background()
+	client, err := armqumulo.NewFileSystemsClient("ulseeqylxb", cred, nil)
+	if err != nil {
+		log.Fatalf("failed to create client: %v", err)
+	}
+	pager := client.NewListBySubscriptionPager(nil)
+	for pager.More() {
+		page, err := pager.NextPage(ctx)
+		if err != nil {
+			log.Fatalf("failed to advance page: %v", err)
+		}
+		for _, v := range page.Value {
+			// You could use page here. We use blank identifier for just demo purposes.
+			_ = v
+		}
+		// If the HTTP response code is 200 as defined in example definition, your page structure would look as follows. Please pay attention that all the values in the output are fake values for just demo purposes.
+		// page.FileSystemResourceListResult = armqumulo.FileSystemResourceListResult{
+		// 	Value: []*armqumulo.FileSystemResource{
+		// 		{
+		// 			Name: to.Ptr("bii"),
+		// 			Type: to.Ptr("qtvxrqwpoistduq"),
+		// 			ID: to.Ptr("tvelgpobdtazrweunifqzaxkgjauyx"),
+		// 			SystemData: &armqumulo.SystemData{
+		// 				CreatedAt: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2022-10-14T04:40:17.991Z"); return t}()),
+		// 				CreatedBy: to.Ptr("mtdhqooysjhueaojwpmvophkgntl"),
+		// 				CreatedByType: to.Ptr(armqumulo.CreatedByTypeUser),
+		// 				LastModifiedAt: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2022-10-14T04:40:17.991Z"); return t}()),
+		// 				LastModifiedBy: to.Ptr("jcywglomzuamsxltnoegdrkzlscxl"),
+		// 				LastModifiedByType: to.Ptr(armqumulo.CreatedByTypeUser),
+		// 			},
+		// 			Location: to.Ptr("przdlsmlzsszphnixq"),
+		// 			Tags: map[string]*string{
+		// 				"key6565": to.Ptr("cgdhmupta"),
+		// 			},
+		// 			Identity: &armqumulo.ManagedServiceIdentity{
+		// 				Type: to.Ptr(armqumulo.ManagedServiceIdentityTypeNone),
+		// 				PrincipalID: to.Ptr("11111111-1111-1111-1111-111111111111"),
+		// 				TenantID: to.Ptr("11111111-1111-1111-1111-111111111111"),
+		// 				UserAssignedIdentities: map[string]*armqumulo.UserAssignedIdentity{
+		// 					"key4522": &armqumulo.UserAssignedIdentity{
+		// 						ClientID: to.Ptr("11111111-1111-1111-1111-111111111111"),
+		// 						PrincipalID: to.Ptr("11111111-1111-1111-1111-111111111111"),
+		// 					},
+		// 				},
+		// 			},
+		// 			Properties: &armqumulo.FileSystemResourceProperties{
+		// 				AvailabilityZone: to.Ptr("maseyqhlnhoiwbabcqabtedbjpip"),
+		// 				ClusterLoginURL: to.Ptr("jjqhgevy"),
+		// 				DelegatedSubnetID: to.Ptr("neqctctqdmjezfgt"),
+		// 				InitialCapacity: to.Ptr[int32](9),
+		// 				MarketplaceDetails: &armqumulo.MarketplaceDetails{
+		// 					MarketplaceSubscriptionID: to.Ptr("ujrcqvxfnhxxheoth"),
+		// 					MarketplaceSubscriptionStatus: to.Ptr(armqumulo.MarketplaceSubscriptionStatusPendingFulfillmentStart),
+		// 					OfferID: to.Ptr("eiyhbmpwgezcmzrrfoiskuxlcvwojf"),
+		// 					PlanID: to.Ptr("x"),
+		// 					PublisherID: to.Ptr("wfmokfdjbwpjhz"),
+		// 				},
+		// 				PrivateIPs: []*string{
+		// 					to.Ptr("kslguxrwbwkrj")},
+		// 					ProvisioningState: to.Ptr(armqumulo.ProvisioningStateSucceeded),
+		// 					StorageSKU: to.Ptr(armqumulo.StorageSKUStandard),
+		// 					UserDetails: &armqumulo.UserDetails{
+		// 					},
+		// 				},
+		// 		}},
+		// 	}
+	}
+}
+
+// Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/9918780b4dc4bdc111cf3facc11561904d609ad7/specification/liftrqumulo/resource-manager/Qumulo.Storage/preview/2022-10-12-preview/examples/FileSystems_ListBySubscription_MinimumSet_Gen.json
+func ExampleFileSystemsClient_NewListBySubscriptionPager_fileSystemsListBySubscriptionMinimumSetGen() {
+	cred, err := azidentity.NewDefaultAzureCredential(nil)
+	if err != nil {
+		log.Fatalf("failed to obtain a credential: %v", err)
+	}
+	ctx := context.Background()
+	client, err := armqumulo.NewFileSystemsClient("aaaaaaa", cred, nil)
+	if err != nil {
+		log.Fatalf("failed to create client: %v", err)
+	}
+	pager := client.NewListBySubscriptionPager(nil)
+	for pager.More() {
+		page, err := pager.NextPage(ctx)
+		if err != nil {
+			log.Fatalf("failed to advance page: %v", err)
+		}
+		for _, v := range page.Value {
+			// You could use page here. We use blank identifier for just demo purposes.
+			_ = v
+		}
+		// If the HTTP response code is 200 as defined in example definition, your page structure would look as follows. Please pay attention that all the values in the output are fake values for just demo purposes.
+		// page.FileSystemResourceListResult = armqumulo.FileSystemResourceListResult{
+		// 	Value: []*armqumulo.FileSystemResource{
+		// 		{
+		// 			Name: to.Ptr("aaaaa"),
+		// 			ID: to.Ptr("aaaaaaaaaaaaaaaaa"),
+		// 			Location: to.Ptr("aaaaaaaaaaaaaaaaaaaaaaaaaaaa"),
+		// 			Properties: &armqumulo.FileSystemResourceProperties{
+		// 				DelegatedSubnetID: to.Ptr("aaaaaaaaaaaaaaaaaaaaaaaaaaaaa"),
+		// 				InitialCapacity: to.Ptr[int32](9),
+		// 				MarketplaceDetails: &armqumulo.MarketplaceDetails{
+		// 					MarketplaceSubscriptionID: to.Ptr("aaaaaaaaaaaaaaaaa"),
+		// 					MarketplaceSubscriptionStatus: to.Ptr(armqumulo.MarketplaceSubscriptionStatusPendingFulfillmentStart),
+		// 					OfferID: to.Ptr("aaaaaaaaa"),
+		// 					PlanID: to.Ptr("aaaaaaa"),
+		// 					PublisherID: to.Ptr("aaaaaaaaaaaaaaaaaaaa"),
+		// 				},
+		// 				ProvisioningState: to.Ptr(armqumulo.ProvisioningStateSucceeded),
+		// 				StorageSKU: to.Ptr(armqumulo.StorageSKUStandard),
+		// 				UserDetails: &armqumulo.UserDetails{
+		// 				},
+		// 			},
+		// 	}},
+		// }
+	}
+}
+
+// Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/9918780b4dc4bdc111cf3facc11561904d609ad7/specification/liftrqumulo/resource-manager/Qumulo.Storage/preview/2022-10-12-preview/examples/FileSystems_ListByResourceGroup_MaximumSet_Gen.json
+func ExampleFileSystemsClient_NewListByResourceGroupPager_fileSystemsListByResourceGroupMaximumSetGen() {
+	cred, err := azidentity.NewDefaultAzureCredential(nil)
+	if err != nil {
+		log.Fatalf("failed to obtain a credential: %v", err)
+	}
+	ctx := context.Background()
+	client, err := armqumulo.NewFileSystemsClient("ulseeqylxb", cred, nil)
+	if err != nil {
+		log.Fatalf("failed to create client: %v", err)
+	}
+	pager := client.NewListByResourceGroupPager("rgQumulo", nil)
+	for pager.More() {
+		page, err := pager.NextPage(ctx)
+		if err != nil {
+			log.Fatalf("failed to advance page: %v", err)
+		}
+		for _, v := range page.Value {
+			// You could use page here. We use blank identifier for just demo purposes.
+			_ = v
+		}
+		// If the HTTP response code is 200 as defined in example definition, your page structure would look as follows. Please pay attention that all the values in the output are fake values for just demo purposes.
+		// page.FileSystemResourceListResult = armqumulo.FileSystemResourceListResult{
+		// 	Value: []*armqumulo.FileSystemResource{
+		// 		{
+		// 			Name: to.Ptr("bii"),
+		// 			Type: to.Ptr("qtvxrqwpoistduq"),
+		// 			ID: to.Ptr("tvelgpobdtazrweunifqzaxkgjauyx"),
+		// 			SystemData: &armqumulo.SystemData{
+		// 				CreatedAt: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2022-10-14T04:40:17.991Z"); return t}()),
+		// 				CreatedBy: to.Ptr("mtdhqooysjhueaojwpmvophkgntl"),
+		// 				CreatedByType: to.Ptr(armqumulo.CreatedByTypeUser),
+		// 				LastModifiedAt: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2022-10-14T04:40:17.991Z"); return t}()),
+		// 				LastModifiedBy: to.Ptr("jcywglomzuamsxltnoegdrkzlscxl"),
+		// 				LastModifiedByType: to.Ptr(armqumulo.CreatedByTypeUser),
+		// 			},
+		// 			Location: to.Ptr("przdlsmlzsszphnixq"),
+		// 			Tags: map[string]*string{
+		// 				"key6565": to.Ptr("cgdhmupta"),
+		// 			},
+		// 			Identity: &armqumulo.ManagedServiceIdentity{
+		// 				Type: to.Ptr(armqumulo.ManagedServiceIdentityTypeNone),
+		// 				PrincipalID: to.Ptr("11111111-1111-1111-1111-111111111111"),
+		// 				TenantID: to.Ptr("11111111-1111-1111-1111-111111111111"),
+		// 				UserAssignedIdentities: map[string]*armqumulo.UserAssignedIdentity{
+		// 					"key4522": &armqumulo.UserAssignedIdentity{
+		// 						ClientID: to.Ptr("11111111-1111-1111-1111-111111111111"),
+		// 						PrincipalID: to.Ptr("11111111-1111-1111-1111-111111111111"),
+		// 					},
+		// 				},
+		// 			},
+		// 			Properties: &armqumulo.FileSystemResourceProperties{
+		// 				AvailabilityZone: to.Ptr("maseyqhlnhoiwbabcqabtedbjpip"),
+		// 				ClusterLoginURL: to.Ptr("jjqhgevy"),
+		// 				DelegatedSubnetID: to.Ptr("neqctctqdmjezfgt"),
+		// 				InitialCapacity: to.Ptr[int32](9),
+		// 				MarketplaceDetails: &armqumulo.MarketplaceDetails{
+		// 					MarketplaceSubscriptionID: to.Ptr("ujrcqvxfnhxxheoth"),
+		// 					MarketplaceSubscriptionStatus: to.Ptr(armqumulo.MarketplaceSubscriptionStatusPendingFulfillmentStart),
+		// 					OfferID: to.Ptr("eiyhbmpwgezcmzrrfoiskuxlcvwojf"),
+		// 					PlanID: to.Ptr("x"),
+		// 					PublisherID: to.Ptr("wfmokfdjbwpjhz"),
+		// 				},
+		// 				PrivateIPs: []*string{
+		// 					to.Ptr("kslguxrwbwkrj")},
+		// 					ProvisioningState: to.Ptr(armqumulo.ProvisioningStateSucceeded),
+		// 					StorageSKU: to.Ptr(armqumulo.StorageSKUStandard),
+		// 					UserDetails: &armqumulo.UserDetails{
+		// 					},
+		// 				},
+		// 		}},
+		// 	}
+	}
+}
+
+// Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/9918780b4dc4bdc111cf3facc11561904d609ad7/specification/liftrqumulo/resource-manager/Qumulo.Storage/preview/2022-10-12-preview/examples/FileSystems_ListByResourceGroup_MinimumSet_Gen.json
+func ExampleFileSystemsClient_NewListByResourceGroupPager_fileSystemsListByResourceGroupMinimumSetGen() {
+	cred, err := azidentity.NewDefaultAzureCredential(nil)
+	if err != nil {
+		log.Fatalf("failed to obtain a credential: %v", err)
+	}
+	ctx := context.Background()
+	client, err := armqumulo.NewFileSystemsClient("aaaaaaa", cred, nil)
+	if err != nil {
+		log.Fatalf("failed to create client: %v", err)
+	}
+	pager := client.NewListByResourceGroupPager("rgQumulo", nil)
+	for pager.More() {
+		page, err := pager.NextPage(ctx)
+		if err != nil {
+			log.Fatalf("failed to advance page: %v", err)
+		}
+		for _, v := range page.Value {
+			// You could use page here. We use blank identifier for just demo purposes.
+			_ = v
+		}
+		// If the HTTP response code is 200 as defined in example definition, your page structure would look as follows. Please pay attention that all the values in the output are fake values for just demo purposes.
+		// page.FileSystemResourceListResult = armqumulo.FileSystemResourceListResult{
+		// 	Value: []*armqumulo.FileSystemResource{
+		// 		{
+		// 			Name: to.Ptr("aaaaa"),
+		// 			ID: to.Ptr("aaaaaaaaaaaaaaaaa"),
+		// 			Location: to.Ptr("aaaaaaaaaaaaaaaaaaaaaaaaaaaa"),
+		// 			Properties: &armqumulo.FileSystemResourceProperties{
+		// 				DelegatedSubnetID: to.Ptr("aaaaaaaaaaaaaaaaaaaaaaaaaaaaa"),
+		// 				InitialCapacity: to.Ptr[int32](9),
+		// 				MarketplaceDetails: &armqumulo.MarketplaceDetails{
+		// 					MarketplaceSubscriptionID: to.Ptr("aaaaaaaaaaaaaaaaa"),
+		// 					MarketplaceSubscriptionStatus: to.Ptr(armqumulo.MarketplaceSubscriptionStatusPendingFulfillmentStart),
+		// 					OfferID: to.Ptr("aaaaaaaaa"),
+		// 					PlanID: to.Ptr("aaaaaaa"),
+		// 					PublisherID: to.Ptr("aaaaaaaaaaaaaaaaaaaa"),
+		// 				},
+		// 				ProvisioningState: to.Ptr(armqumulo.ProvisioningStateSucceeded),
+		// 				StorageSKU: to.Ptr(armqumulo.StorageSKUStandard),
+		// 				UserDetails: &armqumulo.UserDetails{
+		// 				},
+		// 			},
+		// 	}},
+		// }
+	}
+}
+
+// Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/9918780b4dc4bdc111cf3facc11561904d609ad7/specification/liftrqumulo/resource-manager/Qumulo.Storage/preview/2022-10-12-preview/examples/FileSystems_Get_MaximumSet_Gen.json
+func ExampleFileSystemsClient_Get_fileSystemsGetMaximumSetGen() {
+	cred, err := azidentity.NewDefaultAzureCredential(nil)
+	if err != nil {
+		log.Fatalf("failed to obtain a credential: %v", err)
+	}
+	ctx := context.Background()
+	client, err := armqumulo.NewFileSystemsClient("ulseeqylxb", cred, nil)
+	if err != nil {
+		log.Fatalf("failed to create client: %v", err)
+	}
+	res, err := client.Get(ctx, "rgQumulo", "nauwwbfoqehgbhdsmkewoboyxeqg", nil)
+	if err != nil {
+		log.Fatalf("failed to finish the request: %v", err)
+	}
+	// You could use response here. We use blank identifier for just demo purposes.
+	_ = res
+	// If the HTTP response code is 200 as defined in example definition, your response structure would look as follows. Please pay attention that all the values in the output are fake values for just demo purposes.
+	// res.FileSystemResource = armqumulo.FileSystemResource{
+	// 	Name: to.Ptr("bii"),
+	// 	Type: to.Ptr("qtvxrqwpoistduq"),
+	// 	ID: to.Ptr("tvelgpobdtazrweunifqzaxkgjauyx"),
+	// 	SystemData: &armqumulo.SystemData{
+	// 		CreatedAt: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2022-10-14T04:40:17.991Z"); return t}()),
+	// 		CreatedBy: to.Ptr("mtdhqooysjhueaojwpmvophkgntl"),
+	// 		CreatedByType: to.Ptr(armqumulo.CreatedByTypeUser),
+	// 		LastModifiedAt: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2022-10-14T04:40:17.991Z"); return t}()),
+	// 		LastModifiedBy: to.Ptr("jcywglomzuamsxltnoegdrkzlscxl"),
+	// 		LastModifiedByType: to.Ptr(armqumulo.CreatedByTypeUser),
+	// 	},
+	// 	Location: to.Ptr("przdlsmlzsszphnixq"),
+	// 	Tags: map[string]*string{
+	// 		"key6565": to.Ptr("cgdhmupta"),
+	// 	},
+	// 	Identity: &armqumulo.ManagedServiceIdentity{
+	// 		Type: to.Ptr(armqumulo.ManagedServiceIdentityTypeNone),
+	// 		PrincipalID: to.Ptr("11111111-1111-1111-1111-111111111111"),
+	// 		TenantID: to.Ptr("11111111-1111-1111-1111-111111111111"),
+	// 		UserAssignedIdentities: map[string]*armqumulo.UserAssignedIdentity{
+	// 			"key4522": &armqumulo.UserAssignedIdentity{
+	// 				ClientID: to.Ptr("11111111-1111-1111-1111-111111111111"),
+	// 				PrincipalID: to.Ptr("11111111-1111-1111-1111-111111111111"),
+	// 			},
+	// 		},
+	// 	},
+	// 	Properties: &armqumulo.FileSystemResourceProperties{
+	// 		AvailabilityZone: to.Ptr("maseyqhlnhoiwbabcqabtedbjpip"),
+	// 		ClusterLoginURL: to.Ptr("jjqhgevy"),
+	// 		DelegatedSubnetID: to.Ptr("neqctctqdmjezfgt"),
+	// 		InitialCapacity: to.Ptr[int32](9),
+	// 		MarketplaceDetails: &armqumulo.MarketplaceDetails{
+	// 			MarketplaceSubscriptionID: to.Ptr("ujrcqvxfnhxxheoth"),
+	// 			MarketplaceSubscriptionStatus: to.Ptr(armqumulo.MarketplaceSubscriptionStatusPendingFulfillmentStart),
+	// 			OfferID: to.Ptr("eiyhbmpwgezcmzrrfoiskuxlcvwojf"),
+	// 			PlanID: to.Ptr("x"),
+	// 			PublisherID: to.Ptr("wfmokfdjbwpjhz"),
+	// 		},
+	// 		PrivateIPs: []*string{
+	// 			to.Ptr("kslguxrwbwkrj")},
+	// 			ProvisioningState: to.Ptr(armqumulo.ProvisioningStateSucceeded),
+	// 			StorageSKU: to.Ptr(armqumulo.StorageSKUStandard),
+	// 			UserDetails: &armqumulo.UserDetails{
+	// 			},
+	// 		},
+	// 	}
+}
+
+// Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/9918780b4dc4bdc111cf3facc11561904d609ad7/specification/liftrqumulo/resource-manager/Qumulo.Storage/preview/2022-10-12-preview/examples/FileSystems_Get_MinimumSet_Gen.json
+func ExampleFileSystemsClient_Get_fileSystemsGetMinimumSetGen() {
+	cred, err := azidentity.NewDefaultAzureCredential(nil)
+	if err != nil {
+		log.Fatalf("failed to obtain a credential: %v", err)
+	}
+	ctx := context.Background()
+	client, err := armqumulo.NewFileSystemsClient("aaaaaaa", cred, nil)
+	if err != nil {
+		log.Fatalf("failed to create client: %v", err)
+	}
+	res, err := client.Get(ctx, "rgQumulo", "aaaaaaaaaaaaaaaaa", nil)
+	if err != nil {
+		log.Fatalf("failed to finish the request: %v", err)
+	}
+	// You could use response here. We use blank identifier for just demo purposes.
+	_ = res
+	// If the HTTP response code is 200 as defined in example definition, your response structure would look as follows. Please pay attention that all the values in the output are fake values for just demo purposes.
+	// res.FileSystemResource = armqumulo.FileSystemResource{
+	// 	Name: to.Ptr("aaaaa"),
+	// 	ID: to.Ptr("aaaaaaaaaaaaaaaaa"),
+	// 	Location: to.Ptr("aaaaaaaaaaaaaaaaaaaaaaaaaaaa"),
+	// 	Properties: &armqumulo.FileSystemResourceProperties{
+	// 		DelegatedSubnetID: to.Ptr("aaaaaaaaaaaaaaaaaaaaaaaaaaaaa"),
+	// 		InitialCapacity: to.Ptr[int32](9),
+	// 		MarketplaceDetails: &armqumulo.MarketplaceDetails{
+	// 			MarketplaceSubscriptionID: to.Ptr("aaaaaaaaaaaaaaaaa"),
+	// 			MarketplaceSubscriptionStatus: to.Ptr(armqumulo.MarketplaceSubscriptionStatusPendingFulfillmentStart),
+	// 			OfferID: to.Ptr("aaaaaaaaa"),
+	// 			PlanID: to.Ptr("aaaaaaa"),
+	// 			PublisherID: to.Ptr("aaaaaaaaaaaaaaaaaaaa"),
+	// 		},
+	// 		ProvisioningState: to.Ptr(armqumulo.ProvisioningStateSucceeded),
+	// 		StorageSKU: to.Ptr(armqumulo.StorageSKUStandard),
+	// 		UserDetails: &armqumulo.UserDetails{
+	// 		},
+	// 	},
+	// }
+}
+
+// Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/9918780b4dc4bdc111cf3facc11561904d609ad7/specification/liftrqumulo/resource-manager/Qumulo.Storage/preview/2022-10-12-preview/examples/FileSystems_CreateOrUpdate_MaximumSet_Gen.json
+func ExampleFileSystemsClient_BeginCreateOrUpdate_fileSystemsCreateOrUpdateMaximumSetGen() {
+	cred, err := azidentity.NewDefaultAzureCredential(nil)
+	if err != nil {
+		log.Fatalf("failed to obtain a credential: %v", err)
+	}
+	ctx := context.Background()
+	client, err := armqumulo.NewFileSystemsClient("ulseeqylxb", cred, nil)
+	if err != nil {
+		log.Fatalf("failed to create client: %v", err)
+	}
+	poller, err := client.BeginCreateOrUpdate(ctx, "rgQumulo", "nauwwbfoqehgbhdsmkewoboyxeqg", armqumulo.FileSystemResource{
+		Location: to.Ptr("przdlsmlzsszphnixq"),
+		Tags: map[string]*string{
+			"key6565": to.Ptr("cgdhmupta"),
+		},
+		Identity: &armqumulo.ManagedServiceIdentity{
+			Type: to.Ptr(armqumulo.ManagedServiceIdentityTypeNone),
+			UserAssignedIdentities: map[string]*armqumulo.UserAssignedIdentity{
+				"key4522": {},
+			},
+		},
+		Properties: &armqumulo.FileSystemResourceProperties{
+			AdminPassword:     to.Ptr("ekceujoecaashtjlsgcymnrdozk"),
+			AvailabilityZone:  to.Ptr("maseyqhlnhoiwbabcqabtedbjpip"),
+			ClusterLoginURL:   to.Ptr("jjqhgevy"),
+			DelegatedSubnetID: to.Ptr("neqctctqdmjezfgt"),
+			InitialCapacity:   to.Ptr[int32](9),
+			MarketplaceDetails: &armqumulo.MarketplaceDetails{
+				MarketplaceSubscriptionID:     to.Ptr("ujrcqvxfnhxxheoth"),
+				MarketplaceSubscriptionStatus: to.Ptr(armqumulo.MarketplaceSubscriptionStatusPendingFulfillmentStart),
+				OfferID:                       to.Ptr("eiyhbmpwgezcmzrrfoiskuxlcvwojf"),
+				PlanID:                        to.Ptr("x"),
+				PublisherID:                   to.Ptr("wfmokfdjbwpjhz"),
+			},
+			PrivateIPs: []*string{
+				to.Ptr("kslguxrwbwkrj")},
+			ProvisioningState: to.Ptr(armqumulo.ProvisioningStateAccepted),
+			StorageSKU:        to.Ptr(armqumulo.StorageSKUStandard),
+			UserDetails: &armqumulo.UserDetails{
+				Email: to.Ptr("viptslwulnpaupfljvnjeq"),
+			},
+		},
+	}, nil)
+	if err != nil {
+		log.Fatalf("failed to finish the request: %v", err)
+	}
+	res, err := poller.PollUntilDone(ctx, nil)
+	if err != nil {
+		log.Fatalf("failed to pull the result: %v", err)
+	}
+	// You could use response here. We use blank identifier for just demo purposes.
+	_ = res
+	// If the HTTP response code is 200 as defined in example definition, your response structure would look as follows. Please pay attention that all the values in the output are fake values for just demo purposes.
+	// res.FileSystemResource = armqumulo.FileSystemResource{
+	// 	Name: to.Ptr("bii"),
+	// 	Type: to.Ptr("qtvxrqwpoistduq"),
+	// 	ID: to.Ptr("tvelgpobdtazrweunifqzaxkgjauyx"),
+	// 	SystemData: &armqumulo.SystemData{
+	// 		CreatedAt: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2022-10-14T04:40:17.991Z"); return t}()),
+	// 		CreatedBy: to.Ptr("mtdhqooysjhueaojwpmvophkgntl"),
+	// 		CreatedByType: to.Ptr(armqumulo.CreatedByTypeUser),
+	// 		LastModifiedAt: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2022-10-14T04:40:17.991Z"); return t}()),
+	// 		LastModifiedBy: to.Ptr("jcywglomzuamsxltnoegdrkzlscxl"),
+	// 		LastModifiedByType: to.Ptr(armqumulo.CreatedByTypeUser),
+	// 	},
+	// 	Location: to.Ptr("przdlsmlzsszphnixq"),
+	// 	Tags: map[string]*string{
+	// 		"key6565": to.Ptr("cgdhmupta"),
+	// 	},
+	// 	Identity: &armqumulo.ManagedServiceIdentity{
+	// 		Type: to.Ptr(armqumulo.ManagedServiceIdentityTypeNone),
+	// 		PrincipalID: to.Ptr("11111111-1111-1111-1111-111111111111"),
+	// 		TenantID: to.Ptr("11111111-1111-1111-1111-111111111111"),
+	// 		UserAssignedIdentities: map[string]*armqumulo.UserAssignedIdentity{
+	// 			"key4522": &armqumulo.UserAssignedIdentity{
+	// 				ClientID: to.Ptr("11111111-1111-1111-1111-111111111111"),
+	// 				PrincipalID: to.Ptr("11111111-1111-1111-1111-111111111111"),
+	// 			},
+	// 		},
+	// 	},
+	// 	Properties: &armqumulo.FileSystemResourceProperties{
+	// 		AvailabilityZone: to.Ptr("maseyqhlnhoiwbabcqabtedbjpip"),
+	// 		ClusterLoginURL: to.Ptr("jjqhgevy"),
+	// 		DelegatedSubnetID: to.Ptr("neqctctqdmjezfgt"),
+	// 		InitialCapacity: to.Ptr[int32](9),
+	// 		MarketplaceDetails: &armqumulo.MarketplaceDetails{
+	// 			MarketplaceSubscriptionID: to.Ptr("ujrcqvxfnhxxheoth"),
+	// 			MarketplaceSubscriptionStatus: to.Ptr(armqumulo.MarketplaceSubscriptionStatusPendingFulfillmentStart),
+	// 			OfferID: to.Ptr("eiyhbmpwgezcmzrrfoiskuxlcvwojf"),
+	// 			PlanID: to.Ptr("x"),
+	// 			PublisherID: to.Ptr("wfmokfdjbwpjhz"),
+	// 		},
+	// 		PrivateIPs: []*string{
+	// 			to.Ptr("kslguxrwbwkrj")},
+	// 			ProvisioningState: to.Ptr(armqumulo.ProvisioningStateSucceeded),
+	// 			StorageSKU: to.Ptr(armqumulo.StorageSKUStandard),
+	// 			UserDetails: &armqumulo.UserDetails{
+	// 			},
+	// 		},
+	// 	}
+}
+
+// Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/9918780b4dc4bdc111cf3facc11561904d609ad7/specification/liftrqumulo/resource-manager/Qumulo.Storage/preview/2022-10-12-preview/examples/FileSystems_CreateOrUpdate_MinimumSet_Gen.json
+func ExampleFileSystemsClient_BeginCreateOrUpdate_fileSystemsCreateOrUpdateMinimumSetGen() {
+	cred, err := azidentity.NewDefaultAzureCredential(nil)
+	if err != nil {
+		log.Fatalf("failed to obtain a credential: %v", err)
+	}
+	ctx := context.Background()
+	client, err := armqumulo.NewFileSystemsClient("aaaaaaaaaaaaaaaaaaaaaaaa", cred, nil)
+	if err != nil {
+		log.Fatalf("failed to create client: %v", err)
+	}
+	poller, err := client.BeginCreateOrUpdate(ctx, "rgopenapi", "aaaaaaaa", armqumulo.FileSystemResource{
+		Location: to.Ptr("aaaaaaaaaaaaaaaaaaaaaaaaa"),
+		Properties: &armqumulo.FileSystemResourceProperties{
+			AdminPassword:     to.Ptr("ekceujoecaashtjlsgcymnrdozk"),
+			DelegatedSubnetID: to.Ptr("aaaaaaaaaa"),
+			InitialCapacity:   to.Ptr[int32](9),
+			MarketplaceDetails: &armqumulo.MarketplaceDetails{
+				MarketplaceSubscriptionID:     to.Ptr("aaaaaaaaaaaaa"),
+				MarketplaceSubscriptionStatus: to.Ptr(armqumulo.MarketplaceSubscriptionStatusPendingFulfillmentStart),
+				OfferID:                       to.Ptr("aaaaaaaaaaaaaaaaaaaaaaaaa"),
+				PlanID:                        to.Ptr("aaaaaa"),
+				PublisherID:                   to.Ptr("aa"),
+			},
+			ProvisioningState: to.Ptr(armqumulo.ProvisioningStateAccepted),
+			StorageSKU:        to.Ptr(armqumulo.StorageSKUStandard),
+			UserDetails: &armqumulo.UserDetails{
+				Email: to.Ptr("aaaaaaaaaaaaaaaaaaaaaaa"),
+			},
+		},
+	}, nil)
+	if err != nil {
+		log.Fatalf("failed to finish the request: %v", err)
+	}
+	res, err := poller.PollUntilDone(ctx, nil)
+	if err != nil {
+		log.Fatalf("failed to pull the result: %v", err)
+	}
+	// You could use response here. We use blank identifier for just demo purposes.
+	_ = res
+	// If the HTTP response code is 200 as defined in example definition, your response structure would look as follows. Please pay attention that all the values in the output are fake values for just demo purposes.
+	// res.FileSystemResource = armqumulo.FileSystemResource{
+	// 	ID: to.Ptr("aaaaaaaaaaaaaaaaa"),
+	// 	Location: to.Ptr("aaaaaaaaa"),
+	// 	Properties: &armqumulo.FileSystemResourceProperties{
+	// 		DelegatedSubnetID: to.Ptr("aaaaaaaaaa"),
+	// 		InitialCapacity: to.Ptr[int32](9),
+	// 		MarketplaceDetails: &armqumulo.MarketplaceDetails{
+	// 			MarketplaceSubscriptionID: to.Ptr("aaaaaaaaaaaaa"),
+	// 			MarketplaceSubscriptionStatus: to.Ptr(armqumulo.MarketplaceSubscriptionStatusPendingFulfillmentStart),
+	// 			OfferID: to.Ptr("aaaaaaaaaaaaaaaaaaaaaaaaa"),
+	// 			PlanID: to.Ptr("aaaaaa"),
+	// 			PublisherID: to.Ptr("aa"),
+	// 		},
+	// 		ProvisioningState: to.Ptr(armqumulo.ProvisioningStateSucceeded),
+	// 		StorageSKU: to.Ptr(armqumulo.StorageSKUStandard),
+	// 		UserDetails: &armqumulo.UserDetails{
+	// 		},
+	// 	},
+	// }
+}
+
+// Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/9918780b4dc4bdc111cf3facc11561904d609ad7/specification/liftrqumulo/resource-manager/Qumulo.Storage/preview/2022-10-12-preview/examples/FileSystems_Update_MaximumSet_Gen.json
+func ExampleFileSystemsClient_Update_fileSystemsUpdateMaximumSetGen() {
+	cred, err := azidentity.NewDefaultAzureCredential(nil)
+	if err != nil {
+		log.Fatalf("failed to obtain a credential: %v", err)
+	}
+	ctx := context.Background()
+	client, err := armqumulo.NewFileSystemsClient("ulseeqylxb", cred, nil)
+	if err != nil {
+		log.Fatalf("failed to create client: %v", err)
+	}
+	res, err := client.Update(ctx, "rgQumulo", "nauwwbfoqehgbhdsmkewoboyxeqg", armqumulo.FileSystemResourceUpdate{
+		Identity: &armqumulo.ManagedServiceIdentity{
+			Type: to.Ptr(armqumulo.ManagedServiceIdentityTypeNone),
+			UserAssignedIdentities: map[string]*armqumulo.UserAssignedIdentity{
+				"key4522": {},
+			},
+		},
+		Properties: &armqumulo.FileSystemResourceUpdateProperties{
+			ClusterLoginURL:   to.Ptr("adabmuthwrbjshzfbo"),
+			DelegatedSubnetID: to.Ptr("vjfirtaljehawmflyfianw"),
+			MarketplaceDetails: &armqumulo.MarketplaceDetails{
+				MarketplaceSubscriptionID:     to.Ptr("ujrcqvxfnhxxheoth"),
+				MarketplaceSubscriptionStatus: to.Ptr(armqumulo.MarketplaceSubscriptionStatusPendingFulfillmentStart),
+				OfferID:                       to.Ptr("eiyhbmpwgezcmzrrfoiskuxlcvwojf"),
+				PlanID:                        to.Ptr("x"),
+				PublisherID:                   to.Ptr("wfmokfdjbwpjhz"),
+			},
+			PrivateIPs: []*string{
+				to.Ptr("eugjqbaoucgjsopzfrq")},
+			UserDetails: &armqumulo.UserDetails{
+				Email: to.Ptr("viptslwulnpaupfljvnjeq"),
+			},
+		},
+		Tags: map[string]*string{
+			"key7534": to.Ptr("jsgqvqbagquvxowbrkanyhzvo"),
+		},
+	}, nil)
+	if err != nil {
+		log.Fatalf("failed to finish the request: %v", err)
+	}
+	// You could use response here. We use blank identifier for just demo purposes.
+	_ = res
+	// If the HTTP response code is 200 as defined in example definition, your response structure would look as follows. Please pay attention that all the values in the output are fake values for just demo purposes.
+	// res.FileSystemResource = armqumulo.FileSystemResource{
+	// 	Name: to.Ptr("bii"),
+	// 	Type: to.Ptr("qtvxrqwpoistduq"),
+	// 	ID: to.Ptr("tvelgpobdtazrweunifqzaxkgjauyx"),
+	// 	SystemData: &armqumulo.SystemData{
+	// 		CreatedAt: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2022-10-14T04:40:17.991Z"); return t}()),
+	// 		CreatedBy: to.Ptr("mtdhqooysjhueaojwpmvophkgntl"),
+	// 		CreatedByType: to.Ptr(armqumulo.CreatedByTypeUser),
+	// 		LastModifiedAt: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2022-10-14T04:40:17.991Z"); return t}()),
+	// 		LastModifiedBy: to.Ptr("jcywglomzuamsxltnoegdrkzlscxl"),
+	// 		LastModifiedByType: to.Ptr(armqumulo.CreatedByTypeUser),
+	// 	},
+	// 	Location: to.Ptr("przdlsmlzsszphnixq"),
+	// 	Tags: map[string]*string{
+	// 		"key6565": to.Ptr("cgdhmupta"),
+	// 	},
+	// 	Identity: &armqumulo.ManagedServiceIdentity{
+	// 		Type: to.Ptr(armqumulo.ManagedServiceIdentityTypeNone),
+	// 		PrincipalID: to.Ptr("11111111-1111-1111-1111-111111111111"),
+	// 		TenantID: to.Ptr("11111111-1111-1111-1111-111111111111"),
+	// 		UserAssignedIdentities: map[string]*armqumulo.UserAssignedIdentity{
+	// 			"key4522": &armqumulo.UserAssignedIdentity{
+	// 				ClientID: to.Ptr("11111111-1111-1111-1111-111111111111"),
+	// 				PrincipalID: to.Ptr("11111111-1111-1111-1111-111111111111"),
+	// 			},
+	// 		},
+	// 	},
+	// 	Properties: &armqumulo.FileSystemResourceProperties{
+	// 		AvailabilityZone: to.Ptr("maseyqhlnhoiwbabcqabtedbjpip"),
+	// 		ClusterLoginURL: to.Ptr("jjqhgevy"),
+	// 		DelegatedSubnetID: to.Ptr("neqctctqdmjezfgt"),
+	// 		InitialCapacity: to.Ptr[int32](9),
+	// 		MarketplaceDetails: &armqumulo.MarketplaceDetails{
+	// 			MarketplaceSubscriptionID: to.Ptr("ujrcqvxfnhxxheoth"),
+	// 			MarketplaceSubscriptionStatus: to.Ptr(armqumulo.MarketplaceSubscriptionStatusPendingFulfillmentStart),
+	// 			OfferID: to.Ptr("eiyhbmpwgezcmzrrfoiskuxlcvwojf"),
+	// 			PlanID: to.Ptr("x"),
+	// 			PublisherID: to.Ptr("wfmokfdjbwpjhz"),
+	// 		},
+	// 		PrivateIPs: []*string{
+	// 			to.Ptr("eugjqbaoucgjsopzfrq")},
+	// 			ProvisioningState: to.Ptr(armqumulo.ProvisioningStateSucceeded),
+	// 			StorageSKU: to.Ptr(armqumulo.StorageSKUStandard),
+	// 			UserDetails: &armqumulo.UserDetails{
+	// 			},
+	// 		},
+	// 	}
+}
+
+// Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/9918780b4dc4bdc111cf3facc11561904d609ad7/specification/liftrqumulo/resource-manager/Qumulo.Storage/preview/2022-10-12-preview/examples/FileSystems_Update_MinimumSet_Gen.json
+func ExampleFileSystemsClient_Update_fileSystemsUpdateMinimumSetGen() {
+	cred, err := azidentity.NewDefaultAzureCredential(nil)
+	if err != nil {
+		log.Fatalf("failed to obtain a credential: %v", err)
+	}
+	ctx := context.Background()
+	client, err := armqumulo.NewFileSystemsClient("aaaaaaa", cred, nil)
+	if err != nil {
+		log.Fatalf("failed to create client: %v", err)
+	}
+	res, err := client.Update(ctx, "rgQumulo", "aaaaaaaaaaaaaaaaa", armqumulo.FileSystemResourceUpdate{}, nil)
+	if err != nil {
+		log.Fatalf("failed to finish the request: %v", err)
+	}
+	// You could use response here. We use blank identifier for just demo purposes.
+	_ = res
+	// If the HTTP response code is 200 as defined in example definition, your response structure would look as follows. Please pay attention that all the values in the output are fake values for just demo purposes.
+	// res.FileSystemResource = armqumulo.FileSystemResource{
+	// 	Name: to.Ptr("aaaaa"),
+	// 	Location: to.Ptr("aaaaaaaaaaaaaaaaaaaaaaaaaaaa"),
+	// 	Properties: &armqumulo.FileSystemResourceProperties{
+	// 		DelegatedSubnetID: to.Ptr("aaaaaaaaaaaaaaaaaaaaaaaaaaaaa"),
+	// 		InitialCapacity: to.Ptr[int32](9),
+	// 		MarketplaceDetails: &armqumulo.MarketplaceDetails{
+	// 			MarketplaceSubscriptionID: to.Ptr("aaaaaaaaaaaaaaaaa"),
+	// 			MarketplaceSubscriptionStatus: to.Ptr(armqumulo.MarketplaceSubscriptionStatusPendingFulfillmentStart),
+	// 			OfferID: to.Ptr("aaaaaaaaa"),
+	// 			PlanID: to.Ptr("aaaaaaa"),
+	// 			PublisherID: to.Ptr("aaaaaaaaaaaaaaaaaaaa"),
+	// 		},
+	// 		ProvisioningState: to.Ptr(armqumulo.ProvisioningStateSucceeded),
+	// 		StorageSKU: to.Ptr(armqumulo.StorageSKUStandard),
+	// 		UserDetails: &armqumulo.UserDetails{
+	// 		},
+	// 	},
+	// }
+}
+
+// Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/9918780b4dc4bdc111cf3facc11561904d609ad7/specification/liftrqumulo/resource-manager/Qumulo.Storage/preview/2022-10-12-preview/examples/FileSystems_Delete_MaximumSet_Gen.json
+func ExampleFileSystemsClient_BeginDelete_fileSystemsDeleteMaximumSetGen() {
+	cred, err := azidentity.NewDefaultAzureCredential(nil)
+	if err != nil {
+		log.Fatalf("failed to obtain a credential: %v", err)
+	}
+	ctx := context.Background()
+	client, err := armqumulo.NewFileSystemsClient("ulseeqylxb", cred, nil)
+	if err != nil {
+		log.Fatalf("failed to create client: %v", err)
+	}
+	poller, err := client.BeginDelete(ctx, "rgQumulo", "nauwwbfoqehgbhdsmkewoboyxeqg", nil)
+	if err != nil {
+		log.Fatalf("failed to finish the request: %v", err)
+	}
+	_, err = poller.PollUntilDone(ctx, nil)
+	if err != nil {
+		log.Fatalf("failed to pull the result: %v", err)
+	}
+}
+
+// Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/9918780b4dc4bdc111cf3facc11561904d609ad7/specification/liftrqumulo/resource-manager/Qumulo.Storage/preview/2022-10-12-preview/examples/FileSystems_Delete_MinimumSet_Gen.json
+func ExampleFileSystemsClient_BeginDelete_fileSystemsDeleteMinimumSetGen() {
+	cred, err := azidentity.NewDefaultAzureCredential(nil)
+	if err != nil {
+		log.Fatalf("failed to obtain a credential: %v", err)
+	}
+	ctx := context.Background()
+	client, err := armqumulo.NewFileSystemsClient("ulseeqylxb", cred, nil)
+	if err != nil {
+		log.Fatalf("failed to create client: %v", err)
+	}
+	poller, err := client.BeginDelete(ctx, "rgQumulo", "nauwwbfoqehgbhdsmkewoboyxeqg", nil)
+	if err != nil {
+		log.Fatalf("failed to finish the request: %v", err)
+	}
+	_, err = poller.PollUntilDone(ctx, nil)
+	if err != nil {
+		log.Fatalf("failed to pull the result: %v", err)
+	}
+}
diff --git a/sdk/resourcemanager/liftrqumulo/armqumulo/operations_client_example_test.go b/sdk/resourcemanager/liftrqumulo/armqumulo/operations_client_example_test.go
new file mode 100644
index 0000000000..5bf69bc60e
--- /dev/null
+++ b/sdk/resourcemanager/liftrqumulo/armqumulo/operations_client_example_test.go
@@ -0,0 +1,85 @@
+//go:build go1.18
+// +build go1.18
+
+// Copyright (c) Microsoft Corporation. All rights reserved.
+// Licensed under the MIT License. See License.txt in the project root for license information.
+// Code generated by Microsoft (R) AutoRest Code Generator.
+// Changes may cause incorrect behavior and will be lost if the code is regenerated.
+// DO NOT EDIT.
+
+package armqumulo_test
+
+import (
+	"context"
+	"log"
+
+	"github.com/Azure/azure-sdk-for-go/sdk/azidentity"
+	"github.com/Azure/azure-sdk-for-go/sdk/resourcemanager/liftrqumulo/armqumulo"
+)
+
+// Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/9918780b4dc4bdc111cf3facc11561904d609ad7/specification/liftrqumulo/resource-manager/Qumulo.Storage/preview/2022-10-12-preview/examples/Operations_List_MaximumSet_Gen.json
+func ExampleOperationsClient_NewListPager_operationsListMaximumSetGen() {
+	cred, err := azidentity.NewDefaultAzureCredential(nil)
+	if err != nil {
+		log.Fatalf("failed to obtain a credential: %v", err)
+	}
+	ctx := context.Background()
+	client, err := armqumulo.NewOperationsClient(cred, nil)
+	if err != nil {
+		log.Fatalf("failed to create client: %v", err)
+	}
+	pager := client.NewListPager(nil)
+	for pager.More() {
+		page, err := pager.NextPage(ctx)
+		if err != nil {
+			log.Fatalf("failed to advance page: %v", err)
+		}
+		for _, v := range page.Value {
+			// You could use page here. We use blank identifier for just demo purposes.
+			_ = v
+		}
+		// If the HTTP response code is 200 as defined in example definition, your page structure would look as follows. Please pay attention that all the values in the output are fake values for just demo purposes.
+		// page.OperationListResult = armqumulo.OperationListResult{
+		// 	Value: []*armqumulo.Operation{
+		// 		{
+		// 			Name: to.Ptr("runmssufdtztqwcjrxyuyodlzbxidp"),
+		// 			ActionType: to.Ptr(armqumulo.ActionTypeInternal),
+		// 			Display: &armqumulo.OperationDisplay{
+		// 				Description: to.Ptr("cnjdpucbtzreoihwdqnkprk"),
+		// 				Operation: to.Ptr("fgyvgifprfxdgyqdbglrysjjsozm"),
+		// 				Provider: to.Ptr("e"),
+		// 				Resource: to.Ptr("cgzkjnfpkvddogcszpdn"),
+		// 			},
+		// 			IsDataAction: to.Ptr(true),
+		// 			Origin: to.Ptr(armqumulo.OriginUser),
+		// 	}},
+		// }
+	}
+}
+
+// Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/9918780b4dc4bdc111cf3facc11561904d609ad7/specification/liftrqumulo/resource-manager/Qumulo.Storage/preview/2022-10-12-preview/examples/Operations_List_MinimumSet_Gen.json
+func ExampleOperationsClient_NewListPager_operationsListMinimumSetGen() {
+	cred, err := azidentity.NewDefaultAzureCredential(nil)
+	if err != nil {
+		log.Fatalf("failed to obtain a credential: %v", err)
+	}
+	ctx := context.Background()
+	client, err := armqumulo.NewOperationsClient(cred, nil)
+	if err != nil {
+		log.Fatalf("failed to create client: %v", err)
+	}
+	pager := client.NewListPager(nil)
+	for pager.More() {
+		page, err := pager.NextPage(ctx)
+		if err != nil {
+			log.Fatalf("failed to advance page: %v", err)
+		}
+		for _, v := range page.Value {
+			// You could use page here. We use blank identifier for just demo purposes.
+			_ = v
+		}
+		// If the HTTP response code is 200 as defined in example definition, your page structure would look as follows. Please pay attention that all the values in the output are fake values for just demo purposes.
+		// page.OperationListResult = armqumulo.OperationListResult{
+		// }
+	}
+}