Exemple #1
0
        /// <summary>
        /// Constructs a client wrapper for the AccountBudgetService service, with the specified gRPC client and
        /// settings.
        /// </summary>
        /// <param name="grpcClient">The underlying gRPC client.</param>
        /// <param name="settings">The base <see cref="AccountBudgetServiceSettings"/> used within this client.</param>
        public AccountBudgetServiceClientImpl(AccountBudgetService.AccountBudgetServiceClient grpcClient, AccountBudgetServiceSettings settings)
        {
            GrpcClient = grpcClient;
            AccountBudgetServiceSettings effectiveSettings = settings ?? AccountBudgetServiceSettings.GetDefault();
            gaxgrpc::ClientHelper        clientHelper      = new gaxgrpc::ClientHelper(effectiveSettings);

            _callGetAccountBudget = clientHelper.BuildApiCall <GetAccountBudgetRequest, gagvr::AccountBudget>(grpcClient.GetAccountBudgetAsync, grpcClient.GetAccountBudget, effectiveSettings.GetAccountBudgetSettings).WithGoogleRequestParam("resource_name", request => request.ResourceName);
            Modify_ApiCall(ref _callGetAccountBudget);
            Modify_GetAccountBudgetApiCall(ref _callGetAccountBudget);
            OnConstruction(grpcClient, effectiveSettings, clientHelper);
        }
Exemple #2
0
        /// <summary>
        /// Constructs a client wrapper for the ShoppingPerformanceViewService service, with the specified gRPC client
        /// and settings.
        /// </summary>
        /// <param name="grpcClient">The underlying gRPC client.</param>
        /// <param name="settings">
        /// The base <see cref="ShoppingPerformanceViewServiceSettings"/> used within this client.
        /// </param>
        public ShoppingPerformanceViewServiceClientImpl(ShoppingPerformanceViewService.ShoppingPerformanceViewServiceClient grpcClient, ShoppingPerformanceViewServiceSettings settings)
        {
            GrpcClient = grpcClient;
            ShoppingPerformanceViewServiceSettings effectiveSettings = settings ?? ShoppingPerformanceViewServiceSettings.GetDefault();
            gaxgrpc::ClientHelper clientHelper = new gaxgrpc::ClientHelper(effectiveSettings);

            _callGetShoppingPerformanceView = clientHelper.BuildApiCall <GetShoppingPerformanceViewRequest, gagvr::ShoppingPerformanceView>(grpcClient.GetShoppingPerformanceViewAsync, grpcClient.GetShoppingPerformanceView, effectiveSettings.GetShoppingPerformanceViewSettings).WithGoogleRequestParam("resource_name", request => request.ResourceName);
            Modify_ApiCall(ref _callGetShoppingPerformanceView);
            Modify_GetShoppingPerformanceViewApiCall(ref _callGetShoppingPerformanceView);
            OnConstruction(grpcClient, effectiveSettings, clientHelper);
        }
Exemple #3
0
        /// <summary>
        /// Constructs a client wrapper for the DynamicSearchAdsSearchTermViewService service, with the specified gRPC
        /// client and settings.
        /// </summary>
        /// <param name="grpcClient">The underlying gRPC client.</param>
        /// <param name="settings">
        /// The base <see cref="DynamicSearchAdsSearchTermViewServiceSettings"/> used within this client.
        /// </param>
        public DynamicSearchAdsSearchTermViewServiceClientImpl(DynamicSearchAdsSearchTermViewService.DynamicSearchAdsSearchTermViewServiceClient grpcClient, DynamicSearchAdsSearchTermViewServiceSettings settings)
        {
            GrpcClient = grpcClient;
            DynamicSearchAdsSearchTermViewServiceSettings effectiveSettings = settings ?? DynamicSearchAdsSearchTermViewServiceSettings.GetDefault();
            gaxgrpc::ClientHelper clientHelper = new gaxgrpc::ClientHelper(effectiveSettings);

            _callGetDynamicSearchAdsSearchTermView = clientHelper.BuildApiCall <GetDynamicSearchAdsSearchTermViewRequest, gagvr::DynamicSearchAdsSearchTermView>(grpcClient.GetDynamicSearchAdsSearchTermViewAsync, grpcClient.GetDynamicSearchAdsSearchTermView, effectiveSettings.GetDynamicSearchAdsSearchTermViewSettings).WithGoogleRequestParam("resource_name", request => request.ResourceName);
            Modify_ApiCall(ref _callGetDynamicSearchAdsSearchTermView);
            Modify_GetDynamicSearchAdsSearchTermViewApiCall(ref _callGetDynamicSearchAdsSearchTermView);
            OnConstruction(grpcClient, effectiveSettings, clientHelper);
        }
Exemple #4
0
        /// <summary>
        /// Constructs a client wrapper for the CarrierConstantService service, with the specified gRPC client and
        /// settings.
        /// </summary>
        /// <param name="grpcClient">The underlying gRPC client.</param>
        /// <param name="settings">
        /// The base <see cref="CarrierConstantServiceSettings"/> used within this client.
        /// </param>
        public CarrierConstantServiceClientImpl(CarrierConstantService.CarrierConstantServiceClient grpcClient, CarrierConstantServiceSettings settings)
        {
            GrpcClient = grpcClient;
            CarrierConstantServiceSettings effectiveSettings = settings ?? CarrierConstantServiceSettings.GetDefault();
            gaxgrpc::ClientHelper          clientHelper      = new gaxgrpc::ClientHelper(effectiveSettings);

            _callGetCarrierConstant = clientHelper.BuildApiCall <GetCarrierConstantRequest, gagvr::CarrierConstant>(grpcClient.GetCarrierConstantAsync, grpcClient.GetCarrierConstant, effectiveSettings.GetCarrierConstantSettings).WithGoogleRequestParam("resource_name", request => request.ResourceName);
            Modify_ApiCall(ref _callGetCarrierConstant);
            Modify_GetCarrierConstantApiCall(ref _callGetCarrierConstant);
            OnConstruction(grpcClient, effectiveSettings, clientHelper);
        }
