Update public docs with latest sdk changes

Author: cparisineti

articles/communication-services/how-tos/router-sdk/azure-function.md

@@ -64,9 +64,12 @@ public static class GetPriority
 Inspect your deployed function in the Azure portal and locate the function Uri and authentication key. Then use the SDK to configure a policy that uses a rule engine to point to that function.
 
 ```csharp
-await client.SetClassificationPolicyAsync(
-    "policy-1", 
-    prioritizationRule: new AzureFunctionRule("<insert function uri>", new AzureFunctionRuleCredential("<insert function key>")));
+await client.CreateClassificationPolicyAsync(
+    options: new CreateClassificationPolicyOptions("policy-1")
+    {
+        PrioritizationRule = new AzureFunctionRule("<insert function uri>", new AzureFunctionRuleCredential("<insert function key>"))
+    }
+);
 ```
 
 When a new job is submitted or updated, this function will be called to determine the priority of the job.

articles/communication-services/how-tos/router-sdk/manage-queue.md

@@ -29,28 +29,39 @@ This guide outlines the steps to create and manage a Job Router queue.
 To create a simple queue in Job Router, use the SDK to specify the **queue ID**, **name**, and a **distribution policy ID**. The distribution policy must be created in advance as the Job Router will validate its existence upon creation of the queue. In the following example, a distribution policy is created to control how Job offers are generated for Workers.
 
 ```csharp
-var distributionPolicy = await client.SetDistributionPolicyAsync(
-    id: "Longest_Idle_45s_Min1Max10",
-    name: "Longest Idle matching with a 45s offer expiration; min 1, max 10 offers",
-    offerTTL: TimeSpan.FromSeconds(45),
-    mode: new LongestIdleMode(
-        minConcurrentOffers: 1,
-        maxConcurrentOffers: 10)
+var distributionPolicy = await administrationClient.CreateDistributionPolicyAsync(
+    new CreateDistributionPolicyOptions(
+        distributionPolicyId: "Longest_Idle_45s_Min1Max10",
+        offerTtl: TimeSpan.FromSeconds(45),
+        mode: new LongestIdleMode(
+            minConcurrentOffers: 1,
+            maxConcurrentOffers: 10)
+    {
+        Name = ""Longest Idle matching with a 45s offer expiration; min 1, max 10 offers"
+    }
 );
 
-var queue = await client.SetQueueAsync(
-    id: "XBOX_DEFAULT_QUEUE",
-    name: "XBOX Default Queue",
-    distributionPolicy: "Longest_Idle_45s_Min1Max10"
+var queue = await administrationClient.CreateQueue(
+    options: new CreateQueueOptions("XBOX_DEFAULT_QUEUE", "Longest_Idle_45s_Min1Max10")
+    {
+        Name = "XBOX Default Queue"
+    }
 );
 ```
 ## Update a queue
 
-The Job Router SDK will create a new queue or update an existing queue when the `SetQueue` or `SetQueueAsync` method is called.
+The Job Router SDK will update an existing queue when the `UpdateQueue` or `UpdateQueueAsync` method is called.
 
 ```csharp
-var queue = await client.SetQueueAsync(
-    id: "XBOX_DEFAULT_QUEUE",
+var queue = await administrationClient.UpdateQueueAsync(
+    options: new UpdateQueueOptions("XBOX_DEFAULT_QUEUE")
+    {
+        Labels = new Dictionary<string, LabelValue>()
+        {
+            ["Additional-Queue-Label"] = new LabelValue("ChatQueue")
+        }
+    });
+    id: "",
     name: "XBOX Default Queue",
     distributionPolicy: "Longest_Idle_45s_Min1Max10"
 );

articles/communication-services/quickstarts/router/get-started-router.md

@@ -62,26 +62,30 @@ static async Task Main(string[] args)
 }
 ```
 
