resp, _ := treasury.ListTransactions(ctx, &treasury.ListTransactionsRequest{
  Filters: &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: 10,
  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_GTE);
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_UNSPECIFIED);
sortitem.setField("FIELD1");
const sortitem1 = new SortItem();
sortitem1.setDirection(SortDirection.SORT_DIRECTION_DESCENDING);
sortitem1.setField("FIELD2");
const sortby = new SortBy();
sortby.setItemsList([sortitem, sortitem1]);
const listtransactionsrequest = new ListTransactionsRequest();
listtransactionsrequest.setFilters(filter);
listtransactionsrequest.setPage(0);
listtransactionsrequest.setPageSize(10);
listtransactionsrequest.setSortBy(sortby);

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

using System;
using Grpc.Core;
using Common;
using Treasury;

namespace main
{
  class Program
  {
    static void Main(string[] args)
    {
      Channel channel = new Channel("treasury.YOUR_SANDBOX_ID.knoxnetworks.io:443", ChannelCredentials.Insecure); 
      var client = new Treasury.TreasuryClient(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 listTransactionsRequest = new ListTransactionsRequest{
        Filters = filter,
        Page = 0,
        PageSize = 10,
        SortBy = sortBy,
      };
      var reply = client.ListTransactions(listTransactionsRequest, 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 treasury.TreasuryGrpc;
import treasury.Treasury.ListTransactionsRequest;
import treasury.Treasury.ListTransactionsResponse;

public class App {
  public static void main(String[] args) {
    ManagedChannel channel = ManagedChannelBuilder
      .forAddress("treasury.YOUR_SANDBOX_ID.knoxnetworks.io", 443)
      .usePlaintext()
      .build();
    TreasuryGrpc.TreasuryBlockingStub blockStub =
        TreasuryGrpc.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();
    ListTransactionsRequest req_ListTransactionsRequest =
        ListTransactionsRequest.newBuilder()
          .setFilters(req_Filter)
          .setPage(0)
          .setPageSize(10)
          .setSortBy(req_SortBy)
          .build();
    ListTransactionsResponse resp = blockStub.listTransactions(req_ListTransactionsRequest);
    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_LTE);
filteritem1.setIntValue(10);
const filteritem2 = new FilterItem();
filteritem2.setField("FIELD3");
filteritem2.setOperator(FilterItem.FilterOperator.FILTER_OPERATOR_EQ);
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 listtransactionsrequest = new ListTransactionsRequest();
listtransactionsrequest.setFilters(filter);
listtransactionsrequest.setPage(0);
listtransactionsrequest.setPageSize(10);
listtransactionsrequest.setSortBy(sortby);

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

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

use grpc-sdks::treasury::treasury_client::TreasuryClient;
use grpc-sdks::common::filter_item::FilterOperator;
use grpc-sdks::common::SortBy;
use grpc-sdks::common::SortDirection;
use grpc-sdks::common::SortItem;
use grpc-sdks::common::Filter;
use grpc-sdks::common::LogicalOperator;
use grpc-sdks::common::filter_item;
use grpc-sdks::common::FilterItem;
use grpc-sdks::treasury::ListTransactionsRequest;

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

  let request = tonic::Request::new(
    ListTransactionsRequest{
      filters: 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: 10,
      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_transactions(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 treasury.TreasuryGrpc
import treasury.Treasury.ListTransactionsRequest
import treasury.Treasury.ListTransactionsResponse

fun main() {
    val channel = ManagedChannelBuilder
            .forAddress("treasury.YOUR_SANDBOX_ID.knoxnetworks.io", 443)
            .usePlaintext()
            .build()
    var blockStub = TreasuryGrpc.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_ListTransactionsRequest = ListTransactionsRequest.newBuilder()
          .setFilters(req_Filter)
          .setPage(0)
          .setPageSize(10)
          .setSortBy(req_SortBy)
          .build()
    val resp = blockStub.listTransactions(req_ListTransactionsRequest)
    println(resp)
    channel.shutdown()
}

{
  "contracts": [
    {
      "contract_id": "9628a2d9-f932-41f0-b2da-b9de3103d945",
      "contract_type": "Relay",
      "created": "2022-12-19T16:39:57-08:00",
      "counterparties": [
        "zCounterpartyPublicKeyMultibase58Encoded",
        "zCounterpartyPublicKey2Multibase58Encoded"
      ],
      "memo": "Payment"
    }
  ],
  "totalContracts": 1
}