Exemple #5
0
        /// <summary>
        /// Constructs a client wrapper for the CustomerService service, with the specified gRPC client and settings.
        /// </summary>
        /// <param name="grpcClient">The underlying gRPC client.</param>
        /// <param name="settings">The base <see cref="CustomerServiceSettings"/> used within this client.</param>
        public CustomerServiceClientImpl(CustomerService.CustomerServiceClient grpcClient, CustomerServiceSettings settings)
        {
            GrpcClient = grpcClient;
            CustomerServiceSettings effectiveSettings = settings ?? CustomerServiceSettings.GetDefault();
            gaxgrpc::ClientHelper   clientHelper      = new gaxgrpc::ClientHelper(effectiveSettings);

            _callGetCustomer = clientHelper.BuildApiCall <GetCustomerRequest, gagvr::Customer>(grpcClient.GetCustomerAsync, grpcClient.GetCustomer, effectiveSettings.GetCustomerSettings).WithGoogleRequestParam("resource_name", request => request.ResourceName);
            Modify_ApiCall(ref _callGetCustomer);
            Modify_GetCustomerApiCall(ref _callGetCustomer);
            _callMutateCustomer = clientHelper.BuildApiCall <MutateCustomerRequest, MutateCustomerResponse>(grpcClient.MutateCustomerAsync, grpcClient.MutateCustomer, effectiveSettings.MutateCustomerSettings).WithGoogleRequestParam("customer_id", request => request.CustomerId);
            Modify_ApiCall(ref _callMutateCustomer);
            Modify_MutateCustomerApiCall(ref _callMutateCustomer);
            _callListAccessibleCustomers = clientHelper.BuildApiCall <ListAccessibleCustomersRequest, ListAccessibleCustomersResponse>(grpcClient.ListAccessibleCustomersAsync, grpcClient.ListAccessibleCustomers, effectiveSettings.ListAccessibleCustomersSettings);
            Modify_ApiCall(ref _callListAccessibleCustomers);
            Modify_ListAccessibleCustomersApiCall(ref _callListAccessibleCustomers);
            _callCreateCustomerClient = clientHelper.BuildApiCall <CreateCustomerClientRequest, CreateCustomerClientResponse>(grpcClient.CreateCustomerClientAsync, grpcClient.CreateCustomerClient, effectiveSettings.CreateCustomerClientSettings).WithGoogleRequestParam("customer_id", request => request.CustomerId);
            Modify_ApiCall(ref _callCreateCustomerClient);
            Modify_CreateCustomerClientApiCall(ref _callCreateCustomerClient);
            OnConstruction(grpcClient, effectiveSettings, clientHelper);
        }
Exemple #6
0
        /// <summary>
        /// Constructs a client wrapper for the ConnectionService service, with the specified gRPC client and settings.
        /// </summary>
        /// <param name="grpcClient">The underlying gRPC client.</param>
        /// <param name="settings">The base <see cref="ConnectionServiceSettings"/> used within this client.</param>
        public ConnectionServiceClientImpl(ConnectionService.ConnectionServiceClient grpcClient, ConnectionServiceSettings settings)
        {
            GrpcClient = grpcClient;
            ConnectionServiceSettings effectiveSettings = settings ?? ConnectionServiceSettings.GetDefault();
            gaxgrpc::ClientHelper     clientHelper      = new gaxgrpc::ClientHelper(effectiveSettings);

            _callListConnections = clientHelper.BuildApiCall <ListConnectionsRequest, ListConnectionsResponse>(grpcClient.ListConnectionsAsync, grpcClient.ListConnections, effectiveSettings.ListConnectionsSettings).WithGoogleRequestParam("parent", request => request.Parent);
            Modify_ApiCall(ref _callListConnections);
            Modify_ListConnectionsApiCall(ref _callListConnections);
            OnConstruction(grpcClient, effectiveSettings, clientHelper);
        }
Exemple #7
0
        /// <summary>
        /// Constructs a client wrapper for the DomainCategoryService service, with the specified gRPC client and
        /// settings.
        /// </summary>
        /// <param name="grpcClient">The underlying gRPC client.</param>
        /// <param name="settings">The base <see cref="DomainCategoryServiceSettings"/> used within this client.</param>
        public DomainCategoryServiceClientImpl(DomainCategoryService.DomainCategoryServiceClient grpcClient, DomainCategoryServiceSettings settings)
        {
            GrpcClient = grpcClient;
            DomainCategoryServiceSettings effectiveSettings = settings ?? DomainCategoryServiceSettings.GetDefault();
            gaxgrpc::ClientHelper         clientHelper      = new gaxgrpc::ClientHelper(effectiveSettings);

            _callGetDomainCategory = clientHelper.BuildApiCall <GetDomainCategoryRequest, gagvr::DomainCategory>(grpcClient.GetDomainCategoryAsync, grpcClient.GetDomainCategory, effectiveSettings.GetDomainCategorySettings).WithGoogleRequestParam("resource_name", request => request.ResourceName);
            Modify_ApiCall(ref _callGetDomainCategory);
            Modify_GetDomainCategoryApiCall(ref _callGetDomainCategory);
            OnConstruction(grpcClient, effectiveSettings, clientHelper);
        }
Exemple #8
0
        /// <summary>
        /// Constructs a client wrapper for the MessagesV1Beta3 service, with the specified gRPC client and settings.
        /// </summary>
        /// <param name="grpcClient">The underlying gRPC client.</param>
        /// <param name="settings">The base <see cref="MessagesV1Beta3Settings"/> used within this client.</param>
        public MessagesV1Beta3ClientImpl(MessagesV1Beta3.MessagesV1Beta3Client grpcClient, MessagesV1Beta3Settings settings)
        {
            GrpcClient = grpcClient;
            MessagesV1Beta3Settings effectiveSettings = settings ?? MessagesV1Beta3Settings.GetDefault();
            gaxgrpc::ClientHelper   clientHelper      = new gaxgrpc::ClientHelper(effectiveSettings);

            _callListJobMessages = clientHelper.BuildApiCall <ListJobMessagesRequest, ListJobMessagesResponse>(grpcClient.ListJobMessagesAsync, grpcClient.ListJobMessages, effectiveSettings.ListJobMessagesSettings);
            Modify_ApiCall(ref _callListJobMessages);
            Modify_ListJobMessagesApiCall(ref _callListJobMessages);
            OnConstruction(grpcClient, effectiveSettings, clientHelper);
        }
