public async IAsyncEnumerable <KeyValueStoreBaseListResponse> ListAsync(
            KeyValueStoreBaseListRequest request,
            [EnumeratorCancellation] CancellationToken cancellationToken)
        {
            var input = new Protocol.KeyValueStoreBaseListRequest
            {
                KeyPrefix  = request.KeyPrefix,
                Inclusions = OfInclusions(request.Inclusions),
            };

            var callOptions = PrepareCallOptions(cancellationToken);

            var outputStream = listerClient.List(input, callOptions);

            while (await outputStream.ResponseStream.MoveNext(cancellationToken))
            {
                var output = outputStream.ResponseStream.Current;

                var response = new KeyValueStoreBaseListResponse
                {
                    Status     = ToStatus(output.Status),
                    IsLastPage = output.IsLastPage,
                    PageNumber = output.PageNumber,
                    Items      = output.Items
                                 .Select(item =>
                    {
                        return(new KeyValueContent
                        {
                            Key = item.Key,
                            Value = ToBytes(item.Value),
                            Metadata = ToMetadata(item.Metadata),
                            Properties = ToProperties(item.Properties),
                        });
                    })
                                 .ToList()
                };

                yield return(response);
            }
        }
        public async IAsyncEnumerable <KeyValueStoreBaseListResponse> ListAsync(
            KeyValueStoreBaseListRequest request,
            CancellationToken cancellationToken)
        {
            bool includeValue      = request.Inclusions?.IncludeValue ?? false;
            bool includeMetadata   = request.Inclusions?.IncludeMetadata ?? false;
            bool includeProperties = request.Inclusions?.IncludeProperties ?? false;

            var getBlobsResult = containerClient.GetBlobsAsync(BlobTraits.Metadata, BlobStates.None, request.KeyPrefix, cancellationToken);

            var pageSizeHint = includeValue ? 10 : 100; // Add as options

            var pageNumber = 0;

            await foreach (var page in getBlobsResult.AsPages(null, pageSizeHint))
            {
                var isLastPage = page.ContinuationToken == null;

                foreach (var window in page.Values.Windowed(pageSizeHint))
                {
                    if (includeValue)
                    {
                        var loadedItems = await Task.WhenAll(window.Select(async blobItem =>
                        {
                            var blobClient = containerClient.GetBlobClient(blobItem.Name);

                            using var memory = new MemoryStream();

                            var _downloadResponse = await blobClient.DownloadToAsync(memory, cancellationToken);

                            return(blobItem, value: memory.ToArray());
                        }));

                        var items = loadedItems.Select(pair => new KeyValueContent
                        {
                            Key        = pair.blobItem.Name,
                            Metadata   = includeMetadata ? ToMetadata(pair.blobItem) : null,
                            Properties = includeProperties ? ToProperties(pair.blobItem) : null,
                            Value      = pair.value,
                        }).ToList();

                        yield return(new KeyValueStoreBaseListResponse
                        {
                            Status = new Status {
                                Code = 0
                            },
                            IsLastPage = isLastPage,
                            PageNumber = pageNumber++,
                            Items = items,
                        });
                    }
                    else
                    {
                        var items = window.Select(blobItem => new KeyValueContent
                        {
                            Key        = blobItem.Name,
                            Metadata   = includeMetadata ? ToMetadata(blobItem) : null,
                            Properties = includeProperties ? ToProperties(blobItem) : null,
                        }).ToList();

                        yield return(new KeyValueStoreBaseListResponse
                        {
                            Status = new Status {
                                Code = 0
                            },
                            IsLastPage = isLastPage,
                            PageNumber = pageNumber++,
                            Items = items,
                        });
                    }
                }
            }
        }