All Downloads are FREE. Search and download functionalities are using the official Maven repository.

com.huaweicloud.sdk.iotanalytics.v1.IoTAnalyticsMeta Maven / Gradle / Ivy

Go to download

There is a newer version: 3.1.114
Show newest version
package com.huaweicloud.sdk.iotanalytics.v1;

import com.huaweicloud.sdk.core.TypeCasts;
import com.huaweicloud.sdk.core.http.FieldExistence;
import com.huaweicloud.sdk.core.http.HttpMethod;
import com.huaweicloud.sdk.core.http.HttpRequestDef;
import com.huaweicloud.sdk.core.http.LocationType;
import com.huaweicloud.sdk.iotanalytics.v1.model.AddDevDataRequest;
import com.huaweicloud.sdk.iotanalytics.v1.model.AddDevDataResponse;
import com.huaweicloud.sdk.iotanalytics.v1.model.AddPipelineJobRequest;
import com.huaweicloud.sdk.iotanalytics.v1.model.AddPipelineJobResponse;
import com.huaweicloud.sdk.iotanalytics.v1.model.AssetAddRequest;
import com.huaweicloud.sdk.iotanalytics.v1.model.AssetModRequest;
import com.huaweicloud.sdk.iotanalytics.v1.model.AssetModelAddRequest;
import com.huaweicloud.sdk.iotanalytics.v1.model.AssetModelModRequest;
import com.huaweicloud.sdk.iotanalytics.v1.model.CreateAssetModelRequest;
import com.huaweicloud.sdk.iotanalytics.v1.model.CreateAssetModelResponse;
import com.huaweicloud.sdk.iotanalytics.v1.model.CreateAssetNewRequest;
import com.huaweicloud.sdk.iotanalytics.v1.model.CreateAssetNewResponse;
import com.huaweicloud.sdk.iotanalytics.v1.model.CreateBatchJobRequest;
import com.huaweicloud.sdk.iotanalytics.v1.model.CreateBatchJobResponse;
import com.huaweicloud.sdk.iotanalytics.v1.model.CreateComputingResourceRequest;
import com.huaweicloud.sdk.iotanalytics.v1.model.CreateComputingResourceRequestBody;
import com.huaweicloud.sdk.iotanalytics.v1.model.CreateComputingResourceResponse;
import com.huaweicloud.sdk.iotanalytics.v1.model.CreateDatasourceReqDTO;
import com.huaweicloud.sdk.iotanalytics.v1.model.CreateDatasourceRequest;
import com.huaweicloud.sdk.iotanalytics.v1.model.CreateDatasourceResponse;
import com.huaweicloud.sdk.iotanalytics.v1.model.CreateGroupRequest;
import com.huaweicloud.sdk.iotanalytics.v1.model.CreateGroupResponse;
import com.huaweicloud.sdk.iotanalytics.v1.model.CreateRunRequest;
import com.huaweicloud.sdk.iotanalytics.v1.model.CreateRunRequestBody;
import com.huaweicloud.sdk.iotanalytics.v1.model.CreateRunResponse;
import com.huaweicloud.sdk.iotanalytics.v1.model.CreateStreamingJobRequest;
import com.huaweicloud.sdk.iotanalytics.v1.model.CreateStreamingJobResponse;
import com.huaweicloud.sdk.iotanalytics.v1.model.CreateTableRequest;
import com.huaweicloud.sdk.iotanalytics.v1.model.CreateTableRequestBody;
import com.huaweicloud.sdk.iotanalytics.v1.model.CreateTableResponse;
import com.huaweicloud.sdk.iotanalytics.v1.model.DeleteAssetModelRequest;
import com.huaweicloud.sdk.iotanalytics.v1.model.DeleteAssetModelResponse;
import com.huaweicloud.sdk.iotanalytics.v1.model.DeleteAssetNewRequest;
import com.huaweicloud.sdk.iotanalytics.v1.model.DeleteAssetNewResponse;
import com.huaweicloud.sdk.iotanalytics.v1.model.DeleteBatchJobRequest;
import com.huaweicloud.sdk.iotanalytics.v1.model.DeleteBatchJobResponse;
import com.huaweicloud.sdk.iotanalytics.v1.model.DeleteComputingResourceRequest;
import com.huaweicloud.sdk.iotanalytics.v1.model.DeleteComputingResourceResponse;
import com.huaweicloud.sdk.iotanalytics.v1.model.DeleteDataStoreRequest;
import com.huaweicloud.sdk.iotanalytics.v1.model.DeleteDataStoreResponse;
import com.huaweicloud.sdk.iotanalytics.v1.model.DeleteDatasourceRequest;
import com.huaweicloud.sdk.iotanalytics.v1.model.DeleteDatasourceResponse;
import com.huaweicloud.sdk.iotanalytics.v1.model.DeleteGroupRequest;
import com.huaweicloud.sdk.iotanalytics.v1.model.DeleteGroupResponse;
import com.huaweicloud.sdk.iotanalytics.v1.model.DeletePipelineJobRequest;
import com.huaweicloud.sdk.iotanalytics.v1.model.DeletePipelineJobResponse;
import com.huaweicloud.sdk.iotanalytics.v1.model.DeleteRunRequest;
import com.huaweicloud.sdk.iotanalytics.v1.model.DeleteRunResponse;
import com.huaweicloud.sdk.iotanalytics.v1.model.DeleteStreamingJobByIdRequest;
import com.huaweicloud.sdk.iotanalytics.v1.model.DeleteStreamingJobByIdResponse;
import com.huaweicloud.sdk.iotanalytics.v1.model.DeleteTableRequest;
import com.huaweicloud.sdk.iotanalytics.v1.model.DeleteTableResponse;
import com.huaweicloud.sdk.iotanalytics.v1.model.ExportDatasetRequest;
import com.huaweicloud.sdk.iotanalytics.v1.model.ExportDatasetResponse;
import com.huaweicloud.sdk.iotanalytics.v1.model.GetHistoryRequest;
import com.huaweicloud.sdk.iotanalytics.v1.model.GetMetricsRequest;
import com.huaweicloud.sdk.iotanalytics.v1.model.GetMetricsValue;
import com.huaweicloud.sdk.iotanalytics.v1.model.GetPropertyRequest;
import com.huaweicloud.sdk.iotanalytics.v1.model.ImportDataRequest;
import com.huaweicloud.sdk.iotanalytics.v1.model.ImportDataRequestBody;
import com.huaweicloud.sdk.iotanalytics.v1.model.ImportDataResponse;
import com.huaweicloud.sdk.iotanalytics.v1.model.Job;
import com.huaweicloud.sdk.iotanalytics.v1.model.LastAssetPropertyValueRequest;
import com.huaweicloud.sdk.iotanalytics.v1.model.ListAssetModelsRequest;
import com.huaweicloud.sdk.iotanalytics.v1.model.ListAssetModelsResponse;
import com.huaweicloud.sdk.iotanalytics.v1.model.ListAssetsNewRequest;
import com.huaweicloud.sdk.iotanalytics.v1.model.ListAssetsNewResponse;
import com.huaweicloud.sdk.iotanalytics.v1.model.ListBatchJobsRequest;
import com.huaweicloud.sdk.iotanalytics.v1.model.ListBatchJobsResponse;
import com.huaweicloud.sdk.iotanalytics.v1.model.ListComputingResourcesRequest;
import com.huaweicloud.sdk.iotanalytics.v1.model.ListComputingResourcesResponse;
import com.huaweicloud.sdk.iotanalytics.v1.model.ListDataStoresRequest;
import com.huaweicloud.sdk.iotanalytics.v1.model.ListDataStoresResponse;
import com.huaweicloud.sdk.iotanalytics.v1.model.ListGroupsRequest;
import com.huaweicloud.sdk.iotanalytics.v1.model.ListGroupsResponse;
import com.huaweicloud.sdk.iotanalytics.v1.model.ListHistoryRequest;
import com.huaweicloud.sdk.iotanalytics.v1.model.ListHistoryResponse;
import com.huaweicloud.sdk.iotanalytics.v1.model.ListMetricsRequest;
import com.huaweicloud.sdk.iotanalytics.v1.model.ListMetricsResponse;
import com.huaweicloud.sdk.iotanalytics.v1.model.ListPipelineJobsRequest;
import com.huaweicloud.sdk.iotanalytics.v1.model.ListPipelineJobsResponse;
import com.huaweicloud.sdk.iotanalytics.v1.model.ListRunsRequest;
import com.huaweicloud.sdk.iotanalytics.v1.model.ListRunsResponse;
import com.huaweicloud.sdk.iotanalytics.v1.model.ListTablesRequest;
import com.huaweicloud.sdk.iotanalytics.v1.model.ListTablesResponse;
import com.huaweicloud.sdk.iotanalytics.v1.model.ListTagValuesRequest;
import com.huaweicloud.sdk.iotanalytics.v1.model.ListTagValuesResponse;
import com.huaweicloud.sdk.iotanalytics.v1.model.PublishRootAssetRequest;
import com.huaweicloud.sdk.iotanalytics.v1.model.PublishRootAssetResponse;
import com.huaweicloud.sdk.iotanalytics.v1.model.RawRequest;
import com.huaweicloud.sdk.iotanalytics.v1.model.ShowAllDataSourceRequest;
import com.huaweicloud.sdk.iotanalytics.v1.model.ShowAllDataSourceResponse;
import com.huaweicloud.sdk.iotanalytics.v1.model.ShowAssetModelRequest;
import com.huaweicloud.sdk.iotanalytics.v1.model.ShowAssetModelResponse;
import com.huaweicloud.sdk.iotanalytics.v1.model.ShowAssetNewRequest;
import com.huaweicloud.sdk.iotanalytics.v1.model.ShowAssetNewResponse;
import com.huaweicloud.sdk.iotanalytics.v1.model.ShowBatchJobRequest;
import com.huaweicloud.sdk.iotanalytics.v1.model.ShowBatchJobResponse;
import com.huaweicloud.sdk.iotanalytics.v1.model.ShowDataSourceRequest;
import com.huaweicloud.sdk.iotanalytics.v1.model.ShowDataSourceResponse;
import com.huaweicloud.sdk.iotanalytics.v1.model.ShowDatasetRequest;
import com.huaweicloud.sdk.iotanalytics.v1.model.ShowDatasetResponse;
import com.huaweicloud.sdk.iotanalytics.v1.model.ShowJobByIdRequest;
import com.huaweicloud.sdk.iotanalytics.v1.model.ShowJobByIdResponse;
import com.huaweicloud.sdk.iotanalytics.v1.model.ShowJobsRequest;
import com.huaweicloud.sdk.iotanalytics.v1.model.ShowJobsResponse;
import com.huaweicloud.sdk.iotanalytics.v1.model.ShowLastPropertyValueRequest;
import com.huaweicloud.sdk.iotanalytics.v1.model.ShowLastPropertyValueResponse;
import com.huaweicloud.sdk.iotanalytics.v1.model.ShowMetricValueRequest;
import com.huaweicloud.sdk.iotanalytics.v1.model.ShowMetricValueResponse;
import com.huaweicloud.sdk.iotanalytics.v1.model.ShowPipelineJobRequest;
import com.huaweicloud.sdk.iotanalytics.v1.model.ShowPipelineJobResponse;
import com.huaweicloud.sdk.iotanalytics.v1.model.ShowPropertyRawValueRequest;
import com.huaweicloud.sdk.iotanalytics.v1.model.ShowPropertyRawValueResponse;
import com.huaweicloud.sdk.iotanalytics.v1.model.ShowPropertyValuesRequest;
import com.huaweicloud.sdk.iotanalytics.v1.model.ShowPropertyValuesResponse;
import com.huaweicloud.sdk.iotanalytics.v1.model.ShowRunRequest;
import com.huaweicloud.sdk.iotanalytics.v1.model.ShowRunResponse;
import com.huaweicloud.sdk.iotanalytics.v1.model.ShowTablePreviewRequest;
import com.huaweicloud.sdk.iotanalytics.v1.model.ShowTablePreviewResponse;
import com.huaweicloud.sdk.iotanalytics.v1.model.ShowTableSchemaRequest;
import com.huaweicloud.sdk.iotanalytics.v1.model.ShowTableSchemaResponse;
import com.huaweicloud.sdk.iotanalytics.v1.model.StartJobRequest;
import com.huaweicloud.sdk.iotanalytics.v1.model.StartJobResponse;
import com.huaweicloud.sdk.iotanalytics.v1.model.StartPipelineJobRequest;
import com.huaweicloud.sdk.iotanalytics.v1.model.StartPipelineJobResponse;
import com.huaweicloud.sdk.iotanalytics.v1.model.StopJobRequest;
import com.huaweicloud.sdk.iotanalytics.v1.model.StopJobResponse;
import com.huaweicloud.sdk.iotanalytics.v1.model.StopPipelineJobRequest;
import com.huaweicloud.sdk.iotanalytics.v1.model.StopPipelineJobResponse;
import com.huaweicloud.sdk.iotanalytics.v1.model.StorageGroup;
import com.huaweicloud.sdk.iotanalytics.v1.model.UpdateAssetModelRequest;
import com.huaweicloud.sdk.iotanalytics.v1.model.UpdateAssetModelResponse;
import com.huaweicloud.sdk.iotanalytics.v1.model.UpdateAssetNewRequest;
import com.huaweicloud.sdk.iotanalytics.v1.model.UpdateAssetNewResponse;
import com.huaweicloud.sdk.iotanalytics.v1.model.UpdateBatchJobRequest;
import com.huaweicloud.sdk.iotanalytics.v1.model.UpdateBatchJobResponse;
import com.huaweicloud.sdk.iotanalytics.v1.model.UpdateDataSourceRequest;
import com.huaweicloud.sdk.iotanalytics.v1.model.UpdateDataSourceResponse;
import com.huaweicloud.sdk.iotanalytics.v1.model.UpdateDataStore;
import com.huaweicloud.sdk.iotanalytics.v1.model.UpdateDataStoreRequest;
import com.huaweicloud.sdk.iotanalytics.v1.model.UpdateDataStoreResponse;
import com.huaweicloud.sdk.iotanalytics.v1.model.UpdateDatasourceReqDTO;
import com.huaweicloud.sdk.iotanalytics.v1.model.UpdateGroupRequest;
import com.huaweicloud.sdk.iotanalytics.v1.model.UpdateGroupResponse;
import com.huaweicloud.sdk.iotanalytics.v1.model.UpdatePipelineJobRequest;
import com.huaweicloud.sdk.iotanalytics.v1.model.UpdatePipelineJobResponse;
import com.huaweicloud.sdk.iotanalytics.v1.model.UpdateStreamingJobRequest;
import com.huaweicloud.sdk.iotanalytics.v1.model.UpdateStreamingJobResponse;
import com.huaweicloud.sdk.iotanalytics.v1.model.ValidateSqlRequest;
import com.huaweicloud.sdk.iotanalytics.v1.model.ValidateSqlRequestBody;
import com.huaweicloud.sdk.iotanalytics.v1.model.ValidateSqlResponse;

import java.util.Map;

@SuppressWarnings("unchecked")
public class IoTAnalyticsMeta {

    public static final HttpRequestDef createAssetModel =
        genForCreateAssetModel();

    private static HttpRequestDef genForCreateAssetModel() {
        // basic
        HttpRequestDef.Builder builder =
            HttpRequestDef.builder(HttpMethod.POST, CreateAssetModelRequest.class, CreateAssetModelResponse.class)
                .withName("CreateAssetModel")
                .withUri("/v1/{project_id}/asset-models")
                .withContentType("application/json");

        // requests
        builder.withRequestField("body",
            LocationType.Body,
            FieldExistence.NON_NULL_NON_EMPTY,
            TypeCasts.uncheckedConversion(AssetModelAddRequest.class),
            f -> f.withMarshaller(CreateAssetModelRequest::getBody, CreateAssetModelRequest::setBody));

        // response

        return builder.build();
    }

    public static final HttpRequestDef deleteAssetModel =
        genForDeleteAssetModel();

    private static HttpRequestDef genForDeleteAssetModel() {
        // basic
        HttpRequestDef.Builder builder =
            HttpRequestDef.builder(HttpMethod.DELETE, DeleteAssetModelRequest.class, DeleteAssetModelResponse.class)
                .withName("DeleteAssetModel")
                .withUri("/v1/{project_id}/asset-models/{model_id}")
                .withContentType("application/json");

        // requests
        builder.withRequestField("model_id",
            LocationType.Path,
            FieldExistence.NON_NULL_NON_EMPTY,
            TypeCasts.uncheckedConversion(String.class),
            f -> f.withMarshaller(DeleteAssetModelRequest::getModelId, DeleteAssetModelRequest::setModelId));

        // response

        return builder.build();
    }

    public static final HttpRequestDef listAssetModels =
        genForListAssetModels();

    private static HttpRequestDef genForListAssetModels() {
        // basic
        HttpRequestDef.Builder builder =
            HttpRequestDef.builder(HttpMethod.GET, ListAssetModelsRequest.class, ListAssetModelsResponse.class)
                .withName("ListAssetModels")
                .withUri("/v1/{project_id}/asset-models")
                .withContentType("application/json");

        // requests
        builder.withRequestField("filter",
            LocationType.Query,
            FieldExistence.NULL_IGNORE,
            TypeCasts.uncheckedConversion(String.class),
            f -> f.withMarshaller(ListAssetModelsRequest::getFilter, ListAssetModelsRequest::setFilter));
        builder.withRequestField("limit",
            LocationType.Query,
            FieldExistence.NULL_IGNORE,
            TypeCasts.uncheckedConversion(Integer.class),
            f -> f.withMarshaller(ListAssetModelsRequest::getLimit, ListAssetModelsRequest::setLimit));
        builder.withRequestField("offset",
            LocationType.Query,
            FieldExistence.NULL_IGNORE,
            TypeCasts.uncheckedConversion(Integer.class),
            f -> f.withMarshaller(ListAssetModelsRequest::getOffset, ListAssetModelsRequest::setOffset));

        // response

        return builder.build();
    }

    public static final HttpRequestDef showAssetModel =
        genForShowAssetModel();

    private static HttpRequestDef genForShowAssetModel() {
        // basic
        HttpRequestDef.Builder builder =
            HttpRequestDef.builder(HttpMethod.GET, ShowAssetModelRequest.class, ShowAssetModelResponse.class)
                .withName("ShowAssetModel")
                .withUri("/v1/{project_id}/asset-models/{model_id}")
                .withContentType("application/json");

        // requests
        builder.withRequestField("model_id",
            LocationType.Path,
            FieldExistence.NON_NULL_NON_EMPTY,
            TypeCasts.uncheckedConversion(String.class),
            f -> f.withMarshaller(ShowAssetModelRequest::getModelId, ShowAssetModelRequest::setModelId));

        // response

        return builder.build();
    }

    public static final HttpRequestDef updateAssetModel =
        genForUpdateAssetModel();

    private static HttpRequestDef genForUpdateAssetModel() {
        // basic
        HttpRequestDef.Builder builder =
            HttpRequestDef.builder(HttpMethod.PUT, UpdateAssetModelRequest.class, UpdateAssetModelResponse.class)
                .withName("UpdateAssetModel")
                .withUri("/v1/{project_id}/asset-models/{model_id}")
                .withContentType("application/json");

        // requests
        builder.withRequestField("model_id",
            LocationType.Path,
            FieldExistence.NON_NULL_NON_EMPTY,
            TypeCasts.uncheckedConversion(String.class),
            f -> f.withMarshaller(UpdateAssetModelRequest::getModelId, UpdateAssetModelRequest::setModelId));
        builder.withRequestField("body",
            LocationType.Body,
            FieldExistence.NON_NULL_NON_EMPTY,
            TypeCasts.uncheckedConversion(AssetModelModRequest.class),
            f -> f.withMarshaller(UpdateAssetModelRequest::getBody, UpdateAssetModelRequest::setBody));

        // response

        return builder.build();
    }

    public static final HttpRequestDef createAssetNew =
        genForCreateAssetNew();

    private static HttpRequestDef genForCreateAssetNew() {
        // basic
        HttpRequestDef.Builder builder =
            HttpRequestDef.builder(HttpMethod.POST, CreateAssetNewRequest.class, CreateAssetNewResponse.class)
                .withName("CreateAssetNew")
                .withUri("/v1/{project_id}/assets")
                .withContentType("application/json");

        // requests
        builder.withRequestField("body",
            LocationType.Body,
            FieldExistence.NON_NULL_NON_EMPTY,
            TypeCasts.uncheckedConversion(AssetAddRequest.class),
            f -> f.withMarshaller(CreateAssetNewRequest::getBody, CreateAssetNewRequest::setBody));

        // response

        return builder.build();
    }

    public static final HttpRequestDef deleteAssetNew =
        genForDeleteAssetNew();

    private static HttpRequestDef genForDeleteAssetNew() {
        // basic
        HttpRequestDef.Builder builder =
            HttpRequestDef.builder(HttpMethod.DELETE, DeleteAssetNewRequest.class, DeleteAssetNewResponse.class)
                .withName("DeleteAssetNew")
                .withUri("/v1/{project_id}/assets/{asset_id}")
                .withContentType("application/json");

        // requests
        builder.withRequestField("asset_id",
            LocationType.Path,
            FieldExistence.NON_NULL_NON_EMPTY,
            TypeCasts.uncheckedConversion(String.class),
            f -> f.withMarshaller(DeleteAssetNewRequest::getAssetId, DeleteAssetNewRequest::setAssetId));

        // response

        return builder.build();
    }

    public static final HttpRequestDef listAssetsNew =
        genForListAssetsNew();

    private static HttpRequestDef genForListAssetsNew() {
        // basic
        HttpRequestDef.Builder builder =
            HttpRequestDef.builder(HttpMethod.GET, ListAssetsNewRequest.class, ListAssetsNewResponse.class)
                .withName("ListAssetsNew")
                .withUri("/v1/{project_id}/assets")
                .withContentType("application/json");

        // requests
        builder.withRequestField("limit",
            LocationType.Query,
            FieldExistence.NULL_IGNORE,
            TypeCasts.uncheckedConversion(Integer.class),
            f -> f.withMarshaller(ListAssetsNewRequest::getLimit, ListAssetsNewRequest::setLimit));
        builder.withRequestField("offset",
            LocationType.Query,
            FieldExistence.NULL_IGNORE,
            TypeCasts.uncheckedConversion(Integer.class),
            f -> f.withMarshaller(ListAssetsNewRequest::getOffset, ListAssetsNewRequest::setOffset));
        builder.withRequestField("filter",
            LocationType.Query,
            FieldExistence.NULL_IGNORE,
            TypeCasts.uncheckedConversion(String.class),
            f -> f.withMarshaller(ListAssetsNewRequest::getFilter, ListAssetsNewRequest::setFilter));
        builder.withRequestField("type",
            LocationType.Query,
            FieldExistence.NON_NULL_NON_EMPTY,
            TypeCasts.uncheckedConversion(String.class),
            f -> f.withMarshaller(ListAssetsNewRequest::getType, ListAssetsNewRequest::setType));

        // response

        return builder.build();
    }

    public static final HttpRequestDef publishRootAsset =
        genForPublishRootAsset();

    private static HttpRequestDef genForPublishRootAsset() {
        // basic
        HttpRequestDef.Builder builder =
            HttpRequestDef.builder(HttpMethod.POST, PublishRootAssetRequest.class, PublishRootAssetResponse.class)
                .withName("PublishRootAsset")
                .withUri("/v1/{project_id}/assets/{root_asset_id}/publish")
                .withContentType("application/json");

        // requests
        builder.withRequestField("root_asset_id",
            LocationType.Path,
            FieldExistence.NON_NULL_NON_EMPTY,
            TypeCasts.uncheckedConversion(String.class),
            f -> f.withMarshaller(PublishRootAssetRequest::getRootAssetId, PublishRootAssetRequest::setRootAssetId));

        // response

        return builder.build();
    }

    public static final HttpRequestDef showAssetNew = genForShowAssetNew();

    private static HttpRequestDef genForShowAssetNew() {
        // basic
        HttpRequestDef.Builder builder =
            HttpRequestDef.builder(HttpMethod.GET, ShowAssetNewRequest.class, ShowAssetNewResponse.class)
                .withName("ShowAssetNew")
                .withUri("/v1/{project_id}/assets/{asset_id}")
                .withContentType("application/json");

        // requests
        builder.withRequestField("asset_id",
            LocationType.Path,
            FieldExistence.NON_NULL_NON_EMPTY,
            TypeCasts.uncheckedConversion(String.class),
            f -> f.withMarshaller(ShowAssetNewRequest::getAssetId, ShowAssetNewRequest::setAssetId));
        builder.withRequestField("type",
            LocationType.Query,
            FieldExistence.NON_NULL_NON_EMPTY,
            TypeCasts.uncheckedConversion(String.class),
            f -> f.withMarshaller(ShowAssetNewRequest::getType, ShowAssetNewRequest::setType));

        // response

        return builder.build();
    }

    public static final HttpRequestDef updateAssetNew =
        genForUpdateAssetNew();

    private static HttpRequestDef genForUpdateAssetNew() {
        // basic
        HttpRequestDef.Builder builder =
            HttpRequestDef.builder(HttpMethod.PUT, UpdateAssetNewRequest.class, UpdateAssetNewResponse.class)
                .withName("UpdateAssetNew")
                .withUri("/v1/{project_id}/assets/{asset_id}")
                .withContentType("application/json");

        // requests
        builder.withRequestField("asset_id",
            LocationType.Path,
            FieldExistence.NON_NULL_NON_EMPTY,
            TypeCasts.uncheckedConversion(String.class),
            f -> f.withMarshaller(UpdateAssetNewRequest::getAssetId, UpdateAssetNewRequest::setAssetId));
        builder.withRequestField("body",
            LocationType.Body,
            FieldExistence.NON_NULL_NON_EMPTY,
            TypeCasts.uncheckedConversion(AssetModRequest.class),
            f -> f.withMarshaller(UpdateAssetNewRequest::getBody, UpdateAssetNewRequest::setBody));

        // response

        return builder.build();
    }

    public static final HttpRequestDef showLastPropertyValue =
        genForShowLastPropertyValue();

    private static HttpRequestDef genForShowLastPropertyValue() {
        // basic
        HttpRequestDef.Builder builder = HttpRequestDef
            .builder(HttpMethod.POST, ShowLastPropertyValueRequest.class, ShowLastPropertyValueResponse.class)
            .withName("ShowLastPropertyValue")
            .withUri("/v1/{project_id}/assets/{asset_id}/property-values/query-last")
            .withContentType("application/json");

        // requests
        builder.withRequestField("asset_id",
            LocationType.Path,
            FieldExistence.NON_NULL_NON_EMPTY,
            TypeCasts.uncheckedConversion(String.class),
            f -> f.withMarshaller(ShowLastPropertyValueRequest::getAssetId, ShowLastPropertyValueRequest::setAssetId));
        builder.withRequestField("body",
            LocationType.Body,
            FieldExistence.NON_NULL_NON_EMPTY,
            TypeCasts.uncheckedConversion(LastAssetPropertyValueRequest.class),
            f -> f.withMarshaller(ShowLastPropertyValueRequest::getBody, ShowLastPropertyValueRequest::setBody));

        // response

        return builder.build();
    }

    public static final HttpRequestDef showMetricValue =
        genForShowMetricValue();

    private static HttpRequestDef genForShowMetricValue() {
        // basic
        HttpRequestDef.Builder builder =
            HttpRequestDef.builder(HttpMethod.POST, ShowMetricValueRequest.class, ShowMetricValueResponse.class)
                .withName("ShowMetricValue")
                .withUri("/v1/{project_id}/assets/{asset_id}/metrics/query")
                .withContentType("application/json");

        // requests
        builder.withRequestField("asset_id",
            LocationType.Path,
            FieldExistence.NON_NULL_NON_EMPTY,
            TypeCasts.uncheckedConversion(String.class),
            f -> f.withMarshaller(ShowMetricValueRequest::getAssetId, ShowMetricValueRequest::setAssetId));
        builder.withRequestField("body",
            LocationType.Body,
            FieldExistence.NON_NULL_NON_EMPTY,
            TypeCasts.uncheckedConversion(GetMetricsValue.class),
            f -> f.withMarshaller(ShowMetricValueRequest::getBody, ShowMetricValueRequest::setBody));

        // response

        return builder.build();
    }

    public static final HttpRequestDef showPropertyRawValue =
        genForShowPropertyRawValue();

    private static HttpRequestDef genForShowPropertyRawValue() {
        // basic
        HttpRequestDef.Builder builder = HttpRequestDef
            .builder(HttpMethod.POST, ShowPropertyRawValueRequest.class, ShowPropertyRawValueResponse.class)
            .withName("ShowPropertyRawValue")
            .withUri("/v1/{project_id}/assets/{asset_id}/property-values/query")
            .withContentType("application/json");

        // requests
        builder.withRequestField("asset_id",
            LocationType.Path,
            FieldExistence.NON_NULL_NON_EMPTY,
            TypeCasts.uncheckedConversion(String.class),
            f -> f.withMarshaller(ShowPropertyRawValueRequest::getAssetId, ShowPropertyRawValueRequest::setAssetId));
        builder.withRequestField("body",
            LocationType.Body,
            FieldExistence.NON_NULL_NON_EMPTY,
            TypeCasts.uncheckedConversion(RawRequest.class),
            f -> f.withMarshaller(ShowPropertyRawValueRequest::getBody, ShowPropertyRawValueRequest::setBody));

        // response

        return builder.build();
    }

    public static final HttpRequestDef createComputingResource =
        genForCreateComputingResource();

    private static HttpRequestDef genForCreateComputingResource() {
        // basic
        HttpRequestDef.Builder builder = HttpRequestDef
            .builder(HttpMethod.POST, CreateComputingResourceRequest.class, CreateComputingResourceResponse.class)
            .withName("CreateComputingResource")
            .withUri("/v1/{project_id}/batch-computing-resources")
            .withContentType("application/json");

        // requests
        builder.withRequestField("body",
            LocationType.Body,
            FieldExistence.NON_NULL_NON_EMPTY,
            TypeCasts.uncheckedConversion(CreateComputingResourceRequestBody.class),
            f -> f.withMarshaller(CreateComputingResourceRequest::getBody, CreateComputingResourceRequest::setBody));

        // response

        return builder.build();
    }

    public static final HttpRequestDef deleteComputingResource =
        genForDeleteComputingResource();

    private static HttpRequestDef genForDeleteComputingResource() {
        // basic
        HttpRequestDef.Builder builder = HttpRequestDef
            .builder(HttpMethod.DELETE, DeleteComputingResourceRequest.class, DeleteComputingResourceResponse.class)
            .withName("DeleteComputingResource")
            .withUri("/v1/{project_id}/batch-computing-resources/{computing_resource_id}")
            .withContentType("application/json");

        // requests
        builder.withRequestField("computing_resource_id",
            LocationType.Path,
            FieldExistence.NON_NULL_NON_EMPTY,
            TypeCasts.uncheckedConversion(String.class),
            f -> f.withMarshaller(DeleteComputingResourceRequest::getComputingResourceId,
                DeleteComputingResourceRequest::setComputingResourceId));

        // response

        return builder.build();
    }

    public static final HttpRequestDef listComputingResources =
        genForListComputingResources();

    private static HttpRequestDef genForListComputingResources() {
        // basic
        HttpRequestDef.Builder builder = HttpRequestDef
            .builder(HttpMethod.GET, ListComputingResourcesRequest.class, ListComputingResourcesResponse.class)
            .withName("ListComputingResources")
            .withUri("/v1/{project_id}/batch-computing-resources")
            .withContentType("application/json");

        // requests
        builder.withRequestField("computing_resource_name",
            LocationType.Query,
            FieldExistence.NULL_IGNORE,
            TypeCasts.uncheckedConversion(String.class),
            f -> f.withMarshaller(ListComputingResourcesRequest::getComputingResourceName,
                ListComputingResourcesRequest::setComputingResourceName));
        builder.withRequestField("offset",
            LocationType.Query,
            FieldExistence.NULL_IGNORE,
            TypeCasts.uncheckedConversion(Integer.class),
            f -> f.withMarshaller(ListComputingResourcesRequest::getOffset, ListComputingResourcesRequest::setOffset));
        builder.withRequestField("limit",
            LocationType.Query,
            FieldExistence.NULL_IGNORE,
            TypeCasts.uncheckedConversion(Integer.class),
            f -> f.withMarshaller(ListComputingResourcesRequest::getLimit, ListComputingResourcesRequest::setLimit));

        // response

        return builder.build();
    }

    public static final HttpRequestDef createDatasource =
        genForCreateDatasource();

    private static HttpRequestDef genForCreateDatasource() {
        // basic
        HttpRequestDef.Builder builder =
            HttpRequestDef.builder(HttpMethod.POST, CreateDatasourceRequest.class, CreateDatasourceResponse.class)
                .withName("CreateDatasource")
                .withUri("/v1/{project_id}/datasources")
                .withContentType("application/json");

        // requests
        builder.withRequestField("body",
            LocationType.Body,
            FieldExistence.NON_NULL_NON_EMPTY,
            TypeCasts.uncheckedConversion(CreateDatasourceReqDTO.class),
            f -> f.withMarshaller(CreateDatasourceRequest::getBody, CreateDatasourceRequest::setBody));

        // response

        return builder.build();
    }

    public static final HttpRequestDef deleteDatasource =
        genForDeleteDatasource();

    private static HttpRequestDef genForDeleteDatasource() {
        // basic
        HttpRequestDef.Builder builder =
            HttpRequestDef.builder(HttpMethod.DELETE, DeleteDatasourceRequest.class, DeleteDatasourceResponse.class)
                .withName("DeleteDatasource")
                .withUri("/v1/{project_id}/datasources/{datasource_id}")
                .withContentType("application/json");

        // requests
        builder.withRequestField("datasource_id",
            LocationType.Path,
            FieldExistence.NON_NULL_NON_EMPTY,
            TypeCasts.uncheckedConversion(String.class),
            f -> f.withMarshaller(DeleteDatasourceRequest::getDatasourceId, DeleteDatasourceRequest::setDatasourceId));

        // response
        builder.withResponseField("body",
            LocationType.Body,
            FieldExistence.NULL_IGNORE,
            String.class,
            f -> f.withMarshaller(DeleteDatasourceResponse::getBody, DeleteDatasourceResponse::setBody));

        return builder.build();
    }

    public static final HttpRequestDef showAllDataSource =
        genForShowAllDataSource();

    private static HttpRequestDef genForShowAllDataSource() {
        // basic
        HttpRequestDef.Builder builder =
            HttpRequestDef.builder(HttpMethod.GET, ShowAllDataSourceRequest.class, ShowAllDataSourceResponse.class)
                .withName("ShowAllDataSource")
                .withUri("/v1/{project_id}/datasources")
                .withContentType("application/json");

        // requests
        builder.withRequestField("name",
            LocationType.Query,
            FieldExistence.NULL_IGNORE,
            TypeCasts.uncheckedConversion(String.class),
            f -> f.withMarshaller(ShowAllDataSourceRequest::getName, ShowAllDataSourceRequest::setName));
        builder.withRequestField("type",
            LocationType.Query,
            FieldExistence.NULL_IGNORE,
            TypeCasts.uncheckedConversion(String.class),
            f -> f.withMarshaller(ShowAllDataSourceRequest::getType, ShowAllDataSourceRequest::setType));
        builder.withRequestField("limit",
            LocationType.Query,
            FieldExistence.NULL_IGNORE,
            TypeCasts.uncheckedConversion(Integer.class),
            f -> f.withMarshaller(ShowAllDataSourceRequest::getLimit, ShowAllDataSourceRequest::setLimit));
        builder.withRequestField("offset",
            LocationType.Query,
            FieldExistence.NULL_IGNORE,
            TypeCasts.uncheckedConversion(Integer.class),
            f -> f.withMarshaller(ShowAllDataSourceRequest::getOffset, ShowAllDataSourceRequest::setOffset));

        // response

        return builder.build();
    }

    public static final HttpRequestDef showDataSource =
        genForShowDataSource();

    private static HttpRequestDef genForShowDataSource() {
        // basic
        HttpRequestDef.Builder builder =
            HttpRequestDef.builder(HttpMethod.GET, ShowDataSourceRequest.class, ShowDataSourceResponse.class)
                .withName("ShowDataSource")
                .withUri("/v1/{project_id}/datasources/{datasource_id}")
                .withContentType("application/json");

        // requests
        builder.withRequestField("datasource_id",
            LocationType.Path,
            FieldExistence.NON_NULL_NON_EMPTY,
            TypeCasts.uncheckedConversion(String.class),
            f -> f.withMarshaller(ShowDataSourceRequest::getDatasourceId, ShowDataSourceRequest::setDatasourceId));

        // response

        return builder.build();
    }

    public static final HttpRequestDef updateDataSource =
        genForUpdateDataSource();

    private static HttpRequestDef genForUpdateDataSource() {
        // basic
        HttpRequestDef.Builder builder =
            HttpRequestDef.builder(HttpMethod.PUT, UpdateDataSourceRequest.class, UpdateDataSourceResponse.class)
                .withName("UpdateDataSource")
                .withUri("/v1/{project_id}/datasources/{datasource_id}")
                .withContentType("application/json");

        // requests
        builder.withRequestField("datasource_id",
            LocationType.Path,
            FieldExistence.NON_NULL_NON_EMPTY,
            TypeCasts.uncheckedConversion(String.class),
            f -> f.withMarshaller(UpdateDataSourceRequest::getDatasourceId, UpdateDataSourceRequest::setDatasourceId));
        builder.withRequestField("body",
            LocationType.Body,
            FieldExistence.NON_NULL_NON_EMPTY,
            TypeCasts.uncheckedConversion(UpdateDatasourceReqDTO.class),
            f -> f.withMarshaller(UpdateDataSourceRequest::getBody, UpdateDataSourceRequest::setBody));

        // response

        return builder.build();
    }

    public static final HttpRequestDef createGroup = genForCreateGroup();

    private static HttpRequestDef genForCreateGroup() {
        // basic
        HttpRequestDef.Builder builder =
            HttpRequestDef.builder(HttpMethod.POST, CreateGroupRequest.class, CreateGroupResponse.class)
                .withName("CreateGroup")
                .withUri("/v1/{project_id}/data-store-groups")
                .withContentType("application/json");

        // requests
        builder.withRequestField("body",
            LocationType.Body,
            FieldExistence.NON_NULL_NON_EMPTY,
            TypeCasts.uncheckedConversion(StorageGroup.class),
            f -> f.withMarshaller(CreateGroupRequest::getBody, CreateGroupRequest::setBody));

        // response

        return builder.build();
    }

    public static final HttpRequestDef deleteGroup = genForDeleteGroup();

    private static HttpRequestDef genForDeleteGroup() {
        // basic
        HttpRequestDef.Builder builder =
            HttpRequestDef.builder(HttpMethod.DELETE, DeleteGroupRequest.class, DeleteGroupResponse.class)
                .withName("DeleteGroup")
                .withUri("/v1/{project_id}/data-store-groups/{group_id}")
                .withContentType("application/json");

        // requests
        builder.withRequestField("group_id",
            LocationType.Path,
            FieldExistence.NON_NULL_NON_EMPTY,
            TypeCasts.uncheckedConversion(String.class),
            f -> f.withMarshaller(DeleteGroupRequest::getGroupId, DeleteGroupRequest::setGroupId));

        // response

        return builder.build();
    }

    public static final HttpRequestDef listGroups = genForListGroups();

    private static HttpRequestDef genForListGroups() {
        // basic
        HttpRequestDef.Builder builder =
            HttpRequestDef.builder(HttpMethod.GET, ListGroupsRequest.class, ListGroupsResponse.class)
                .withName("ListGroups")
                .withUri("/v1/{project_id}/data-store-groups")
                .withContentType("application/json");

        // requests
        builder.withRequestField("unit",
            LocationType.Query,
            FieldExistence.NULL_IGNORE,
            TypeCasts.uncheckedConversion(ListGroupsRequest.UnitEnum.class),
            f -> f.withMarshaller(ListGroupsRequest::getUnit, ListGroupsRequest::setUnit));
        builder.withRequestField("type",
            LocationType.Query,
            FieldExistence.NULL_IGNORE,
            TypeCasts.uncheckedConversion(String.class),
            f -> f.withMarshaller(ListGroupsRequest::getType, ListGroupsRequest::setType));
        builder.withRequestField("group_id",
            LocationType.Query,
            FieldExistence.NULL_IGNORE,
            TypeCasts.uncheckedConversion(String.class),
            f -> f.withMarshaller(ListGroupsRequest::getGroupId, ListGroupsRequest::setGroupId));
        builder.withRequestField("name",
            LocationType.Query,
            FieldExistence.NULL_IGNORE,
            TypeCasts.uncheckedConversion(String.class),
            f -> f.withMarshaller(ListGroupsRequest::getName, ListGroupsRequest::setName));
        builder.withRequestField("offset",
            LocationType.Query,
            FieldExistence.NULL_IGNORE,
            TypeCasts.uncheckedConversion(Integer.class),
            f -> f.withMarshaller(ListGroupsRequest::getOffset, ListGroupsRequest::setOffset));
        builder.withRequestField("limit",
            LocationType.Query,
            FieldExistence.NULL_IGNORE,
            TypeCasts.uncheckedConversion(Integer.class),
            f -> f.withMarshaller(ListGroupsRequest::getLimit, ListGroupsRequest::setLimit));

        // response

        return builder.build();
    }

    public static final HttpRequestDef updateGroup = genForUpdateGroup();

    private static HttpRequestDef genForUpdateGroup() {
        // basic
        HttpRequestDef.Builder builder =
            HttpRequestDef.builder(HttpMethod.PUT, UpdateGroupRequest.class, UpdateGroupResponse.class)
                .withName("UpdateGroup")
                .withUri("/v1/{project_id}/data-store-groups/{group_id}")
                .withContentType("application/json");

        // requests
        builder.withRequestField("group_id",
            LocationType.Path,
            FieldExistence.NON_NULL_NON_EMPTY,
            TypeCasts.uncheckedConversion(String.class),
            f -> f.withMarshaller(UpdateGroupRequest::getGroupId, UpdateGroupRequest::setGroupId));
        builder.withRequestField("body",
            LocationType.Body,
            FieldExistence.NON_NULL_NON_EMPTY,
            TypeCasts.uncheckedConversion(StorageGroup.class),
            f -> f.withMarshaller(UpdateGroupRequest::getBody, UpdateGroupRequest::setBody));

        // response

        return builder.build();
    }

    public static final HttpRequestDef deleteDataStore =
        genForDeleteDataStore();

    private static HttpRequestDef genForDeleteDataStore() {
        // basic
        HttpRequestDef.Builder builder =
            HttpRequestDef.builder(HttpMethod.DELETE, DeleteDataStoreRequest.class, DeleteDataStoreResponse.class)
                .withName("DeleteDataStore")
                .withUri("/v1/{project_id}/data-stores/{data_store_id}")
                .withContentType("application/json");

        // requests
        builder.withRequestField("data_store_id",
            LocationType.Path,
            FieldExistence.NON_NULL_NON_EMPTY,
            TypeCasts.uncheckedConversion(String.class),
            f -> f.withMarshaller(DeleteDataStoreRequest::getDataStoreId, DeleteDataStoreRequest::setDataStoreId));

        // response

        return builder.build();
    }

    public static final HttpRequestDef listDataStores =
        genForListDataStores();

    private static HttpRequestDef genForListDataStores() {
        // basic
        HttpRequestDef.Builder builder =
            HttpRequestDef.builder(HttpMethod.GET, ListDataStoresRequest.class, ListDataStoresResponse.class)
                .withName("ListDataStores")
                .withUri("/v1/{project_id}/data-stores")
                .withContentType("application/json");

        // requests
        builder.withRequestField("group_id",
            LocationType.Query,
            FieldExistence.NULL_IGNORE,
            TypeCasts.uncheckedConversion(String.class),
            f -> f.withMarshaller(ListDataStoresRequest::getGroupId, ListDataStoresRequest::setGroupId));
        builder.withRequestField("data_store_id",
            LocationType.Query,
            FieldExistence.NULL_IGNORE,
            TypeCasts.uncheckedConversion(String.class),
            f -> f.withMarshaller(ListDataStoresRequest::getDataStoreId, ListDataStoresRequest::setDataStoreId));
        builder.withRequestField("name",
            LocationType.Query,
            FieldExistence.NULL_IGNORE,
            TypeCasts.uncheckedConversion(String.class),
            f -> f.withMarshaller(ListDataStoresRequest::getName, ListDataStoresRequest::setName));
        builder.withRequestField("offset",
            LocationType.Query,
            FieldExistence.NULL_IGNORE,
            TypeCasts.uncheckedConversion(Integer.class),
            f -> f.withMarshaller(ListDataStoresRequest::getOffset, ListDataStoresRequest::setOffset));
        builder.withRequestField("limit",
            LocationType.Query,
            FieldExistence.NULL_IGNORE,
            TypeCasts.uncheckedConversion(Integer.class),
            f -> f.withMarshaller(ListDataStoresRequest::getLimit, ListDataStoresRequest::setLimit));

        // response

        return builder.build();
    }

    public static final HttpRequestDef updateDataStore =
        genForUpdateDataStore();

    private static HttpRequestDef genForUpdateDataStore() {
        // basic
        HttpRequestDef.Builder builder =
            HttpRequestDef.builder(HttpMethod.PUT, UpdateDataStoreRequest.class, UpdateDataStoreResponse.class)
                .withName("UpdateDataStore")
                .withUri("/v1/{project_id}/data-stores/{data_store_id}")
                .withContentType("application/json");

        // requests
        builder.withRequestField("data_store_id",
            LocationType.Path,
            FieldExistence.NON_NULL_NON_EMPTY,
            TypeCasts.uncheckedConversion(String.class),
            f -> f.withMarshaller(UpdateDataStoreRequest::getDataStoreId, UpdateDataStoreRequest::setDataStoreId));
        builder.withRequestField("body",
            LocationType.Body,
            FieldExistence.NON_NULL_NON_EMPTY,
            TypeCasts.uncheckedConversion(UpdateDataStore.class),
            f -> f.withMarshaller(UpdateDataStoreRequest::getBody, UpdateDataStoreRequest::setBody));

        // response

        return builder.build();
    }

    public static final HttpRequestDef listHistory = genForListHistory();

    private static HttpRequestDef genForListHistory() {
        // basic
        HttpRequestDef.Builder builder =
            HttpRequestDef.builder(HttpMethod.POST, ListHistoryRequest.class, ListHistoryResponse.class)
                .withName("ListHistory")
                .withUri("/v1/{project_id}/data-stores/{data_store_id}/property-values/query")
                .withContentType("application/json");

        // requests
        builder.withRequestField("data_store_id",
            LocationType.Path,
            FieldExistence.NON_NULL_NON_EMPTY,
            TypeCasts.uncheckedConversion(String.class),
            f -> f.withMarshaller(ListHistoryRequest::getDataStoreId, ListHistoryRequest::setDataStoreId));
        builder.withRequestField("body",
            LocationType.Body,
            FieldExistence.NON_NULL_NON_EMPTY,
            TypeCasts.uncheckedConversion(GetHistoryRequest.class),
            f -> f.withMarshaller(ListHistoryRequest::getBody, ListHistoryRequest::setBody));

        // response

        return builder.build();
    }

    public static final HttpRequestDef listMetrics = genForListMetrics();

    private static HttpRequestDef genForListMetrics() {
        // basic
        HttpRequestDef.Builder builder =
            HttpRequestDef.builder(HttpMethod.POST, ListMetricsRequest.class, ListMetricsResponse.class)
                .withName("ListMetrics")
                .withUri("/v1/{project_id}/data-stores/{data_store_id}/metrics/query")
                .withContentType("application/json");

        // requests
        builder.withRequestField("data_store_id",
            LocationType.Path,
            FieldExistence.NON_NULL_NON_EMPTY,
            TypeCasts.uncheckedConversion(String.class),
            f -> f.withMarshaller(ListMetricsRequest::getDataStoreId, ListMetricsRequest::setDataStoreId));
        builder.withRequestField("body",
            LocationType.Body,
            FieldExistence.NON_NULL_NON_EMPTY,
            TypeCasts.uncheckedConversion(GetMetricsRequest.class),
            f -> f.withMarshaller(ListMetricsRequest::getBody, ListMetricsRequest::setBody));

        // response

        return builder.build();
    }

    public static final HttpRequestDef showPropertyValues =
        genForShowPropertyValues();

    private static HttpRequestDef genForShowPropertyValues() {
        // basic
        HttpRequestDef.Builder builder =
            HttpRequestDef.builder(HttpMethod.POST, ShowPropertyValuesRequest.class, ShowPropertyValuesResponse.class)
                .withName("ShowPropertyValues")
                .withUri("/v1/{project_id}/data-stores/{data_store_id}/property-values/query-last")
                .withContentType("application/json");

        // requests
        builder.withRequestField("data_store_id",
            LocationType.Path,
            FieldExistence.NON_NULL_NON_EMPTY,
            TypeCasts.uncheckedConversion(String.class),
            f -> f.withMarshaller(ShowPropertyValuesRequest::getDataStoreId,
                ShowPropertyValuesRequest::setDataStoreId));
        builder.withRequestField("body",
            LocationType.Body,
            FieldExistence.NON_NULL_NON_EMPTY,
            TypeCasts.uncheckedConversion(GetPropertyRequest.class),
            f -> f.withMarshaller(ShowPropertyValuesRequest::getBody, ShowPropertyValuesRequest::setBody));

        // response

        return builder.build();
    }

    public static final HttpRequestDef listTagValues =
        genForListTagValues();

    private static HttpRequestDef genForListTagValues() {
        // basic
        HttpRequestDef.Builder builder =
            HttpRequestDef.builder(HttpMethod.GET, ListTagValuesRequest.class, ListTagValuesResponse.class)
                .withName("ListTagValues")
                .withUri("/v1/{project_id}/data-stores/{data_store_id}/tags/{tag_name}")
                .withContentType("application/json");

        // requests
        builder.withRequestField("data_store_id",
            LocationType.Path,
            FieldExistence.NON_NULL_NON_EMPTY,
            TypeCasts.uncheckedConversion(String.class),
            f -> f.withMarshaller(ListTagValuesRequest::getDataStoreId, ListTagValuesRequest::setDataStoreId));
        builder.withRequestField("tag_name",
            LocationType.Path,
            FieldExistence.NON_NULL_NON_EMPTY,
            TypeCasts.uncheckedConversion(String.class),
            f -> f.withMarshaller(ListTagValuesRequest::getTagName, ListTagValuesRequest::setTagName));
        builder.withRequestField("filters",
            LocationType.Query,
            FieldExistence.NULL_IGNORE,
            TypeCasts.uncheckedConversion(String.class),
            f -> f.withMarshaller(ListTagValuesRequest::getFilters, ListTagValuesRequest::setFilters));
        builder.withRequestField("offset",
            LocationType.Query,
            FieldExistence.NULL_IGNORE,
            TypeCasts.uncheckedConversion(Integer.class),
            f -> f.withMarshaller(ListTagValuesRequest::getOffset, ListTagValuesRequest::setOffset));
        builder.withRequestField("limit",
            LocationType.Query,
            FieldExistence.NULL_IGNORE,
            TypeCasts.uncheckedConversion(Integer.class),
            f -> f.withMarshaller(ListTagValuesRequest::getLimit, ListTagValuesRequest::setLimit));

        // response

        return builder.build();
    }

    public static final HttpRequestDef exportDataset =
        genForExportDataset();

    private static HttpRequestDef genForExportDataset() {
        // basic
        HttpRequestDef.Builder builder =
            HttpRequestDef.builder(HttpMethod.POST, ExportDatasetRequest.class, ExportDatasetResponse.class)
                .withName("ExportDataset")
                .withUri("/v1/{project_id}/batch/jobs/{job_id}/runs/{run_id}/export-dataset")
                .withContentType("application/json");

        // requests
        builder.withRequestField("job_id",
            LocationType.Path,
            FieldExistence.NON_NULL_NON_EMPTY,
            TypeCasts.uncheckedConversion(String.class),
            f -> f.withMarshaller(ExportDatasetRequest::getJobId, ExportDatasetRequest::setJobId));
        builder.withRequestField("run_id",
            LocationType.Path,
            FieldExistence.NON_NULL_NON_EMPTY,
            TypeCasts.uncheckedConversion(String.class),
            f -> f.withMarshaller(ExportDatasetRequest::getRunId, ExportDatasetRequest::setRunId));

        // response

        return builder.build();
    }

    public static final HttpRequestDef importData = genForImportData();

    private static HttpRequestDef genForImportData() {
        // basic
        HttpRequestDef.Builder builder =
            HttpRequestDef.builder(HttpMethod.POST, ImportDataRequest.class, ImportDataResponse.class)
                .withName("ImportData")
                .withUri("/v1/{project_id}/batch/jobs/import/runs")
                .withContentType("application/json");

        // requests
        builder.withRequestField("body",
            LocationType.Body,
            FieldExistence.NON_NULL_NON_EMPTY,
            TypeCasts.uncheckedConversion(ImportDataRequestBody.class),
            f -> f.withMarshaller(ImportDataRequest::getBody, ImportDataRequest::setBody));

        // response

        return builder.build();
    }

    public static final HttpRequestDef showDataset = genForShowDataset();

    private static HttpRequestDef genForShowDataset() {
        // basic
        HttpRequestDef.Builder builder =
            HttpRequestDef.builder(HttpMethod.POST, ShowDatasetRequest.class, ShowDatasetResponse.class)
                .withName("ShowDataset")
                .withUri("/v1/{project_id}/batch/jobs/{job_id}/runs/{run_id}/query-dataset")
                .withContentType("application/json");

        // requests
        builder.withRequestField("job_id",
            LocationType.Path,
            FieldExistence.NON_NULL_NON_EMPTY,
            TypeCasts.uncheckedConversion(String.class),
            f -> f.withMarshaller(ShowDatasetRequest::getJobId, ShowDatasetRequest::setJobId));
        builder.withRequestField("run_id",
            LocationType.Path,
            FieldExistence.NON_NULL_NON_EMPTY,
            TypeCasts.uncheckedConversion(String.class),
            f -> f.withMarshaller(ShowDatasetRequest::getRunId, ShowDatasetRequest::setRunId));
        builder.withRequestField("offset",
            LocationType.Query,
            FieldExistence.NULL_IGNORE,
            TypeCasts.uncheckedConversion(Integer.class),
            f -> f.withMarshaller(ShowDatasetRequest::getOffset, ShowDatasetRequest::setOffset));
        builder.withRequestField("limit",
            LocationType.Query,
            FieldExistence.NULL_IGNORE,
            TypeCasts.uncheckedConversion(Integer.class),
            f -> f.withMarshaller(ShowDatasetRequest::getLimit, ShowDatasetRequest::setLimit));

        // response

        return builder.build();
    }

    public static final HttpRequestDef validateSql = genForValidateSql();

    private static HttpRequestDef genForValidateSql() {
        // basic
        HttpRequestDef.Builder builder =
            HttpRequestDef.builder(HttpMethod.POST, ValidateSqlRequest.class, ValidateSqlResponse.class)
                .withName("ValidateSql")
                .withUri("/v1/{project_id}/batch/validate-sql")
                .withContentType("application/json");

        // requests
        builder.withRequestField("body",
            LocationType.Body,
            FieldExistence.NON_NULL_NON_EMPTY,
            TypeCasts.uncheckedConversion(ValidateSqlRequestBody.class),
            f -> f.withMarshaller(ValidateSqlRequest::getBody, ValidateSqlRequest::setBody));

        // response

        return builder.build();
    }

    public static final HttpRequestDef addDevData = genForAddDevData();

    private static HttpRequestDef genForAddDevData() {
        // basic
        HttpRequestDef.Builder builder =
            HttpRequestDef.builder(HttpMethod.POST, AddDevDataRequest.class, AddDevDataResponse.class)
                .withName("AddDevData")
                .withUri("/v1/{project_id}/datasources/{datasource_id}/dev-data")
                .withContentType("application/json");

        // requests
        builder.withRequestField("datasource_id",
            LocationType.Path,
            FieldExistence.NON_NULL_NON_EMPTY,
            TypeCasts.uncheckedConversion(String.class),
            f -> f.withMarshaller(AddDevDataRequest::getDatasourceId, AddDevDataRequest::setDatasourceId));
        builder.withRequestField("body",
            LocationType.Body,
            FieldExistence.NON_NULL_NON_EMPTY,
            TypeCasts.uncheckedConversion(Object.class),
            f -> f.withMarshaller(AddDevDataRequest::getBody, AddDevDataRequest::setBody));

        // response
        builder.withResponseField("body",
            LocationType.Body,
            FieldExistence.NULL_IGNORE,
            String.class,
            f -> f.withMarshaller(AddDevDataResponse::getBody, AddDevDataResponse::setBody));

        return builder.build();
    }

    public static final HttpRequestDef createBatchJob =
        genForCreateBatchJob();

    private static HttpRequestDef genForCreateBatchJob() {
        // basic
        HttpRequestDef.Builder builder =
            HttpRequestDef.builder(HttpMethod.POST, CreateBatchJobRequest.class, CreateBatchJobResponse.class)
                .withName("CreateBatchJob")
                .withUri("/v1/{project_id}/batch/jobs")
                .withContentType("application/json");

        // requests
        builder.withRequestField("body",
            LocationType.Body,
            FieldExistence.NON_NULL_NON_EMPTY,
            TypeCasts.uncheckedConversion(Job.class),
            f -> f.withMarshaller(CreateBatchJobRequest::getBody, CreateBatchJobRequest::setBody));

        // response

        return builder.build();
    }

    public static final HttpRequestDef deleteBatchJob =
        genForDeleteBatchJob();

    private static HttpRequestDef genForDeleteBatchJob() {
        // basic
        HttpRequestDef.Builder builder =
            HttpRequestDef.builder(HttpMethod.DELETE, DeleteBatchJobRequest.class, DeleteBatchJobResponse.class)
                .withName("DeleteBatchJob")
                .withUri("/v1/{project_id}/batch/jobs/{job_id}")
                .withContentType("application/json");

        // requests
        builder.withRequestField("job_id",
            LocationType.Path,
            FieldExistence.NON_NULL_NON_EMPTY,
            TypeCasts.uncheckedConversion(String.class),
            f -> f.withMarshaller(DeleteBatchJobRequest::getJobId, DeleteBatchJobRequest::setJobId));

        // response

        return builder.build();
    }

    public static final HttpRequestDef listBatchJobs =
        genForListBatchJobs();

    private static HttpRequestDef genForListBatchJobs() {
        // basic
        HttpRequestDef.Builder builder =
            HttpRequestDef.builder(HttpMethod.GET, ListBatchJobsRequest.class, ListBatchJobsResponse.class)
                .withName("ListBatchJobs")
                .withUri("/v1/{project_id}/batch/jobs")
                .withContentType("application/json");

        // requests
        builder.withRequestField("offset",
            LocationType.Query,
            FieldExistence.NULL_IGNORE,
            TypeCasts.uncheckedConversion(Integer.class),
            f -> f.withMarshaller(ListBatchJobsRequest::getOffset, ListBatchJobsRequest::setOffset));
        builder.withRequestField("limit",
            LocationType.Query,
            FieldExistence.NULL_IGNORE,
            TypeCasts.uncheckedConversion(Integer.class),
            f -> f.withMarshaller(ListBatchJobsRequest::getLimit, ListBatchJobsRequest::setLimit));
        builder.withRequestField("has_schedule",
            LocationType.Query,
            FieldExistence.NULL_IGNORE,
            TypeCasts.uncheckedConversion(Boolean.class),
            f -> f.withMarshaller(ListBatchJobsRequest::getHasSchedule, ListBatchJobsRequest::setHasSchedule));
        builder.withRequestField("job_name",
            LocationType.Query,
            FieldExistence.NULL_IGNORE,
            TypeCasts.uncheckedConversion(String.class),
            f -> f.withMarshaller(ListBatchJobsRequest::getJobName, ListBatchJobsRequest::setJobName));
        builder.withRequestField("schedule_status",
            LocationType.Query,
            FieldExistence.NULL_IGNORE,
            TypeCasts.uncheckedConversion(String.class),
            f -> f.withMarshaller(ListBatchJobsRequest::getScheduleStatus, ListBatchJobsRequest::setScheduleStatus));
        builder.withRequestField("order_by",
            LocationType.Query,
            FieldExistence.NULL_IGNORE,
            TypeCasts.uncheckedConversion(String.class),
            f -> f.withMarshaller(ListBatchJobsRequest::getOrderBy, ListBatchJobsRequest::setOrderBy));
        builder.withRequestField("order",
            LocationType.Query,
            FieldExistence.NULL_IGNORE,
            TypeCasts.uncheckedConversion(String.class),
            f -> f.withMarshaller(ListBatchJobsRequest::getOrder, ListBatchJobsRequest::setOrder));

        // response

        return builder.build();
    }

    public static final HttpRequestDef showBatchJob = genForShowBatchJob();

    private static HttpRequestDef genForShowBatchJob() {
        // basic
        HttpRequestDef.Builder builder =
            HttpRequestDef.builder(HttpMethod.GET, ShowBatchJobRequest.class, ShowBatchJobResponse.class)
                .withName("ShowBatchJob")
                .withUri("/v1/{project_id}/batch/jobs/{job_id}")
                .withContentType("application/json");

        // requests
        builder.withRequestField("job_id",
            LocationType.Path,
            FieldExistence.NON_NULL_NON_EMPTY,
            TypeCasts.uncheckedConversion(String.class),
            f -> f.withMarshaller(ShowBatchJobRequest::getJobId, ShowBatchJobRequest::setJobId));

        // response

        return builder.build();
    }

    public static final HttpRequestDef updateBatchJob =
        genForUpdateBatchJob();

    private static HttpRequestDef genForUpdateBatchJob() {
        // basic
        HttpRequestDef.Builder builder =
            HttpRequestDef.builder(HttpMethod.PUT, UpdateBatchJobRequest.class, UpdateBatchJobResponse.class)
                .withName("UpdateBatchJob")
                .withUri("/v1/{project_id}/batch/jobs/{job_id}")
                .withContentType("application/json");

        // requests
        builder.withRequestField("job_id",
            LocationType.Path,
            FieldExistence.NON_NULL_NON_EMPTY,
            TypeCasts.uncheckedConversion(String.class),
            f -> f.withMarshaller(UpdateBatchJobRequest::getJobId, UpdateBatchJobRequest::setJobId));
        builder.withRequestField("body",
            LocationType.Body,
            FieldExistence.NON_NULL_NON_EMPTY,
            TypeCasts.uncheckedConversion(Job.class),
            f -> f.withMarshaller(UpdateBatchJobRequest::getBody, UpdateBatchJobRequest::setBody));

        // response

        return builder.build();
    }

    public static final HttpRequestDef addPipelineJob =
        genForAddPipelineJob();

    private static HttpRequestDef genForAddPipelineJob() {
        // basic
        HttpRequestDef.Builder builder =
            HttpRequestDef.builder(HttpMethod.POST, AddPipelineJobRequest.class, AddPipelineJobResponse.class)
                .withName("AddPipelineJob")
                .withUri("/v1/{project_id}/pipelines")
                .withContentType("application/json");

        // requests
        builder.withRequestField("check",
            LocationType.Query,
            FieldExistence.NULL_IGNORE,
            TypeCasts.uncheckedConversion(Boolean.class),
            f -> f.withMarshaller(AddPipelineJobRequest::getCheck, AddPipelineJobRequest::setCheck));
        builder.>withRequestField("body",
            LocationType.Body,
            FieldExistence.NON_NULL_NON_EMPTY,
            TypeCasts.uncheckedConversion(Map.class),
            f -> f.withMarshaller(AddPipelineJobRequest::getBody, AddPipelineJobRequest::setBody)
                .withInnerContainerType(Object.class));

        // response

        return builder.build();
    }

    public static final HttpRequestDef deletePipelineJob =
        genForDeletePipelineJob();

    private static HttpRequestDef genForDeletePipelineJob() {
        // basic
        HttpRequestDef.Builder builder =
            HttpRequestDef.builder(HttpMethod.DELETE, DeletePipelineJobRequest.class, DeletePipelineJobResponse.class)
                .withName("DeletePipelineJob")
                .withUri("/v1/{project_id}/pipelines/{pipeline_id}")
                .withContentType("application/json");

        // requests
        builder.withRequestField("pipeline_id",
            LocationType.Path,
            FieldExistence.NON_NULL_NON_EMPTY,
            TypeCasts.uncheckedConversion(String.class),
            f -> f.withMarshaller(DeletePipelineJobRequest::getPipelineId, DeletePipelineJobRequest::setPipelineId));

        // response
        builder.withResponseField("body",
            LocationType.Body,
            FieldExistence.NULL_IGNORE,
            String.class,
            f -> f.withMarshaller(DeletePipelineJobResponse::getBody, DeletePipelineJobResponse::setBody));

        return builder.build();
    }

    public static final HttpRequestDef listPipelineJobs =
        genForListPipelineJobs();

    private static HttpRequestDef genForListPipelineJobs() {
        // basic
        HttpRequestDef.Builder builder =
            HttpRequestDef.builder(HttpMethod.GET, ListPipelineJobsRequest.class, ListPipelineJobsResponse.class)
                .withName("ListPipelineJobs")
                .withUri("/v1/{project_id}/pipelines")
                .withContentType("application/json");

        // requests
        builder.withRequestField("data_store_id",
            LocationType.Query,
            FieldExistence.NULL_IGNORE,
            TypeCasts.uncheckedConversion(String.class),
            f -> f.withMarshaller(ListPipelineJobsRequest::getDataStoreId, ListPipelineJobsRequest::setDataStoreId));
        builder.withRequestField("data_store_group_id",
            LocationType.Query,
            FieldExistence.NULL_IGNORE,
            TypeCasts.uncheckedConversion(String.class),
            f -> f.withMarshaller(ListPipelineJobsRequest::getDataStoreGroupId,
                ListPipelineJobsRequest::setDataStoreGroupId));
        builder.withRequestField("data_source_id",
            LocationType.Query,
            FieldExistence.NULL_IGNORE,
            TypeCasts.uncheckedConversion(String.class),
            f -> f.withMarshaller(ListPipelineJobsRequest::getDataSourceId, ListPipelineJobsRequest::setDataSourceId));
        builder.withRequestField("pipeline_name",
            LocationType.Query,
            FieldExistence.NULL_IGNORE,
            TypeCasts.uncheckedConversion(String.class),
            f -> f.withMarshaller(ListPipelineJobsRequest::getPipelineName, ListPipelineJobsRequest::setPipelineName));
        builder.withRequestField("operator_class_name",
            LocationType.Query,
            FieldExistence.NULL_IGNORE,
            TypeCasts.uncheckedConversion(String.class),
            f -> f.withMarshaller(ListPipelineJobsRequest::getOperatorClassName,
                ListPipelineJobsRequest::setOperatorClassName));
        builder.withRequestField("offset",
            LocationType.Query,
            FieldExistence.NULL_IGNORE,
            TypeCasts.uncheckedConversion(Long.class),
            f -> f.withMarshaller(ListPipelineJobsRequest::getOffset, ListPipelineJobsRequest::setOffset));
        builder.withRequestField("limit",
            LocationType.Query,
            FieldExistence.NULL_IGNORE,
            TypeCasts.uncheckedConversion(Integer.class),
            f -> f.withMarshaller(ListPipelineJobsRequest::getLimit, ListPipelineJobsRequest::setLimit));
        builder.withRequestField("sync_status",
            LocationType.Query,
            FieldExistence.NULL_IGNORE,
            TypeCasts.uncheckedConversion(Boolean.class),
            f -> f.withMarshaller(ListPipelineJobsRequest::getSyncStatus, ListPipelineJobsRequest::setSyncStatus));

        // response

        return builder.build();
    }

    public static final HttpRequestDef showPipelineJob =
        genForShowPipelineJob();

    private static HttpRequestDef genForShowPipelineJob() {
        // basic
        HttpRequestDef.Builder builder =
            HttpRequestDef.builder(HttpMethod.GET, ShowPipelineJobRequest.class, ShowPipelineJobResponse.class)
                .withName("ShowPipelineJob")
                .withUri("/v1/{project_id}/pipelines/{pipeline_id}")
                .withContentType("application/json");

        // requests
        builder.withRequestField("pipeline_id",
            LocationType.Path,
            FieldExistence.NON_NULL_NON_EMPTY,
            TypeCasts.uncheckedConversion(String.class),
            f -> f.withMarshaller(ShowPipelineJobRequest::getPipelineId, ShowPipelineJobRequest::setPipelineId));

        // response

        return builder.build();
    }

    public static final HttpRequestDef startPipelineJob =
        genForStartPipelineJob();

    private static HttpRequestDef genForStartPipelineJob() {
        // basic
        HttpRequestDef.Builder builder =
            HttpRequestDef.builder(HttpMethod.POST, StartPipelineJobRequest.class, StartPipelineJobResponse.class)
                .withName("StartPipelineJob")
                .withUri("/v1/{project_id}/pipelines/{pipeline_id}/start")
                .withContentType("application/json");

        // requests
        builder.withRequestField("pipeline_id",
            LocationType.Path,
            FieldExistence.NON_NULL_NON_EMPTY,
            TypeCasts.uncheckedConversion(String.class),
            f -> f.withMarshaller(StartPipelineJobRequest::getPipelineId, StartPipelineJobRequest::setPipelineId));
        builder.withRequestField("parallel",
            LocationType.Query,
            FieldExistence.NULL_IGNORE,
            TypeCasts.uncheckedConversion(Integer.class),
            f -> f.withMarshaller(StartPipelineJobRequest::getParallel, StartPipelineJobRequest::setParallel));
        builder.withRequestField("rtu",
            LocationType.Query,
            FieldExistence.NULL_IGNORE,
            TypeCasts.uncheckedConversion(Integer.class),
            f -> f.withMarshaller(StartPipelineJobRequest::getRtu, StartPipelineJobRequest::setRtu));
        builder.withRequestField("resume_savepoint",
            LocationType.Query,
            FieldExistence.NULL_IGNORE,
            TypeCasts.uncheckedConversion(Boolean.class),
            f -> f.withMarshaller(StartPipelineJobRequest::getResumeSavepoint,
                StartPipelineJobRequest::setResumeSavepoint));

        // response

        return builder.build();
    }

    public static final HttpRequestDef stopPipelineJob =
        genForStopPipelineJob();

    private static HttpRequestDef genForStopPipelineJob() {
        // basic
        HttpRequestDef.Builder builder =
            HttpRequestDef.builder(HttpMethod.POST, StopPipelineJobRequest.class, StopPipelineJobResponse.class)
                .withName("StopPipelineJob")
                .withUri("/v1/{project_id}/pipelines/{pipeline_id}/stop")
                .withContentType("application/json");

        // requests
        builder.withRequestField("pipeline_id",
            LocationType.Path,
            FieldExistence.NON_NULL_NON_EMPTY,
            TypeCasts.uncheckedConversion(String.class),
            f -> f.withMarshaller(StopPipelineJobRequest::getPipelineId, StopPipelineJobRequest::setPipelineId));
        builder.withRequestField("trigger_savepoint",
            LocationType.Query,
            FieldExistence.NULL_IGNORE,
            TypeCasts.uncheckedConversion(Boolean.class),
            f -> f.withMarshaller(StopPipelineJobRequest::getTriggerSavepoint,
                StopPipelineJobRequest::setTriggerSavepoint));

        // response

        return builder.build();
    }

    public static final HttpRequestDef updatePipelineJob =
        genForUpdatePipelineJob();

    private static HttpRequestDef genForUpdatePipelineJob() {
        // basic
        HttpRequestDef.Builder builder =
            HttpRequestDef.builder(HttpMethod.PUT, UpdatePipelineJobRequest.class, UpdatePipelineJobResponse.class)
                .withName("UpdatePipelineJob")
                .withUri("/v1/{project_id}/pipelines/{pipeline_id}")
                .withContentType("application/json");

        // requests
        builder.withRequestField("pipeline_id",
            LocationType.Path,
            FieldExistence.NON_NULL_NON_EMPTY,
            TypeCasts.uncheckedConversion(String.class),
            f -> f.withMarshaller(UpdatePipelineJobRequest::getPipelineId, UpdatePipelineJobRequest::setPipelineId));
        builder.withRequestField("check",
            LocationType.Query,
            FieldExistence.NULL_IGNORE,
            TypeCasts.uncheckedConversion(Boolean.class),
            f -> f.withMarshaller(UpdatePipelineJobRequest::getCheck, UpdatePipelineJobRequest::setCheck));
        builder.>withRequestField("body",
            LocationType.Body,
            FieldExistence.NON_NULL_NON_EMPTY,
            TypeCasts.uncheckedConversion(Map.class),
            f -> f.withMarshaller(UpdatePipelineJobRequest::getBody, UpdatePipelineJobRequest::setBody)
                .withInnerContainerType(Object.class));

        // response

        return builder.build();
    }

    public static final HttpRequestDef createStreamingJob =
        genForCreateStreamingJob();

    private static HttpRequestDef genForCreateStreamingJob() {
        // basic
        HttpRequestDef.Builder builder =
            HttpRequestDef.builder(HttpMethod.POST, CreateStreamingJobRequest.class, CreateStreamingJobResponse.class)
                .withName("CreateStreamingJob")
                .withUri("/v1/{project_id}/streaming/jobs")
                .withContentType("application/json");

        // requests
        builder.withRequestField("check",
            LocationType.Query,
            FieldExistence.NULL_IGNORE,
            TypeCasts.uncheckedConversion(Boolean.class),
            f -> f.withMarshaller(CreateStreamingJobRequest::getCheck, CreateStreamingJobRequest::setCheck));
        builder.>withRequestField("body",
            LocationType.Body,
            FieldExistence.NON_NULL_NON_EMPTY,
            TypeCasts.uncheckedConversion(Map.class),
            f -> f.withMarshaller(CreateStreamingJobRequest::getBody, CreateStreamingJobRequest::setBody)
                .withInnerContainerType(Object.class));

        // response

        return builder.build();
    }

    public static final HttpRequestDef deleteStreamingJobById =
        genForDeleteStreamingJobById();

    private static HttpRequestDef genForDeleteStreamingJobById() {
        // basic
        HttpRequestDef.Builder builder = HttpRequestDef
            .builder(HttpMethod.DELETE, DeleteStreamingJobByIdRequest.class, DeleteStreamingJobByIdResponse.class)
            .withName("DeleteStreamingJobById")
            .withUri("/v1/{project_id}/streaming/jobs/{job_id}")
            .withContentType("application/json");

        // requests
        builder.withRequestField("job_id",
            LocationType.Path,
            FieldExistence.NON_NULL_NON_EMPTY,
            TypeCasts.uncheckedConversion(String.class),
            f -> f.withMarshaller(DeleteStreamingJobByIdRequest::getJobId, DeleteStreamingJobByIdRequest::setJobId));

        // response
        builder.withResponseField("body",
            LocationType.Body,
            FieldExistence.NULL_IGNORE,
            String.class,
            f -> f.withMarshaller(DeleteStreamingJobByIdResponse::getBody, DeleteStreamingJobByIdResponse::setBody));

        return builder.build();
    }

    public static final HttpRequestDef showJobById = genForShowJobById();

    private static HttpRequestDef genForShowJobById() {
        // basic
        HttpRequestDef.Builder builder =
            HttpRequestDef.builder(HttpMethod.GET, ShowJobByIdRequest.class, ShowJobByIdResponse.class)
                .withName("ShowJobById")
                .withUri("/v1/{project_id}/streaming/jobs/{job_id}")
                .withContentType("application/json");

        // requests
        builder.withRequestField("job_id",
            LocationType.Path,
            FieldExistence.NON_NULL_NON_EMPTY,
            TypeCasts.uncheckedConversion(String.class),
            f -> f.withMarshaller(ShowJobByIdRequest::getJobId, ShowJobByIdRequest::setJobId));

        // response

        return builder.build();
    }

    public static final HttpRequestDef showJobs = genForShowJobs();

    private static HttpRequestDef genForShowJobs() {
        // basic
        HttpRequestDef.Builder builder =
            HttpRequestDef.builder(HttpMethod.GET, ShowJobsRequest.class, ShowJobsResponse.class)
                .withName("ShowJobs")
                .withUri("/v1/{project_id}/streaming/jobs")
                .withContentType("application/json");

        // requests
        builder.withRequestField("job_input_type",
            LocationType.Query,
            FieldExistence.NULL_IGNORE,
            TypeCasts.uncheckedConversion(ShowJobsRequest.JobInputTypeEnum.class),
            f -> f.withMarshaller(ShowJobsRequest::getJobInputType, ShowJobsRequest::setJobInputType));
        builder.withRequestField("offset",
            LocationType.Query,
            FieldExistence.NULL_IGNORE,
            TypeCasts.uncheckedConversion(Long.class),
            f -> f.withMarshaller(ShowJobsRequest::getOffset, ShowJobsRequest::setOffset));
        builder.withRequestField("limit",
            LocationType.Query,
            FieldExistence.NULL_IGNORE,
            TypeCasts.uncheckedConversion(Integer.class),
            f -> f.withMarshaller(ShowJobsRequest::getLimit, ShowJobsRequest::setLimit));
        builder.withRequestField("sync_status",
            LocationType.Query,
            FieldExistence.NULL_IGNORE,
            TypeCasts.uncheckedConversion(Boolean.class),
            f -> f.withMarshaller(ShowJobsRequest::getSyncStatus, ShowJobsRequest::setSyncStatus));

        // response

        return builder.build();
    }

    public static final HttpRequestDef updateStreamingJob =
        genForUpdateStreamingJob();

    private static HttpRequestDef genForUpdateStreamingJob() {
        // basic
        HttpRequestDef.Builder builder =
            HttpRequestDef.builder(HttpMethod.PUT, UpdateStreamingJobRequest.class, UpdateStreamingJobResponse.class)
                .withName("UpdateStreamingJob")
                .withUri("/v1/{project_id}/streaming/jobs/{job_id}")
                .withContentType("application/json");

        // requests
        builder.withRequestField("job_id",
            LocationType.Path,
            FieldExistence.NON_NULL_NON_EMPTY,
            TypeCasts.uncheckedConversion(String.class),
            f -> f.withMarshaller(UpdateStreamingJobRequest::getJobId, UpdateStreamingJobRequest::setJobId));
        builder.withRequestField("check",
            LocationType.Query,
            FieldExistence.NULL_IGNORE,
            TypeCasts.uncheckedConversion(Boolean.class),
            f -> f.withMarshaller(UpdateStreamingJobRequest::getCheck, UpdateStreamingJobRequest::setCheck));
        builder.>withRequestField("body",
            LocationType.Body,
            FieldExistence.NON_NULL_NON_EMPTY,
            TypeCasts.uncheckedConversion(Map.class),
            f -> f.withMarshaller(UpdateStreamingJobRequest::getBody, UpdateStreamingJobRequest::setBody)
                .withInnerContainerType(Object.class));

        // response

        return builder.build();
    }

    public static final HttpRequestDef startJob = genForStartJob();

    private static HttpRequestDef genForStartJob() {
        // basic
        HttpRequestDef.Builder builder =
            HttpRequestDef.builder(HttpMethod.POST, StartJobRequest.class, StartJobResponse.class)
                .withName("StartJob")
                .withUri("/v1/{project_id}/streaming/jobs/{job_id}/start")
                .withContentType("application/json");

        // requests
        builder.withRequestField("job_id",
            LocationType.Path,
            FieldExistence.NON_NULL_NON_EMPTY,
            TypeCasts.uncheckedConversion(String.class),
            f -> f.withMarshaller(StartJobRequest::getJobId, StartJobRequest::setJobId));
        builder.withRequestField("parallel",
            LocationType.Query,
            FieldExistence.NULL_IGNORE,
            TypeCasts.uncheckedConversion(Integer.class),
            f -> f.withMarshaller(StartJobRequest::getParallel, StartJobRequest::setParallel));
        builder.withRequestField("rtu",
            LocationType.Query,
            FieldExistence.NULL_IGNORE,
            TypeCasts.uncheckedConversion(Integer.class),
            f -> f.withMarshaller(StartJobRequest::getRtu, StartJobRequest::setRtu));
        builder.withRequestField("resume_savepoint",
            LocationType.Query,
            FieldExistence.NULL_IGNORE,
            TypeCasts.uncheckedConversion(Boolean.class),
            f -> f.withMarshaller(StartJobRequest::getResumeSavepoint, StartJobRequest::setResumeSavepoint));

        // response

        return builder.build();
    }

    public static final HttpRequestDef stopJob = genForStopJob();

    private static HttpRequestDef genForStopJob() {
        // basic
        HttpRequestDef.Builder builder =
            HttpRequestDef.builder(HttpMethod.POST, StopJobRequest.class, StopJobResponse.class)
                .withName("StopJob")
                .withUri("/v1/{project_id}/streaming/jobs/{job_id}/stop")
                .withContentType("application/json");

        // requests
        builder.withRequestField("job_id",
            LocationType.Path,
            FieldExistence.NON_NULL_NON_EMPTY,
            TypeCasts.uncheckedConversion(String.class),
            f -> f.withMarshaller(StopJobRequest::getJobId, StopJobRequest::setJobId));
        builder.withRequestField("trigger_savepoint",
            LocationType.Query,
            FieldExistence.NULL_IGNORE,
            TypeCasts.uncheckedConversion(Boolean.class),
            f -> f.withMarshaller(StopJobRequest::getTriggerSavepoint, StopJobRequest::setTriggerSavepoint));

        // response

        return builder.build();
    }

    public static final HttpRequestDef createRun = genForCreateRun();

    private static HttpRequestDef genForCreateRun() {
        // basic
        HttpRequestDef.Builder builder =
            HttpRequestDef.builder(HttpMethod.POST, CreateRunRequest.class, CreateRunResponse.class)
                .withName("CreateRun")
                .withUri("/v1/{project_id}/batch/jobs/{job_id}/runs")
                .withContentType("application/json");

        // requests
        builder.withRequestField("job_id",
            LocationType.Path,
            FieldExistence.NON_NULL_NON_EMPTY,
            TypeCasts.uncheckedConversion(String.class),
            f -> f.withMarshaller(CreateRunRequest::getJobId, CreateRunRequest::setJobId));
        builder.withRequestField("body",
            LocationType.Body,
            FieldExistence.NON_NULL_NON_EMPTY,
            TypeCasts.uncheckedConversion(CreateRunRequestBody.class),
            f -> f.withMarshaller(CreateRunRequest::getBody, CreateRunRequest::setBody));

        // response

        return builder.build();
    }

    public static final HttpRequestDef deleteRun = genForDeleteRun();

    private static HttpRequestDef genForDeleteRun() {
        // basic
        HttpRequestDef.Builder builder =
            HttpRequestDef.builder(HttpMethod.DELETE, DeleteRunRequest.class, DeleteRunResponse.class)
                .withName("DeleteRun")
                .withUri("/v1/{project_id}/batch/jobs/{job_id}/runs/{run_id}")
                .withContentType("application/json");

        // requests
        builder.withRequestField("job_id",
            LocationType.Path,
            FieldExistence.NON_NULL_NON_EMPTY,
            TypeCasts.uncheckedConversion(String.class),
            f -> f.withMarshaller(DeleteRunRequest::getJobId, DeleteRunRequest::setJobId));
        builder.withRequestField("run_id",
            LocationType.Path,
            FieldExistence.NON_NULL_NON_EMPTY,
            TypeCasts.uncheckedConversion(String.class),
            f -> f.withMarshaller(DeleteRunRequest::getRunId, DeleteRunRequest::setRunId));

        // response

        return builder.build();
    }

    public static final HttpRequestDef listRuns = genForListRuns();

    private static HttpRequestDef genForListRuns() {
        // basic
        HttpRequestDef.Builder builder =
            HttpRequestDef.builder(HttpMethod.GET, ListRunsRequest.class, ListRunsResponse.class)
                .withName("ListRuns")
                .withUri("/v1/{project_id}/batch/jobs/runs")
                .withContentType("application/json");

        // requests
        builder.withRequestField("offset",
            LocationType.Query,
            FieldExistence.NULL_IGNORE,
            TypeCasts.uncheckedConversion(Integer.class),
            f -> f.withMarshaller(ListRunsRequest::getOffset, ListRunsRequest::setOffset));
        builder.withRequestField("limit",
            LocationType.Query,
            FieldExistence.NULL_IGNORE,
            TypeCasts.uncheckedConversion(Integer.class),
            f -> f.withMarshaller(ListRunsRequest::getLimit, ListRunsRequest::setLimit));
        builder.withRequestField("start_time",
            LocationType.Query,
            FieldExistence.NULL_IGNORE,
            TypeCasts.uncheckedConversion(String.class),
            f -> f.withMarshaller(ListRunsRequest::getStartTime, ListRunsRequest::setStartTime));
        builder.withRequestField("end_time",
            LocationType.Query,
            FieldExistence.NULL_IGNORE,
            TypeCasts.uncheckedConversion(String.class),
            f -> f.withMarshaller(ListRunsRequest::getEndTime, ListRunsRequest::setEndTime));
        builder.withRequestField("sql_pattern",
            LocationType.Query,
            FieldExistence.NULL_IGNORE,
            TypeCasts.uncheckedConversion(String.class),
            f -> f.withMarshaller(ListRunsRequest::getSqlPattern, ListRunsRequest::setSqlPattern));
        builder.withRequestField("sql_type",
            LocationType.Query,
            FieldExistence.NULL_IGNORE,
            TypeCasts.uncheckedConversion(String.class),
            f -> f.withMarshaller(ListRunsRequest::getSqlType, ListRunsRequest::setSqlType));
        builder.withRequestField("job_type",
            LocationType.Query,
            FieldExistence.NULL_IGNORE,
            TypeCasts.uncheckedConversion(String.class),
            f -> f.withMarshaller(ListRunsRequest::getJobType, ListRunsRequest::setJobType));
        builder.withRequestField("status",
            LocationType.Query,
            FieldExistence.NULL_IGNORE,
            TypeCasts.uncheckedConversion(String.class),
            f -> f.withMarshaller(ListRunsRequest::getStatus, ListRunsRequest::setStatus));
        builder.withRequestField("order_by",
            LocationType.Query,
            FieldExistence.NULL_IGNORE,
            TypeCasts.uncheckedConversion(String.class),
            f -> f.withMarshaller(ListRunsRequest::getOrderBy, ListRunsRequest::setOrderBy));
        builder.withRequestField("order",
            LocationType.Query,
            FieldExistence.NULL_IGNORE,
            TypeCasts.uncheckedConversion(ListRunsRequest.OrderEnum.class),
            f -> f.withMarshaller(ListRunsRequest::getOrder, ListRunsRequest::setOrder));
        builder.withRequestField("job_name",
            LocationType.Query,
            FieldExistence.NULL_IGNORE,
            TypeCasts.uncheckedConversion(String.class),
            f -> f.withMarshaller(ListRunsRequest::getJobName, ListRunsRequest::setJobName));

        // response

        return builder.build();
    }

    public static final HttpRequestDef showRun = genForShowRun();

    private static HttpRequestDef genForShowRun() {
        // basic
        HttpRequestDef.Builder builder =
            HttpRequestDef.builder(HttpMethod.GET, ShowRunRequest.class, ShowRunResponse.class)
                .withName("ShowRun")
                .withUri("/v1/{project_id}/batch/jobs/{job_id}/runs/{run_id}")
                .withContentType("application/json");

        // requests
        builder.withRequestField("job_id",
            LocationType.Path,
            FieldExistence.NON_NULL_NON_EMPTY,
            TypeCasts.uncheckedConversion(String.class),
            f -> f.withMarshaller(ShowRunRequest::getJobId, ShowRunRequest::setJobId));
        builder.withRequestField("run_id",
            LocationType.Path,
            FieldExistence.NON_NULL_NON_EMPTY,
            TypeCasts.uncheckedConversion(String.class),
            f -> f.withMarshaller(ShowRunRequest::getRunId, ShowRunRequest::setRunId));
        builder.withRequestField("with_details",
            LocationType.Query,
            FieldExistence.NULL_IGNORE,
            TypeCasts.uncheckedConversion(Boolean.class),
            f -> f.withMarshaller(ShowRunRequest::getWithDetails, ShowRunRequest::setWithDetails));

        // response

        return builder.build();
    }

    public static final HttpRequestDef createTable = genForCreateTable();

    private static HttpRequestDef genForCreateTable() {
        // basic
        HttpRequestDef.Builder builder =
            HttpRequestDef.builder(HttpMethod.POST, CreateTableRequest.class, CreateTableResponse.class)
                .withName("CreateTable")
                .withUri("/v1/{project_id}/tables")
                .withContentType("application/json");

        // requests
        builder.withRequestField("body",
            LocationType.Body,
            FieldExistence.NON_NULL_NON_EMPTY,
            TypeCasts.uncheckedConversion(CreateTableRequestBody.class),
            f -> f.withMarshaller(CreateTableRequest::getBody, CreateTableRequest::setBody));

        // response

        return builder.build();
    }

    public static final HttpRequestDef deleteTable = genForDeleteTable();

    private static HttpRequestDef genForDeleteTable() {
        // basic
        HttpRequestDef.Builder builder =
            HttpRequestDef.builder(HttpMethod.DELETE, DeleteTableRequest.class, DeleteTableResponse.class)
                .withName("DeleteTable")
                .withUri("/v1/{project_id}/tables/{table_id}")
                .withContentType("application/json");

        // requests
        builder.withRequestField("table_id",
            LocationType.Path,
            FieldExistence.NON_NULL_NON_EMPTY,
            TypeCasts.uncheckedConversion(String.class),
            f -> f.withMarshaller(DeleteTableRequest::getTableId, DeleteTableRequest::setTableId));

        // response

        return builder.build();
    }

    public static final HttpRequestDef listTables = genForListTables();

    private static HttpRequestDef genForListTables() {
        // basic
        HttpRequestDef.Builder builder =
            HttpRequestDef.builder(HttpMethod.GET, ListTablesRequest.class, ListTablesResponse.class)
                .withName("ListTables")
                .withUri("/v1/{project_id}/tables")
                .withContentType("application/json");

        // requests
        builder.withRequestField("keyword",
            LocationType.Query,
            FieldExistence.NULL_IGNORE,
            TypeCasts.uncheckedConversion(String.class),
            f -> f.withMarshaller(ListTablesRequest::getKeyword, ListTablesRequest::setKeyword));
        builder.withRequestField("tag",
            LocationType.Query,
            FieldExistence.NULL_IGNORE,
            TypeCasts.uncheckedConversion(String.class),
            f -> f.withMarshaller(ListTablesRequest::getTag, ListTablesRequest::setTag));
        builder.withRequestField("offset",
            LocationType.Query,
            FieldExistence.NULL_IGNORE,
            TypeCasts.uncheckedConversion(Integer.class),
            f -> f.withMarshaller(ListTablesRequest::getOffset, ListTablesRequest::setOffset));
        builder.withRequestField("limit",
            LocationType.Query,
            FieldExistence.NULL_IGNORE,
            TypeCasts.uncheckedConversion(Integer.class),
            f -> f.withMarshaller(ListTablesRequest::getLimit, ListTablesRequest::setLimit));
        builder.withRequestField("order_by",
            LocationType.Query,
            FieldExistence.NULL_IGNORE,
            TypeCasts.uncheckedConversion(String.class),
            f -> f.withMarshaller(ListTablesRequest::getOrderBy, ListTablesRequest::setOrderBy));
        builder.withRequestField("order",
            LocationType.Query,
            FieldExistence.NULL_IGNORE,
            TypeCasts.uncheckedConversion(String.class),
            f -> f.withMarshaller(ListTablesRequest::getOrder, ListTablesRequest::setOrder));

        // response

        return builder.build();
    }

    public static final HttpRequestDef showTablePreview =
        genForShowTablePreview();

    private static HttpRequestDef genForShowTablePreview() {
        // basic
        HttpRequestDef.Builder builder =
            HttpRequestDef.builder(HttpMethod.GET, ShowTablePreviewRequest.class, ShowTablePreviewResponse.class)
                .withName("ShowTablePreview")
                .withUri("/v1/{project_id}/tables/{table_id}/preview")
                .withContentType("application/json");

        // requests
        builder.withRequestField("table_id",
            LocationType.Path,
            FieldExistence.NON_NULL_NON_EMPTY,
            TypeCasts.uncheckedConversion(String.class),
            f -> f.withMarshaller(ShowTablePreviewRequest::getTableId, ShowTablePreviewRequest::setTableId));

        // response

        return builder.build();
    }

    public static final HttpRequestDef showTableSchema =
        genForShowTableSchema();

    private static HttpRequestDef genForShowTableSchema() {
        // basic
        HttpRequestDef.Builder builder =
            HttpRequestDef.builder(HttpMethod.GET, ShowTableSchemaRequest.class, ShowTableSchemaResponse.class)
                .withName("ShowTableSchema")
                .withUri("/v1/{project_id}/tables/{table_id}/schema")
                .withContentType("application/json");

        // requests
        builder.withRequestField("table_id",
            LocationType.Path,
            FieldExistence.NON_NULL_NON_EMPTY,
            TypeCasts.uncheckedConversion(String.class),
            f -> f.withMarshaller(ShowTableSchemaRequest::getTableId, ShowTableSchemaRequest::setTableId));

        // response

        return builder.build();
    }

}
    

    

    
            
    
            







    
© 2015 - 2024 Weber Informatics LLC | Privacy Policy