Exemple #9
0
        /// <summary>
        /// Constructs a client wrapper for the ThirdPartyAppAnalyticsLinkService service, with the specified gRPC
        /// client and settings.
        /// </summary>
        /// <param name="grpcClient">The underlying gRPC client.</param>
        /// <param name="settings">
        /// The base <see cref="ThirdPartyAppAnalyticsLinkServiceSettings"/> used within this client.
        /// </param>
        public ThirdPartyAppAnalyticsLinkServiceClientImpl(ThirdPartyAppAnalyticsLinkService.ThirdPartyAppAnalyticsLinkServiceClient grpcClient, ThirdPartyAppAnalyticsLinkServiceSettings settings)
        {
            GrpcClient = grpcClient;
            ThirdPartyAppAnalyticsLinkServiceSettings effectiveSettings = settings ?? ThirdPartyAppAnalyticsLinkServiceSettings.GetDefault();
            gaxgrpc::ClientHelper clientHelper = new gaxgrpc::ClientHelper(effectiveSettings);

            _callGetThirdPartyAppAnalyticsLink = clientHelper.BuildApiCall <GetThirdPartyAppAnalyticsLinkRequest, gagvr::ThirdPartyAppAnalyticsLink>(grpcClient.GetThirdPartyAppAnalyticsLinkAsync, grpcClient.GetThirdPartyAppAnalyticsLink, effectiveSettings.GetThirdPartyAppAnalyticsLinkSettings).WithGoogleRequestParam("resource_name", request => request.ResourceName);
            Modify_ApiCall(ref _callGetThirdPartyAppAnalyticsLink);
            Modify_GetThirdPartyAppAnalyticsLinkApiCall(ref _callGetThirdPartyAppAnalyticsLink);
            OnConstruction(grpcClient, effectiveSettings, clientHelper);
        }
        /// <summary>
        /// Constructs a client wrapper for the AssetService service, with the specified gRPC client and settings.
        /// </summary>
        /// <param name="grpcClient">The underlying gRPC client.</param>
        /// <param name="settings">The base <see cref="AssetServiceSettings"/> used within this client </param>
        public AssetServiceClientImpl(AssetService.AssetServiceClient grpcClient, AssetServiceSettings settings)
        {
            GrpcClient = grpcClient;
            AssetServiceSettings  effectiveSettings = settings ?? AssetServiceSettings.GetDefault();
            gaxgrpc::ClientHelper clientHelper      = new gaxgrpc::ClientHelper(effectiveSettings);

            ExportAssetsOperationsClient = new lro::OperationsClientImpl(
                grpcClient.CreateOperationsClient(), effectiveSettings.ExportAssetsOperationsSettings);
            _callExportAssets = clientHelper.BuildApiCall <ExportAssetsRequest, lro::Operation>(
                GrpcClient.ExportAssetsAsync, GrpcClient.ExportAssets, effectiveSettings.ExportAssetsSettings)
                                .WithCallSettingsOverlay(request => gaxgrpc::CallSettings.FromHeader("x-goog-request-params", $"parent={request.Parent}"));
            _callBatchGetAssetsHistory = clientHelper.BuildApiCall <BatchGetAssetsHistoryRequest, BatchGetAssetsHistoryResponse>(
                GrpcClient.BatchGetAssetsHistoryAsync, GrpcClient.BatchGetAssetsHistory, effectiveSettings.BatchGetAssetsHistorySettings)
                                         .WithCallSettingsOverlay(request => gaxgrpc::CallSettings.FromHeader("x-goog-request-params", $"parent={request.Parent}"));
            Modify_ApiCall(ref _callExportAssets);
            Modify_ExportAssetsApiCall(ref _callExportAssets);
            Modify_ApiCall(ref _callBatchGetAssetsHistory);
            Modify_BatchGetAssetsHistoryApiCall(ref _callBatchGetAssetsHistory);
            OnConstruction(grpcClient, effectiveSettings, clientHelper);
        }
        /// <summary>
        /// Constructs a client wrapper for the VideoService service, with the specified gRPC client and settings.
        /// </summary>
        /// <param name="grpcClient">The underlying gRPC client.</param>
        /// <param name="settings">The base <see cref="VideoServiceSettings"/> used within this client.</param>
        public VideoServiceClientImpl(VideoService.VideoServiceClient grpcClient, VideoServiceSettings settings)
        {
            GrpcClient = grpcClient;
            VideoServiceSettings  effectiveSettings = settings ?? VideoServiceSettings.GetDefault();
            gaxgrpc::ClientHelper clientHelper      = new gaxgrpc::ClientHelper(effectiveSettings);

            _callGetVideo = clientHelper.BuildApiCall <GetVideoRequest, gagvr::Video>(grpcClient.GetVideoAsync, grpcClient.GetVideo, effectiveSettings.GetVideoSettings).WithGoogleRequestParam("resource_name", request => request.ResourceName);
            Modify_ApiCall(ref _callGetVideo);
            Modify_GetVideoApiCall(ref _callGetVideo);
            OnConstruction(grpcClient, effectiveSettings, clientHelper);
        }