-## Authenticate the Job Router client
+## Authenticate the Job Router clients
 
 Job Router clients can be authenticated using your connection string acquired from an Azure Communication Services resource in the Azure portal.
 
 ```csharp
 // Get a connection string to our Azure Communication Services resource.
 var connectionString = "your_connection_string";
-var client = new RouterClient(connectionString);
+var routerClient = new RouterClient(connectionString);
+var routerAdministrationClient = new RouterAdministrationClient(connectionString);
 ```
 
 ## Create a distribution policy
 
 Job Router uses a distribution policy to decide how Workers will be notified of available Jobs and the time to live for the notifications, known as **Offers**. Create the policy by specifying the **ID**, a **name**, an **offerTTL**, and a distribution **mode**.
 
 ```csharp
-var distributionPolicy = await routerClient.SetDistributionPolicyAsync(
-    id: "distribution-policy-1",
-    name: "My Distribution Policy",
-    offerTTL: TimeSpan.FromSeconds(30),
-    mode: new LongestIdleMode()
+var distributionPolicy = await routerAdministrationClient.CreateDistributionPolicyAsync(
+    new CreateDistributionPolicyOptions(
+        distributionPolicyId: "distribution-policy-1",
+        offerTtl: TimeSpan.FromMinutes(1),
+        mode: new LongestIdleMode())
+    {
+        Name = "My distribution policy"
+    }
 );
 ```
 
@@ -90,10 +94,11 @@ var distributionPolicy = await routerClient.SetDistributionPolicyAsync(
 Create the Queue by specifying an **ID**, **name**, and provide the **Distribution Policy** object's ID you created above.
 
 ```csharp
-var queue = await routerClient.SetQueueAsync(
-    id: "queue-1",
-    name: "My Queue",
-    distributionPolicyId: distributionPolicy.Value.Id
+var queue = await routerAdministrationClient.CreateQueueAsync(
+    options: new CreateQueueOptions("queue-1", distributionPolicy.Value.Id)
+    {
+        Name = "My job queue"
+    }
 );
 ```
 
@@ -103,34 +108,45 @@ Now, we can submit a job directly to that queue, with a worker selector the requ
 
 ```csharp
 var job = await routerClient.CreateJobAsync(
-    channelId: "my-channel",
-    queueId: queue.Value.Id,
-    priority: 1,
-    workerSelectors: new List<LabelSelector>
+    options: new CreateJobOptions(
+            jobId: jobId,
+            channelId: "my-channel",
+            queueId: queue.Value.Id) // this is optional
     {
-        new LabelSelector(
-            key: "Some-Skill", 
-            @operator: LabelOperator.GreaterThan, 
-            value: 10)
-    });
+        Priority = 1,
+        RequestedWorkerSelectors = new List<WorkerSelector>
+        {
+            new WorkerSelector(
+                key: "Some-Skill", 
+                labelOperator: LabelOperator.GreaterThan, 
+                value: 10)
+        }
+    }
+);
 ```
 
-## Register a worker
+## Create a worker
 
-Now, we register a worker to receive work from that queue, with a label of `Some-Skill` equal to 11 and capacity on `my-channel`.
+Now, we create a worker to receive work from that queue, with a label of `Some-Skill` equal to 11 and capacity on `my-channel`.
 
 ```csharp
-var worker = await routerClient.RegisterWorkerAsync(
-    id: "worker-1",
-    queueIds: new[] { queue.Value.Id },
-    totalCapacity: 1,
-    labels: new LabelCollection()
-    {
-        ["Some-Skill"] = 11
-    },
-    channelConfigurations: new List<ChannelConfiguration>
+var worker = await routerClient.CreateWorkerAsync(
+    new CreateWorkerOptions(
+        workerId: "worker-1",
+        totalCapacity: 1)
     {
-        new ChannelConfiguration("my-channel", 1)
+        QueueIds = new Dictionary<string, QueueAssignment>()
+        {
+            [queue.Value.Id] = new QueueAssignment()
+        },
+        ChannelConfigurations = new Dictionary<string, ChannelConfiguration>()
+        {
+            ["my-channel"] = new ChannelConfiguration(1)
+        },
+        Labels = new Dictionary<string, LabelValue>()
+        {
+            ["Some-Skill"] = new LabelValue(11)
+        }
     }
 );
 ```