resp, _ := userApiService.ListUsers(ctx, &v1.ListUsersRequest{
  Filter: &common.Filter{
    Operator: common.LogicalOperator_LOGICAL_OPERATOR_UNSPECIFIED,
    Filters: []*common.FilterItem{
      &common.FilterItem{
        Field: "FIELD1",
        Operator: common.FilterItem_FILTER_OPERATOR_UNSPECIFIED,
        Value: &common.FilterItem_StrValue{
          StrValue:"STRINGVAL",
        },
      },
      &common.FilterItem{
        Field: "FIELD2",
        Operator: common.FilterItem_FILTER_OPERATOR_UNSPECIFIED,
        Value: &common.FilterItem_IntValue{
          IntValue:10,
        },
      },
      &common.FilterItem{
        Field: "FIELD3",
        Operator: common.FilterItem_FILTER_OPERATOR_UNSPECIFIED,
        Value: &common.FilterItem_BoolValue{
          BoolValue:false,
        },
      },
    },
  },
  Page: 0,
  PageSize: 100,
  SortBy: &common.SortBy{
    Items: []*common.SortItem{
      &common.SortItem{
        Direction: common.SortDirection_SORT_DIRECTION_UNSPECIFIED,
        Field: "FIELD1",
      },
      &common.SortItem{
        Direction: common.SortDirection_SORT_DIRECTION_UNSPECIFIED,
        Field: "FIELD2",
      },
    },
  },
})
fmt.Println(resp)

const filteritem = new FilterItem();
filteritem.setField("FIELD1");
filteritem.setOperator(FilterItem.FilterOperator.FILTER_OPERATOR_GT);
filteritem.setStrValue("STRINGVAL");
const filteritem1 = new FilterItem();
filteritem1.setField("FIELD2");
filteritem1.setOperator(FilterItem.FilterOperator.FILTER_OPERATOR_UNSPECIFIED);
filteritem1.setIntValue(10);
const filteritem2 = new FilterItem();
filteritem2.setField("FIELD3");
filteritem2.setOperator(FilterItem.FilterOperator.FILTER_OPERATOR_NE);
filteritem2.setBoolValue(false);
const filter = new Filter();
filter.setOperator(LogicalOperator.LOGICAL_OPERATOR_AND);
filter.setFiltersList([filteritem, filteritem1, filteritem2]);
const sortitem = new SortItem();
sortitem.setDirection(SortDirection.SORT_DIRECTION_ASCENDING);
sortitem.setField("FIELD1");
const sortitem1 = new SortItem();
sortitem1.setDirection(SortDirection.SORT_DIRECTION_UNSPECIFIED);
sortitem1.setField("FIELD2");
const sortby = new SortBy();
sortby.setItemsList([sortitem, sortitem1]);
const listusersrequest = new ListUsersRequest();
listusersrequest.setFilter(filter);
listusersrequest.setPage(0);
listusersrequest.setPageSize(100);
listusersrequest.setSortBy(sortby);

service.listUsers(listusersrequest, (err, value:ListUsersResponse|null) => {
    const resp = JSON.stringify(err ? err : value);
    console.log("received ", resp);
})

using System;
using Grpc.Core;
using Common;
using UserApi.V1;

