armrelay

Generated from example definition: 2026-01-01/HybridConnection/RelayHybridConnectionCreate.json

package main

import (
	"context"
	"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/relay/armrelay/v2"
	"log"
)

func main() {
	cred, err := azidentity.NewDefaultAzureCredential(nil)
	if err != nil {
		log.Fatalf("failed to obtain a credential: %v", err)
	}
	ctx := context.Background()
	clientFactory, err := armrelay.NewClientFactory("ffffffff-ffff-ffff-ffff-ffffffffffff", cred, nil)
	if err != nil {
		log.Fatalf("failed to create client: %v", err)
	}
	res, err := clientFactory.NewHybridConnectionsClient().CreateOrUpdate(ctx, "resourcegroup", "example-RelayNamespace-01", "example-Relay-Hybrid-01", armrelay.HybridConnection{
		Properties: &armrelay.HybridConnectionProperties{
			RequiresClientAuthorization: to.Ptr(true),
		},
	}, 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 = armrelay.HybridConnectionsClientCreateOrUpdateResponse{
	// 	HybridConnection: armrelay.HybridConnection{
	// 		Name: to.Ptr("example-Relay-Hybrid-01"),
	// 		Type: to.Ptr("Microsoft.Relay/Namespaces/HybridConnections"),
	// 		ID: to.Ptr("/subscriptions/ffffffff-ffff-ffff-ffff-ffffffffffff/resourceGroups/resourcegroup/providers/Microsoft.Relay/namespaces/example-RelayNamespace-01/HybridConnections/example-Relay-Hybrid-01"),
	// 		Properties: &armrelay.HybridConnectionProperties{
	// 			CreatedAt: to.Ptr(time.Date(2017, time.January, 23, 20, 34, 49, 413172400, time.UTC)),
	// 			RequiresClientAuthorization: to.Ptr(true),
	// 			UpdatedAt: to.Ptr(time.Date(2017, time.January, 23, 20, 34, 49, 413172400, time.UTC)),
	// 		},
	// 	},
	// }
}

Output:

Generated from example definition: 2026-01-01/HybridConnection/RelayHybridConnectionAuthorizationRuleCreate.json

package main

import (
	"context"
	"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/relay/armrelay/v2"
	"log"
)

func main() {
	cred, err := azidentity.NewDefaultAzureCredential(nil)
	if err != nil {
		log.Fatalf("failed to obtain a credential: %v", err)
	}
	ctx := context.Background()
	clientFactory, err := armrelay.NewClientFactory("ffffffff-ffff-ffff-ffff-ffffffffffff", cred, nil)
	if err != nil {
		log.Fatalf("failed to create client: %v", err)
	}
	res, err := clientFactory.NewHybridConnectionsClient().CreateOrUpdateAuthorizationRule(ctx, "resourcegroup", "example-RelayNamespace-01", "example-Relay-Hybrid-01", "example-RelayAuthRules-01", armrelay.AuthorizationRule{
		Properties: &armrelay.AuthorizationRuleProperties{
			Rights: []*armrelay.AccessRights{
				to.Ptr(armrelay.AccessRightsListen),
				to.Ptr(armrelay.AccessRightsSend),
			},
		},
	}, 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 = armrelay.HybridConnectionsClientCreateOrUpdateAuthorizationRuleResponse{
	// 	AuthorizationRule: armrelay.AuthorizationRule{
	// 		Name: to.Ptr("example-RelayAuthRules-01"),
	// 		Type: to.Ptr("Microsoft.Relay/Namespaces/Hybridconnections/AuthorizationRules"),
	// 		ID: to.Ptr("/subscriptions/ffffffff-ffff-ffff-ffff-ffffffffffff/resourceGroups/resourcegroup/providers/Microsoft.Relay/namespaces/example-RelayNamespace-01/HybridConnections/example-Relay-Hybrid-01/AuthorizationRules/example-RelayAuthRules-01"),
	// 		Properties: &armrelay.AuthorizationRuleProperties{
	// 			Rights: []*armrelay.AccessRights{
	// 				to.Ptr(armrelay.AccessRightsListen),
	// 				to.Ptr(armrelay.AccessRightsSend),
	// 			},
	// 		},
	// 	},
	// }
}

Output:

Generated from example definition: 2026-01-01/HybridConnection/RelayHybridconnectionDelete.json

package main

import (
	"context"
	"github.com/Azure/azure-sdk-for-go/sdk/azidentity"
	"github.com/Azure/azure-sdk-for-go/sdk/resourcemanager/relay/armrelay/v2"
	"log"
)

func main() {
	cred, err := azidentity.NewDefaultAzureCredential(nil)
	if err != nil {
		log.Fatalf("failed to obtain a credential: %v", err)
	}
	ctx := context.Background()
	clientFactory, err := armrelay.NewClientFactory("ffffffff-ffff-ffff-ffff-ffffffffffff", cred, nil)
	if err != nil {
		log.Fatalf("failed to create client: %v", err)
	}
	res, err := clientFactory.NewHybridConnectionsClient().Delete(ctx, "resourcegroup", "example-RelayNamespace-01", "example-Relay-Hybrid-01", 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 = armrelay.HybridConnectionsClientDeleteResponse{
	// }
}

Output:

Generated from example definition: 2026-01-01/HybridConnection/RelayHybridConnectionAuthorizationRuleDelete.json

package main

import (
	"context"
	"github.com/Azure/azure-sdk-for-go/sdk/azidentity"
	"github.com/Azure/azure-sdk-for-go/sdk/resourcemanager/relay/armrelay/v2"
	"log"
)

func main() {
	cred, err := azidentity.NewDefaultAzureCredential(nil)
	if err != nil {
		log.Fatalf("failed to obtain a credential: %v", err)
	}
	ctx := context.Background()
	clientFactory, err := armrelay.NewClientFactory("ffffffff-ffff-ffff-ffff-ffffffffffff", cred, nil)
	if err != nil {
		log.Fatalf("failed to create client: %v", err)
	}
	res, err := clientFactory.NewHybridConnectionsClient().DeleteAuthorizationRule(ctx, "resourcegroup", "example-RelayNamespace-01", "example-Relay-Hybrid-01", "example-RelayAuthRules-01", 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 = armrelay.HybridConnectionsClientDeleteAuthorizationRuleResponse{
	// }
}

Output:

Generated from example definition: 2026-01-01/HybridConnection/RelayHybridConnectionGet.json

package main

import (
	"context"
	"github.com/Azure/azure-sdk-for-go/sdk/azidentity"
	"github.com/Azure/azure-sdk-for-go/sdk/resourcemanager/relay/armrelay/v2"
	"log"
)

func main() {
	cred, err := azidentity.NewDefaultAzureCredential(nil)
	if err != nil {
		log.Fatalf("failed to obtain a credential: %v", err)
	}
	ctx := context.Background()
	clientFactory, err := armrelay.NewClientFactory("ffffffff-ffff-ffff-ffff-ffffffffffff", cred, nil)
	if err != nil {
		log.Fatalf("failed to create client: %v", err)
	}
	res, err := clientFactory.NewHybridConnectionsClient().Get(ctx, "resourcegroup", "example-RelayNamespace-01", "example-Relay-Hybrid-01", 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 = armrelay.HybridConnectionsClientGetResponse{
	// 	HybridConnection: armrelay.HybridConnection{
	// 		Name: to.Ptr("example-Relay-Hybrid-01"),
	// 		Type: to.Ptr("Microsoft.Relay/Namespaces/HybridConnections"),
	// 		ID: to.Ptr("/subscriptions/ffffffff-ffff-ffff-ffff-ffffffffffff/resourceGroups/resourcegroup/providers/Microsoft.Relay/namespaces/example-RelayNamespace-01/HybridConnections/example-Relay-Hybrid-01"),
	// 		Properties: &armrelay.HybridConnectionProperties{
	// 			CreatedAt: to.Ptr(time.Date(2017, time.January, 23, 20, 34, 49, 413172400, time.UTC)),
	// 			ListenerCount: to.Ptr[int32](1),
	// 			RequiresClientAuthorization: to.Ptr(true),
	// 			UpdatedAt: to.Ptr(time.Date(2017, time.January, 23, 20, 34, 49, 413172400, time.UTC)),
	// 			UserMetadata: to.Ptr("usermetadata is a placeholder to store user-defined string data for the HybridConnection endpoint.e.g. it can be used to store  descriptive data, such as list of teams and their contact information also user-defined configuration settings can be stored."),
	// 		},
	// 	},
	// }
}

Output:

Generated from example definition: 2026-01-01/HybridConnection/RelayHybridConnectionAuthorizationRuleGet.json

package main

import (
	"context"
	"github.com/Azure/azure-sdk-for-go/sdk/azidentity"
	"github.com/Azure/azure-sdk-for-go/sdk/resourcemanager/relay/armrelay/v2"
	"log"
)

func main() {
	cred, err := azidentity.NewDefaultAzureCredential(nil)
	if err != nil {
		log.Fatalf("failed to obtain a credential: %v", err)
	}
	ctx := context.Background()
	clientFactory, err := armrelay.NewClientFactory("ffffffff-ffff-ffff-ffff-ffffffffffff", cred, nil)
	if err != nil {
		log.Fatalf("failed to create client: %v", err)
	}
	res, err := clientFactory.NewHybridConnectionsClient().GetAuthorizationRule(ctx, "resourcegroup", "example-RelayNamespace-01", "example-Relay-Hybrid-01", "example-RelayAuthRules-01", 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 = armrelay.HybridConnectionsClientGetAuthorizationRuleResponse{
	// 	AuthorizationRule: armrelay.AuthorizationRule{
	// 		Name: to.Ptr("example-RelayAuthRules-01"),
	// 		Type: to.Ptr("Microsoft.Relay/Namespaces/Hybridconnections/AuthorizationRules"),
	// 		ID: to.Ptr("/subscriptions/ffffffff-ffff-ffff-ffff-ffffffffffff/resourceGroups/resourcegroup/providers/Microsoft.Relay/namespaces/example-RelayNamespace-01/HybridConnections/example-Relay-Hybrid-01/AuthorizationRules/example-RelayAuthRules-01"),
	// 		Properties: &armrelay.AuthorizationRuleProperties{
	// 			Rights: []*armrelay.AccessRights{
	// 				to.Ptr(armrelay.AccessRightsListen),
	// 			},
	// 		},
	// 	},
	// }
}

Output:

Generated from example definition: 2026-01-01/HybridConnection/RelayHybridConnectionAuthorizationRuleListKey.json

package main

import (
	"context"
	"github.com/Azure/azure-sdk-for-go/sdk/azidentity"
	"github.com/Azure/azure-sdk-for-go/sdk/resourcemanager/relay/armrelay/v2"
	"log"
)

func main() {
	cred, err := azidentity.NewDefaultAzureCredential(nil)
	if err != nil {
		log.Fatalf("failed to obtain a credential: %v", err)
	}
	ctx := context.Background()
	clientFactory, err := armrelay.NewClientFactory("ffffffff-ffff-ffff-ffff-ffffffffffff", cred, nil)
	if err != nil {
		log.Fatalf("failed to create client: %v", err)
	}
	res, err := clientFactory.NewHybridConnectionsClient().ListKeys(ctx, "resourcegroup", "example-RelayNamespace-01", "example-Relay-Hybrid-01", "example-RelayAuthRules-01", 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 = armrelay.HybridConnectionsClientListKeysResponse{
	// 	AccessKeys: armrelay.AccessKeys{
	// 		KeyName: to.Ptr("example-RelayAuthRules-01"),
	// 		PrimaryConnectionString: to.Ptr("Endpoint=sb://example-Relaynamespace-01.servicebus.windows.net/;SharedAccessKeyName=example-RelayAuthRules-01;SharedAccessKey=############################################"),
	// 		PrimaryKey: to.Ptr("############################################"),
	// 		SecondaryConnectionString: to.Ptr("Endpoint=sb://example-Relaynamespace-01.servicebus.windows.net/;SharedAccessKeyName=example-RelayAuthRules-01;SharedAccessKey=############################################"),
	// 		SecondaryKey: to.Ptr("############################################"),
	// 	},
	// }
}

Output:

Generated from example definition: 2026-01-01/HybridConnection/RelayHybridConnectionAuthorizationRuleListAll.json

package main

import (
	"context"
	"github.com/Azure/azure-sdk-for-go/sdk/azidentity"
	"github.com/Azure/azure-sdk-for-go/sdk/resourcemanager/relay/armrelay/v2"
	"log"
)

func main() {
	cred, err := azidentity.NewDefaultAzureCredential(nil)
	if err != nil {
		log.Fatalf("failed to obtain a credential: %v", err)
	}
	ctx := context.Background()
	clientFactory, err := armrelay.NewClientFactory("ffffffff-ffff-ffff-ffff-ffffffffffff", cred, nil)
	if err != nil {
		log.Fatalf("failed to create client: %v", err)
	}
	pager := clientFactory.NewHybridConnectionsClient().NewListAuthorizationRulesPager("resourcegroup", "example-RelayNamespace-01", "example-Relay-Hybrid-01", 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 = armrelay.HybridConnectionsClientListAuthorizationRulesResponse{
		// 	AuthorizationRuleListResult: armrelay.AuthorizationRuleListResult{
		// 		Value: []*armrelay.AuthorizationRule{
		// 			{
		// 				Name: to.Ptr("example-RelayAuthRules-01"),
		// 				Type: to.Ptr("Microsoft.Relay/Namespaces/Hybridconnections/AuthorizationRules"),
		// 				ID: to.Ptr("/subscriptions/ffffffff-ffff-ffff-ffff-ffffffffffff/resourceGroups/resourcegroup/providers/Microsoft.Relay/namespaces/example-RelayNamespace-01/HybridConnections/example-Relay-Hybrid-01/AuthorizationRules/example-RelayAuthRules-01"),
		// 				Properties: &armrelay.AuthorizationRuleProperties{
		// 					Rights: []*armrelay.AccessRights{
		// 						to.Ptr(armrelay.AccessRightsListen),
		// 						to.Ptr(armrelay.AccessRightsSend),
		// 					},
		// 				},
		// 			},
		// 		},
		// 	},
		// }
	}
}

Output:

Generated from example definition: 2026-01-01/HybridConnection/RelayHybridConnectionListAll.json

package main

import (
	"context"
	"github.com/Azure/azure-sdk-for-go/sdk/azidentity"
	"github.com/Azure/azure-sdk-for-go/sdk/resourcemanager/relay/armrelay/v2"
	"log"
)

func main() {
	cred, err := azidentity.NewDefaultAzureCredential(nil)
	if err != nil {
		log.Fatalf("failed to obtain a credential: %v", err)
	}
	ctx := context.Background()
	clientFactory, err := armrelay.NewClientFactory("ffffffff-ffff-ffff-ffff-ffffffffffff", cred, nil)
	if err != nil {
		log.Fatalf("failed to create client: %v", err)
	}
	pager := clientFactory.NewHybridConnectionsClient().NewListByNamespacePager("resourcegroup", "example-RelayNamespace-01", 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 = armrelay.HybridConnectionsClientListByNamespaceResponse{
		// 	HybridConnectionListResult: armrelay.HybridConnectionListResult{
		// 		Value: []*armrelay.HybridConnection{
		// 			{
		// 				Name: to.Ptr("example-Relay-Hybrid-01"),
		// 				Type: to.Ptr("Microsoft.Relay/Namespaces/HybridConnections"),
		// 				ID: to.Ptr("/subscriptions/ffffffff-ffff-ffff-ffff-ffffffffffff/resourceGroups/resourcegroup/providers/Microsoft.Relay/namespaces/example-RelayNamespace-01/HybridConnections/example-Relay-Hybrid-01"),
		// 				Properties: &armrelay.HybridConnectionProperties{
		// 					CreatedAt: to.Ptr(time.Date(2017, time.January, 23, 20, 34, 49, 413172400, time.UTC)),
		// 					ListenerCount: to.Ptr[int32](1),
		// 					RequiresClientAuthorization: to.Ptr(true),
		// 					UpdatedAt: to.Ptr(time.Date(2017, time.January, 23, 20, 34, 49, 413172400, time.UTC)),
		// 					UserMetadata: to.Ptr("usermetadata is a placeholder to store user-defined string data for the HybridConnection endpoint.e.g. it can be used to store  descriptive data, such as list of teams and their contact information also user-defined configuration settings can be stored."),
		// 				},
		// 			},
		// 		},
		// 	},
		// }
	}
}

Output:

Generated from example definition: 2026-01-01/HybridConnection/RelayHybridConnectionAuthorizationRuleRegenerateKey.json

package main

import (
	"context"
	"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/relay/armrelay/v2"
	"log"
)

func main() {
	cred, err := azidentity.NewDefaultAzureCredential(nil)
	if err != nil {
		log.Fatalf("failed to obtain a credential: %v", err)
	}
	ctx := context.Background()
	clientFactory, err := armrelay.NewClientFactory("ffffffff-ffff-ffff-ffff-ffffffffffff", cred, nil)
	if err != nil {
		log.Fatalf("failed to create client: %v", err)
	}
	res, err := clientFactory.NewHybridConnectionsClient().RegenerateKeys(ctx, "resourcegroup", "example-RelayNamespace-01", "example-Relay-Hybrid-01", "example-RelayAuthRules-01", armrelay.RegenerateAccessKeyParameters{
		KeyType: to.Ptr(armrelay.KeyTypePrimaryKey),
	}, 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 = armrelay.HybridConnectionsClientRegenerateKeysResponse{
	// 	AccessKeys: armrelay.AccessKeys{
	// 		KeyName: to.Ptr("example-RelayAuthRules-01"),
	// 		PrimaryConnectionString: to.Ptr("Endpoint=sb://example-Relaynamespace-01.servicebus.windows.net/;SharedAccessKeyName=example-RelayAuthRules-01;SharedAccessKey=############################################"),
	// 		PrimaryKey: to.Ptr("############################################"),
	// 		SecondaryConnectionString: to.Ptr("Endpoint=sb://example-Relaynamespace-01.servicebus.windows.net/;SharedAccessKeyName=example-RelayAuthRules-01;SharedAccessKey=############################################"),
	// 		SecondaryKey: to.Ptr("############################################"),
	// 	},
	// }
}

Output:

Generated from example definition: 2026-01-01/NameSpaces/RelayNameSpaceCreate.json

package main

import (
	"context"
	"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/relay/armrelay/v2"
	"log"
)

func main() {
	cred, err := azidentity.NewDefaultAzureCredential(nil)
	if err != nil {
		log.Fatalf("failed to obtain a credential: %v", err)
	}
	ctx := context.Background()
	clientFactory, err := armrelay.NewClientFactory("ffffffff-ffff-ffff-ffff-ffffffffffff", cred, nil)
	if err != nil {
		log.Fatalf("failed to create client: %v", err)
	}
	poller, err := clientFactory.NewNamespacesClient().BeginCreateOrUpdate(ctx, "resourcegroup", "example-RelayNamespace-5849", armrelay.Namespace{
		Location: to.Ptr("South Central US"),
		SKU: &armrelay.SKU{
			Name: to.Ptr(armrelay.SKUNameStandard),
			Tier: to.Ptr(armrelay.SKUTierStandard),
		},
		Tags: map[string]*string{
			"tag1": to.Ptr("value1"),
			"tag2": to.Ptr("value2"),
		},
		Properties: &armrelay.NamespaceProperties{
			MinimumTLSVersion: to.Ptr(armrelay.TLSVersion12),
		},
	}, 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 poll 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 = armrelay.NamespacesClientCreateOrUpdateResponse{
	// 	Namespace: armrelay.Namespace{
	// 		Name: to.Ptr("example-RelayNamespace-5849"),
	// 		Type: to.Ptr("Microsoft.Relay/Namespaces"),
	// 		ID: to.Ptr("/subscriptions/ffffffff-ffff-ffff-ffff-ffffffffffff/resourceGroups/resourcegroup/providers/Microsoft.Relay/namespaces/example-RelayNamespace-5849"),
	// 		Location: to.Ptr("South Central US"),
	// 		Properties: &armrelay.NamespaceProperties{
	// 			MetricID: to.Ptr("ffffffff-ffff-ffff-ffff-ffffffffffff:example-Relaynamespace-5849"),
	// 			ProvisioningState: to.Ptr("Created"),
	// 			ServiceBusEndpoint: to.Ptr("https://example-RelayNamespace-5849.servicebus.windows-int.net:443/"),
	// 			MinimumTLSVersion: to.Ptr(armrelay.TLSVersion12),
	// 		},
	// 		SKU: &armrelay.SKU{
	// 			Name: to.Ptr(armrelay.SKUNameStandard),
	// 			Tier: to.Ptr(armrelay.SKUTierStandard),
	// 		},
	// 		Tags: map[string]*string{
	// 			"tag1": to.Ptr("value1"),
	// 			"tag2": to.Ptr("value2"),
	// 		},
	// 	},
	// }
}

Output:

Generated from example definition: 2026-01-01/NameSpaces/RelayNameSpaceDelete.json

package main

import (
	"context"
	"github.com/Azure/azure-sdk-for-go/sdk/azidentity"
	"github.com/Azure/azure-sdk-for-go/sdk/resourcemanager/relay/armrelay/v2"
	"log"
)

func main() {
	cred, err := azidentity.NewDefaultAzureCredential(nil)
	if err != nil {
		log.Fatalf("failed to obtain a credential: %v", err)
	}
	ctx := context.Background()
	clientFactory, err := armrelay.NewClientFactory("ffffffff-ffff-ffff-ffff-ffffffffffff", cred, nil)
	if err != nil {
		log.Fatalf("failed to create client: %v", err)
	}
	poller, err := clientFactory.NewNamespacesClient().BeginDelete(ctx, "SouthCentralUS", "example-RelayNamespace-5849", 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 poll 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 = armrelay.NamespacesClientDeleteResponse{
	// }
}

Output:

Generated from example definition: 2026-01-01/NameSpaces/RelayNameSpaceCheckNameAvailability.json

package main

import (
	"context"
	"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/relay/armrelay/v2"
	"log"
)

func main() {
	cred, err := azidentity.NewDefaultAzureCredential(nil)
	if err != nil {
		log.Fatalf("failed to obtain a credential: %v", err)
	}
	ctx := context.Background()
	clientFactory, err := armrelay.NewClientFactory("ffffffff-ffff-ffff-ffff-ffffffffffff", cred, nil)
	if err != nil {
		log.Fatalf("failed to create client: %v", err)
	}
	res, err := clientFactory.NewNamespacesClient().CheckNameAvailability(ctx, armrelay.CheckNameAvailability{
		Name: to.Ptr("example-RelayNamespace1321"),
	}, 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 = armrelay.NamespacesClientCheckNameAvailabilityResponse{
	// 	CheckNameAvailabilityResult: armrelay.CheckNameAvailabilityResult{
	// 		Message: to.Ptr(""),
	// 		NameAvailable: to.Ptr(true),
	// 		Reason: to.Ptr(armrelay.UnavailableReasonNone),
	// 	},
	// }
}

Output:

Generated from example definition: 2026-01-01/NameSpaces/RelayNameSpaceAuthorizationRuleCreate.json

package main

import (
	"context"
	"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/relay/armrelay/v2"
	"log"
)

func main() {
	cred, err := azidentity.NewDefaultAzureCredential(nil)
	if err != nil {
		log.Fatalf("failed to obtain a credential: %v", err)
	}
	ctx := context.Background()
	clientFactory, err := armrelay.NewClientFactory("ffffffff-ffff-ffff-ffff-ffffffffffff", cred, nil)
	if err != nil {
		log.Fatalf("failed to create client: %v", err)
	}
	res, err := clientFactory.NewNamespacesClient().CreateOrUpdateAuthorizationRule(ctx, "resourcegroup", "example-RelayNamespace-01", "example-RelayAuthRules-01", armrelay.AuthorizationRule{
		Properties: &armrelay.AuthorizationRuleProperties{
			Rights: []*armrelay.AccessRights{
				to.Ptr(armrelay.AccessRightsListen),
				to.Ptr(armrelay.AccessRightsSend),
			},
		},
	}, 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 = armrelay.NamespacesClientCreateOrUpdateAuthorizationRuleResponse{
	// 	AuthorizationRule: armrelay.AuthorizationRule{
	// 		Name: to.Ptr("example-RelayAuthRules-01"),
	// 		Type: to.Ptr("Microsoft.Relay/Namespaces/AuthorizationRules"),
	// 		ID: to.Ptr("/subscriptions/ffffffff-ffff-ffff-ffff-ffffffffffff/resourceGroups/resourcegroup/providers/Microsoft.Relay/namespaces/example-RelayNamespace-01/AuthorizationRules/example-RelayAuthRules-01"),
	// 		Properties: &armrelay.AuthorizationRuleProperties{
	// 			Rights: []*armrelay.AccessRights{
	// 				to.Ptr(armrelay.AccessRightsListen),
	// 				to.Ptr(armrelay.AccessRightsSend),
	// 			},
	// 		},
	// 	},
	// }
}

Output:

Generated from example definition: 2026-01-01/VirtualNetworkRules/RelayNetworkRuleSetCreate.json

package main

import (
	"context"
	"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/relay/armrelay/v2"
	"log"
)

func main() {
	cred, err := azidentity.NewDefaultAzureCredential(nil)
	if err != nil {
		log.Fatalf("failed to obtain a credential: %v", err)
	}
	ctx := context.Background()
	clientFactory, err := armrelay.NewClientFactory("Subscription", cred, nil)
	if err != nil {
		log.Fatalf("failed to create client: %v", err)
	}
	res, err := clientFactory.NewNamespacesClient().CreateOrUpdateNetworkRuleSet(ctx, "ResourceGroup", "example-RelayNamespace-6019", armrelay.NetworkRuleSet{
		Properties: &armrelay.NetworkRuleSetProperties{
			DefaultAction: to.Ptr(armrelay.DefaultActionDeny),
			IPRules: []*armrelay.NWRuleSetIPRules{
				{
					Action: to.Ptr(armrelay.NetworkRuleIPActionAllow),
					IPMask: to.Ptr("1.1.1.1"),
				},
				{
					Action: to.Ptr(armrelay.NetworkRuleIPActionAllow),
					IPMask: to.Ptr("1.1.1.2"),
				},
				{
					Action: to.Ptr(armrelay.NetworkRuleIPActionAllow),
					IPMask: to.Ptr("1.1.1.3"),
				},
				{
					Action: to.Ptr(armrelay.NetworkRuleIPActionAllow),
					IPMask: to.Ptr("1.1.1.4"),
				},
				{
					Action: to.Ptr(armrelay.NetworkRuleIPActionAllow),
					IPMask: to.Ptr("1.1.1.5"),
				},
			},
			TrustedServiceAccessEnabled: to.Ptr(false),
		},
	}, 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 = armrelay.NamespacesClientCreateOrUpdateNetworkRuleSetResponse{
	// 	NetworkRuleSet: armrelay.NetworkRuleSet{
	// 		Name: to.Ptr("default"),
	// 		Type: to.Ptr("Microsoft.Relay/Namespaces/NetworkRuleSet"),
	// 		ID: to.Ptr("/subscriptions/ffffffff-ffff-ffff-ffff-ffffffffffff/resourceGroups/resourcegroupid/providers/Microsoft.Relay/namespaces/example-RelayNamespace-9659/networkruleset/default"),
	// 		Properties: &armrelay.NetworkRuleSetProperties{
	// 			DefaultAction: to.Ptr(armrelay.DefaultActionDeny),
	// 			IPRules: []*armrelay.NWRuleSetIPRules{
	// 				{
	// 					Action: to.Ptr(armrelay.NetworkRuleIPActionAllow),
	// 					IPMask: to.Ptr("1.1.1.1"),
	// 				},
	// 				{
	// 					Action: to.Ptr(armrelay.NetworkRuleIPActionAllow),
	// 					IPMask: to.Ptr("1.1.1.2"),
	// 				},
	// 				{
	// 					Action: to.Ptr(armrelay.NetworkRuleIPActionAllow),
	// 					IPMask: to.Ptr("1.1.1.3"),
	// 				},
	// 				{
	// 					Action: to.Ptr(armrelay.NetworkRuleIPActionAllow),
	// 					IPMask: to.Ptr("1.1.1.4"),
	// 				},
	// 				{
	// 					Action: to.Ptr(armrelay.NetworkRuleIPActionAllow),
	// 					IPMask: to.Ptr("1.1.1.5"),
	// 				},
	// 			},
	// 			TrustedServiceAccessEnabled: to.Ptr(false),
	// 		},
	// 	},
	// }
}

Output:

Generated from example definition: 2026-01-01/NameSpaces/RelayNameSpaceAuthorizationRuleDelete.json

package main

import (
	"context"
	"github.com/Azure/azure-sdk-for-go/sdk/azidentity"
	"github.com/Azure/azure-sdk-for-go/sdk/resourcemanager/relay/armrelay/v2"
	"log"
)

func main() {
	cred, err := azidentity.NewDefaultAzureCredential(nil)
	if err != nil {
		log.Fatalf("failed to obtain a credential: %v", err)
	}
	ctx := context.Background()
	clientFactory, err := armrelay.NewClientFactory("ffffffff-ffff-ffff-ffff-ffffffffffff", cred, nil)
	if err != nil {
		log.Fatalf("failed to create client: %v", err)
	}
	res, err := clientFactory.NewNamespacesClient().DeleteAuthorizationRule(ctx, "resourcegroup", "example-RelayNamespace-01", "example-RelayAuthRules-01", 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 = armrelay.NamespacesClientDeleteAuthorizationRuleResponse{
	// }
}

Output:

Generated from example definition: 2026-01-01/NameSpaces/RelayNameSpaceGet.json

package main

import (
	"context"
	"github.com/Azure/azure-sdk-for-go/sdk/azidentity"
	"github.com/Azure/azure-sdk-for-go/sdk/resourcemanager/relay/armrelay/v2"
	"log"
)

func main() {
	cred, err := azidentity.NewDefaultAzureCredential(nil)
	if err != nil {
		log.Fatalf("failed to obtain a credential: %v", err)
	}
	ctx := context.Background()
	clientFactory, err := armrelay.NewClientFactory("ffffffff-ffff-ffff-ffff-ffffffffffff", cred, nil)
	if err != nil {
		log.Fatalf("failed to create client: %v", err)
	}
	res, err := clientFactory.NewNamespacesClient().Get(ctx, "RG-eg", "example-RelayRelayNamespace-01", 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 = armrelay.NamespacesClientGetResponse{
	// 	Namespace: armrelay.Namespace{
	// 		Name: to.Ptr("example-RelayRelayNamespace-01"),
	// 		Type: to.Ptr("Microsoft.Relay/Namespaces"),
	// 		ID: to.Ptr("/subscriptions/ffffffff-ffff-ffff-ffff-ffffffffffff/resourceGroups/RG-eg/providers/Microsoft.Relay/namespaces/example-RelayRelayNamespace-01"),
	// 		Location: to.Ptr("West US"),
	// 		Properties: &armrelay.NamespaceProperties{
	// 			CreatedAt: to.Ptr(time.Date(2017, time.January, 23, 20, 38, 12, 460000000, time.UTC)),
	// 			MetricID: to.Ptr("ffffffff-ffff-ffff-ffff-ffffffffffff:example-RelayRelayNamespace-01"),
	// 			ProvisioningState: to.Ptr("Succeeded"),
	// 			ServiceBusEndpoint: to.Ptr("https://example-RelayRelayNamespace-01.servicebus.windows.net:443/"),
	// 			UpdatedAt: to.Ptr(time.Date(2017, time.January, 23, 20, 38, 34, 533000000, time.UTC)),
	// 			MinimumTLSVersion: to.Ptr(armrelay.TLSVersion12),
	// 		},
	// 		SKU: &armrelay.SKU{
	// 			Name: to.Ptr(armrelay.SKUNameStandard),
	// 			Tier: to.Ptr(armrelay.SKUTierStandard),
	// 		},
	// 		Tags: map[string]*string{
	// 			"tag1": to.Ptr("value1"),
	// 			"tag2": to.Ptr("value2"),
	// 		},
	// 	},
	// }
}

Output:

Generated from example definition: 2026-01-01/NameSpaces/RelayNameSpaceAuthorizationRuleGet.json

package main

import (
	"context"
	"github.com/Azure/azure-sdk-for-go/sdk/azidentity"
	"github.com/Azure/azure-sdk-for-go/sdk/resourcemanager/relay/armrelay/v2"
	"log"
)

func main() {
	cred, err := azidentity.NewDefaultAzureCredential(nil)
	if err != nil {
		log.Fatalf("failed to obtain a credential: %v", err)
	}
	ctx := context.Background()
	clientFactory, err := armrelay.NewClientFactory("ffffffff-ffff-ffff-ffff-ffffffffffff", cred, nil)
	if err != nil {
		log.Fatalf("failed to create client: %v", err)
	}
	res, err := clientFactory.NewNamespacesClient().GetAuthorizationRule(ctx, "resourcegroup", "example-RelayNamespace-01", "example-RelayAuthRules-01", 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 = armrelay.NamespacesClientGetAuthorizationRuleResponse{
	// 	AuthorizationRule: armrelay.AuthorizationRule{
	// 		Name: to.Ptr("example-RelayAuthRules-01"),
	// 		Type: to.Ptr("Microsoft.Relay/Namespaces/AuthorizationRules"),
	// 		ID: to.Ptr("/subscriptions/ffffffff-ffff-ffff-ffff-ffffffffffff/resourceGroups/resourcegroup/providers/Microsoft.Relay/namespaces/example-RelayNamespace-01/AuthorizationRules/example-RelayAuthRules-01"),
	// 		Properties: &armrelay.AuthorizationRuleProperties{
	// 			Rights: []*armrelay.AccessRights{
	// 				to.Ptr(armrelay.AccessRightsListen),
	// 			},
	// 		},
	// 	},
	// }
}

Output:

Generated from example definition: 2026-01-01/VirtualNetworkRules/RelayNetworkRuleSetGet.json

package main

import (
	"context"
	"github.com/Azure/azure-sdk-for-go/sdk/azidentity"
	"github.com/Azure/azure-sdk-for-go/sdk/resourcemanager/relay/armrelay/v2"
	"log"
)

func main() {
	cred, err := azidentity.NewDefaultAzureCredential(nil)
	if err != nil {
		log.Fatalf("failed to obtain a credential: %v", err)
	}
	ctx := context.Background()
	clientFactory, err := armrelay.NewClientFactory("Subscription", cred, nil)
	if err != nil {
		log.Fatalf("failed to create client: %v", err)
	}
	res, err := clientFactory.NewNamespacesClient().GetNetworkRuleSet(ctx, "ResourceGroup", "example-RelayNamespace-6019", 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 = armrelay.NamespacesClientGetNetworkRuleSetResponse{
	// 	NetworkRuleSet: armrelay.NetworkRuleSet{
	// 		Name: to.Ptr("default"),
	// 		Type: to.Ptr("Microsoft.Relay/Namespaces/NetworkRuleSet"),
	// 		ID: to.Ptr("/subscriptions/ffffffff-ffff-ffff-ffff-ffffffffffff/resourceGroups/resourcegroupid/providers/Microsoft.Relay/namespaces/example-RelayNamespace-9659/networkruleset/default"),
	// 		Properties: &armrelay.NetworkRuleSetProperties{
	// 			DefaultAction: to.Ptr(armrelay.DefaultActionDeny),
	// 			IPRules: []*armrelay.NWRuleSetIPRules{
	// 				{
	// 					Action: to.Ptr(armrelay.NetworkRuleIPActionAllow),
	// 					IPMask: to.Ptr("1.1.1.1"),
	// 				},
	// 				{
	// 					Action: to.Ptr(armrelay.NetworkRuleIPActionAllow),
	// 					IPMask: to.Ptr("1.1.1.2"),
	// 				},
	// 				{
	// 					Action: to.Ptr(armrelay.NetworkRuleIPActionAllow),
	// 					IPMask: to.Ptr("1.1.1.3"),
	// 				},
	// 				{
	// 					Action: to.Ptr(armrelay.NetworkRuleIPActionAllow),
	// 					IPMask: to.Ptr("1.1.1.4"),
	// 				},
	// 				{
	// 					Action: to.Ptr(armrelay.NetworkRuleIPActionAllow),
	// 					IPMask: to.Ptr("1.1.1.5"),
	// 				},
	// 			},
	// 			TrustedServiceAccessEnabled: to.Ptr(false),
	// 		},
	// 	},
	// }
}

Output:

Generated from example definition: 2026-01-01/NameSpaces/RelayNameSpaceAuthorizationRuleListKey.json

package main

import (
	"context"
	"github.com/Azure/azure-sdk-for-go/sdk/azidentity"
	"github.com/Azure/azure-sdk-for-go/sdk/resourcemanager/relay/armrelay/v2"
	"log"
)

func main() {
	cred, err := azidentity.NewDefaultAzureCredential(nil)
	if err != nil {
		log.Fatalf("failed to obtain a credential: %v", err)
	}
	ctx := context.Background()
	clientFactory, err := armrelay.NewClientFactory("ffffffff-ffff-ffff-ffff-ffffffffffff", cred, nil)
	if err != nil {
		log.Fatalf("failed to create client: %v", err)
	}
	res, err := clientFactory.NewNamespacesClient().ListKeys(ctx, "resourcegroup", "example-RelayNamespace-01", "example-RelayAuthRules-01", 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 = armrelay.NamespacesClientListKeysResponse{
	// 	AccessKeys: armrelay.AccessKeys{
	// 		KeyName: to.Ptr("example-RelayAuthRules-01"),
	// 		PrimaryConnectionString: to.Ptr("Endpoint=sb://example-Relaynamespace-01.servicebus.windows.net/;SharedAccessKeyName=example-RelayAuthRules-01;SharedAccessKey=############################################"),
	// 		PrimaryKey: to.Ptr("############################################"),
	// 		SecondaryConnectionString: to.Ptr("Endpoint=sb://example-Relaynamespace-01.servicebus.windows.net/;SharedAccessKeyName=example-RelayAuthRules-01;SharedAccessKey=############################################"),
	// 		SecondaryKey: to.Ptr("############################################"),
	// 	},
	// }
}

Output:

Generated from example definition: 2026-01-01/NameSpaces/RelayNameSpaceAuthorizationRuleListAll.json

package main

import (
	"context"
	"github.com/Azure/azure-sdk-for-go/sdk/azidentity"
	"github.com/Azure/azure-sdk-for-go/sdk/resourcemanager/relay/armrelay/v2"
	"log"
)

func main() {
	cred, err := azidentity.NewDefaultAzureCredential(nil)
	if err != nil {
		log.Fatalf("failed to obtain a credential: %v", err)
	}
	ctx := context.Background()
	clientFactory, err := armrelay.NewClientFactory("ffffffff-ffff-ffff-ffff-ffffffffffff", cred, nil)
	if err != nil {
		log.Fatalf("failed to create client: %v", err)
	}
	pager := clientFactory.NewNamespacesClient().NewListAuthorizationRulesPager("resourcegroup", "example-RelayNamespace-01", 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 = armrelay.NamespacesClientListAuthorizationRulesResponse{
		// 	AuthorizationRuleListResult: armrelay.AuthorizationRuleListResult{
		// 		Value: []*armrelay.AuthorizationRule{
		// 			{
		// 				Name: to.Ptr("RootManageSharedAccessKey"),
		// 				Type: to.Ptr("Microsoft.Relay/Namespaces/AuthorizationRules"),
		// 				ID: to.Ptr("/subscriptions/ffffffff-ffff-ffff-ffff-ffffffffffff/resourceGroups/resourcegroup/providers/Microsoft.Relay/namespaces/example-RelayNamespace-01/AuthorizationRules/RootManageSharedAccessKey"),
		// 				Properties: &armrelay.AuthorizationRuleProperties{
		// 					Rights: []*armrelay.AccessRights{
		// 						to.Ptr(armrelay.AccessRightsListen),
		// 						to.Ptr(armrelay.AccessRightsManage),
		// 						to.Ptr(armrelay.AccessRightsSend),
		// 					},
		// 				},
		// 			},
		// 			{
		// 				Name: to.Ptr("example-RelayAuthRules-01"),
		// 				Type: to.Ptr("Microsoft.Relay/Namespaces/AuthorizationRules"),
		// 				ID: to.Ptr("/subscriptions/ffffffff-ffff-ffff-ffff-ffffffffffff/resourceGroups/resourcegroup/providers/Microsoft.Relay/namespaces/example-RelayNamespace-01/AuthorizationRules/example-RelayAuthRules-01"),
		// 				Properties: &armrelay.AuthorizationRuleProperties{
		// 					Rights: []*armrelay.AccessRights{
		// 						to.Ptr(armrelay.AccessRightsListen),
		// 						to.Ptr(armrelay.AccessRightsSend),
		// 					},
		// 				},
		// 			},
		// 		},
		// 	},
		// }
	}
}

Output:

Generated from example definition: 2026-01-01/NameSpaces/RelayNameSpaceListByResourceGroup.json

package main

import (
	"context"
	"github.com/Azure/azure-sdk-for-go/sdk/azidentity"
	"github.com/Azure/azure-sdk-for-go/sdk/resourcemanager/relay/armrelay/v2"
	"log"
)

func main() {
	cred, err := azidentity.NewDefaultAzureCredential(nil)
	if err != nil {
		log.Fatalf("failed to obtain a credential: %v", err)
	}
	ctx := context.Background()
	clientFactory, err := armrelay.NewClientFactory("ffffffff-ffff-ffff-ffff-ffffffffffff", cred, nil)
	if err != nil {
		log.Fatalf("failed to create client: %v", err)
	}
	pager := clientFactory.NewNamespacesClient().NewListByResourceGroupPager("resourcegroup", 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 = armrelay.NamespacesClientListByResourceGroupResponse{
		// 	NamespaceListResult: armrelay.NamespaceListResult{
		// 		Value: []*armrelay.Namespace{
		// 			{
		// 				Name: to.Ptr("example-RelayNamespace-3054"),
		// 				Type: to.Ptr("Microsoft.Relay/Namespaces"),
		// 				ID: to.Ptr("/subscriptions/ffffffff-ffff-ffff-ffff-ffffffffffff/resourceGroups/resourcegroup/providers/Microsoft.Relay/namespaces/example-RelayNamespace-3054"),
		// 				Location: to.Ptr("South Central US"),
		// 				Properties: &armrelay.NamespaceProperties{
		// 					MetricID: to.Ptr("ffffffff-ffff-ffff-ffff-ffffffffffff:example-Relaynamespace-3054"),
		// 					ProvisioningState: to.Ptr("Succeeded"),
		// 					ServiceBusEndpoint: to.Ptr("https://example-RelayNamespace-3054.servicebus.windows-int.net:443/"),
		// 					MinimumTLSVersion: to.Ptr(armrelay.TLSVersion12),
		// 				},
		// 				SKU: &armrelay.SKU{
		// 					Name: to.Ptr(armrelay.SKUNameStandard),
		// 					Tier: to.Ptr(armrelay.SKUTierStandard),
		// 				},
		// 				Tags: map[string]*string{
		// 				},
		// 			},
		// 			{
		// 				Name: to.Ptr("oaisdjfoiasdjfoiajsdfoijasd"),
		// 				Type: to.Ptr("Microsoft.Relay/Namespaces"),
		// 				ID: to.Ptr("/subscriptions/ffffffff-ffff-ffff-ffff-ffffffffffff/resourceGroups/resourcegroup/providers/Microsoft.Relay/namespaces/oaisdjfoiasdjfoiajsdfoijasd"),
		// 				Location: to.Ptr("South Central US"),
		// 				Properties: &armrelay.NamespaceProperties{
		// 					MetricID: to.Ptr("ffffffff-ffff-ffff-ffff-ffffffffffff:oaisdjfoiasdjfoiajsdfoijasd"),
		// 					ProvisioningState: to.Ptr("Succeeded"),
		// 					ServiceBusEndpoint: to.Ptr("https://oaisdjfoiasdjfoiajsdfoijasd.servicebus.windows-int.net:443/"),
		// 					MinimumTLSVersion: to.Ptr(armrelay.TLSVersion12),
		// 				},
		// 				SKU: &armrelay.SKU{
		// 					Name: to.Ptr(armrelay.SKUNameStandard),
		// 					Tier: to.Ptr(armrelay.SKUTierStandard),
		// 				},
		// 				Tags: map[string]*string{
		// 				},
		// 			},
		// 			{
		// 				Name: to.Ptr("abc123"),
		// 				Type: to.Ptr("Microsoft.Relay/Namespaces"),
		// 				ID: to.Ptr("/subscriptions/ffffffff-ffff-ffff-ffff-ffffffffffff/resourceGroups/resourcegroup/providers/Microsoft.Relay/namespaces/abc123"),
		// 				Location: to.Ptr("South Central US"),
		// 				Properties: &armrelay.NamespaceProperties{
		// 					MetricID: to.Ptr("ffffffff-ffff-ffff-ffff-ffffffffffff:abc123"),
		// 					ProvisioningState: to.Ptr("Succeeded"),
		// 					ServiceBusEndpoint: to.Ptr("https://abc123.servicebus.windows-int.net:443/"),
		// 					MinimumTLSVersion: to.Ptr(armrelay.TLSVersion12),
		// 				},
		// 				SKU: &armrelay.SKU{
		// 					Name: to.Ptr(armrelay.SKUNameStandard),
		// 					Tier: to.Ptr(armrelay.SKUTierStandard),
		// 				},
		// 				Tags: map[string]*string{
		// 				},
		// 			},
		// 			{
		// 				Name: to.Ptr("example-RelayNamespace-5849"),
		// 				Type: to.Ptr("Microsoft.Relay/Namespaces"),
		// 				ID: to.Ptr("/subscriptions/ffffffff-ffff-ffff-ffff-ffffffffffff/resourceGroups/resourcegroup/providers/Microsoft.Relay/namespaces/example-RelayNamespace-5849"),
		// 				Location: to.Ptr("South Central US"),
		// 				Properties: &armrelay.NamespaceProperties{
		// 					MetricID: to.Ptr("ffffffff-ffff-ffff-ffff-ffffffffffff:example-Relaynamespace-5849"),
		// 					ProvisioningState: to.Ptr("Succeeded"),
		// 					ServiceBusEndpoint: to.Ptr("https://example-RelayNamespace-5849.servicebus.windows-int.net:443/"),
		// 					MinimumTLSVersion: to.Ptr(armrelay.TLSVersion12),
		// 				},
		// 				SKU: &armrelay.SKU{
		// 					Name: to.Ptr(armrelay.SKUNameStandard),
		// 					Tier: to.Ptr(armrelay.SKUTierStandard),
		// 				},
		// 				Tags: map[string]*string{
		// 					"tag1": to.Ptr("value1"),
		// 					"tag2": to.Ptr("value2"),
		// 				},
		// 			},
		// 			{
		// 				Name: to.Ptr("example-RelayNamespace-4984"),
		// 				Type: to.Ptr("Microsoft.Relay/Namespaces"),
		// 				ID: to.Ptr("/subscriptions/ffffffff-ffff-ffff-ffff-ffffffffffff/resourceGroups/resourcegroup/providers/Microsoft.Relay/namespaces/example-RelayNamespace-4984"),
		// 				Location: to.Ptr("South Central US"),
		// 				Properties: &armrelay.NamespaceProperties{
		// 					MetricID: to.Ptr("ffffffff-ffff-ffff-ffff-ffffffffffff:example-Relaynamespace-4984"),
		// 					ProvisioningState: to.Ptr("Succeeded"),
		// 					ServiceBusEndpoint: to.Ptr("https://example-RelayNamespace-4984.servicebus.windows-int.net:443/"),
		// 					MinimumTLSVersion: to.Ptr(armrelay.TLSVersion12),
		// 				},
		// 				SKU: &armrelay.SKU{
		// 					Name: to.Ptr(armrelay.SKUNameStandard),
		// 					Tier: to.Ptr(armrelay.SKUTierStandard),
		// 				},
		// 				Tags: map[string]*string{
		// 				},
		// 			},
		// 			{
		// 				Name: to.Ptr("example-RelayNamespace-5606"),
		// 				Type: to.Ptr("Microsoft.Relay/Namespaces"),
		// 				ID: to.Ptr("/subscriptions/ffffffff-ffff-ffff-ffff-ffffffffffff/resourceGroups/resourcegroup/providers/Microsoft.Relay/namespaces/example-RelayNamespace-5606"),
		// 				Location: to.Ptr("South Central US"),
		// 				Properties: &armrelay.NamespaceProperties{
		// 					MetricID: to.Ptr("ffffffff-ffff-ffff-ffff-ffffffffffff:example-Relaynamespace-5606"),
		// 					ProvisioningState: to.Ptr("Succeeded"),
		// 					ServiceBusEndpoint: to.Ptr("https://example-RelayNamespace-5606.servicebus.windows-int.net:443/"),
		// 					MinimumTLSVersion: to.Ptr(armrelay.TLSVersion12),
		// 				},
		// 				SKU: &armrelay.SKU{
		// 					Name: to.Ptr(armrelay.SKUNameStandard),
		// 					Tier: to.Ptr(armrelay.SKUTierStandard),
		// 				},
		// 				Tags: map[string]*string{
		// 				},
		// 			},
		// 			{
		// 				Name: to.Ptr("example-RelayNamespace-7703"),
		// 				Type: to.Ptr("Microsoft.Relay/Namespaces"),
		// 				ID: to.Ptr("/subscriptions/ffffffff-ffff-ffff-ffff-ffffffffffff/resourceGroups/resourcegroup/providers/Microsoft.Relay/namespaces/example-RelayNamespace-7703"),
		// 				Location: to.Ptr("South Central US"),
		// 				Properties: &armrelay.NamespaceProperties{
		// 					MetricID: to.Ptr("ffffffff-ffff-ffff-ffff-ffffffffffff:example-Relaynamespace-7703"),
		// 					ProvisioningState: to.Ptr("Succeeded"),
		// 					ServiceBusEndpoint: to.Ptr("https://example-RelayNamespace-7703.servicebus.windows-int.net:443/"),
		// 					MinimumTLSVersion: to.Ptr(armrelay.TLSVersion12),
		// 				},
		// 				SKU: &armrelay.SKU{
		// 					Name: to.Ptr(armrelay.SKUNameStandard),
		// 					Tier: to.Ptr(armrelay.SKUTierStandard),
		// 				},
		// 				Tags: map[string]*string{
		// 				},
		// 			},
		// 			{
		// 				Name: to.Ptr("zzzzzzzzzzzzzzzzzzzzzz-00001"),
		// 				Type: to.Ptr("Microsoft.Relay/Namespaces"),
		// 				ID: to.Ptr("/subscriptions/ffffffff-ffff-ffff-ffff-ffffffffffff/resourceGroups/resourcegroup/providers/Microsoft.Relay/namespaces/zzzzzzzzzzzzzzzzzzzzzz-00001"),
		// 				Location: to.Ptr("South Central US"),
		// 				Properties: &armrelay.NamespaceProperties{
		// 					MetricID: to.Ptr("ffffffff-ffff-ffff-ffff-ffffffffffff:zzzzzzzzzzzzzzzzzzzzzz-00001"),
		// 					ProvisioningState: to.Ptr("Succeeded"),
		// 					ServiceBusEndpoint: to.Ptr("https://zzzzzzzzzzzzzzzzzzzzzz-00001.servicebus.windows-int.net:443/"),
		// 					MinimumTLSVersion: to.Ptr(armrelay.TLSVersion12),
		// 				},
		// 				SKU: &armrelay.SKU{
		// 					Name: to.Ptr(armrelay.SKUNameStandard),
		// 					Tier: to.Ptr(armrelay.SKUTierStandard),
		// 				},
		// 				Tags: map[string]*string{
		// 				},
		// 			},
		// 			{
		// 				Name: to.Ptr("example-RelayNamespace-3919"),
		// 				Type: to.Ptr("Microsoft.Relay/Namespaces"),
		// 				ID: to.Ptr("/subscriptions/ffffffff-ffff-ffff-ffff-ffffffffffff/resourceGroups/resourcegroup/providers/Microsoft.Relay/namespaces/example-RelayNamespace-3919"),
		// 				Location: to.Ptr("South Central US"),
		// 				Properties: &armrelay.NamespaceProperties{
		// 					MetricID: to.Ptr("ffffffff-ffff-ffff-ffff-ffffffffffff:example-Relaynamespace-3919"),
		// 					ProvisioningState: to.Ptr("Succeeded"),
		// 					ServiceBusEndpoint: to.Ptr("https://example-RelayNamespace-3919.servicebus.windows-int.net:443/"),
		// 					MinimumTLSVersion: to.Ptr(armrelay.TLSVersion12),
		// 				},
		// 				SKU: &armrelay.SKU{
		// 					Name: to.Ptr(armrelay.SKUNameStandard),
		// 					Tier: to.Ptr(armrelay.SKUTierStandard),
		// 				},
		// 				Tags: map[string]*string{
		// 				},
		// 			},
		// 			{
		// 				Name: to.Ptr("aiosdjfaoidjasdoijasdfoijasdfofijsdf"),
		// 				Type: to.Ptr("Microsoft.Relay/Namespaces"),
		// 				ID: to.Ptr("/subscriptions/ffffffff-ffff-ffff-ffff-ffffffffffff/resourceGroups/resourcegroup/providers/Microsoft.Relay/namespaces/aiosdjfaoidjasdoijasdfoijasdfofijsdf"),
		// 				Location: to.Ptr("South Central US"),
		// 				Properties: &armrelay.NamespaceProperties{
		// 					MetricID: to.Ptr("ffffffff-ffff-ffff-ffff-ffffffffffff:aiosdjfaoidjasdoijasdfoijasdfofijsdf"),
		// 					ProvisioningState: to.Ptr("Succeeded"),
		// 					ServiceBusEndpoint: to.Ptr("https://aiosdjfaoidjasdoijasdfoijasdfofijsdf.servicebus.windows-int.net:443/"),
		// 					MinimumTLSVersion: to.Ptr(armrelay.TLSVersion12),
		// 				},
		// 				SKU: &armrelay.SKU{
		// 					Name: to.Ptr(armrelay.SKUNameStandard),
		// 					Tier: to.Ptr(armrelay.SKUTierStandard),
		// 				},
		// 				Tags: map[string]*string{
		// 				},
		// 			},
		// 			{
		// 				Name: to.Ptr("example-RelayNamespace-3413"),
		// 				Type: to.Ptr("Microsoft.Relay/Namespaces"),
		// 				ID: to.Ptr("/subscriptions/ffffffff-ffff-ffff-ffff-ffffffffffff/resourceGroups/resourcegroup/providers/Microsoft.Relay/namespaces/example-RelayNamespace-3413"),
		// 				Location: to.Ptr("South Central US"),
		// 				Properties: &armrelay.NamespaceProperties{
		// 					MetricID: to.Ptr("ffffffff-ffff-ffff-ffff-ffffffffffff:example-Relaynamespace-3413"),
		// 					ProvisioningState: to.Ptr("Succeeded"),
		// 					ServiceBusEndpoint: to.Ptr("https://example-RelayNamespace-3413.servicebus.windows-int.net:443/"),
		// 					MinimumTLSVersion: to.Ptr(armrelay.TLSVersion12),
		// 				},
		// 				SKU: &armrelay.SKU{
		// 					Name: to.Ptr(armrelay.SKUNameStandard),
		// 					Tier: to.Ptr(armrelay.SKUTierStandard),
		// 				},
		// 				Tags: map[string]*string{
		// 				},
		// 			},
		// 			{
		// 				Name: to.Ptr("example-RelayNamespace-8695"),
		// 				Type: to.Ptr("Microsoft.Relay/Namespaces"),
		// 				ID: to.Ptr("/subscriptions/ffffffff-ffff-ffff-ffff-ffffffffffff/resourceGroups/resourcegroup/providers/Microsoft.Relay/namespaces/example-RelayNamespace-8695"),
		// 				Location: to.Ptr("South Central US"),
		// 				Properties: &armrelay.NamespaceProperties{
		// 					MetricID: to.Ptr("ffffffff-ffff-ffff-ffff-ffffffffffff:example-Relaynamespace-8695"),
		// 					ProvisioningState: to.Ptr("Succeeded"),
		// 					ServiceBusEndpoint: to.Ptr("https://example-RelayNamespace-8695.servicebus.windows-int.net:443/"),
		// 					MinimumTLSVersion: to.Ptr(armrelay.TLSVersion12),
		// 				},
		// 				SKU: &armrelay.SKU{
		// 					Name: to.Ptr(armrelay.SKUNameStandard),
		// 					Tier: to.Ptr(armrelay.SKUTierStandard),
		// 				},
		// 				Tags: map[string]*string{
		// 				},
		// 			},
		// 			{
		// 				Name: to.Ptr("example-RelayNamespace-4801"),
		// 				Type: to.Ptr("Microsoft.Relay/Namespaces"),
		// 				ID: to.Ptr("/subscriptions/ffffffff-ffff-ffff-ffff-ffffffffffff/resourceGroups/resourcegroup/providers/Microsoft.Relay/namespaces/example-RelayNamespace-4801"),
		// 				Location: to.Ptr("South Central US"),
		// 				Properties: &armrelay.NamespaceProperties{
		// 					MetricID: to.Ptr("ffffffff-ffff-ffff-ffff-ffffffffffff:example-Relaynamespace-4801"),
		// 					ProvisioningState: to.Ptr("Succeeded"),
		// 					ServiceBusEndpoint: to.Ptr("https://example-RelayNamespace-4801.servicebus.windows-int.net:443/"),
		// 					MinimumTLSVersion: to.Ptr(armrelay.TLSVersion12),
		// 				},
		// 				SKU: &armrelay.SKU{
		// 					Name: to.Ptr(armrelay.SKUNameStandard),
		// 					Tier: to.Ptr(armrelay.SKUTierStandard),
		// 				},
		// 				Tags: map[string]*string{
		// 				},
		// 			},
		// 			{
		// 				Name: to.Ptr("example-RelayNamespace-2812"),
		// 				Type: to.Ptr("Microsoft.Relay/Namespaces"),
		// 				ID: to.Ptr("/subscriptions/ffffffff-ffff-ffff-ffff-ffffffffffff/resourceGroups/resourcegroup/providers/Microsoft.Relay/namespaces/example-RelayNamespace-2812"),
		// 				Location: to.Ptr("South Central US"),
		// 				Properties: &armrelay.NamespaceProperties{
		// 					MetricID: to.Ptr("ffffffff-ffff-ffff-ffff-ffffffffffff:example-Relaynamespace-2812"),
		// 					ProvisioningState: to.Ptr("Succeeded"),
		// 					ServiceBusEndpoint: to.Ptr("https://example-RelayNamespace-2812.servicebus.windows-int.net:443/"),
		// 					MinimumTLSVersion: to.Ptr(armrelay.TLSVersion12),
		// 				},
		// 				SKU: &armrelay.SKU{
		// 					Name: to.Ptr(armrelay.SKUNameStandard),
		// 					Tier: to.Ptr(armrelay.SKUTierStandard),
		// 				},
		// 				Tags: map[string]*string{
		// 				},
		// 			},
		// 		},
		// 	},
		// }
	}
}

Output:

Generated from example definition: 2026-01-01/NameSpaces/RelayNameSpaceListBySubscription.json

package main

import (
	"context"
	"github.com/Azure/azure-sdk-for-go/sdk/azidentity"
	"github.com/Azure/azure-sdk-for-go/sdk/resourcemanager/relay/armrelay/v2"
	"log"
)

func main() {
	cred, err := azidentity.NewDefaultAzureCredential(nil)
	if err != nil {
		log.Fatalf("failed to obtain a credential: %v", err)
	}
	ctx := context.Background()
	clientFactory, err := armrelay.NewClientFactory("ffffffff-ffff-ffff-ffff-ffffffffffff", cred, nil)
	if err != nil {
		log.Fatalf("failed to create client: %v", err)
	}
	pager := clientFactory.NewNamespacesClient().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 = armrelay.NamespacesClientListResponse{
		// 	NamespaceListResult: armrelay.NamespaceListResult{
		// 		Value: []*armrelay.Namespace{
		// 			{
		// 				Name: to.Ptr("example-RelayRelayNamespace-01"),
		// 				Type: to.Ptr("Microsoft.Relay/Namespaces"),
		// 				ID: to.Ptr("/subscriptions/ffffffff-ffff-ffff-ffff-ffffffffffff/resourceGroups/RG1-eg/providers/Microsoft.Relay/namespaces/example-RelayRelayNamespace-01"),
		// 				Location: to.Ptr("West US"),
		// 				Properties: &armrelay.NamespaceProperties{
		// 					CreatedAt: to.Ptr(time.Date(2017, time.January, 23, 20, 34, 49, 413172400, time.UTC)),
		// 					MetricID: to.Ptr("ffffffff-ffff-ffff-ffff-ffffffffffff:example-RelayRelayNamespace-01"),
		// 					ProvisioningState: to.Ptr("Succeeded"),
		// 					ServiceBusEndpoint: to.Ptr("https://example-RelayRelayNamespace-01.servicebus.windows.net:443/"),
		// 					UpdatedAt: to.Ptr(time.Date(2017, time.January, 23, 20, 34, 59, 413172400, time.UTC)),
		// 					MinimumTLSVersion: to.Ptr(armrelay.TLSVersion12),
		// 				},
		// 				SKU: &armrelay.SKU{
		// 					Name: to.Ptr(armrelay.SKUNameStandard),
		// 					Tier: to.Ptr(armrelay.SKUTierStandard),
		// 				},
		// 				Tags: map[string]*string{
		// 					"tag1": to.Ptr("value1"),
		// 					"tag2": to.Ptr("value2"),
		// 				},
		// 			},
		// 			{
		// 				Name: to.Ptr("example-RelayRelayNamespace-02"),
		// 				Type: to.Ptr("Microsoft.Relay/Namespaces"),
		// 				ID: to.Ptr("/subscriptions/ffffffff-ffff-ffff-ffff-ffffffffffff/resourceGroups/RG1-eg/providers/Microsoft.Relay/namespaces/example-RelayRelayNamespace-02"),
		// 				Location: to.Ptr("West US"),
		// 				Properties: &armrelay.NamespaceProperties{
		// 					CreatedAt: to.Ptr(time.Date(2017, time.January, 23, 20, 34, 39, 413172400, time.UTC)),
		// 					MetricID: to.Ptr("ffffffff-ffff-ffff-ffff-ffffffffffff:example-RelayRelayNamespace-02"),
		// 					ProvisioningState: to.Ptr("Succeeded"),
		// 					ServiceBusEndpoint: to.Ptr("https://example-RelayRelayNamespace-02.servicebus.windows.net:443/"),
		// 					UpdatedAt: to.Ptr(time.Date(2017, time.January, 23, 20, 34, 49, 413172400, time.UTC)),
		// 					MinimumTLSVersion: to.Ptr(armrelay.TLSVersion12),
		// 				},
		// 				SKU: &armrelay.SKU{
		// 					Name: to.Ptr(armrelay.SKUNameStandard),
		// 					Tier: to.Ptr(armrelay.SKUTierStandard),
		// 				},
		// 				Tags: map[string]*string{
		// 					"tag1": to.Ptr("value1"),
		// 					"tag2": to.Ptr("value2"),
		// 				},
		// 			},
		// 		},
		// 	},
		// }
	}
}

Output:

Generated from example definition: 2026-01-01/NameSpaces/RelayNameSpaceAuthorizationRuleRegenerateKey.json

package main

import (
	"context"
	"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/relay/armrelay/v2"
	"log"
)

func main() {
	cred, err := azidentity.NewDefaultAzureCredential(nil)
	if err != nil {
		log.Fatalf("failed to obtain a credential: %v", err)
	}
	ctx := context.Background()
	clientFactory, err := armrelay.NewClientFactory("ffffffff-ffff-ffff-ffff-ffffffffffff", cred, nil)
	if err != nil {
		log.Fatalf("failed to create client: %v", err)
	}
	res, err := clientFactory.NewNamespacesClient().RegenerateKeys(ctx, "resourcegroup", "example-RelayNamespace-01", "example-RelayAuthRules-01", armrelay.RegenerateAccessKeyParameters{
		KeyType: to.Ptr(armrelay.KeyTypePrimaryKey),
	}, 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 = armrelay.NamespacesClientRegenerateKeysResponse{
	// 	AccessKeys: armrelay.AccessKeys{
	// 		KeyName: to.Ptr("example-RelayAuthRules-01"),
	// 		PrimaryConnectionString: to.Ptr("Endpoint=sb://example-Relaynamespace-01.servicebus.windows.net/;SharedAccessKeyName=example-RelayAuthRules-01;SharedAccessKey=############################################"),
	// 		PrimaryKey: to.Ptr("############################################"),
	// 		SecondaryConnectionString: to.Ptr("Endpoint=sb://example-Relaynamespace-01.servicebus.windows.net/;SharedAccessKeyName=example-RelayAuthRules-01;SharedAccessKey=############################################"),
	// 		SecondaryKey: to.Ptr("############################################"),
	// 	},
	// }
}

Output:

Generated from example definition: 2026-01-01/NameSpaces/RelayNameSpaceUpdate.json

package main

import (
	"context"
	"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/relay/armrelay/v2"
	"log"
)

func main() {
	cred, err := azidentity.NewDefaultAzureCredential(nil)
	if err != nil {
		log.Fatalf("failed to obtain a credential: %v", err)
	}
	ctx := context.Background()
	clientFactory, err := armrelay.NewClientFactory("ffffffff-ffff-ffff-ffff-ffffffffffff", cred, nil)
	if err != nil {
		log.Fatalf("failed to create client: %v", err)
	}
	res, err := clientFactory.NewNamespacesClient().Update(ctx, "RG-eg", "example-RelayRelayNamespace-01", armrelay.UpdateParameters{
		Tags: map[string]*string{
			"tag3": to.Ptr("value3"),
			"tag4": to.Ptr("value4"),
			"tag5": to.Ptr("value5"),
			"tag6": to.Ptr("value6"),
		},
		Properties: &armrelay.NamespaceProperties{
			MinimumTLSVersion: to.Ptr(armrelay.TLSVersion13),
		},
	}, 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 = armrelay.NamespacesClientUpdateResponse{
	// 	Namespace: armrelay.Namespace{
	// 		Name: to.Ptr("example-RelayRelayNamespace-01"),
	// 		Type: to.Ptr("Microsoft.Relay/Namespaces"),
	// 		ID: to.Ptr("/subscriptions/ffffffff-ffff-ffff-ffff-ffffffffffff/resourceGroups/RG-eg/providers/Microsoft.Relay/namespaces/example-RelayRelayNamespace-01"),
	// 		Location: to.Ptr("West US"),
	// 		Properties: &armrelay.NamespaceProperties{
	// 			MetricID: to.Ptr("ffffffff-ffff-ffff-ffff-ffffffffffff:example-Relayrelaynamespace-01"),
	// 			ProvisioningState: to.Ptr("Succeeded"),
	// 			MinimumTLSVersion: to.Ptr(armrelay.TLSVersion13),
	// 		},
	// 		Tags: map[string]*string{
	// 			"tag3": to.Ptr("value3"),
	// 			"tag4": to.Ptr("value4"),
	// 			"tag5": to.Ptr("value5"),
	// 			"tag6": to.Ptr("value6"),
	// 		},
	// 	},
	// }
}

Output:

Generated from example definition: 2026-01-01/RelayOperations_List.json

package main

import (
	"context"
	"github.com/Azure/azure-sdk-for-go/sdk/azidentity"
	"github.com/Azure/azure-sdk-for-go/sdk/resourcemanager/relay/armrelay/v2"
	"log"
)

func main() {
	cred, err := azidentity.NewDefaultAzureCredential(nil)
	if err != nil {
		log.Fatalf("failed to obtain a credential: %v", err)
	}
	ctx := context.Background()
	clientFactory, err := armrelay.NewClientFactory("", cred, nil)
	if err != nil {
		log.Fatalf("failed to create client: %v", err)
	}
	pager := clientFactory.NewOperationsClient().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 = armrelay.OperationsClientListResponse{
		// 	OperationListResult: armrelay.OperationListResult{
		// 		Value: []*armrelay.Operation{
		// 			{
		// 				Name: to.Ptr("Microsoft.Relay/checkNameAvailability/action"),
		// 				Display: &armrelay.OperationDisplay{
		// 					Operation: to.Ptr("Get namespace availability."),
		// 					Provider: to.Ptr("Microsoft Azure Relay"),
		// 					Resource: to.Ptr("Non Resource Operation"),
		// 				},
		// 			},
		// 			{
		// 				Name: to.Ptr("Microsoft.Relay/register/action"),
		// 				Display: &armrelay.OperationDisplay{
		// 					Operation: to.Ptr("Registers the Relay Resource Provider"),
		// 					Provider: to.Ptr("Microsoft Azure Relay"),
		// 					Resource: to.Ptr("Relay Resource Provider"),
		// 				},
		// 			},
		// 			{
		// 				Name: to.Ptr("Microsoft.Relay/namespaces/write"),
		// 				Display: &armrelay.OperationDisplay{
		// 					Operation: to.Ptr("Create Or Update Namespace "),
		// 					Provider: to.Ptr("Microsoft Azure Relay"),
		// 					Resource: to.Ptr("Namespace"),
		// 				},
		// 			},
		// 			{
		// 				Name: to.Ptr("Microsoft.Relay/namespaces/read"),
		// 				Display: &armrelay.OperationDisplay{
		// 					Operation: to.Ptr("Get Namespace Resource"),
		// 					Provider: to.Ptr("Microsoft Azure Relay"),
		// 					Resource: to.Ptr("Namespace"),
		// 				},
		// 			},
		// 			{
		// 				Name: to.Ptr("Microsoft.Relay/namespaces/Delete"),
		// 				Display: &armrelay.OperationDisplay{
		// 					Operation: to.Ptr("Delete Namespace"),
		// 					Provider: to.Ptr("Microsoft Azure Relay"),
		// 					Resource: to.Ptr("Namespace"),
		// 				},
		// 			},
		// 			{
		// 				Name: to.Ptr("Microsoft.Relay/namespaces/Relays/write"),
		// 				Display: &armrelay.OperationDisplay{
		// 					Operation: to.Ptr("Create or Update Relay"),
		// 					Provider: to.Ptr("Microsoft Azure Relay"),
		// 					Resource: to.Ptr("Relay"),
		// 				},
		// 			},
		// 			{
		// 				Name: to.Ptr("Microsoft.Relay/namespaces/Relays/read"),
		// 				Display: &armrelay.OperationDisplay{
		// 					Operation: to.Ptr("Get Relay"),
		// 					Provider: to.Ptr("Microsoft Azure Relay"),
		// 					Resource: to.Ptr("Relay"),
		// 				},
		// 			},
		// 			{
		// 				Name: to.Ptr("Microsoft.Relay/namespaces/Relays/Delete"),
		// 				Display: &armrelay.OperationDisplay{
		// 					Operation: to.Ptr("Delete Relay"),
		// 					Provider: to.Ptr("Microsoft Azure Relay"),
		// 					Resource: to.Ptr("Relay"),
		// 				},
		// 			},
		// 			{
		// 				Name: to.Ptr("Microsoft.Relay/namespaces/metricDefinitions/read"),
		// 				Display: &armrelay.OperationDisplay{
		// 					Operation: to.Ptr("Get Namespace metrics"),
		// 					Provider: to.Ptr("Microsoft Azure Relay"),
		// 					Resource: to.Ptr("Namespace metrics"),
		// 				},
		// 			},
		// 			{
		// 				Name: to.Ptr("Microsoft.Relay/namespaces/diagnosticSettings/read"),
		// 				Display: &armrelay.OperationDisplay{
		// 					Operation: to.Ptr("Get Namespace diagnostic settings"),
		// 					Provider: to.Ptr("Microsoft Azure Relay"),
		// 					Resource: to.Ptr("Namespace diagnostic settings"),
		// 				},
		// 			},
		// 			{
		// 				Name: to.Ptr("Microsoft.Relay/namespaces/diagnosticSettings/write"),
		// 				Display: &armrelay.OperationDisplay{
		// 					Operation: to.Ptr("Create or Update Namespace diagnostic settings"),
		// 					Provider: to.Ptr("Microsoft Azure Relay"),
		// 					Resource: to.Ptr("Namespace diagnostic settings"),
		// 				},
		// 			},
		// 			{
		// 				Name: to.Ptr("Microsoft.Relay/namespaces/logDefinitions/read"),
		// 				Display: &armrelay.OperationDisplay{
		// 					Operation: to.Ptr("Get Namespace logs"),
		// 					Provider: to.Ptr("Microsoft Azure Relay"),
		// 					Resource: to.Ptr("Namespace logs"),
		// 				},
		// 			},
		// 		},
		// 	},
		// }
	}
}

Output:

Generated from example definition: 2026-01-01/PrivateEndpointConnections/PrivateEndpointConnectionsDelete.json

package main

import (
	"context"
	"github.com/Azure/azure-sdk-for-go/sdk/azidentity"
	"github.com/Azure/azure-sdk-for-go/sdk/resourcemanager/relay/armrelay/v2"
	"log"
)

func main() {
	cred, err := azidentity.NewDefaultAzureCredential(nil)
	if err != nil {
		log.Fatalf("failed to obtain a credential: %v", err)
	}
	ctx := context.Background()
	clientFactory, err := armrelay.NewClientFactory("ffffffff-ffff-ffff-ffff-ffffffffffff", cred, nil)
	if err != nil {
		log.Fatalf("failed to create client: %v", err)
	}
	poller, err := clientFactory.NewPrivateEndpointConnectionsClient().BeginDelete(ctx, "myResourceGroup", "example-RelayNamespace-5849", "{privateEndpointConnection name}", 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 poll 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 = armrelay.PrivateEndpointConnectionsClientDeleteResponse{
	// }
}

Output:

Generated from example definition: 2026-01-01/PrivateEndpointConnections/PrivateEndpointConnectionsCreate.json

package main

import (
	"context"
	"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/relay/armrelay/v2"
	"log"
)

func main() {
	cred, err := azidentity.NewDefaultAzureCredential(nil)
	if err != nil {
		log.Fatalf("failed to obtain a credential: %v", err)
	}
	ctx := context.Background()
	clientFactory, err := armrelay.NewClientFactory("ffffffff-ffff-ffff-ffff-ffffffffffff", cred, nil)
	if err != nil {
		log.Fatalf("failed to create client: %v", err)
	}
	res, err := clientFactory.NewPrivateEndpointConnectionsClient().CreateOrUpdate(ctx, "resourcegroup", "example-RelayNamespace-5849", "{privateEndpointConnection name}", armrelay.PrivateEndpointConnection{
		Properties: &armrelay.PrivateEndpointConnectionProperties{
			PrivateEndpoint: &armrelay.PrivateEndpoint{
				ID: to.Ptr("/subscriptions/ffffffff-ffff-ffff-ffff-ffffffffffff/resourceGroups/resourcegroup/providers/Microsoft.Network/privateEndpoints/ali-relay-pve-1"),
			},
			PrivateLinkServiceConnectionState: &armrelay.ConnectionState{
				Description: to.Ptr("You may pass"),
				Status:      to.Ptr(armrelay.PrivateLinkConnectionStatusApproved),
			},
		},
	}, 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 = armrelay.PrivateEndpointConnectionsClientCreateOrUpdateResponse{
	// 	PrivateEndpointConnection: armrelay.PrivateEndpointConnection{
	// 		Name: to.Ptr("{privateEndpointConnection name}"),
	// 		Type: to.Ptr("Microsoft.Relay/Namespaces/PrivateEndpointConnections"),
	// 		ID: to.Ptr("/subscriptions/ffffffff-ffff-ffff-ffff-ffffffffffff/resourceGroups/alitest/providers/Microsoft.Relay/namespaces/relay-private-endpoint-test/privateEndpointConnections/{privateEndpointConnection name}"),
	// 		Location: to.Ptr("South Central US"),
	// 		Properties: &armrelay.PrivateEndpointConnectionProperties{
	// 			PrivateEndpoint: &armrelay.PrivateEndpoint{
	// 				ID: to.Ptr("/subscriptions/ffffffff-ffff-ffff-ffff-ffffffffffff/resourceGroups/resourcegroup/providers/Microsoft.Network/privateEndpoints/ali-relay-pve-1"),
	// 			},
	// 			PrivateLinkServiceConnectionState: &armrelay.ConnectionState{
	// 				Description: to.Ptr("You may pass"),
	// 				Status: to.Ptr(armrelay.PrivateLinkConnectionStatusApproved),
	// 			},
	// 			ProvisioningState: to.Ptr(armrelay.EndPointProvisioningStateUpdating),
	// 		},
	// 	},
	// }
}

Output:

Generated from example definition: 2026-01-01/PrivateEndpointConnections/PrivateEndpointConnectionsGet.json

package main

import (
	"context"
	"github.com/Azure/azure-sdk-for-go/sdk/azidentity"
	"github.com/Azure/azure-sdk-for-go/sdk/resourcemanager/relay/armrelay/v2"
	"log"
)

func main() {
	cred, err := azidentity.NewDefaultAzureCredential(nil)
	if err != nil {
		log.Fatalf("failed to obtain a credential: %v", err)
	}
	ctx := context.Background()
	clientFactory, err := armrelay.NewClientFactory("ffffffff-ffff-ffff-ffff-ffffffffffff", cred, nil)
	if err != nil {
		log.Fatalf("failed to create client: %v", err)
	}
	res, err := clientFactory.NewPrivateEndpointConnectionsClient().Get(ctx, "myResourceGroup", "example-RelayNamespace-5849", "{privateEndpointConnection name}", 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 = armrelay.PrivateEndpointConnectionsClientGetResponse{
	// 	PrivateEndpointConnection: armrelay.PrivateEndpointConnection{
	// 		Name: to.Ptr("{privateEndpointConnection name}"),
	// 		Type: to.Ptr("Microsoft.Relay/Namespaces/PrivateEndpointConnections"),
	// 		ID: to.Ptr("/subscriptions/ffffffff-ffff-ffff-ffff-ffffffffffff/resourceGroups/{RGName}/providers/Microsoft.Relay/namespaces/relay-private-endpoint-test/privateEndpointConnections/{privateEndpointConnection name}"),
	// 		Location: to.Ptr("South Central US"),
	// 		Properties: &armrelay.PrivateEndpointConnectionProperties{
	// 			PrivateEndpoint: &armrelay.PrivateEndpoint{
	// 				ID: to.Ptr("/subscriptions/326100e2-f69d-4268-8503-075374f62b6e/resourceGroups/resourcegroup/providers/Microsoft.Network/privateEndpoints/ali-relay-pve-1"),
	// 			},
	// 			PrivateLinkServiceConnectionState: &armrelay.ConnectionState{
	// 				Description: to.Ptr("approve please"),
	// 				Status: to.Ptr(armrelay.PrivateLinkConnectionStatusPending),
	// 			},
	// 			ProvisioningState: to.Ptr(armrelay.EndPointProvisioningStateSucceeded),
	// 		},
	// 	},
	// }
}

Output:

Generated from example definition: 2026-01-01/PrivateEndpointConnections/PrivateEndpointConnectionsList.json

package main

import (
	"context"
	"github.com/Azure/azure-sdk-for-go/sdk/azidentity"
	"github.com/Azure/azure-sdk-for-go/sdk/resourcemanager/relay/armrelay/v2"
	"log"
)

func main() {
	cred, err := azidentity.NewDefaultAzureCredential(nil)
	if err != nil {
		log.Fatalf("failed to obtain a credential: %v", err)
	}
	ctx := context.Background()
	clientFactory, err := armrelay.NewClientFactory("ffffffff-ffff-ffff-ffff-ffffffffffff", cred, nil)
	if err != nil {
		log.Fatalf("failed to create client: %v", err)
	}
	pager := clientFactory.NewPrivateEndpointConnectionsClient().NewListPager("myResourceGroup", "example-RelayNamespace-5849", 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 = armrelay.PrivateEndpointConnectionsClientListResponse{
		// 	PrivateEndpointConnectionListResult: armrelay.PrivateEndpointConnectionListResult{
		// 		Value: []*armrelay.PrivateEndpointConnection{
		// 			{
		// 				Name: to.Ptr("{privateEndpointConnection name}"),
		// 				Type: to.Ptr("Microsoft.Relay/Namespaces/PrivateEndpointConnections"),
		// 				ID: to.Ptr("/subscriptions/ffffffff-ffff-ffff-ffff-ffffffffffff/resourceGroups/alitest/providers/Microsoft.Relay/namespaces/relay-private-endpoint-test/privateEndpointConnections/{privateEndpointConnection name}"),
		// 				Location: to.Ptr("South Central US"),
		// 				Properties: &armrelay.PrivateEndpointConnectionProperties{
		// 					PrivateEndpoint: &armrelay.PrivateEndpoint{
		// 						ID: to.Ptr("/subscriptions/ffffffff-ffff-ffff-ffff-ffffffffffff/resourceGroups/resourcegroup/providers/Microsoft.Network/privateEndpoints/ali-relay-pve-1"),
		// 					},
		// 					PrivateLinkServiceConnectionState: &armrelay.ConnectionState{
		// 						Description: to.Ptr("approve please"),
		// 						Status: to.Ptr(armrelay.PrivateLinkConnectionStatusPending),
		// 					},
		// 					ProvisioningState: to.Ptr(armrelay.EndPointProvisioningStateSucceeded),
		// 				},
		// 			},
		// 		},
		// 	},
		// }
	}
}

Output:

Generated from example definition: 2026-01-01/PrivateEndpointConnections/PrivateLinkResourcesGet.json

package main

import (
	"context"
	"github.com/Azure/azure-sdk-for-go/sdk/azidentity"
	"github.com/Azure/azure-sdk-for-go/sdk/resourcemanager/relay/armrelay/v2"
	"log"
)

func main() {
	cred, err := azidentity.NewDefaultAzureCredential(nil)
	if err != nil {
		log.Fatalf("failed to obtain a credential: %v", err)
	}
	ctx := context.Background()
	clientFactory, err := armrelay.NewClientFactory("ffffffff-ffff-ffff-ffff-ffffffffffff", cred, nil)
	if err != nil {
		log.Fatalf("failed to create client: %v", err)
	}
	res, err := clientFactory.NewPrivateLinkResourcesClient().Get(ctx, "resourcegroup", "example-RelayNamespace-5849", "{PrivateLinkResource name}", 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 = armrelay.PrivateLinkResourcesClientGetResponse{
	// 	PrivateLinkResource: armrelay.PrivateLinkResource{
	// 		Name: to.Ptr("namespace"),
	// 		Type: to.Ptr("Microsoft.Relay/namespaces/privateLinkResources"),
	// 		ID: to.Ptr("subscriptions/dbedb4e0-40e6-4145-81f3-f1314c150774/resourceGroups/alitest/providers/Microsoft.Relay/namespaces/relay-private-endpoint-test/privateLinkResources/namespace"),
	// 		Properties: &armrelay.PrivateLinkResourceProperties{
	// 			GroupID: to.Ptr("namespace"),
	// 			RequiredMembers: []*string{
	// 				to.Ptr("namespace"),
	// 			},
	// 			RequiredZoneNames: []*string{
	// 				to.Ptr("privatelink.servicebus.windows.net"),
	// 			},
	// 		},
	// 	},
	// }
}

Output:

Generated from example definition: 2026-01-01/PrivateEndpointConnections/PrivateLinkResourcesList.json

package main

import (
	"context"
	"github.com/Azure/azure-sdk-for-go/sdk/azidentity"
	"github.com/Azure/azure-sdk-for-go/sdk/resourcemanager/relay/armrelay/v2"
	"log"
)

func main() {
	cred, err := azidentity.NewDefaultAzureCredential(nil)
	if err != nil {
		log.Fatalf("failed to obtain a credential: %v", err)
	}
	ctx := context.Background()
	clientFactory, err := armrelay.NewClientFactory("ffffffff-ffff-ffff-ffff-ffffffffffff", cred, nil)
	if err != nil {
		log.Fatalf("failed to create client: %v", err)
	}
	res, err := clientFactory.NewPrivateLinkResourcesClient().List(ctx, "resourcegroup", "example-RelayNamespace-5849", 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 = armrelay.PrivateLinkResourcesClientListResponse{
	// 	PrivateLinkResourcesListResult: armrelay.PrivateLinkResourcesListResult{
	// 		Value: []*armrelay.PrivateLinkResource{
	// 			{
	// 				Name: to.Ptr("namespace"),
	// 				Type: to.Ptr("Microsoft.Relay/namespaces/privateLinkResources"),
	// 				ID: to.Ptr("subscriptions/dbedb4e0-40e6-4145-81f3-f1314c150774/resourceGroups/alitest/providers/Microsoft.Relay/namespaces/relay-private-endpoint-test/privateLinkResources/namespace"),
	// 				Properties: &armrelay.PrivateLinkResourceProperties{
	// 					GroupID: to.Ptr("namespace"),
	// 					RequiredMembers: []*string{
	// 						to.Ptr("namespace"),
	// 					},
	// 					RequiredZoneNames: []*string{
	// 						to.Ptr("privatelink.servicebus.windows.net"),
	// 					},
	// 				},
	// 			},
	// 		},
	// 	},
	// }
}

Output:

Generated from example definition: 2026-01-01/Relay/RelayCreate.json

package main

import (
	"context"
	"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/relay/armrelay/v2"
	"log"
)

func main() {
	cred, err := azidentity.NewDefaultAzureCredential(nil)
	if err != nil {
		log.Fatalf("failed to obtain a credential: %v", err)
	}
	ctx := context.Background()
	clientFactory, err := armrelay.NewClientFactory("ffffffff-ffff-ffff-ffff-ffffffffffff", cred, nil)
	if err != nil {
		log.Fatalf("failed to create client: %v", err)
	}
	res, err := clientFactory.NewWCFRelaysClient().CreateOrUpdate(ctx, "resourcegroup", "example-RelayNamespace-9953", "example-Relay-Wcf-1194", armrelay.WcfRelay{
		Properties: &armrelay.WcfRelayProperties{
			RelayType:                   to.Ptr(armrelay.RelaytypeNetTCP),
			RequiresClientAuthorization: to.Ptr(true),
			RequiresTransportSecurity:   to.Ptr(true),
		},
	}, 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 = armrelay.WCFRelaysClientCreateOrUpdateResponse{
	// 	WcfRelay: armrelay.WcfRelay{
	// 		Name: to.Ptr("example-Relay-Wcf-1194"),
	// 		Type: to.Ptr("Microsoft.Relay/WcfRelays"),
	// 		ID: to.Ptr("/subscriptions/ffffffff-ffff-ffff-ffff-ffffffffffff/resourceGroups/resourcegroup/providers/Microsoft.Relay/namespaces/example-RelayNamespace-9953/WcfRelays/example-Relay-Wcf-1194"),
	// 		Properties: &armrelay.WcfRelayProperties{
	// 			CreatedAt: to.Ptr(time.Date(2017, time.March, 16, 0, 26, 17, 501466100, time.UTC)),
	// 			IsDynamic: to.Ptr(false),
	// 			RelayType: to.Ptr(armrelay.RelaytypeNetTCP),
	// 			RequiresClientAuthorization: to.Ptr(true),
	// 			RequiresTransportSecurity: to.Ptr(true),
	// 			UpdatedAt: to.Ptr(time.Date(2017, time.March, 16, 0, 26, 17, 501466100, time.UTC)),
	// 		},
	// 	},
	// }
}

Output:

Generated from example definition: 2026-01-01/Relay/RelayAuthorizationRuleCreate.json

package main

import (
	"context"
	"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/relay/armrelay/v2"
	"log"
)

func main() {
	cred, err := azidentity.NewDefaultAzureCredential(nil)
	if err != nil {
		log.Fatalf("failed to obtain a credential: %v", err)
	}
	ctx := context.Background()
	clientFactory, err := armrelay.NewClientFactory("ffffffff-ffff-ffff-ffff-ffffffffffff", cred, nil)
	if err != nil {
		log.Fatalf("failed to create client: %v", err)
	}
	res, err := clientFactory.NewWCFRelaysClient().CreateOrUpdateAuthorizationRule(ctx, "resourcegroup", "example-RelayNamespace-01", "example-Relay-wcf-01", "example-RelayAuthRules-01", armrelay.AuthorizationRule{
		Properties: &armrelay.AuthorizationRuleProperties{
			Rights: []*armrelay.AccessRights{
				to.Ptr(armrelay.AccessRightsListen),
				to.Ptr(armrelay.AccessRightsSend),
			},
		},
	}, 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 = armrelay.WCFRelaysClientCreateOrUpdateAuthorizationRuleResponse{
	// 	AuthorizationRule: armrelay.AuthorizationRule{
	// 		Name: to.Ptr("example-RelayAuthRules-01"),
	// 		Type: to.Ptr("Microsoft.Relay/Namespaces/WcfRelay/AuthorizationRules"),
	// 		ID: to.Ptr("/subscriptions/ffffffff-ffff-ffff-ffff-ffffffffffff/resourceGroups/resourcegroup/providers/Microsoft.Relay/namespaces/example-RelayNamespace-01/WcfRelays/example-Relay-Wcf-01/AuthorizationRules/example-RelayAuthRules-01"),
	// 		Properties: &armrelay.AuthorizationRuleProperties{
	// 			Rights: []*armrelay.AccessRights{
	// 				to.Ptr(armrelay.AccessRightsListen),
	// 				to.Ptr(armrelay.AccessRightsSend),
	// 			},
	// 		},
	// 	},
	// }
}

Output:

Generated from example definition: 2026-01-01/Relay/RelayDelete.json

package main

import (
	"context"
	"github.com/Azure/azure-sdk-for-go/sdk/azidentity"
	"github.com/Azure/azure-sdk-for-go/sdk/resourcemanager/relay/armrelay/v2"
	"log"
)

func main() {
	cred, err := azidentity.NewDefaultAzureCredential(nil)
	if err != nil {
		log.Fatalf("failed to obtain a credential: %v", err)
	}
	ctx := context.Background()
	clientFactory, err := armrelay.NewClientFactory("ffffffff-ffff-ffff-ffff-ffffffffffff", cred, nil)
	if err != nil {
		log.Fatalf("failed to create client: %v", err)
	}
	res, err := clientFactory.NewWCFRelaysClient().Delete(ctx, "resourcegroup", "example-RelayNamespace-01", "example-Relay-wcf-01", 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 = armrelay.WCFRelaysClientDeleteResponse{
	// }
}

Output:

Generated from example definition: 2026-01-01/Relay/RelayAuthorizationRuleDelete.json

package main

import (
	"context"
	"github.com/Azure/azure-sdk-for-go/sdk/azidentity"
	"github.com/Azure/azure-sdk-for-go/sdk/resourcemanager/relay/armrelay/v2"
	"log"
)

func main() {
	cred, err := azidentity.NewDefaultAzureCredential(nil)
	if err != nil {
		log.Fatalf("failed to obtain a credential: %v", err)
	}
	ctx := context.Background()
	clientFactory, err := armrelay.NewClientFactory("ffffffff-ffff-ffff-ffff-ffffffffffff", cred, nil)
	if err != nil {
		log.Fatalf("failed to create client: %v", err)
	}
	res, err := clientFactory.NewWCFRelaysClient().DeleteAuthorizationRule(ctx, "resourcegroup", "example-RelayNamespace-01", "example-Relay-wcf-01", "example-RelayAuthRules-01", 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 = armrelay.WCFRelaysClientDeleteAuthorizationRuleResponse{
	// }
}

Output:

Generated from example definition: 2026-01-01/Relay/RelayGet.json

package main

import (
	"context"
	"github.com/Azure/azure-sdk-for-go/sdk/azidentity"
	"github.com/Azure/azure-sdk-for-go/sdk/resourcemanager/relay/armrelay/v2"
	"log"
)

func main() {
	cred, err := azidentity.NewDefaultAzureCredential(nil)
	if err != nil {
		log.Fatalf("failed to obtain a credential: %v", err)
	}
	ctx := context.Background()
	clientFactory, err := armrelay.NewClientFactory("ffffffff-ffff-ffff-ffff-ffffffffffff", cred, nil)
	if err != nil {
		log.Fatalf("failed to create client: %v", err)
	}
	res, err := clientFactory.NewWCFRelaysClient().Get(ctx, "resourcegroup", "example-RelayNamespace-9953", "example-Relay-Wcf-1194", 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 = armrelay.WCFRelaysClientGetResponse{
	// 	WcfRelay: armrelay.WcfRelay{
	// 		Name: to.Ptr("example-Relay-Wcf-1194"),
	// 		Type: to.Ptr("Microsoft.Relay/WcfRelays"),
	// 		ID: to.Ptr("/subscriptions/ffffffff-ffff-ffff-ffff-ffffffffffff/resourceGroups/Default-ServiceBus-WestUS/providers/Microsoft.Relay/namespaces/example-RelayNamespace-9953/WcfRelays/example-Relay-Wcf-1194"),
	// 		Properties: &armrelay.WcfRelayProperties{
	// 			CreatedAt: to.Ptr(time.Date(2017, time.March, 16, 0, 26, 17, 501466100, time.UTC)),
	// 			IsDynamic: to.Ptr(false),
	// 			ListenerCount: to.Ptr[int32](0),
	// 			RelayType: to.Ptr(armrelay.RelaytypeNetTCP),
	// 			RequiresClientAuthorization: to.Ptr(true),
	// 			RequiresTransportSecurity: to.Ptr(true),
	// 			UpdatedAt: to.Ptr(time.Date(2017, time.March, 16, 0, 26, 17, 501466100, time.UTC)),
	// 		},
	// 	},
	// }
}

Output:

Generated from example definition: 2026-01-01/Relay/RelayAuthorizationRuleGet.json

package main

import (
	"context"
	"github.com/Azure/azure-sdk-for-go/sdk/azidentity"
	"github.com/Azure/azure-sdk-for-go/sdk/resourcemanager/relay/armrelay/v2"
	"log"
)

func main() {
	cred, err := azidentity.NewDefaultAzureCredential(nil)
	if err != nil {
		log.Fatalf("failed to obtain a credential: %v", err)
	}
	ctx := context.Background()
	clientFactory, err := armrelay.NewClientFactory("ffffffff-ffff-ffff-ffff-ffffffffffff", cred, nil)
	if err != nil {
		log.Fatalf("failed to create client: %v", err)
	}
	res, err := clientFactory.NewWCFRelaysClient().GetAuthorizationRule(ctx, "resourcegroup", "example-RelayNamespace-01", "example-Relay-wcf-01", "example-RelayAuthRules-01", 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 = armrelay.WCFRelaysClientGetAuthorizationRuleResponse{
	// 	AuthorizationRule: armrelay.AuthorizationRule{
	// 		Name: to.Ptr("example-RelayAuthRules-01"),
	// 		Type: to.Ptr("Microsoft.Relay/Namespaces/WcfRelay/AuthorizationRules"),
	// 		ID: to.Ptr("/subscriptions/ffffffff-ffff-ffff-ffff-ffffffffffff/resourceGroups/resourcegroup/providers/Microsoft.Relay/namespaces/example-RelayNamespace-01/WcfRelays/example-Relay-Wcf-01/AuthorizationRules/example-RelayAuthRules-01"),
	// 		Properties: &armrelay.AuthorizationRuleProperties{
	// 			Rights: []*armrelay.AccessRights{
	// 				to.Ptr(armrelay.AccessRightsListen),
	// 			},
	// 		},
	// 	},
	// }
}

Output:

Generated from example definition: 2026-01-01/Relay/RelayAuthorizationRuleListKey.json

package main

import (
	"context"
	"github.com/Azure/azure-sdk-for-go/sdk/azidentity"
	"github.com/Azure/azure-sdk-for-go/sdk/resourcemanager/relay/armrelay/v2"
	"log"
)

func main() {
	cred, err := azidentity.NewDefaultAzureCredential(nil)
	if err != nil {
		log.Fatalf("failed to obtain a credential: %v", err)
	}
	ctx := context.Background()
	clientFactory, err := armrelay.NewClientFactory("ffffffff-ffff-ffff-ffff-ffffffffffff", cred, nil)
	if err != nil {
		log.Fatalf("failed to create client: %v", err)
	}
	res, err := clientFactory.NewWCFRelaysClient().ListKeys(ctx, "resourcegroup", "example-RelayNamespace-01", "example-Relay-wcf-01", "example-RelayAuthRules-01", 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 = armrelay.WCFRelaysClientListKeysResponse{
	// 	AccessKeys: armrelay.AccessKeys{
	// 		KeyName: to.Ptr("example-RelayAuthRules-01"),
	// 		PrimaryConnectionString: to.Ptr("Endpoint=sb://example-Relaynamespace-01.servicebus.windows.net/;SharedAccessKeyName=example-RelayAuthRules-01;SharedAccessKey=############################################"),
	// 		PrimaryKey: to.Ptr("############################################"),
	// 		SecondaryConnectionString: to.Ptr("Endpoint=sb://example-Relaynamespace-01.servicebus.windows.net/;SharedAccessKeyName=example-RelayAuthRules-01;SharedAccessKey=############################################"),
	// 		SecondaryKey: to.Ptr("############################################"),
	// 	},
	// }
}

Output:

Generated from example definition: 2026-01-01/Relay/RelayAuthorizationRuleListAll.json

package main

import (
	"context"
	"github.com/Azure/azure-sdk-for-go/sdk/azidentity"
	"github.com/Azure/azure-sdk-for-go/sdk/resourcemanager/relay/armrelay/v2"
	"log"
)

func main() {
	cred, err := azidentity.NewDefaultAzureCredential(nil)
	if err != nil {
		log.Fatalf("failed to obtain a credential: %v", err)
	}
	ctx := context.Background()
	clientFactory, err := armrelay.NewClientFactory("ffffffff-ffff-ffff-ffff-ffffffffffff", cred, nil)
	if err != nil {
		log.Fatalf("failed to create client: %v", err)
	}
	pager := clientFactory.NewWCFRelaysClient().NewListAuthorizationRulesPager("resourcegroup", "example-RelayNamespace-01", "example-Relay-Wcf-01", 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 = armrelay.WCFRelaysClientListAuthorizationRulesResponse{
		// 	AuthorizationRuleListResult: armrelay.AuthorizationRuleListResult{
		// 		Value: []*armrelay.AuthorizationRule{
		// 			{
		// 				Name: to.Ptr("example-RelayAuthRules-01"),
		// 				Type: to.Ptr("Microsoft.Relay/Namespaces/WcfRelay/AuthorizationRules"),
		// 				ID: to.Ptr("/subscriptions/ffffffff-ffff-ffff-ffff-ffffffffffff/resourceGroups/resourcegroup/providers/Microsoft.Relay/namespaces/example-RelayNamespace-01/WcfRelays/example-Relay-Wcf-01/AuthorizationRules/example-RelayAuthRules-01"),
		// 				Properties: &armrelay.AuthorizationRuleProperties{
		// 					Rights: []*armrelay.AccessRights{
		// 						to.Ptr(armrelay.AccessRightsListen),
		// 						to.Ptr(armrelay.AccessRightsSend),
		// 					},
		// 				},
		// 			},
		// 		},
		// 	},
		// }
	}
}

Output:

Generated from example definition: 2026-01-01/Relay/RelayListAll.json

package main

import (
	"context"
	"github.com/Azure/azure-sdk-for-go/sdk/azidentity"
	"github.com/Azure/azure-sdk-for-go/sdk/resourcemanager/relay/armrelay/v2"
	"log"
)

func main() {
	cred, err := azidentity.NewDefaultAzureCredential(nil)
	if err != nil {
		log.Fatalf("failed to obtain a credential: %v", err)
	}
	ctx := context.Background()
	clientFactory, err := armrelay.NewClientFactory("ffffffff-ffff-ffff-ffff-ffffffffffff", cred, nil)
	if err != nil {
		log.Fatalf("failed to create client: %v", err)
	}
	pager := clientFactory.NewWCFRelaysClient().NewListByNamespacePager("resourcegroup", "example-RelayNamespace-01", 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 = armrelay.WCFRelaysClientListByNamespaceResponse{
		// 	WcfRelaysListResult: armrelay.WcfRelaysListResult{
		// 		Value: []*armrelay.WcfRelay{
		// 			{
		// 				Name: to.Ptr("example-Relay-Wcf-01"),
		// 				Type: to.Ptr("Microsoft.Relay/Namespaces/WcfRelays"),
		// 				ID: to.Ptr("/subscriptions/ffffffff-ffff-ffff-ffff-ffffffffffff/resourceGroups/RG1-eg/providers/Microsoft.Relay/namespaces/example-RelayNamespace-01/WcfRelays/example-Relay-Wcf-01"),
		// 				Properties: &armrelay.WcfRelayProperties{
		// 					CreatedAt: to.Ptr(time.Date(2017, time.January, 24, 0, 46, 27, 4998300, time.UTC)),
		// 					IsDynamic: to.Ptr(false),
		// 					RelayType: to.Ptr(armrelay.RelaytypeNetTCP),
		// 					RequiresClientAuthorization: to.Ptr(true),
		// 					RequiresTransportSecurity: to.Ptr(true),
		// 					UpdatedAt: to.Ptr(time.Date(2017, time.January, 24, 0, 46, 27, 4998300, time.UTC)),
		// 					UserMetadata: to.Ptr("usermetadata is a placeholder to store user-defined string data for the HybridConnection endpoint.e.g. it can be used to store  descriptive data, such as list of teams and their contact information also user-defined configuration settings can be stored"),
		// 				},
		// 			},
		// 		},
		// 	},
		// }
	}
}

Output:

Generated from example definition: 2026-01-01/Relay/RelayAuthorizationRuleRegenerateKey.json

package main

import (
	"context"
	"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/relay/armrelay/v2"
	"log"
)

func main() {
	cred, err := azidentity.NewDefaultAzureCredential(nil)
	if err != nil {
		log.Fatalf("failed to obtain a credential: %v", err)
	}
	ctx := context.Background()
	clientFactory, err := armrelay.NewClientFactory("ffffffff-ffff-ffff-ffff-ffffffffffff", cred, nil)
	if err != nil {
		log.Fatalf("failed to create client: %v", err)
	}
	res, err := clientFactory.NewWCFRelaysClient().RegenerateKeys(ctx, "resourcegroup", "example-RelayNamespace-01", "example-Relay-wcf-01", "example-RelayAuthRules-01", armrelay.RegenerateAccessKeyParameters{
		KeyType: to.Ptr(armrelay.KeyTypePrimaryKey),
	}, 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 = armrelay.WCFRelaysClientRegenerateKeysResponse{
	// 	AccessKeys: armrelay.AccessKeys{
	// 		KeyName: to.Ptr("example-RelayAuthRules-01"),
	// 		PrimaryConnectionString: to.Ptr("Endpoint=sb://example-Relaynamespace-01.servicebus.windows.net/;SharedAccessKeyName=example-RelayAuthRules-01;SharedAccessKey=############################################"),
	// 		PrimaryKey: to.Ptr("############################################"),
	// 		SecondaryConnectionString: to.Ptr("Endpoint=sb://example-Relaynamespace-01.servicebus.windows.net/;SharedAccessKeyName=example-RelayAuthRules-01;SharedAccessKey=############################################"),
	// 		SecondaryKey: to.Ptr("############################################"),
	// 	},
	// }
}

Output: