google-ads-api 10.0.0 → 11.0.0

package/build/src/customer.js

@@ -1,151 +1,62 @@
 "use strict";
-var __extends = (this && this.__extends) || (function () {
-    var extendStatics = function (d, b) {
-        extendStatics = Object.setPrototypeOf ||
-            ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
-            function (d, b) { for (var p in b) if (Object.prototype.hasOwnProperty.call(b, p)) d[p] = b[p]; };
-        return extendStatics(d, b);
-    };
-    return function (d, b) {
-        extendStatics(d, b);
-        function __() { this.constructor = d; }
-        d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
-    };
-})();
-var __assign = (this && this.__assign) || function () {
-    __assign = Object.assign || function(t) {
-        for (var s, i = 1, n = arguments.length; i < n; i++) {
-            s = arguments[i];
-            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
-                t[p] = s[p];
-        }
-        return t;
-    };
-    return __assign.apply(this, arguments);
-};
-var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
-    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
-    return new (P || (P = Promise))(function (resolve, reject) {
-        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
-        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
-        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
-        step((generator = generator.apply(thisArg, _arguments || [])).next());
-    });
-};
-var __generator = (this && this.__generator) || function (thisArg, body) {
-    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g;
-    return g = { next: verb(0), "throw": verb(1), "return": verb(2) }, typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
-    function verb(n) { return function (v) { return step([n, v]); }; }
-    function step(op) {
-        if (f) throw new TypeError("Generator is already executing.");
-        while (_) try {
-            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
-            if (y = 0, t) op = [op[0] & 2, t.value];
-            switch (op[0]) {
-                case 0: case 1: t = op; break;
-                case 4: _.label++; return { value: op[1], done: false };
-                case 5: _.label++; y = op[1]; op = [0]; continue;
-                case 7: op = _.ops.pop(); _.trys.pop(); continue;
-                default:
-                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
-                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
-                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
-                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
-                    if (t[2]) _.ops.pop();
-                    _.trys.pop(); continue;
-            }
-            op = body.call(thisArg, _);
-        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
-        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
-    }
-};
-var __await = (this && this.__await) || function (v) { return this instanceof __await ? (this.v = v, this) : new __await(v); }
-var __asyncGenerator = (this && this.__asyncGenerator) || function (thisArg, _arguments, generator) {
-    if (!Symbol.asyncIterator) throw new TypeError("Symbol.asyncIterator is not defined.");
-    var g = generator.apply(thisArg, _arguments || []), i, q = [];
-    return i = {}, verb("next"), verb("throw"), verb("return"), i[Symbol.asyncIterator] = function () { return this; }, i;
-    function verb(n) { if (g[n]) i[n] = function (v) { return new Promise(function (a, b) { q.push([n, v, a, b]) > 1 || resume(n, v); }); }; }
-    function resume(n, v) { try { step(g[n](v)); } catch (e) { settle(q[0][3], e); } }
-    function step(r) { r.value instanceof __await ? Promise.resolve(r.value.v).then(fulfill, reject) : settle(q[0][2], r); }
-    function fulfill(value) { resume("next", value); }
-    function reject(value) { resume("throw", value); }
-    function settle(f, v) { if (f(v), q.shift(), q.length) resume(q[0][0], q[0][1]); }
-};
 var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.Customer = void 0;
-var parser_1 = require("./parser");
-var serviceFactory_1 = __importDefault(require("./protos/autogen/serviceFactory"));
-var query_1 = require("./query");
-var utils_1 = require("./utils");
-var Customer = /** @class */ (function (_super) {
-    __extends(Customer, _super);
-    function Customer(clientOptions, customerOptions, hooks) {
-        return _super.call(this, clientOptions, customerOptions, hooks !== null && hooks !== void 0 ? hooks : {}) || this;
+const parser_1 = require("./parser");
+const serviceFactory_1 = __importDefault(require("./protos/autogen/serviceFactory"));
+const query_1 = require("./query");
+const utils_1 = require("./utils");
+class Customer extends serviceFactory_1.default {
+    constructor(clientOptions, customerOptions, hooks) {
+        super(clientOptions, customerOptions, hooks !== null && hooks !== void 0 ? hooks : {});
     }
     /**
       @description Single query using a raw GAQL string.
       @hooks onQueryStart, onQueryError, onQueryEnd
     */
-    Customer.prototype.query = function (gaqlQuery, requestOptions) {
-        if (requestOptions === void 0) { requestOptions = {}; }
-        return __awaiter(this, void 0, void 0, function () {
-            var response;
-            return __generator(this, function (_a) {
-                switch (_a.label) {
-                    case 0: return [4 /*yield*/, this.querier(gaqlQuery, requestOptions)];
-                    case 1:
-                        response = (_a.sent()).response;
-                        return [2 /*return*/, response];
-                }
-            });
-        });
-    };
+    async query(gaqlQuery, requestOptions = {}) {
+        const { response } = await this.querier(gaqlQuery, requestOptions);
+        return response;
+    }
+    /**
+      @description Stream query using a raw GAQL string. If a generic type is provided, it must be the type of a single row.
+      If a summary row is requested then this will be the last emitted row of the stream.
+      @hooks onStreamStart, onStreamError
+      @example
+      const stream = queryStream<T>(gaqlQuery)
+      for await (const row of stream) { ... }
+    */
+    async *queryStream(gaqlQuery, requestOptions = {}) {
+        const stream = this.streamer(gaqlQuery, requestOptions);
+        for await (const row of stream) {
+            yield row;
+        }
+    }
     /**
       @description Single query using ReportOptions.
       If a summary row is requested then this will be the first row of the results.
       @hooks onQueryStart, onQueryError, onQueryEnd
     */
-    Customer.prototype.report = function (options) {
-        return __awaiter(this, void 0, void 0, function () {
-            var _a, gaqlQuery, requestOptions, response;
-            return __generator(this, function (_b) {
-                switch (_b.label) {
-                    case 0:
-                        _a = query_1.buildQuery(options), gaqlQuery = _a.gaqlQuery, requestOptions = _a.requestOptions;
-                        return [4 /*yield*/, this.querier(gaqlQuery, requestOptions, options)];
-                    case 1:
-                        response = (_b.sent()).response;
-                        return [2 /*return*/, response];
-                }
-            });
-        });
-    };
+    async report(options) {
+        const { gaqlQuery, requestOptions } = query_1.buildQuery(options);
+        const { response } = await this.querier(gaqlQuery, requestOptions, options);
+        return response;
+    }
     /**
       @description Get the total row count of a report.
       @hooks none
     */
-    Customer.prototype.reportCount = function (options) {
-        return __awaiter(this, void 0, void 0, function () {
-            var _a, gaqlQuery, requestOptions, useHooks, totalResultsCount;
-            return __generator(this, function (_b) {
-                switch (_b.label) {
-                    case 0:
-                        options.limit = 1; // must get at least one row
-                        _a = query_1.buildQuery(options), gaqlQuery = _a.gaqlQuery, requestOptions = _a.requestOptions;
-                        // @ts-expect-error we do not allow this field in reportOptions, however it is still a valid request option
-                        requestOptions.return_total_results_count = true;
-                        useHooks = false;
-                        return [4 /*yield*/, this.querier(gaqlQuery, requestOptions, options, useHooks)];
-                    case 1:
-                        totalResultsCount = (_b.sent()).totalResultsCount;
-                        return [2 /*return*/, totalResultsCount];
-                }
-            });
-        });
-    };
+    async reportCount(options) {
+        options.limit = 1; // must get at least one row
+        const { gaqlQuery, requestOptions } = query_1.buildQuery(options);
+        // @ts-expect-error we do not allow this field in reportOptions, however it is still a valid request option
+        requestOptions.return_total_results_count = true;
+        const useHooks = false; // to avoid cacheing conflicts
+        const { totalResultsCount } = await this.querier(gaqlQuery, requestOptions, options, useHooks);
+        return totalResultsCount;
+    }
     /**
       @description Stream query using ReportOptions. If a generic type is provided, it must be the type of a single row.
       If a summary row is requested then this will be the last emitted row of the stream.
@@ -154,98 +65,13 @@ var Customer = /** @class */ (function (_super) {
       const stream = reportStream<T>(reportOptions)
       for await (const row of stream) { ... }
     */
-    Customer.prototype.reportStream = function (reportOptions) {
-        return __asyncGenerator(this, arguments, function reportStream_1() {
-            var _a, gaqlQuery, requestOptions, baseHookArguments, queryStart_1, _b, service, request, stream, streamFinished, accumulator, nextChunk, item, searchError_1, googleAdsError;
-            var _this = this;
-            return __generator(this, function (_c) {
-                switch (_c.label) {
-                    case 0:
-                        _a = query_1.buildQuery(reportOptions), gaqlQuery = _a.gaqlQuery, requestOptions = _a.requestOptions;
-                        baseHookArguments = {
-                            credentials: this.credentials,
-                            query: gaqlQuery,
-                            reportOptions: reportOptions,
-                        };
-                        if (!this.hooks.onStreamStart) return [3 /*break*/, 3];
-                        queryStart_1 = { cancelled: false };
-                        return [4 /*yield*/, __await(this.hooks.onStreamStart(__assign(__assign({}, baseHookArguments), { cancel: function () {
-                                    queryStart_1.cancelled = true;
-                                }, editOptions: function (options) {
-                                    Object.entries(options).forEach(function (_a) {
-                                        var key = _a[0], val = _a[1];
-                                        // @ts-expect-error
-                                        requestOptions[key] = val;
-                                    });
-                                } })))];
-                    case 1:
-                        _c.sent();
-                        if (!queryStart_1.cancelled) return [3 /*break*/, 3];
-                        return [4 /*yield*/, __await(void 0)];
-                    case 2: return [2 /*return*/, _c.sent()];
-                    case 3:
-                        _b = this.buildSearchStreamRequestAndService(gaqlQuery, requestOptions), service = _b.service, request = _b.request;
-                        stream = service.searchStream(request, {
-                            otherArgs: { headers: this.callHeaders },
-                        });
-                        streamFinished = false;
-                        accumulator = [];
-                        nextChunk = utils_1.createNextChunkArrivedPromise();
-                        stream.on("data", function (chunk) {
-                            var results = chunk.summary_row ? [chunk.summary_row] : chunk.results;
-                            var parsedResponse = _this.clientOptions.disable_parsing
-                                ? results
-                                : parser_1.parse({ results: results, reportOptions: reportOptions });
-                            accumulator.push.apply(accumulator, parsedResponse);
-                            nextChunk.resolve();
-                            nextChunk = utils_1.createNextChunkArrivedPromise();
-                        });
-                        stream.on("error", function (searchError) {
-                            nextChunk.reject(searchError);
-                        });
-                        stream.on("end", function () {
-                            streamFinished = true;
-                            nextChunk.resolve();
-                        });
-                        _c.label = 4;
-                    case 4:
-                        _c.trys.push([4, 12, 15, 16]);
-                        _c.label = 5;
-                    case 5:
-                        if (!(!streamFinished || accumulator.length)) return [3 /*break*/, 11];
-                        if (!(accumulator.length > 0)) return [3 /*break*/, 8];
-                        item = accumulator.shift();
-                        if (item === undefined) {
-                            throw new Error("UNDEFINED_STREAM_ERROR");
-                        }
-                        return [4 /*yield*/, __await(item)];
-                    case 6: return [4 /*yield*/, _c.sent()];
-                    case 7:
-                        _c.sent();
-                        return [3 /*break*/, 10];
-                    case 8: return [4 /*yield*/, __await(nextChunk.newPromise)];
-                    case 9:
-                        _c.sent();
-                        _c.label = 10;
-                    case 10: return [3 /*break*/, 5];
-                    case 11: return [3 /*break*/, 16];
-                    case 12:
-                        searchError_1 = _c.sent();
-                        googleAdsError = this.getGoogleAdsError(searchError_1);
-                        if (!this.hooks.onStreamError) return [3 /*break*/, 14];
-                        return [4 /*yield*/, __await(this.hooks.onStreamError(__assign(__assign({}, baseHookArguments), { error: googleAdsError })))];
-                    case 13:
-                        _c.sent();
-                        _c.label = 14;
-                    case 14: throw googleAdsError;
-                    case 15:
-                        stream.destroy();
-                        return [7 /*endfinally*/];
-                    case 16: return [2 /*return*/];
-                }
-            });
-        });
-    };
+    async *reportStream(reportOptions) {
+        const { gaqlQuery, requestOptions } = query_1.buildQuery(reportOptions);
+        const stream = this.streamer(gaqlQuery, requestOptions, reportOptions);
+        for await (const row of stream) {
+            yield row;
+        }
+    }
     /**
       @description Retreive the raw stream using ReportOptions.
       @hooks onStreamStart
@@ -255,270 +81,285 @@ var Customer = /** @class */ (function (_super) {
       stream.on('error', (error) => { ... })
       stream.on('end', () => { ... })
     */
-    Customer.prototype.reportStreamRaw = function (reportOptions) {
-        return __awaiter(this, void 0, void 0, function () {
-            var _a, gaqlQuery, requestOptions, baseHookArguments, queryStart, _b, service, request;
-            return __generator(this, function (_c) {
-                switch (_c.label) {
-                    case 0:
-                        _a = query_1.buildQuery(reportOptions), gaqlQuery = _a.gaqlQuery, requestOptions = _a.requestOptions;
-                        baseHookArguments = {
-                            credentials: this.credentials,
-                            query: gaqlQuery,
-                            reportOptions: reportOptions,
-                        };
-                        queryStart = { cancelled: false };
-                        if (!this.hooks.onStreamStart) return [3 /*break*/, 2];
-                        return [4 /*yield*/, this.hooks.onStreamStart(__assign(__assign({}, baseHookArguments), { cancel: function () {
-                                    queryStart.cancelled = true;
-                                }, editOptions: function (options) {
-                                    Object.entries(options).forEach(function (_a) {
-                                        var key = _a[0], val = _a[1];
-                                        // @ts-ignore
-                                        requestOptions[key] = val;
-                                    });
-                                } }))];
-                    case 1:
-                        _c.sent();
-                        if (queryStart.cancelled) {
-                            return [2 /*return*/];
-                        }
-                        _c.label = 2;
-                    case 2:
-                        _b = this.buildSearchStreamRequestAndService(gaqlQuery, requestOptions), service = _b.service, request = _b.request;
-                        return [2 /*return*/, service.searchStream(request, {
-                                otherArgs: { headers: this.callHeaders },
-                            })];
-                }
+    async reportStreamRaw(reportOptions) {
+        const { gaqlQuery, requestOptions } = query_1.buildQuery(reportOptions);
+        const baseHookArguments = {
+            credentials: this.credentials,
+            query: gaqlQuery,
+            reportOptions,
+        };
+        const queryStart = { cancelled: false };
+        if (this.hooks.onStreamStart) {
+            await this.hooks.onStreamStart({
+                ...baseHookArguments,
+                cancel: () => {
+                    queryStart.cancelled = true;
+                },
+                editOptions: (options) => {
+                    Object.entries(options).forEach(([key, val]) => {
+                        // @ts-ignore
+                        requestOptions[key] = val;
+                    });
+                },
             });
+            if (queryStart.cancelled) {
+                return;
+            }
+        }
+        const { service, request } = this.buildSearchStreamRequestAndService(gaqlQuery, requestOptions);
+        return service.searchStream(request, {
+            otherArgs: { headers: this.callHeaders },
         });
-    };
-    Customer.prototype.search = function (gaqlQuery, requestOptions) {
-        return __awaiter(this, void 0, void 0, function () {
-            var _a, service, request, searchResponse, response, summaryRow, nextPageToken, totalResultsCount;
-            return __generator(this, function (_b) {
-                switch (_b.label) {
-                    case 0:
-                        _a = this.buildSearchRequestAndService(gaqlQuery, requestOptions), service = _a.service, request = _a.request;
-                        return [4 /*yield*/, service.search(request, {
-                                otherArgs: { headers: this.callHeaders },
-                                autoPaginate: false,
-                            })];
-                    case 1:
-                        searchResponse = _b.sent();
-                        response = searchResponse[0];
-                        summaryRow = searchResponse[2].summary_row;
-                        nextPageToken = searchResponse[2].next_page_token;
-                        totalResultsCount = searchResponse[2].total_results_count
-                            ? +searchResponse[2].total_results_count
-                            : undefined;
-                        if (summaryRow) {
-                            response.unshift(summaryRow);
-                        }
-                        return [2 /*return*/, { response: response, nextPageToken: nextPageToken, totalResultsCount: totalResultsCount }];
-                }
-            });
+    }
+    async search(gaqlQuery, requestOptions) {
+        const { service, request } = this.buildSearchRequestAndService(gaqlQuery, requestOptions);
+        const searchResponse = await service.search(request, {
+            otherArgs: { headers: this.callHeaders },
+            autoPaginate: false,
         });
-    };
-    Customer.prototype.paginatedSearch = function (gaqlQuery, requestOptions, parser) {
-        return __awaiter(this, void 0, void 0, function () {
-            var response, nextPageToken, initialSearch, totalResultsCount, nextSearch;
-            return __generator(this, function (_a) {
-                switch (_a.label) {
-                    case 0:
-                        response = [];
-                        nextPageToken = undefined;
-                        return [4 /*yield*/, this.search(gaqlQuery, requestOptions)];
-                    case 1:
-                        initialSearch = _a.sent();
-                        totalResultsCount = initialSearch.totalResultsCount;
-                        response.push.apply(response, parser(initialSearch.response));
-                        nextPageToken = initialSearch.nextPageToken;
-                        _a.label = 2;
-                    case 2:
-                        if (!nextPageToken) return [3 /*break*/, 4];
-                        return [4 /*yield*/, this.search(gaqlQuery, __assign(__assign({}, requestOptions), { page_token: nextPageToken }))];
-                    case 3:
-                        nextSearch = _a.sent();
-                        response.push.apply(response, parser(nextSearch.response));
-                        nextPageToken = nextSearch.nextPageToken;
-                        return [3 /*break*/, 2];
-                    case 4: return [2 /*return*/, { response: response, totalResultsCount: totalResultsCount }];
-                }
+        const response = searchResponse[0];
+        const summaryRow = searchResponse[2].summary_row;
+        const nextPageToken = searchResponse[2].next_page_token;
+        const totalResultsCount = searchResponse[2].total_results_count
+            ? +searchResponse[2].total_results_count
+            : undefined;
+        if (summaryRow) {
+            response.unshift(summaryRow);
+        }
+        return { response, nextPageToken, totalResultsCount };
+    }
+    async paginatedSearch(gaqlQuery, requestOptions, parser) {
+        const response = [];
+        let nextPageToken = undefined;
+        const initialSearch = await this.search(gaqlQuery, requestOptions);
+        const totalResultsCount = initialSearch.totalResultsCount;
+        response.push(...parser(initialSearch.response));
+        nextPageToken = initialSearch.nextPageToken;
+        while (nextPageToken) {
+            const nextSearch = await this.search(gaqlQuery, {
+                ...requestOptions,
+                page_token: nextPageToken,
             });
-        });
-    };
-    Customer.prototype.querier = function (gaqlQuery, requestOptions, reportOptions, useHooks) {
-        if (requestOptions === void 0) { requestOptions = {}; }
-        if (useHooks === void 0) { useHooks = true; }
-        return __awaiter(this, void 0, void 0, function () {
-            var baseHookArguments, queryCancellation_1, parsingWapper, _a, response, totalResultsCount, queryResolution_1, searchError_2, googleAdsError;
-            var _this = this;
-            return __generator(this, function (_b) {
-                switch (_b.label) {
-                    case 0:
-                        baseHookArguments = {
-                            credentials: this.credentials,
-                            query: gaqlQuery,
-                            reportOptions: reportOptions,
-                        };
-                        if (!(this.hooks.onQueryStart && useHooks)) return [3 /*break*/, 2];
-                        queryCancellation_1 = { cancelled: false };
-                        return [4 /*yield*/, this.hooks.onQueryStart(__assign(__assign({}, baseHookArguments), { cancel: function (res) {
-                                    queryCancellation_1.cancelled = true;
-                                    queryCancellation_1.res = res;
-                                }, editOptions: function (options) {
-                                    Object.entries(options).forEach(function (_a) {
-                                        var key = _a[0], val = _a[1];
-                                        // @ts-ignore
-                                        requestOptions[key] = val;
-                                    });
-                                } }))];
-                    case 1:
-                        _b.sent();
-                        if (queryCancellation_1.cancelled) {
-                            return [2 /*return*/, { response: queryCancellation_1.res }];
-                        }
-                        _b.label = 2;
-                    case 2:
-                        _b.trys.push([2, 6, , 9]);
-                        parsingWapper = function (rows) {
-                            return _this.clientOptions.disable_parsing
-                                ? rows
-                                : reportOptions
-                                    ? parser_1.parse({ results: rows, reportOptions: reportOptions })
-                                    : parser_1.parse({ results: rows, gaqlString: gaqlQuery });
-                        };
-                        return [4 /*yield*/, this.paginatedSearch(gaqlQuery, requestOptions, parsingWapper)];
-                    case 3:
-                        _a = _b.sent(), response = _a.response, totalResultsCount = _a.totalResultsCount;
-                        if (!(this.hooks.onQueryEnd && useHooks)) return [3 /*break*/, 5];
-                        queryResolution_1 = { resolved: false };
-                        return [4 /*yield*/, this.hooks.onQueryEnd(__assign(__assign({}, baseHookArguments), { response: response, resolve: function (res) {
-                                    queryResolution_1.resolved = true;
-                                    queryResolution_1.res = res;
-                                } }))];
-                    case 4:
-                        _b.sent();
-                        if (queryResolution_1.resolved) {
-                            return [2 /*return*/, { response: queryResolution_1.res, totalResultsCount: totalResultsCount }];
-                        }
-                        _b.label = 5;
-                    case 5: return [2 /*return*/, { response: response, totalResultsCount: totalResultsCount }];
-                    case 6:
-                        searchError_2 = _b.sent();
-                        googleAdsError = this.getGoogleAdsError(searchError_2);
-                        if (!(this.hooks.onQueryError && useHooks)) return [3 /*break*/, 8];
-                        return [4 /*yield*/, this.hooks.onQueryError(__assign(__assign({}, baseHookArguments), { error: googleAdsError }))];
-                    case 7:
-                        _b.sent();
-                        _b.label = 8;
-                    case 8: throw googleAdsError;
-                    case 9: return [2 /*return*/];
+            response.push(...parser(nextSearch.response));
+            nextPageToken = nextSearch.nextPageToken;
+        }
+        return { response, totalResultsCount };
+    }
+    async querier(gaqlQuery, requestOptions = {}, reportOptions, useHooks = true) {
+        const baseHookArguments = {
+            credentials: this.credentials,
+            query: gaqlQuery,
+            reportOptions,
+        };
+        if (this.hooks.onQueryStart && useHooks) {
+            const queryCancellation = { cancelled: false };
+            await this.hooks.onQueryStart({
+                ...baseHookArguments,
+                cancel: (res) => {
+                    queryCancellation.cancelled = true;
+                    queryCancellation.res = res;
+                },
+                editOptions: (options) => {
+                    Object.entries(options).forEach(([key, val]) => {
+                        // @ts-ignore
+                        requestOptions[key] = val;
+                    });
+                },
+            });
+            if (queryCancellation.cancelled) {
+                return { response: queryCancellation.res };
+            }
+        }
+        try {
+            const parsingWapper = (rows) => {
+                return this.clientOptions.disable_parsing
+                    ? rows
+                    : reportOptions
+                        ? parser_1.parse({ results: rows, reportOptions })
+                        : parser_1.parse({ results: rows, gaqlString: gaqlQuery });
+            };
+            const { response, totalResultsCount } = await this.paginatedSearch(gaqlQuery, requestOptions, parsingWapper);
+            if (this.hooks.onQueryEnd && useHooks) {
+                const queryResolution = { resolved: false };
+                await this.hooks.onQueryEnd({
+                    ...baseHookArguments,
+                    response,
+                    resolve: (res) => {
+                        queryResolution.resolved = true;
+                        queryResolution.res = res;
+                    },
+                });
+                if (queryResolution.resolved) {
+                    return { response: queryResolution.res, totalResultsCount };
                 }
+            }
+            return { response: response, totalResultsCount };
+        }
+        catch (searchError) {
+            const googleAdsError = this.getGoogleAdsError(searchError);
+            if (this.hooks.onQueryError && useHooks) {
+                await this.hooks.onQueryError({
+                    ...baseHookArguments,
+                    error: googleAdsError,
+                });
+            }
+            throw googleAdsError;
+        }
+    }
+    async *streamer(gaqlQuery, requestOptions = {}, reportOptions) {
+        const baseHookArguments = {
+            credentials: this.credentials,
+            query: gaqlQuery,
+            reportOptions,
+        };
+        if (this.hooks.onStreamStart) {
+            const queryStart = { cancelled: false };
+            await this.hooks.onStreamStart({
+                ...baseHookArguments,
+                cancel: () => {
+                    queryStart.cancelled = true;
+                },
+                editOptions: (options) => {
+                    Object.entries(options).forEach(([key, val]) => {
+                        // @ts-expect-error
+                        requestOptions[key] = val;
+                    });
+                },
             });
+            if (queryStart.cancelled) {
+                return;
+            }
+        }
+        const { service, request } = this.buildSearchStreamRequestAndService(gaqlQuery, requestOptions);
+        const stream = service.searchStream(request, {
+            otherArgs: { headers: this.callHeaders },
         });
-    };
+        let streamFinished = false;
+        const accumulator = [];
+        let nextChunk = utils_1.createNextChunkArrivedPromise();
+        stream.on("data", (chunk) => {
+            const results = chunk.summary_row ? [chunk.summary_row] : chunk.results;
+            const parsedResponse = this.clientOptions.disable_parsing
+                ? results
+                : reportOptions
+                    ? parser_1.parse({ results, reportOptions })
+                    : parser_1.parse({ results, gaqlString: gaqlQuery });
+            accumulator.push(...parsedResponse);
+            nextChunk.resolve();
+            nextChunk = utils_1.createNextChunkArrivedPromise();
+        });
+        stream.on("error", (searchError) => {
+            nextChunk.reject(searchError);
+        });
+        stream.on("end", () => {
+            streamFinished = true;
+            nextChunk.resolve();
+        });
+        try {
+            while (!streamFinished || accumulator.length) {
+                if (accumulator.length > 0) {
+                    const item = accumulator.shift();
+                    if (item === undefined) {
+                        throw new Error("UNDEFINED_STREAM_ERROR");
+                    }
+                    yield item;
+                }
+                else {
+                    await nextChunk.newPromise;
+                }
+            }
+        }
+        catch (searchError) {
+            const googleAdsError = this.getGoogleAdsError(searchError);
+            if (this.hooks.onStreamError) {
+                await this.hooks.onStreamError({
+                    ...baseHookArguments,
+                    error: googleAdsError,
+                });
+            }
+            throw googleAdsError;
+        }
+        finally {
+            stream.destroy();
+        }
+    }
     /**
      * @description Creates, updates, or removes resources. This method supports atomic transactions
      * with multiple types of resources. For example, you can atomically create a campaign and a
      * campaign budget, or perform up to thousands of mutates atomically.
      * @hooks onMutationStart, onMutationError, onMutationEnd
      */
-    Customer.prototype.mutateResources = function (mutations, mutateOptions) {
-        if (mutateOptions === void 0) { mutateOptions = {}; }
-        return __awaiter(this, void 0, void 0, function () {
-            var baseHookArguments, mutationCancellation_1, _a, service, request, response, parsedResponse, mutationResolution_1, mutateError_1, googleAdsError;
-            return __generator(this, function (_b) {
-                switch (_b.label) {
-                    case 0:
-                        baseHookArguments = {
-                            credentials: this.credentials,
-                            method: "GoogleAdsService.mutate",
-                            mutations: mutations,
-                            isServiceCall: false,
-                        };
-                        if (!this.hooks.onMutationStart) return [3 /*break*/, 2];
-                        mutationCancellation_1 = { cancelled: false };
-                        return [4 /*yield*/, this.hooks.onMutationStart(__assign(__assign({}, baseHookArguments), { cancel: function (res) {
-                                    mutationCancellation_1.cancelled = true;
-                                    mutationCancellation_1.res = res;
-                                }, editOptions: function (options) {
-                                    Object.entries(options).forEach(function (_a) {
-                                        var key = _a[0], val = _a[1];
-                                        // @ts-ignore
-                                        mutateOptions[key] = val;
-                                    });
-                                } }))];
-                    case 1:
-                        _b.sent();
-                        if (mutationCancellation_1.cancelled) {
-                            return [2 /*return*/, mutationCancellation_1.res];
-                        }
-                        _b.label = 2;
-                    case 2:
-                        _a = this.buildMutationRequestAndService(mutations, mutateOptions), service = _a.service, request = _a.request;
-                        _b.label = 3;
-                    case 3:
-                        _b.trys.push([3, 7, , 10]);
-                        return [4 /*yield*/, service.mutate(request, {
-                                otherArgs: { headers: this.callHeaders },
-                            })];
-                    case 4:
-                        response = (_b.sent())[0];
-                        parsedResponse = request.partial_failure
-                            ? this.decodePartialFailureError(response)
-                            : response;
-                        if (!this.hooks.onMutationEnd) return [3 /*break*/, 6];
-                        mutationResolution_1 = { resolved: false };
-                        return [4 /*yield*/, this.hooks.onMutationEnd(__assign(__assign({}, baseHookArguments), { response: parsedResponse, resolve: function (res) {
-                                    mutationResolution_1.resolved = true;
-                                    mutationResolution_1.res = res;
-                                } }))];
-                    case 5:
-                        _b.sent();
-                        if (mutationResolution_1.resolved) {
-                            return [2 /*return*/, mutationResolution_1.res];
-                        }
-                        _b.label = 6;
-                    case 6: return [2 /*return*/, parsedResponse];
-                    case 7:
-                        mutateError_1 = _b.sent();
-                        googleAdsError = this.getGoogleAdsError(mutateError_1);
-                        if (!this.hooks.onMutationError) return [3 /*break*/, 9];
-                        return [4 /*yield*/, this.hooks.onMutationError(__assign(__assign({}, baseHookArguments), { error: googleAdsError }))];
-                    case 8:
-                        _b.sent();
-                        _b.label = 9;
-                    case 9: throw googleAdsError;
-                    case 10: return [2 /*return*/];
-                }
-            });
-        });
-    };
-    Object.defineProperty(Customer.prototype, "googleAdsFields", {
-        get: function () {
-            var _this = this;
-            return {
-                searchGoogleAdsFields: function (request) { return __awaiter(_this, void 0, void 0, function () {
-                    var service;
-                    return __generator(this, function (_a) {
-                        switch (_a.label) {
-                            case 0: return [4 /*yield*/, this.loadService("GoogleAdsFieldServiceClient")];
-                            case 1:
-                                service = _a.sent();
-                                return [2 /*return*/, service.searchGoogleAdsFields(request, {
-                                        // @ts-expect-error This method does support call headers
-                                        otherArgs: { headers: this.callHeaders },
-                                    })];
-                        }
+    async mutateResources(mutations, mutateOptions = {}) {
+        const baseHookArguments = {
+            credentials: this.credentials,
+            method: "GoogleAdsService.mutate",
+            mutations,
+            isServiceCall: false,
+        };
+        if (this.hooks.onMutationStart) {
+            const mutationCancellation = { cancelled: false };
+            await this.hooks.onMutationStart({
+                ...baseHookArguments,
+                cancel: (res) => {
+                    mutationCancellation.cancelled = true;
+                    mutationCancellation.res = res;
+                },
+                editOptions: (options) => {
+                    Object.entries(options).forEach(([key, val]) => {
+                        // @ts-ignore
+                        mutateOptions[key] = val;
                     });
-                }); },
-            };
-        },
-        enumerable: false,
-        configurable: true
-    });
-    return Customer;
-}(serviceFactory_1.default));
+                },
+            });
+            if (mutationCancellation.cancelled) {
+                return mutationCancellation.res;
+            }
+        }
+        const { service, request } = this.buildMutationRequestAndService(mutations, mutateOptions);
+        try {
+            const response = (await service.mutate(request, {
+                otherArgs: { headers: this.callHeaders },
+            }))[0];
+            const parsedResponse = request.partial_failure
+                ? this.decodePartialFailureError(response)
+                : response;
+            if (this.hooks.onMutationEnd) {
+                const mutationResolution = { resolved: false };
+                await this.hooks.onMutationEnd({
+                    ...baseHookArguments,
+                    response: parsedResponse,
+                    resolve: (res) => {
+                        mutationResolution.resolved = true;
+                        mutationResolution.res = res;
+                    },
+                });
+                if (mutationResolution.resolved) {
+                    return mutationResolution.res;
+                }
+            }
+            return parsedResponse;
+        }
+        catch (mutateError) {
+            const googleAdsError = this.getGoogleAdsError(mutateError);
+            if (this.hooks.onMutationError) {
+                await this.hooks.onMutationError({
+                    ...baseHookArguments,
+                    error: googleAdsError,
+                });
+            }
+            throw googleAdsError;
+        }
+    }
+    get googleAdsFields() {
+        return {
+            searchGoogleAdsFields: async (request) => {
+                const service = await this.loadService("GoogleAdsFieldServiceClient");
+                return service.searchGoogleAdsFields(request, {
+                    // @ts-expect-error This method does support call headers
+                    otherArgs: { headers: this.callHeaders },
+                });
+            },
+        };
+    }
+}
 exports.Customer = Customer;