namespace main
{
  class Program
  {
    static void Main(string[] args)
    {
      Channel channel = new Channel("user-mgmt.YOUR_SANDBOX_ID.knoxnetworks.io:443", ChannelCredentials.Insecure); 
      var client = new UserApiService.UserApiServiceClient(channel); 
      var headers = new Metadata();
      var filterItem = new FilterItem{
        Field = "FIELD1",
        Operator = FilterItem.Types.FilterOperator.Filter_operator_unspecified,
        StrValue = "STRINGVAL",
      };
      var filterItem1 = new FilterItem{
        Field = "FIELD2",
        Operator = FilterItem.Types.FilterOperator.Filter_operator_unspecified,
        IntValue = 10,
      };
      var filterItem2 = new FilterItem{
        Field = "FIELD3",
        Operator = FilterItem.Types.FilterOperator.Filter_operator_unspecified,
        BoolValue = false,
      };
      var filter = new Filter{
        Operator = LogicalOperator.Logical_operator_unspecified,
        Filters = {filterItem, filterItem1, filterItem2},
      };
      var sortItem = new SortItem{
        Direction = SortDirection.Sort_direction_unspecified,
        Field = "FIELD1",
      };
      var sortItem1 = new SortItem{
        Direction = SortDirection.Sort_direction_unspecified,
        Field = "FIELD2",
      };
      var sortBy = new SortBy{
        Items = {sortItem, sortItem1},
      };
      var listUsersRequest = new ListUsersRequest{
        Filter = filter,
        Page = 0,
        PageSize = 100,
        SortBy = sortBy,
      };
      var reply = client.ListUsers(listUsersRequest, headers);
      Console.WriteLine("Response: " + reply);
      channel.ShutdownAsync().Wait();
    }
  }
}

package demo;

import io.grpc.Channel;
import io.grpc.ManagedChannel;
import io.grpc.ManagedChannelBuilder;
import common.Common.Filter;
import common.Common.FilterItem;
import common.Common.LogicalOperator;
import common.Common.SortBy;
import common.Common.SortDirection;
import common.Common.SortItem;
import user_api.v1.User.ListUsersRequest;
import user_api.v1.User.ListUsersResponse;
import user_api.v1.UserApiServiceGrpc;

public class App {
  public static void main(String[] args) {
    ManagedChannel channel = ManagedChannelBuilder
      .forAddress("user-mgmt.YOUR_SANDBOX_ID.knoxnetworks.io", 443)
      .usePlaintext()
      .build();
    UserApiServiceGrpc.UserApiServiceBlockingStub blockStub =
        UserApiServiceGrpc.newBlockingStub(channel);
    
    FilterItem req_FilterItem =
        FilterItem.newBuilder()
          .setField("FIELD1")
          .setOperator(FilterItem.FilterOperator.FILTER_OPERATOR_UNSPECIFIED)
          .setStrValue("STRINGVAL")
          .build();
    FilterItem req_FilterItem2 =
        FilterItem.newBuilder()
          .setField("FIELD2")
          .setOperator(FilterItem.FilterOperator.FILTER_OPERATOR_UNSPECIFIED)
          .setIntValue(10)
          .build();
    FilterItem req_FilterItem3 =
        FilterItem.newBuilder()
          .setField("FIELD3")
          .setOperator(FilterItem.FilterOperator.FILTER_OPERATOR_UNSPECIFIED)
          .setBoolValue(false)
          .build();
    Filter req_Filter =
        Filter.newBuilder()
          .setOperator(LogicalOperator.LOGICAL_OPERATOR_UNSPECIFIED)
          .addFilters(req_FilterItem)
          .addFilters(req_FilterItem2)
          .addFilters(req_FilterItem3)
          .build();
    SortItem req_SortItem =
        SortItem.newBuilder()
          .setDirection(SortDirection.SORT_DIRECTION_UNSPECIFIED)
          .setField("FIELD1")
          .build();
    SortItem req_SortItem2 =
        SortItem.newBuilder()
          .setDirection(SortDirection.SORT_DIRECTION_UNSPECIFIED)
          .setField("FIELD2")
          .build();
    SortBy req_SortBy =
        SortBy.newBuilder()
          .addItems(req_SortItem)
          .addItems(req_SortItem2)
          .build();
    ListUsersRequest req_ListUsersRequest =
        ListUsersRequest.newBuilder()
          .setFilter(req_Filter)
          .setPage(0)
          .setPageSize(100)
          .setSortBy(req_SortBy)
          .build();
    ListUsersResponse resp = blockStub.listUsers(req_ListUsersRequest);
    System.out.println(resp);
    channel.shutdown();
  }
}

