/*
  * Copyright (C) 2024 The Android Open Source Project
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
  * You may obtain a copy of the License at
  *
  *      http://www.apache.org/licenses/LICENSE-2.0
  *
  * Unless required by applicable law or agreed to in writing, software
  * distributed under the License is distributed on an "AS IS" BASIS,
  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
 package android.health.connect;
 
 import static android.health.connect.Constants.DEFAULT_PAGE_SIZE;
 import static android.health.connect.Constants.MAXIMUM_PAGE_SIZE;
 import static android.health.connect.Constants.MINIMUM_PAGE_SIZE;
 import static android.health.connect.datatypes.MedicalDataSource.validateMedicalDataSourceIds;
 import static android.health.connect.datatypes.MedicalResource.MedicalResourceType;
 import static android.health.connect.datatypes.MedicalResource.validateMedicalResourceType;
 import static android.health.connect.datatypes.validation.ValidationUtils.requireInRange;
 
 import static com.android.healthfitness.flags.Flags.FLAG_PERSONAL_HEALTH_RECORD;
 
 import static java.util.Objects.hash;
 import static java.util.Objects.requireNonNull;
 
 import android.annotation.FlaggedApi;
 import android.annotation.IntRange;
 import android.annotation.NonNull;
 import android.health.connect.aidl.ReadMedicalResourcesRequestParcel;
 import android.health.connect.datatypes.MedicalDataSource;
 import android.health.connect.datatypes.MedicalResource;
 import android.util.ArraySet;
 
 import java.util.HashSet;
 import java.util.Set;
 
 /**
  * An initial read request with specified filters for {@link
  * HealthConnectManager#readMedicalResources}.
  *
  * <p>On receiving the response, if {@link ReadMedicalResourcesResponse#getNextPageToken()} is not
  * {@code null}, then use the next token with {@link ReadMedicalResourcesPageRequest} to read the
  * next page.
  *
  * <p>Example usage:
  *
  * <pre>{@code
  * ReadMedicalResourcesInitialRequest initialRequest
  *     = new ReadMedicalResourcesInitialRequest.Builder(...).build();
  * ReadMedicalResourcesResponse response = makeRequest(initialRequest);
  * String pageToken = response.getNextPageToken();
  *
  * while (pageToken != null) {
  *     ReadMedicalResourcesPageRequest pageRequest = new ReadMedicalResourcesPageRequest(pageToken);
  *     response = makeRequest(pageRequest);
  *     pageToken = response.getNextPageToken();
  * }
  * }</pre>
  */
 @FlaggedApi(FLAG_PERSONAL_HEALTH_RECORD)
 public final class ReadMedicalResourcesInitialRequest extends ReadMedicalResourcesRequest {
     @MedicalResourceType private final int mMedicalResourceType;
     @NonNull private final Set<String> mDataSourceIds;
 
     /**
      * Creates a new instance of {@link ReadMedicalResourcesInitialRequest}. Please see {@link
      * ReadMedicalResourcesInitialRequest.Builder} for more detailed parameters information.
      */
ReadMedicalResourcesInitialRequest( @edicalResourceType int medicalResourceType, @NonNull Set<String> dataSourceIds, @IntRange(from = MINIMUM_PAGE_SIZE, to = MAXIMUM_PAGE_SIZE) int pageSize)     private ReadMedicalResourcesInitialRequest(
             @MedicalResourceType int medicalResourceType,
             @NonNull Set<String> dataSourceIds,
             @IntRange(from = MINIMUM_PAGE_SIZE, to = MAXIMUM_PAGE_SIZE) int pageSize) {
         super(pageSize);
         validateMedicalResourceType(medicalResourceType);
         requireNonNull(dataSourceIds);
         validateMedicalDataSourceIds(dataSourceIds);
 
         mMedicalResourceType = medicalResourceType;
         mDataSourceIds = dataSourceIds;
     }
 
     /** Returns the medical resource type. */
     @MedicalResourceType
getMedicalResourceType()     public int getMedicalResourceType() {
         return mMedicalResourceType;
     }
 
     /**
      * Returns the set of IDs of the {@link MedicalDataSource} filter to read from, or an empty set
      * for no filter.
      */
     @NonNull
getDataSourceIds()     public Set<String> getDataSourceIds() {
         return new ArraySet<>(mDataSourceIds);
     }
 
     @Override
equals(Object o)     public boolean equals(Object o) {
         if (this == o) return true;
         if (!(o instanceof ReadMedicalResourcesInitialRequest that)) return false;
 
         return getMedicalResourceType() == that.getMedicalResourceType()
                 && getDataSourceIds().equals(that.getDataSourceIds())
                 && getPageSize() == that.getPageSize();
     }
 
     @Override
hashCode()     public int hashCode() {
         return hash(getMedicalResourceType(), getDataSourceIds(), getPageSize());
     }
 
     @Override
toString()     public String toString() {
         return this.getClass().getSimpleName()
                 + "{"
                 + "medicalResourceType="
                 + getMedicalResourceType()
                 + ",dataSourceIds="
                 + getDataSourceIds()
                 + ",pageSize="
                 + getPageSize()
                 + "}";
     }
 
     /**
      * Returns an instance of {@link ReadMedicalResourcesRequestParcel} to carry the request.
      *
      * @hide
      */
toParcel()     public ReadMedicalResourcesRequestParcel toParcel() {
         return new ReadMedicalResourcesRequestParcel(this);
     }
 
     /** Builder class for {@link ReadMedicalResourcesInitialRequest}. */
     public static final class Builder {
         @MedicalResourceType private int mMedicalResourceType;
         @NonNull private Set<String> mDataSourceIds = new HashSet<>();
         private int mPageSize = DEFAULT_PAGE_SIZE;
 
         /**
          * Constructs a new {@link ReadMedicalResourcesInitialRequest.Builder} instance.
          *
          * @param medicalResourceType The medical resource type.
          * @throws IllegalArgumentException if the provided {@code medicalResourceType} is not a
          *     supported type.
          */
Builder(@edicalResourceType int medicalResourceType)         public Builder(@MedicalResourceType int medicalResourceType) {
             validateMedicalResourceType(medicalResourceType);
             mMedicalResourceType = medicalResourceType;
         }
 
         /** Constructs a clone of the other {@link ReadMedicalResourcesInitialRequest.Builder}. */
Builder(@onNull Builder other)         public Builder(@NonNull Builder other) {
             mMedicalResourceType = other.mMedicalResourceType;
             mDataSourceIds.addAll(other.mDataSourceIds);
             mPageSize = other.mPageSize;
         }
 
         /** Constructs a clone of the other {@link ReadMedicalResourcesInitialRequest} instance. */
Builder(@onNull ReadMedicalResourcesInitialRequest other)         public Builder(@NonNull ReadMedicalResourcesInitialRequest other) {
             mMedicalResourceType = other.getMedicalResourceType();
             mDataSourceIds.addAll(other.getDataSourceIds());
             mPageSize = other.getPageSize();
         }
 
         /**
          * Sets the medical resource type.
          *
          * @throws IllegalArgumentException if the provided {@code medicalResourceType} is not a
          *     supported type.
          */
         @NonNull
setMedicalResourceType(@edicalResourceType int medicalResourceType)         public Builder setMedicalResourceType(@MedicalResourceType int medicalResourceType) {
             validateMedicalResourceType(medicalResourceType);
             mMedicalResourceType = medicalResourceType;
             return this;
         }
 
         /**
          * Adds the data source ID based on which the read operation is to be performed. This should
          * be an ID of the existing {@link MedicalDataSource}.
          *
          * <p>If no {@link MedicalDataSource} ID is added, then {@link MedicalResource}s from all
          * {@link MedicalDataSource}s will be read.
          *
          * @throws IllegalArgumentException if the provided {@code dataSourceId} is not a valid ID.
          */
         @NonNull
addDataSourceId(@onNull String dataSourceId)         public Builder addDataSourceId(@NonNull String dataSourceId) {
             requireNonNull(dataSourceId);
             validateMedicalDataSourceIds(Set.of(dataSourceId));
             mDataSourceIds.add(dataSourceId);
             return this;
         }
 
         /**
          * Adds all data source IDs based on which the read operation is to be performed. This
          * should all be IDs of existing {@link MedicalDataSource}s.
          *
          * <p>If no {@link MedicalDataSource} IDs are added, then {@link MedicalResource}s from all
          * {@link MedicalDataSource}s will be read.
          *
          * @throws IllegalArgumentException if the provided {@code dataSourceIds} is null, or any ID
          *     in it is not valid.
          */
         @NonNull
addDataSourceIds(@onNull Set<String> dataSourceIds)         public Builder addDataSourceIds(@NonNull Set<String> dataSourceIds) {
             requireNonNull(dataSourceIds);
             validateMedicalDataSourceIds(dataSourceIds);
             mDataSourceIds.addAll(dataSourceIds);
             return this;
         }
 
         /** Clears all the {@link MedicalDataSource} filters for this builder. */
         @NonNull
clearDataSourceIds()         public Builder clearDataSourceIds() {
             mDataSourceIds.clear();
             return this;
         }
 
         /**
          * Sets the maximum number of {@code MedicalResource}s to be returned by the read operation.
          *
          * <p>If not set, default to 1000.
          *
          * @throws IllegalArgumentException if the provided {@code pageSize} is less than 1 or more
          *     than 5000.
          */
         @NonNull
setPageSize( @ntRangefrom = MINIMUM_PAGE_SIZE, to = MAXIMUM_PAGE_SIZE) int pageSize)         public Builder setPageSize(
                 @IntRange(from = MINIMUM_PAGE_SIZE, to = MAXIMUM_PAGE_SIZE) int pageSize) {
             requireInRange(pageSize, MINIMUM_PAGE_SIZE, MAXIMUM_PAGE_SIZE, "pageSize");
             mPageSize = pageSize;
             return this;
         }
 
         /**
          * Returns a new instance of {@link ReadMedicalResourcesInitialRequest} with the specified
          * parameters.
          */
         @NonNull
build()         public ReadMedicalResourcesInitialRequest build() {
             return new ReadMedicalResourcesInitialRequest(
                     mMedicalResourceType, mDataSourceIds, mPageSize);
         }
     }
 }
 

 /*
  * Copyright (C) 2024 The Android Open Source Project
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
  * You may obtain a copy of the License at
  *
  *      http://www.apache.org/licenses/LICENSE-2.0
  *
  * Unless required by applicable law or agreed to in writing, software
  * distributed under the License is distributed on an "AS IS" BASIS,
  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
 package android.health.connect;
 
 import static android.health.connect.Constants.DEFAULT_PAGE_SIZE;
 import static android.health.connect.Constants.MAXIMUM_PAGE_SIZE;
 import static android.health.connect.Constants.MINIMUM_PAGE_SIZE;
 import static android.health.connect.datatypes.validation.ValidationUtils.requireInRange;
 
 import static com.android.healthfitness.flags.Flags.FLAG_PERSONAL_HEALTH_RECORD;
 
 import static java.util.Objects.hash;
 import static java.util.Objects.requireNonNull;
 
 import android.annotation.FlaggedApi;
 import android.annotation.IntRange;
 import android.annotation.NonNull;
 import android.health.connect.aidl.ReadMedicalResourcesRequestParcel;
 
 /**
  * A page read request with specified {@code pageToken} for {@link
  * HealthConnectManager#readMedicalResources}.
  *
  * <p>When making a new initial request with new filters, use {@link
  * ReadMedicalResourcesInitialRequest}.
  *
  * <p>Example usage:
  *
  * <pre>{@code
  * ReadMedicalResourcesInitialRequest initialRequest
  *     = new ReadMedicalResourcesInitialRequest.Builder(...).build();
  * ReadMedicalResourcesResponse response = makeRequest(initialRequest);
  * String pageToken = response.getNextPageToken();
  *
  * while (pageToken != null) {
  *     ReadMedicalResourcesPageRequest pageRequest = new ReadMedicalResourcesPageRequest(pageToken);
  *     response = makeRequest(pageRequest);
  *     pageToken = response.getNextPageToken();
  * }
  * }</pre>
  */
 @FlaggedApi(FLAG_PERSONAL_HEALTH_RECORD)
 public final class ReadMedicalResourcesPageRequest extends ReadMedicalResourcesRequest {
     @NonNull private final String mPageToken;
 
     /**
      * Creates a new instance of {@link ReadMedicalResourcesPageRequest}. Please see {@link
      * ReadMedicalResourcesPageRequest.Builder} for more detailed parameters information.
      */
ReadMedicalResourcesPageRequest( @onNull String pageToken, @IntRange(from = MINIMUM_PAGE_SIZE, to = MAXIMUM_PAGE_SIZE) int pageSize)     private ReadMedicalResourcesPageRequest(
             @NonNull String pageToken,
             @IntRange(from = MINIMUM_PAGE_SIZE, to = MAXIMUM_PAGE_SIZE) int pageSize) {
         super(pageSize);
         requireNonNull(pageToken);
         mPageToken = pageToken;
     }
 
     /** Returns the page token to read the requested page. */
     @NonNull
getPageToken()     public String getPageToken() {
         return mPageToken;
     }
 
     @Override
equals(Object o)     public boolean equals(Object o) {
         if (this == o) return true;
         if (!(o instanceof ReadMedicalResourcesPageRequest that)) return false;
         return getPageToken().equals(that.getPageToken()) && getPageSize() == that.getPageSize();
     }
 
     @Override
hashCode()     public int hashCode() {
         return hash(getPageToken(), getPageSize());
     }
 
     @Override
toString()     public String toString() {
         return this.getClass().getSimpleName()
                 + "{"
                 + "pageToken="
                 + getPageToken()
                 + ",pageSize="
                 + getPageSize()
                 + "}";
     }
 
     /**
      * Returns an instance of {@link ReadMedicalResourcesRequestParcel} to carry the request.
      *
      * @hide
      */
toParcel()     public ReadMedicalResourcesRequestParcel toParcel() {
         return new ReadMedicalResourcesRequestParcel(this);
     }
 
     /** Builder class for {@link ReadMedicalResourcesPageRequest}. */
     public static final class Builder {
         @NonNull private String mPageToken;
         private int mPageSize = DEFAULT_PAGE_SIZE;
 
         /**
          * Constructs a new {@link ReadMedicalResourcesPageRequest} instance.
          *
          * @param pageToken The page token to read the requested page of the result, from the
          *     previous {@link ReadMedicalResourcesResponse#getNextPageToken()}.
          */
Builder(@onNull String pageToken)         public Builder(@NonNull String pageToken) {
             requireNonNull(pageToken);
             mPageToken = pageToken;
         }
 
         /** Constructs a clone of the other {@link ReadMedicalResourcesPageRequest.Builder}. */
Builder(@onNull Builder other)         public Builder(@NonNull Builder other) {
             mPageToken = other.mPageToken;
             mPageSize = other.mPageSize;
         }
 
         /** Constructs a clone of the other {@link ReadMedicalResourcesPageRequest} instance. */
Builder(@onNull ReadMedicalResourcesPageRequest other)         public Builder(@NonNull ReadMedicalResourcesPageRequest other) {
             mPageToken = other.getPageToken();
             mPageSize = other.getPageSize();
         }
 
         /**
          * Sets page token to read the requested page of the result, from the previous {@link
          * ReadMedicalResourcesResponse#getNextPageToken()}.
          */
         @NonNull
setPageToken(@onNull String pageToken)         public Builder setPageToken(@NonNull String pageToken) {
             requireNonNull(pageToken);
             mPageToken = pageToken;
             return this;
         }
 
         /**
          * Sets the maximum number of {@code MedicalResource}s to be returned by the read operation.
          *
          * <p>If not set, default to 1000.
          *
          * @throws IllegalArgumentException if the provided {@code pageSize} is less than 1 or more
          *     than 5000.
          */
         @NonNull
setPageSize( @ntRangefrom = MINIMUM_PAGE_SIZE, to = MAXIMUM_PAGE_SIZE) int pageSize)         public Builder setPageSize(
                 @IntRange(from = MINIMUM_PAGE_SIZE, to = MAXIMUM_PAGE_SIZE) int pageSize) {
             requireInRange(pageSize, MINIMUM_PAGE_SIZE, MAXIMUM_PAGE_SIZE, "pageSize");
             mPageSize = pageSize;
             return this;
         }
 
         /**
          * Returns a new instance of {@link ReadMedicalResourcesPageRequest} with the specified
          * parameters.
          */
         @NonNull
build()         public ReadMedicalResourcesPageRequest build() {
             return new ReadMedicalResourcesPageRequest(mPageToken, mPageSize);
         }
     }
 }
 

 /*
  * Copyright (C) 2024 The Android Open Source Project
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
  * You may obtain a copy of the License at
  *
  *      http://www.apache.org/licenses/LICENSE-2.0
  *
  * Unless required by applicable law or agreed to in writing, software
  * distributed under the License is distributed on an "AS IS" BASIS,
  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
 
 package android.health.connect;
 
 import static android.health.connect.Constants.MAXIMUM_PAGE_SIZE;
 import static android.health.connect.Constants.MINIMUM_PAGE_SIZE;
 import static android.health.connect.datatypes.validation.ValidationUtils.requireInRange;
 
 import static com.android.healthfitness.flags.Flags.FLAG_PERSONAL_HEALTH_RECORD;
 
 import android.annotation.FlaggedApi;
 import android.annotation.IntRange;
 import android.health.connect.aidl.ReadMedicalResourcesRequestParcel;
 
 /**
  * A base class to represent a read request for {@link HealthConnectManager#readMedicalResources}.
  */
 @FlaggedApi(FLAG_PERSONAL_HEALTH_RECORD)
 public abstract class ReadMedicalResourcesRequest {
     private final int mPageSize;
 
     /**
      * @param pageSize The maximum number of {@code MedicalResource}s to be returned by the read
      *     operation.
      * @throws IllegalArgumentException if {@code pageSize} is less than 1 or more than 5000.
      * @hide
      */
ReadMedicalResourcesRequest( @ntRangefrom = MINIMUM_PAGE_SIZE, to = MAXIMUM_PAGE_SIZE) int pageSize)     protected ReadMedicalResourcesRequest(
             @IntRange(from = MINIMUM_PAGE_SIZE, to = MAXIMUM_PAGE_SIZE) int pageSize) {
         requireInRange(pageSize, MINIMUM_PAGE_SIZE, MAXIMUM_PAGE_SIZE, "pageSize");
         mPageSize = pageSize;
     }
 
     /**
      * Returns maximum number of {@code MedicalResource}s to be returned by the read operation if
      * set, 1000 otherwise.
      */
     @IntRange(from = MINIMUM_PAGE_SIZE, to = MAXIMUM_PAGE_SIZE)