Exemple #12
0
        /// <summary>
        /// Constructs a client wrapper for the RegionInstanceGroups service, with the specified gRPC client and
        /// settings.
        /// </summary>
        /// <param name="grpcClient">The underlying gRPC client.</param>
        /// <param name="settings">The base <see cref="RegionInstanceGroupsSettings"/> used within this client.</param>
        public RegionInstanceGroupsClientImpl(RegionInstanceGroups.RegionInstanceGroupsClient grpcClient, RegionInstanceGroupsSettings settings)
        {
            GrpcClient = grpcClient;
            RegionInstanceGroupsSettings effectiveSettings = settings ?? RegionInstanceGroupsSettings.GetDefault();
            gaxgrpc::ClientHelper        clientHelper      = new gaxgrpc::ClientHelper(effectiveSettings);

            _callGet = clientHelper.BuildApiCall <GetRegionInstanceGroupRequest, InstanceGroup>(grpcClient.GetAsync, grpcClient.Get, effectiveSettings.GetSettings).WithGoogleRequestParam("project", request => request.Project).WithGoogleRequestParam("region", request => request.Region).WithGoogleRequestParam("instance_group", request => request.InstanceGroup);
            Modify_ApiCall(ref _callGet);
            Modify_GetApiCall(ref _callGet);
            _callList = clientHelper.BuildApiCall <ListRegionInstanceGroupsRequest, RegionInstanceGroupList>(grpcClient.ListAsync, grpcClient.List, effectiveSettings.ListSettings).WithGoogleRequestParam("project", request => request.Project).WithGoogleRequestParam("region", request => request.Region);
            Modify_ApiCall(ref _callList);
            Modify_ListApiCall(ref _callList);
            _callListInstances = clientHelper.BuildApiCall <ListInstancesRegionInstanceGroupsRequest, RegionInstanceGroupsListInstances>(grpcClient.ListInstancesAsync, grpcClient.ListInstances, effectiveSettings.ListInstancesSettings).WithGoogleRequestParam("project", request => request.Project).WithGoogleRequestParam("region", request => request.Region).WithGoogleRequestParam("instance_group", request => request.InstanceGroup);
            Modify_ApiCall(ref _callListInstances);
            Modify_ListInstancesApiCall(ref _callListInstances);
            _callSetNamedPorts = clientHelper.BuildApiCall <SetNamedPortsRegionInstanceGroupRequest, Operation>(grpcClient.SetNamedPortsAsync, grpcClient.SetNamedPorts, effectiveSettings.SetNamedPortsSettings).WithGoogleRequestParam("project", request => request.Project).WithGoogleRequestParam("region", request => request.Region).WithGoogleRequestParam("instance_group", request => request.InstanceGroup);
            Modify_ApiCall(ref _callSetNamedPorts);
            Modify_SetNamedPortsApiCall(ref _callSetNamedPorts);
            OnConstruction(grpcClient, effectiveSettings, clientHelper);
        }
Exemple #13
0
        /// <summary>
        /// Constructs a client wrapper for the AssetGroupListingGroupFilterService service, with the specified gRPC
        /// client and settings.
        /// </summary>
        /// <param name="grpcClient">The underlying gRPC client.</param>
        /// <param name="settings">
        /// The base <see cref="AssetGroupListingGroupFilterServiceSettings"/> used within this client.
        /// </param>
        public AssetGroupListingGroupFilterServiceClientImpl(AssetGroupListingGroupFilterService.AssetGroupListingGroupFilterServiceClient grpcClient, AssetGroupListingGroupFilterServiceSettings settings)
        {
            GrpcClient = grpcClient;
            AssetGroupListingGroupFilterServiceSettings effectiveSettings = settings ?? AssetGroupListingGroupFilterServiceSettings.GetDefault();
            gaxgrpc::ClientHelper clientHelper = new gaxgrpc::ClientHelper(effectiveSettings);

            _callMutateAssetGroupListingGroupFilters = clientHelper.BuildApiCall <MutateAssetGroupListingGroupFiltersRequest, MutateAssetGroupListingGroupFiltersResponse>(grpcClient.MutateAssetGroupListingGroupFiltersAsync, grpcClient.MutateAssetGroupListingGroupFilters, effectiveSettings.MutateAssetGroupListingGroupFiltersSettings).WithGoogleRequestParam("customer_id", request => request.CustomerId);
            Modify_ApiCall(ref _callMutateAssetGroupListingGroupFilters);
            Modify_MutateAssetGroupListingGroupFiltersApiCall(ref _callMutateAssetGroupListingGroupFilters);
            OnConstruction(grpcClient, effectiveSettings, clientHelper);
        }
        /// <summary>
        /// Constructs a client wrapper for the RegionInstances service, with the specified gRPC client and settings.
        /// </summary>
        /// <param name="grpcClient">The underlying gRPC client.</param>
        /// <param name="settings">The base <see cref="RegionInstancesSettings"/> used within this client.</param>
        public RegionInstancesClientImpl(RegionInstances.RegionInstancesClient grpcClient, RegionInstancesSettings settings)
        {
            GrpcClient = grpcClient;
            RegionInstancesSettings effectiveSettings = settings ?? RegionInstancesSettings.GetDefault();
            gaxgrpc::ClientHelper   clientHelper      = new gaxgrpc::ClientHelper(effectiveSettings);

            _callBulkInsert = clientHelper.BuildApiCall <BulkInsertRegionInstanceRequest, Operation>(grpcClient.BulkInsertAsync, grpcClient.BulkInsert, effectiveSettings.BulkInsertSettings).WithGoogleRequestParam("project", request => request.Project).WithGoogleRequestParam("region", request => request.Region);
            Modify_ApiCall(ref _callBulkInsert);
            Modify_BulkInsertApiCall(ref _callBulkInsert);
            OnConstruction(grpcClient, effectiveSettings, clientHelper);
        }
        /// <summary>
        /// Constructs a client wrapper for the PredictionService service, with the specified gRPC client and settings.
        /// </summary>
        /// <param name="grpcClient">The underlying gRPC client.</param>
        /// <param name="settings">The base <see cref="PredictionServiceSettings"/> used within this client.</param>
        public PredictionServiceClientImpl(PredictionService.PredictionServiceClient grpcClient, PredictionServiceSettings settings)
        {
            GrpcClient = grpcClient;
            PredictionServiceSettings effectiveSettings = settings ?? PredictionServiceSettings.GetDefault();
            gaxgrpc::ClientHelper     clientHelper      = new gaxgrpc::ClientHelper(effectiveSettings);

            _callPredict = clientHelper.BuildApiCall <PredictRequest, PredictResponse>(grpcClient.PredictAsync, grpcClient.Predict, effectiveSettings.PredictSettings).WithGoogleRequestParam("name", request => request.Name);
            Modify_ApiCall(ref _callPredict);
            Modify_PredictApiCall(ref _callPredict);
            OnConstruction(grpcClient, effectiveSettings, clientHelper);
        }
Exemple #16
0
        /// <summary>
        /// Constructs a client wrapper for the QuotaController service, with the specified gRPC client and settings.
        /// </summary>
        /// <param name="grpcClient">The underlying gRPC client.</param>
        /// <param name="settings">The base <see cref="QuotaControllerSettings"/> used within this client.</param>
        public QuotaControllerClientImpl(QuotaController.QuotaControllerClient grpcClient, QuotaControllerSettings settings)
        {
            GrpcClient = grpcClient;
            QuotaControllerSettings effectiveSettings = settings ?? QuotaControllerSettings.GetDefault();
            gaxgrpc::ClientHelper   clientHelper      = new gaxgrpc::ClientHelper(effectiveSettings);

            _callAllocateQuota = clientHelper.BuildApiCall <AllocateQuotaRequest, AllocateQuotaResponse>(grpcClient.AllocateQuotaAsync, grpcClient.AllocateQuota, effectiveSettings.AllocateQuotaSettings).WithGoogleRequestParam("service_name", request => request.ServiceName);
            Modify_ApiCall(ref _callAllocateQuota);
            Modify_AllocateQuotaApiCall(ref _callAllocateQuota);
            OnConstruction(grpcClient, effectiveSettings, clientHelper);
        }
        /// <summary>
        /// Constructs a client wrapper for the KeywordPlanAdGroupService service, with the specified gRPC client and
        /// settings.
        /// </summary>
        /// <param name="grpcClient">The underlying gRPC client.</param>
        /// <param name="settings">
        /// The base <see cref="KeywordPlanAdGroupServiceSettings"/> used within this client.
        /// </param>
        public KeywordPlanAdGroupServiceClientImpl(KeywordPlanAdGroupService.KeywordPlanAdGroupServiceClient grpcClient, KeywordPlanAdGroupServiceSettings settings)
        {
            GrpcClient = grpcClient;
            KeywordPlanAdGroupServiceSettings effectiveSettings = settings ?? KeywordPlanAdGroupServiceSettings.GetDefault();
            gaxgrpc::ClientHelper             clientHelper      = new gaxgrpc::ClientHelper(effectiveSettings);

            _callMutateKeywordPlanAdGroups = clientHelper.BuildApiCall <MutateKeywordPlanAdGroupsRequest, MutateKeywordPlanAdGroupsResponse>(grpcClient.MutateKeywordPlanAdGroupsAsync, grpcClient.MutateKeywordPlanAdGroups, effectiveSettings.MutateKeywordPlanAdGroupsSettings).WithGoogleRequestParam("customer_id", request => request.CustomerId);
            Modify_ApiCall(ref _callMutateKeywordPlanAdGroups);
            Modify_MutateKeywordPlanAdGroupsApiCall(ref _callMutateKeywordPlanAdGroups);
            OnConstruction(grpcClient, effectiveSettings, clientHelper);
        }
        /// <summary>
        /// Constructs a client wrapper for the PhishingProtectionServiceV1Beta1 service, with the specified gRPC client
        /// and settings.
        /// </summary>
        /// <param name="grpcClient">The underlying gRPC client.</param>
        /// <param name="settings">
        /// The base <see cref="PhishingProtectionServiceV1Beta1Settings"/> used within this client.
        /// </param>
        public PhishingProtectionServiceV1Beta1ClientImpl(PhishingProtectionServiceV1Beta1.PhishingProtectionServiceV1Beta1Client grpcClient, PhishingProtectionServiceV1Beta1Settings settings)
        {
            GrpcClient = grpcClient;
            PhishingProtectionServiceV1Beta1Settings effectiveSettings = settings ?? PhishingProtectionServiceV1Beta1Settings.GetDefault();
            gaxgrpc::ClientHelper clientHelper = new gaxgrpc::ClientHelper(effectiveSettings);

            _callReportPhishing = clientHelper.BuildApiCall <ReportPhishingRequest, ReportPhishingResponse>(grpcClient.ReportPhishingAsync, grpcClient.ReportPhishing, effectiveSettings.ReportPhishingSettings).WithGoogleRequestParam("parent", request => request.Parent);
            Modify_ApiCall(ref _callReportPhishing);
            Modify_ReportPhishingApiCall(ref _callReportPhishing);
            OnConstruction(grpcClient, effectiveSettings, clientHelper);
        }
Exemple #19
0
        /// <summary>
        /// Constructs a client wrapper for the FeedPlaceholderViewService service, with the specified gRPC client and
        /// settings.
        /// </summary>
        /// <param name="grpcClient">The underlying gRPC client.</param>
        /// <param name="settings">
        /// The base <see cref="FeedPlaceholderViewServiceSettings"/> used within this client.
        /// </param>
        public FeedPlaceholderViewServiceClientImpl(FeedPlaceholderViewService.FeedPlaceholderViewServiceClient grpcClient, FeedPlaceholderViewServiceSettings settings)
        {
            GrpcClient = grpcClient;
            FeedPlaceholderViewServiceSettings effectiveSettings = settings ?? FeedPlaceholderViewServiceSettings.GetDefault();
            gaxgrpc::ClientHelper clientHelper = new gaxgrpc::ClientHelper(effectiveSettings);

            _callGetFeedPlaceholderView = clientHelper.BuildApiCall <GetFeedPlaceholderViewRequest, gagvr::FeedPlaceholderView>(grpcClient.GetFeedPlaceholderViewAsync, grpcClient.GetFeedPlaceholderView, effectiveSettings.GetFeedPlaceholderViewSettings).WithGoogleRequestParam("resource_name", request => request.ResourceName);
            Modify_ApiCall(ref _callGetFeedPlaceholderView);
            Modify_GetFeedPlaceholderViewApiCall(ref _callGetFeedPlaceholderView);
            OnConstruction(grpcClient, effectiveSettings, clientHelper);
        }
Exemple #20
0
        /// <summary>
        /// Constructs a client wrapper for the TraceService service, with the specified gRPC client and settings.
        /// </summary>
        /// <param name="grpcClient">The underlying gRPC client.</param>
        /// <param name="settings">The base <see cref="TraceServiceSettings"/> used within this client </param>
        public TraceServiceClientImpl(TraceService.TraceServiceClient grpcClient, TraceServiceSettings settings)
        {
            GrpcClient = grpcClient;
            TraceServiceSettings  effectiveSettings = settings ?? TraceServiceSettings.GetDefault();
            gaxgrpc::ClientHelper clientHelper      = new gaxgrpc::ClientHelper(effectiveSettings);

            _callPatchTraces = clientHelper.BuildApiCall <PatchTracesRequest, pbwkt::Empty>(
                GrpcClient.PatchTracesAsync, GrpcClient.PatchTraces, effectiveSettings.PatchTracesSettings);
            _callGetTrace = clientHelper.BuildApiCall <GetTraceRequest, Trace>(
                GrpcClient.GetTraceAsync, GrpcClient.GetTrace, effectiveSettings.GetTraceSettings);
            _callListTraces = clientHelper.BuildApiCall <ListTracesRequest, ListTracesResponse>(
                GrpcClient.ListTracesAsync, GrpcClient.ListTraces, effectiveSettings.ListTracesSettings);
            Modify_ApiCall(ref _callPatchTraces);
            Modify_PatchTracesApiCall(ref _callPatchTraces);
            Modify_ApiCall(ref _callGetTrace);
            Modify_GetTraceApiCall(ref _callGetTrace);
            Modify_ApiCall(ref _callListTraces);
            Modify_ListTracesApiCall(ref _callListTraces);
            OnConstruction(grpcClient, effectiveSettings, clientHelper);
        }
Exemple #21
0
        /// <summary>
        /// Constructs a client wrapper for the ConversionAdjustmentUploadService service, with the specified gRPC
        /// client and settings.
        /// </summary>
        /// <param name="grpcClient">The underlying gRPC client.</param>
        /// <param name="settings">
        /// The base <see cref="ConversionAdjustmentUploadServiceSettings"/> used within this client.
        /// </param>
        public ConversionAdjustmentUploadServiceClientImpl(ConversionAdjustmentUploadService.ConversionAdjustmentUploadServiceClient grpcClient, ConversionAdjustmentUploadServiceSettings settings)
        {
            GrpcClient = grpcClient;
            ConversionAdjustmentUploadServiceSettings effectiveSettings = settings ?? ConversionAdjustmentUploadServiceSettings.GetDefault();
            gaxgrpc::ClientHelper clientHelper = new gaxgrpc::ClientHelper(effectiveSettings);

            _callUploadConversionAdjustments = clientHelper.BuildApiCall <UploadConversionAdjustmentsRequest, UploadConversionAdjustmentsResponse>(grpcClient.UploadConversionAdjustmentsAsync, grpcClient.UploadConversionAdjustments, effectiveSettings.UploadConversionAdjustmentsSettings).WithGoogleRequestParam("customer_id", request => request.CustomerId);
            Modify_ApiCall(ref _callUploadConversionAdjustments);
            Modify_UploadConversionAdjustmentsApiCall(ref _callUploadConversionAdjustments);
            OnConstruction(grpcClient, effectiveSettings, clientHelper);
        }
Exemple #22
0
        /// <summary>
        /// Constructs a client wrapper for the AdMobApi service, with the specified gRPC client and settings.
        /// </summary>
        /// <param name="grpcClient">The underlying gRPC client.</param>
        /// <param name="settings">The base <see cref="AdMobApiSettings"/> used within this client.</param>
        public AdMobApiClientImpl(AdMobApi.AdMobApiClient grpcClient, AdMobApiSettings settings)
        {
            GrpcClient = grpcClient;
            AdMobApiSettings      effectiveSettings = settings ?? AdMobApiSettings.GetDefault();
            gaxgrpc::ClientHelper clientHelper      = new gaxgrpc::ClientHelper(effectiveSettings);

            _callGetPublisherAccount = clientHelper.BuildApiCall <GetPublisherAccountRequest, PublisherAccount>(grpcClient.GetPublisherAccountAsync, grpcClient.GetPublisherAccount, effectiveSettings.GetPublisherAccountSettings).WithGoogleRequestParam("name", request => request.Name);
            Modify_ApiCall(ref _callGetPublisherAccount);
            Modify_GetPublisherAccountApiCall(ref _callGetPublisherAccount);
            _callListPublisherAccounts = clientHelper.BuildApiCall <ListPublisherAccountsRequest, ListPublisherAccountsResponse>(grpcClient.ListPublisherAccountsAsync, grpcClient.ListPublisherAccounts, effectiveSettings.ListPublisherAccountsSettings);
            Modify_ApiCall(ref _callListPublisherAccounts);
            Modify_ListPublisherAccountsApiCall(ref _callListPublisherAccounts);
            _callGenerateNetworkReport = clientHelper.BuildApiCall <GenerateNetworkReportRequest, GenerateNetworkReportResponse>(grpcClient.GenerateNetworkReport, effectiveSettings.GenerateNetworkReportSettings).WithGoogleRequestParam("parent", request => request.Parent);
            Modify_ApiCall(ref _callGenerateNetworkReport);
            Modify_GenerateNetworkReportApiCall(ref _callGenerateNetworkReport);
            _callGenerateMediationReport = clientHelper.BuildApiCall <GenerateMediationReportRequest, GenerateMediationReportResponse>(grpcClient.GenerateMediationReport, effectiveSettings.GenerateMediationReportSettings).WithGoogleRequestParam("parent", request => request.Parent);
            Modify_ApiCall(ref _callGenerateMediationReport);
            Modify_GenerateMediationReportApiCall(ref _callGenerateMediationReport);
            OnConstruction(grpcClient, effectiveSettings, clientHelper);
        }
Exemple #23
0
        /// <summary>
        /// Constructs a client wrapper for the AdGroupSimulationService service, with the specified gRPC client and
        /// settings.
        /// </summary>
        /// <param name="grpcClient">The underlying gRPC client.</param>
        /// <param name="settings">
        /// The base <see cref="AdGroupSimulationServiceSettings"/> used within this client.
        /// </param>
        public AdGroupSimulationServiceClientImpl(AdGroupSimulationService.AdGroupSimulationServiceClient grpcClient, AdGroupSimulationServiceSettings settings)
        {
            GrpcClient = grpcClient;
            AdGroupSimulationServiceSettings effectiveSettings = settings ?? AdGroupSimulationServiceSettings.GetDefault();
            gaxgrpc::ClientHelper            clientHelper      = new gaxgrpc::ClientHelper(effectiveSettings);

            _callGetAdGroupSimulation = clientHelper.BuildApiCall <GetAdGroupSimulationRequest, gagvr::AdGroupSimulation>(grpcClient.GetAdGroupSimulationAsync, grpcClient.GetAdGroupSimulation, effectiveSettings.GetAdGroupSimulationSettings).WithGoogleRequestParam("resource_name", request => request.ResourceName);
            Modify_ApiCall(ref _callGetAdGroupSimulation);
            Modify_GetAdGroupSimulationApiCall(ref _callGetAdGroupSimulation);
            OnConstruction(grpcClient, effectiveSettings, clientHelper);
        }
        /// <summary>
        /// Constructs a client wrapper for the RegionNotificationEndpoints service, with the specified gRPC client and
        /// settings.
        /// </summary>
        /// <param name="grpcClient">The underlying gRPC client.</param>
        /// <param name="settings">
        /// The base <see cref="RegionNotificationEndpointsSettings"/> used within this client.
        /// </param>
        public RegionNotificationEndpointsClientImpl(RegionNotificationEndpoints.RegionNotificationEndpointsClient grpcClient, RegionNotificationEndpointsSettings settings)
        {
            GrpcClient = grpcClient;
            RegionNotificationEndpointsSettings effectiveSettings = settings ?? RegionNotificationEndpointsSettings.GetDefault();
            gaxgrpc::ClientHelper clientHelper = new gaxgrpc::ClientHelper(effectiveSettings);

            _callDelete = clientHelper.BuildApiCall <DeleteRegionNotificationEndpointRequest, Operation>(grpcClient.DeleteAsync, grpcClient.Delete, effectiveSettings.DeleteSettings).WithGoogleRequestParam("project", request => request.Project).WithGoogleRequestParam("region", request => request.Region).WithGoogleRequestParam("notification_endpoint", request => request.NotificationEndpoint);
            Modify_ApiCall(ref _callDelete);
            Modify_DeleteApiCall(ref _callDelete);
            _callGet = clientHelper.BuildApiCall <GetRegionNotificationEndpointRequest, NotificationEndpoint>(grpcClient.GetAsync, grpcClient.Get, effectiveSettings.GetSettings).WithGoogleRequestParam("project", request => request.Project).WithGoogleRequestParam("region", request => request.Region).WithGoogleRequestParam("notification_endpoint", request => request.NotificationEndpoint);
            Modify_ApiCall(ref _callGet);
            Modify_GetApiCall(ref _callGet);
            _callInsert = clientHelper.BuildApiCall <InsertRegionNotificationEndpointRequest, Operation>(grpcClient.InsertAsync, grpcClient.Insert, effectiveSettings.InsertSettings).WithGoogleRequestParam("project", request => request.Project).WithGoogleRequestParam("region", request => request.Region);
            Modify_ApiCall(ref _callInsert);
            Modify_InsertApiCall(ref _callInsert);
            _callList = clientHelper.BuildApiCall <ListRegionNotificationEndpointsRequest, NotificationEndpointList>(grpcClient.ListAsync, grpcClient.List, effectiveSettings.ListSettings).WithGoogleRequestParam("project", request => request.Project).WithGoogleRequestParam("region", request => request.Region);
            Modify_ApiCall(ref _callList);
            Modify_ListApiCall(ref _callList);
            OnConstruction(grpcClient, effectiveSettings, clientHelper);
        }
Exemple #25
0
        /// <summary>
        /// Constructs a client wrapper for the PaymentsAccountService service, with the specified gRPC client and
        /// settings.
        /// </summary>
        /// <param name="grpcClient">The underlying gRPC client.</param>
        /// <param name="settings">
        /// The base <see cref="PaymentsAccountServiceSettings"/> used within this client.
        /// </param>
        public PaymentsAccountServiceClientImpl(PaymentsAccountService.PaymentsAccountServiceClient grpcClient, PaymentsAccountServiceSettings settings)
        {
            GrpcClient = grpcClient;
            PaymentsAccountServiceSettings effectiveSettings = settings ?? PaymentsAccountServiceSettings.GetDefault();
            gaxgrpc::ClientHelper          clientHelper      = new gaxgrpc::ClientHelper(effectiveSettings);

            _callListPaymentsAccounts = clientHelper.BuildApiCall <ListPaymentsAccountsRequest, ListPaymentsAccountsResponse>(grpcClient.ListPaymentsAccountsAsync, grpcClient.ListPaymentsAccounts, effectiveSettings.ListPaymentsAccountsSettings).WithGoogleRequestParam("customer_id", request => request.CustomerId);
            Modify_ApiCall(ref _callListPaymentsAccounts);
            Modify_ListPaymentsAccountsApiCall(ref _callListPaymentsAccounts);
            OnConstruction(grpcClient, effectiveSettings, clientHelper);
        }
        /// <summary>
        /// Constructs a client wrapper for the CampaignAssetSetService service, with the specified gRPC client and
        /// settings.
        /// </summary>
        /// <param name="grpcClient">The underlying gRPC client.</param>
        /// <param name="settings">
        /// The base <see cref="CampaignAssetSetServiceSettings"/> used within this client.
        /// </param>
        public CampaignAssetSetServiceClientImpl(CampaignAssetSetService.CampaignAssetSetServiceClient grpcClient, CampaignAssetSetServiceSettings settings)
        {
            GrpcClient = grpcClient;
            CampaignAssetSetServiceSettings effectiveSettings = settings ?? CampaignAssetSetServiceSettings.GetDefault();
            gaxgrpc::ClientHelper           clientHelper      = new gaxgrpc::ClientHelper(effectiveSettings);

            _callMutateCampaignAssetSets = clientHelper.BuildApiCall <MutateCampaignAssetSetsRequest, MutateCampaignAssetSetsResponse>(grpcClient.MutateCampaignAssetSetsAsync, grpcClient.MutateCampaignAssetSets, effectiveSettings.MutateCampaignAssetSetsSettings).WithGoogleRequestParam("customer_id", request => request.CustomerId);
            Modify_ApiCall(ref _callMutateCampaignAssetSets);
            Modify_MutateCampaignAssetSetsApiCall(ref _callMutateCampaignAssetSets);
            OnConstruction(grpcClient, effectiveSettings, clientHelper);
        }