const filteritem = new FilterItem();
filteritem.setField("FIELD1");
filteritem.setOperator(FilterItem.FilterOperator.FILTER_OPERATOR_LTE);
filteritem.setStrValue("STRINGVAL");
const filteritem1 = new FilterItem();
filteritem1.setField("FIELD2");
filteritem1.setOperator(FilterItem.FilterOperator.FILTER_OPERATOR_NE);
filteritem1.setIntValue(10);
const filteritem2 = new FilterItem();
filteritem2.setField("FIELD3");
filteritem2.setOperator(FilterItem.FilterOperator.FILTER_OPERATOR_LTE);
filteritem2.setBoolValue(false);
const filter = new Filter();
filter.setOperator(LogicalOperator.LOGICAL_OPERATOR_UNSPECIFIED);
filter.setFiltersList([filteritem, filteritem1, filteritem2]);
const sortitem = new SortItem();
sortitem.setDirection(SortDirection.SORT_DIRECTION_UNSPECIFIED);
sortitem.setField("FIELD1");
const sortitem1 = new SortItem();
sortitem1.setDirection(SortDirection.SORT_DIRECTION_UNSPECIFIED);
sortitem1.setField("FIELD2");
const sortby = new SortBy();
sortby.setItemsList([sortitem, sortitem1]);
const listusersrequest = new ListUsersRequest();
listusersrequest.setFilter(filter);
listusersrequest.setPage(0);
listusersrequest.setPageSize(100);
listusersrequest.setSortBy(sortby);

service.listUsers(listusersrequest, (err, value) => {
    const resp = JSON.stringify(err ? err : value);
    console.log("received ", resp);
})

extern crate grpc-sdks;
use tonic::transport::Channel;

use grpc-sdks::user_api::v1::user_api_service_client::UserApiServiceClient;
use grpc-sdks::common::Filter;
use grpc-sdks::common::LogicalOperator;
use grpc-sdks::common::filter_item::FilterOperator;
use grpc-sdks::common::SortBy;
use grpc-sdks::common::filter_item;
use grpc-sdks::common::FilterItem;
use grpc-sdks::common::SortDirection;
use grpc-sdks::common::SortItem;
use grpc-sdks::user_api::v1::ListUsersRequest;

#[tokio::main]
async fn main() -> Result<(), Box<dyn std::error::Error>> {
  let channel = Channel::from_static("user-mgmt.YOUR_SANDBOX_ID.knoxnetworks.io")
    .connect()
    .await?;
  let mut client = UserApiServiceClient::new(channel); 

  let request = tonic::Request::new(
    ListUsersRequest{
      filter: Some(Filter{
        filters: Vec::from([FilterItem{
          field: String::from("FIELD1"),
          operator: FilterOperator::FilterOperatorUnspecified as i32,
          value: Some(filter_item::Value::StrValue(String::from("STRINGVAL")))
        }, FilterItem{
          field: String::from("FIELD2"),
          operator: FilterOperator::FilterOperatorUnspecified as i32,
          value: Some(filter_item::Value::IntValue(10))
        }, FilterItem{
          field: String::from("FIELD3"),
          operator: FilterOperator::FilterOperatorUnspecified as i32,
          value: Some(filter_item::Value::BoolValue(false))
        }]),
        operator: LogicalOperator::LogicalOperatorUnspecified as i32
      }),
      page: 0,
      page_size: 100,
      sort_by: Some(SortBy{
        items: Vec::from([SortItem{
          direction: SortDirection::SortDirectionUnspecified as i32,
          field: String::from("FIELD1")
        }, SortItem{
          direction: SortDirection::SortDirectionUnspecified as i32,
          field: String::from("FIELD2")
        }])
      })
    });
// sending request and waiting for response
  let response = client.list_users(request).await?.into_inner();
  println!("RESPONSE={:?}", response);
  Ok(())
}

package app

import io.grpc.ManagedChannelBuilder
import common.Common.Filter
import common.Common.FilterItem
import common.Common.LogicalOperator
import common.Common.SortBy
import common.Common.SortDirection
import common.Common.SortItem
import user_api.v1.User.ListUsersRequest
import user_api.v1.User.ListUsersResponse
import user_api.v1.UserApiServiceGrpc

fun main() {
    val channel = ManagedChannelBuilder
            .forAddress("user-mgmt.YOUR_SANDBOX_ID.knoxnetworks.io", 443)
            .usePlaintext()
            .build()
    var blockStub = UserApiServiceGrpc.newBlockingStub(channel)
    
    val req_FilterItem = FilterItem.newBuilder()
          .setField("FIELD1")
          .setOperator(FilterItem.FilterOperator.FILTER_OPERATOR_UNSPECIFIED)
          .setStrValue("STRINGVAL")
          .build()
    val req_FilterItem2 = FilterItem.newBuilder()
          .setField("FIELD2")
          .setOperator(FilterItem.FilterOperator.FILTER_OPERATOR_UNSPECIFIED)
          .setIntValue(10)
          .build()
    val req_FilterItem3 = FilterItem.newBuilder()
          .setField("FIELD3")
          .setOperator(FilterItem.FilterOperator.FILTER_OPERATOR_UNSPECIFIED)
          .setBoolValue(false)
          .build()
    val req_Filter = Filter.newBuilder()
          .setOperator(LogicalOperator.LOGICAL_OPERATOR_UNSPECIFIED)
          .addFilters(req_FilterItem)
          .addFilters(req_FilterItem2)
          .addFilters(req_FilterItem3)
          .build()
    val req_SortItem = SortItem.newBuilder()
          .setDirection(SortDirection.SORT_DIRECTION_UNSPECIFIED)
          .setField("FIELD1")
          .build()
    val req_SortItem2 = SortItem.newBuilder()
          .setDirection(SortDirection.SORT_DIRECTION_UNSPECIFIED)
          .setField("FIELD2")
          .build()
    val req_SortBy = SortBy.newBuilder()
          .addItems(req_SortItem)
          .addItems(req_SortItem2)
          .build()
    val req_ListUsersRequest = ListUsersRequest.newBuilder()
          .setFilter(req_Filter)
          .setPage(0)
          .setPageSize(100)
          .setSortBy(req_SortBy)
          .build()
    val resp = blockStub.listUsers(req_ListUsersRequest)
    println(resp)
    channel.shutdown()
}

{
  "total_matching_users": 2,
  "users": [
    {
      "uuid": "UUID",
      "first_name": "John",
      "last_name": "Doe",
      "email": "[email protected]",
      "role": 0,
      "avatar": "AVATAR_URL",
      "phone": "+1 555 555 5555",
      "dids": [
        "did:method-name:zDIDMultibase58Encoded",
        "did:method-name:zDIDMultibase58Encoded"
      ],
      "external_ids": [
        {
          "key": "KEY1",
          "value": "VALUE1"
        },
        {
          "key": "KEY2",
          "value": "VALUE2"
        }
      ],
      "metadata": {
        "fields": [
          {
            "key": "VALUE"
          }
        ]
      },
      "account": "15436675"
    },
    {
      "uuid": "UUID",
      "first_name": "Jane",
      "last_name": "Doe",
      "email": "[email protected]",
      "role": 0,
      "avatar": "AVATAR_URL",
      "phone": "+1 555 555 5555",
      "dids": [
        "did:method-name:zDIDMultibase58Encoded",
        "did:method-name:zDIDMultibase58Encoded"
      ],
      "external_ids": [
        {
          "key": "KEY1",
          "value": "VALUE1"
        },
        {
          "key": "KEY2",
          "value": "VALUE2"
        }
      ],
      "metadata": {
        "fields": [
          {
            "key": "VALUE"
          }
        ]
      },
      "account": "15436676"
    }
  ]
}