getPageSize()     public int getPageSize() {
         return mPageSize;
     }
 
     /**
      * Returns an instance of {@link ReadMedicalResourcesRequestParcel} to carry the request.
      *
      * @hide
      */
     @SuppressWarnings("HiddenAbstractMethod")
toParcel()     abstract ReadMedicalResourcesRequestParcel toParcel();
 }
 

 package android.health.connect;
 
 /** @hide */
 parcelable ReadMedicalResourcesResponse;

 /*
  * Copyright (C) 2024 The Android Open Source Project
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
  * You may obtain a copy of the License at
  *
  *      http://www.apache.org/licenses/LICENSE-2.0
  *
  * Unless required by applicable law or agreed to in writing, software
  * distributed under the License is distributed on an "AS IS" BASIS,
  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
 
 package android.health.connect;
 
 import static com.android.healthfitness.flags.Flags.FLAG_PERSONAL_HEALTH_RECORD;
 
 import static java.util.Objects.hash;
 import static java.util.Objects.requireNonNull;
 
 import android.annotation.FlaggedApi;
 import android.annotation.NonNull;
 import android.annotation.Nullable;
 import android.health.connect.datatypes.MedicalResource;
 import android.health.connect.internal.ParcelUtils;
 import android.os.Parcel;
 import android.os.Parcelable;
 
 import java.util.ArrayList;
 import java.util.List;
 import java.util.Objects;
 
 /** A read response for {@link HealthConnectManager#readMedicalResources}. */
 @FlaggedApi(FLAG_PERSONAL_HEALTH_RECORD)
 public final class ReadMedicalResourcesResponse implements Parcelable {
     @NonNull private final List<MedicalResource> mMedicalResources;
     @Nullable private final String mNextPageToken;
     private final int mRemainingCount;
 
     /**
      * Constructs a new {@link ReadMedicalResourcesResponse} instance.
      *
      * @param medicalResources List of {@link MedicalResource}s.
      * @param nextPageToken The token value of the read result which can be used as input token for
      *     next read request. {@code null} if there are no more pages available.
      * @param remainingCount the total number of medical resources remaining, excluding the ones in
      *     this response
      */
ReadMedicalResourcesResponse( @onNull List<MedicalResource> medicalResources, @Nullable String nextPageToken, int remainingCount)     public ReadMedicalResourcesResponse(
             @NonNull List<MedicalResource> medicalResources,
             @Nullable String nextPageToken,
             int remainingCount) {
         requireNonNull(medicalResources);
         if (nextPageToken == null && remainingCount > 0) {
             throw new IllegalArgumentException(
                     String.format(
                             "Remaining count must be 0 to have a null next page token, but was %d",
                             remainingCount));
         }
         if (nextPageToken != null && remainingCount == 0) {
             throw new IllegalArgumentException("Next page token provided with no remaining data");
         }
         mMedicalResources = medicalResources;
         mNextPageToken = nextPageToken;
         mRemainingCount = remainingCount;
     }
 
ReadMedicalResourcesResponse(@onNull Parcel in)     private ReadMedicalResourcesResponse(@NonNull Parcel in) {
         requireNonNull(in);
         in = ParcelUtils.getParcelForSharedMemoryIfRequired(in);
         mMedicalResources = new ArrayList<>();
         in.readParcelableList(
                 mMedicalResources, MedicalResource.class.getClassLoader(), MedicalResource.class);
         mNextPageToken = in.readString();
         mRemainingCount = in.readInt();
     }
 
     @NonNull
     public static final Creator<ReadMedicalResourcesResponse> CREATOR =
             new Creator<>() {
                 @Override
                 public ReadMedicalResourcesResponse createFromParcel(Parcel in) {
                     return new ReadMedicalResourcesResponse(in);
                 }
 
                 @Override
                 public ReadMedicalResourcesResponse[] newArray(int size) {
                     return new ReadMedicalResourcesResponse[size];
                 }
             };
 
     /** Returns list of {@link MedicalResource}s. */
     @NonNull
getMedicalResources()     public List<MedicalResource> getMedicalResources() {
         return mMedicalResources;
     }
 
     /**
      * Returns a page token to read the next page of the result. {@code null} if there are no more
      * pages available.
      */
     @Nullable
getNextPageToken()     public String getNextPageToken() {
         return mNextPageToken;
     }
 
     /**
      * Returns the count of medical resources still remaining which were not returned due to
      * pagination.
      *
      * <p>For a response with a null next page token, this will be 0. This result is accurate at the
      * time the request was made, and with the permissions when the request was made. However, the
      * actual results may change if permissions change or resources are inserted or deleted.
      */
getRemainingCount()     public int getRemainingCount() {
         return mRemainingCount;
     }
 
     @Override
describeContents()     public int describeContents() {
         return 0;
     }
 
     @Override
writeToParcel(@onNull Parcel dest, int flags)     public void writeToParcel(@NonNull Parcel dest, int flags) {
         requireNonNull(dest);
         ParcelUtils.putToRequiredMemory(dest, flags, this::writeToParcelInternal);
     }
 
writeToParcelInternal(@onNull Parcel dest)     private void writeToParcelInternal(@NonNull Parcel dest) {
         requireNonNull(dest);
         dest.writeParcelableList(mMedicalResources, 0);
         dest.writeString(mNextPageToken);
         dest.writeInt(mRemainingCount);
     }
 
     @Override
equals(Object o)     public boolean equals(Object o) {
         if (this == o) return true;
         if (!(o instanceof ReadMedicalResourcesResponse that)) return false;
         return getMedicalResources().equals(that.getMedicalResources())
                 && Objects.equals(getNextPageToken(), that.getNextPageToken())
                 && mRemainingCount == that.getRemainingCount();
     }
 
     @Override
hashCode()     public int hashCode() {
         return hash(getMedicalResources(), getNextPageToken(), mRemainingCount);
     }
 
     @Override
toString()     public String toString() {
         StringBuilder sb = new StringBuilder();
         sb.append(this.getClass().getSimpleName()).append("{");
         sb.append("medicalResources=").append(getMedicalResources());
         sb.append(",nextPageToken=").append(getNextPageToken());
         sb.append("}");
         return sb.toString();
     }
 }