Exemple #27
0
        /// <summary>
        /// Constructs a client wrapper for the Sessions service, with the specified gRPC client and settings.
        /// </summary>
        /// <param name="grpcClient">The underlying gRPC client.</param>
        /// <param name="settings">The base <see cref="SessionsSettings"/> used within this client.</param>
        public SessionsClientImpl(Sessions.SessionsClient grpcClient, SessionsSettings settings)
        {
            GrpcClient = grpcClient;
            SessionsSettings      effectiveSettings = settings ?? SessionsSettings.GetDefault();
            gaxgrpc::ClientHelper clientHelper      = new gaxgrpc::ClientHelper(effectiveSettings);

            _callDetectIntent = clientHelper.BuildApiCall <DetectIntentRequest, DetectIntentResponse>(grpcClient.DetectIntentAsync, grpcClient.DetectIntent, effectiveSettings.DetectIntentSettings).WithGoogleRequestParam("session", request => request.Session);
            Modify_ApiCall(ref _callDetectIntent);
            Modify_DetectIntentApiCall(ref _callDetectIntent);
            _callStreamingDetectIntent = clientHelper.BuildApiCall <StreamingDetectIntentRequest, StreamingDetectIntentResponse>(grpcClient.StreamingDetectIntent, effectiveSettings.StreamingDetectIntentSettings, effectiveSettings.StreamingDetectIntentStreamingSettings);
            Modify_ApiCall(ref _callStreamingDetectIntent);
            Modify_StreamingDetectIntentApiCall(ref _callStreamingDetectIntent);
            _callMatchIntent = clientHelper.BuildApiCall <MatchIntentRequest, MatchIntentResponse>(grpcClient.MatchIntentAsync, grpcClient.MatchIntent, effectiveSettings.MatchIntentSettings).WithGoogleRequestParam("session", request => request.Session);
            Modify_ApiCall(ref _callMatchIntent);
            Modify_MatchIntentApiCall(ref _callMatchIntent);
            _callFulfillIntent = clientHelper.BuildApiCall <FulfillIntentRequest, FulfillIntentResponse>(grpcClient.FulfillIntentAsync, grpcClient.FulfillIntent, effectiveSettings.FulfillIntentSettings).WithGoogleRequestParam("match_intent_request.session", request => request.MatchIntentRequest?.Session);
            Modify_ApiCall(ref _callFulfillIntent);
            Modify_FulfillIntentApiCall(ref _callFulfillIntent);
            OnConstruction(grpcClient, effectiveSettings, clientHelper);
        }
Exemple #28
0
        /// <summary>
        /// Constructs a client wrapper for the ReportErrorsService service, with the specified gRPC client and
        /// settings.
        /// </summary>
        /// <param name="grpcClient">The underlying gRPC client.</param>
        /// <param name="settings">The base <see cref="ReportErrorsServiceSettings"/> used within this client.</param>
        public ReportErrorsServiceClientImpl(ReportErrorsService.ReportErrorsServiceClient grpcClient, ReportErrorsServiceSettings settings)
        {
            GrpcClient = grpcClient;
            ReportErrorsServiceSettings effectiveSettings = settings ?? ReportErrorsServiceSettings.GetDefault();
            gaxgrpc::ClientHelper       clientHelper      = new gaxgrpc::ClientHelper(effectiveSettings);

            _callReportErrorEvent = clientHelper.BuildApiCall <ReportErrorEventRequest, ReportErrorEventResponse>(grpcClient.ReportErrorEventAsync, grpcClient.ReportErrorEvent, effectiveSettings.ReportErrorEventSettings).WithGoogleRequestParam("project_name", request => request.ProjectName);
            Modify_ApiCall(ref _callReportErrorEvent);
            Modify_ReportErrorEventApiCall(ref _callReportErrorEvent);
            OnConstruction(grpcClient, effectiveSettings, clientHelper);
        }
        /// <summary>
        /// Constructs a client wrapper for the UserDataService service, with the specified gRPC client and settings.
        /// </summary>
        /// <param name="grpcClient">The underlying gRPC client.</param>
        /// <param name="settings">The base <see cref="UserDataServiceSettings"/> used within this client.</param>
        public UserDataServiceClientImpl(UserDataService.UserDataServiceClient grpcClient, UserDataServiceSettings settings)
        {
            GrpcClient = grpcClient;
            UserDataServiceSettings effectiveSettings = settings ?? UserDataServiceSettings.GetDefault();
            gaxgrpc::ClientHelper   clientHelper      = new gaxgrpc::ClientHelper(effectiveSettings);

            _callUploadUserData = clientHelper.BuildApiCall <UploadUserDataRequest, UploadUserDataResponse>(grpcClient.UploadUserDataAsync, grpcClient.UploadUserData, effectiveSettings.UploadUserDataSettings).WithGoogleRequestParam("customer_id", request => request.CustomerId);
            Modify_ApiCall(ref _callUploadUserData);
            Modify_UploadUserDataApiCall(ref _callUploadUserData);
            OnConstruction(grpcClient, effectiveSettings, clientHelper);
        }
Exemple #30
0
        /// <summary>
        /// Constructs a client wrapper for the LicenseNotificationService service, with the specified gRPC client and
        /// settings.
        /// </summary>
        /// <param name="grpcClient">The underlying gRPC client.</param>
        /// <param name="settings">
        /// The base <see cref="LicenseNotificationServiceSettings"/> used within this client.
        /// </param>
        public LicenseNotificationServiceClientImpl(LicenseNotificationService.LicenseNotificationServiceClient grpcClient, LicenseNotificationServiceSettings settings)
        {
            GrpcClient = grpcClient;
            LicenseNotificationServiceSettings effectiveSettings = settings ?? LicenseNotificationServiceSettings.GetDefault();
            gaxgrpc::ClientHelper clientHelper = new gaxgrpc::ClientHelper(effectiveSettings);

            _callList = clientHelper.BuildApiCall <LicenseNotificationListRequest, LicenseNotificationList>(grpcClient.ListAsync, grpcClient.List, effectiveSettings.ListSettings).WithGoogleRequestParam("application_id", request => request.ApplicationId);
            Modify_ApiCall(ref _callList);
            Modify_ListApiCall(ref _callList);
            OnConstruction(grpcClient, effectiveSettings, clientHelper);
        }