google-ads-api 24.1.0 → 25.1.0-beta.0

package/build/esm/customer.js

@@ -0,0 +1,502 @@
+import axios from "axios";
+import Chain from "stream-chain";
+import streamJson from "stream-json";
+import StreamArray from "stream-json/streamers/StreamArray.js";
+import { decamelizeKeys } from "./parserRest.js";
+import { errors } from "./protos/index.js";
+import ServiceFactory from "./protos/autogen/serviceFactory.js";
+import { buildQuery } from "./query.js";
+import { googleAdsVersion } from "./version.js";
+const ROWS_PER_STREAMED_CHUNK = 10_000; // From experience, this is what can be expected from the API.
+export class Customer extends ServiceFactory {
+    constructor(clientOptions, customerOptions, hooks) {
+        super(clientOptions, customerOptions, hooks ?? {});
+    }
+    /**
+      @description Single query using a raw GAQL string.
+      @hooks onQueryStart, onQueryError, onQueryEnd
+    */
+    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
+    */
+    async report(options) {
+        const { gaqlQuery, requestOptions } = buildQuery(options);
+        const { response } = await this.querier(gaqlQuery, requestOptions, options);
+        return response;
+    }
+    /**
+      @description Get the total row count of a report.
+      @hooks none
+    */
+    async reportCount(options) {
+        // must get at least one row
+        const { gaqlQuery, requestOptions } = buildQuery({ ...options, limit: 1 });
+        // We do not allow this field in reportOptions, however it is still a valid request option
+        requestOptions.search_settings = {
+            return_total_results_count: true,
+            return_summary_row: false,
+        };
+        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.
+      @hooks onStreamStart, onStreamError
+      @example
+      const stream = reportStream<T>(reportOptions)
+      for await (const row of stream) { ... }
+    */
+    async *reportStream(reportOptions) {
+        const { gaqlQuery, requestOptions } = 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
+      @example
+      const stream = reportStreamRaw(reportOptions)
+      stream.on('data', (chunk) => { ... }) // a chunk contains up to 10,000 un-parsed rows
+      stream.on('error', (error) => { ... })
+      stream.on('end', () => { ... })
+    */
+    async reportStreamRaw(reportOptions) {
+        const { gaqlQuery, requestOptions } = 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 },
+        });
+    }
+    async search(gaqlQuery, requestOptions) {
+        const accessToken = await this.getAccessToken();
+        try {
+            const rawResponse = await axios(this.prepareGoogleAdsServicePostRequestArgs("search", accessToken, {
+                data: {
+                    query: gaqlQuery,
+                    ...requestOptions,
+                },
+            }));
+            const searchResponse = rawResponse.data;
+            const results = searchResponse.results ?? [];
+            const response = results.map((row) => this.decamelizeKeysIfNeeded(row));
+            const summaryRow = this.decamelizeKeysIfNeeded(searchResponse.summaryRow);
+            const nextPageToken = searchResponse.nextPageToken;
+            const totalResultsCount = searchResponse.totalResultsCount
+                ? +searchResponse.totalResultsCount
+                : undefined;
+            return { response, nextPageToken, totalResultsCount, summaryRow };
+        }
+        catch (e) {
+            if (e.response?.data.error.details[0]) {
+                throw new errors.GoogleAdsFailure(this.decamelizeKeysIfNeeded(e.response.data.error.details[0]));
+            }
+            throw e;
+        }
+    }
+    async paginatedSearch(gaqlQuery, requestOptions) {
+        /*
+          When possible, use the searchStream method to avoid the overhead of pagination.
+        */
+        if (requestOptions.page_size === undefined &&
+            requestOptions.search_settings === undefined // If search_settings is set, we can't use searchStream.
+        ) {
+            // If no pagination or summary options are set, we can use the non-paginated search method.
+            const { response } = await this.useStreamToImitateRegularSearch(gaqlQuery, requestOptions);
+            return { response };
+        }
+        const response = [];
+        let nextPageToken = undefined;
+        const initialSearch = await this.search(gaqlQuery, requestOptions);
+        let totalResultsCount = initialSearch.totalResultsCount;
+        // Sometimes (when no results?) the totalResultsCount field is not included in the response.
+        // In this case, we set it to 0.
+        if (requestOptions.search_settings?.return_total_results_count &&
+            initialSearch.totalResultsCount === undefined) {
+            totalResultsCount = 0;
+        }
+        let summaryRow = initialSearch.summaryRow;
+        response.push(...initialSearch.response);
+        nextPageToken = initialSearch.nextPageToken;
+        while (nextPageToken) {
+            const nextSearch = await this.search(gaqlQuery, {
+                ...requestOptions,
+                page_token: nextPageToken,
+            });
+            response.push(...nextSearch.response);
+            nextPageToken = nextSearch.nextPageToken;
+            if (nextSearch.summaryRow) {
+                summaryRow = nextSearch.summaryRow;
+            }
+        }
+        if (summaryRow) {
+            response.unshift(summaryRow);
+        }
+        return { response, totalResultsCount };
+    }
+    // Google's searchStream method is faster than search, but it does not support all features.
+    // When report() is called, we use searchStream if possible, otherwise we use paginatedSearch.
+    // Note that just like `paginatedSearch`, this method accumulates results in memory. Use
+    // `reportStream` for a more memory-efficient alternative (at the cost of more CPU usage).
+    async useStreamToImitateRegularSearch(gaqlQuery, requestOptions) {
+        const accessToken = await this.getAccessToken();
+        try {
+            const args = this.prepareGoogleAdsServicePostRequestArgs("searchStream", accessToken, {
+                responseType: "stream",
+                data: {
+                    query: gaqlQuery,
+                    ...requestOptions,
+                },
+            });
+            const response = await axios(args);
+            const stream = response.data;
+            const buffers = [];
+            let rowCount = -ROWS_PER_STREAMED_CHUNK;
+            for await (const data of stream) {
+                if (this.clientOptions.max_reporting_rows &&
+                    !this.gaqlQueryStringIncludesLimit(gaqlQuery)) {
+                    // This is a quick-and-dirty way to count rows, but it's good enough for our purposes.
+                    // We want to avoid using a proper JSON streamer here for performance reasons.
+                    if (data.toString("utf-8").includes(`results":`)) {
+                        rowCount += ROWS_PER_STREAMED_CHUNK;
+                    }
+                    if (rowCount > this.clientOptions.max_reporting_rows) {
+                        throw this.generateTooManyRowsError();
+                    }
+                }
+                buffers.push(data);
+            }
+            const asString = Buffer.concat(buffers).toString("utf-8");
+            const accumulator = [];
+            let foundSummaryRow;
+            for (const { results, summaryRow } of JSON.parse(asString)) {
+                if (summaryRow) {
+                    foundSummaryRow = this.decamelizeKeysIfNeeded(summaryRow);
+                }
+                accumulator.push(...(results ?? []).map((row) => {
+                    return this.decamelizeKeysIfNeeded(row);
+                }));
+                if (foundSummaryRow) {
+                    accumulator.unshift(foundSummaryRow);
+                }
+            }
+            return { response: accumulator };
+        }
+        catch (e) {
+            await this.handleStreamError(e);
+            throw e; // The line above should always throw.
+        }
+    }
+    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 { response, totalResultsCount } = await this.paginatedSearch(gaqlQuery, requestOptions);
+            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;
+            }
+        }
+        try {
+            const accessToken = await this.getAccessToken();
+            const args = this.prepareGoogleAdsServicePostRequestArgs("searchStream", accessToken, {
+                responseType: "stream",
+                data: {
+                    query: gaqlQuery,
+                    ...requestOptions,
+                },
+            });
+            const response = await axios(args);
+            const stream = response.data;
+            // The options below help to make the stream less CPU intensive.
+            const parser = new streamJson.Parser({
+                streamValues: false,
+                streamKeys: false,
+                packValues: true,
+                packKeys: true,
+            });
+            const pipeline = Chain.chain([stream, parser, StreamArray.streamArray()]);
+            let count = 0;
+            try {
+                for await (const data of pipeline) {
+                    const results = data.value.results ??
+                        (data.value.summaryRow ? [data.value.summaryRow] : undefined) ??
+                        [];
+                    count += results.length;
+                    if (this.clientOptions.max_reporting_rows &&
+                        count > this.clientOptions.max_reporting_rows &&
+                        !this.gaqlQueryStringIncludesLimit(gaqlQuery)) {
+                        throw this.generateTooManyRowsError();
+                    }
+                    for (const row of results) {
+                        const parsed = this.decamelizeKeysIfNeeded(row);
+                        yield parsed;
+                    }
+                }
+            }
+            finally {
+                pipeline.destroy();
+                parser.destroy();
+                stream.destroy();
+            }
+            return;
+        }
+        catch (e) {
+            try {
+                await this.handleStreamError(e);
+            }
+            catch (_e) {
+                if (this.hooks.onStreamError) {
+                    await this.hooks.onStreamError({
+                        ...baseHookArguments,
+                        error: _e,
+                    });
+                }
+                throw _e;
+            }
+        }
+    }
+    async handleStreamError(e) {
+        if (!e?.response?.data) {
+            throw e;
+        }
+        // The error is a stream, so some effort is required to parse it.
+        const stream = e.response.data;
+        const pipeline = Chain.chain([
+            stream,
+            streamJson.parser(),
+            StreamArray.streamArray(),
+        ]);
+        const defaultErrorMessage = "Unknown GoogleAdsFailure";
+        let googleAdsFailure = new Error(defaultErrorMessage);
+        // Only throw the first error.
+        pipeline.once("data", (data) => {
+            if (data?.value?.error?.details?.[0]) {
+                googleAdsFailure = new errors.GoogleAdsFailure(this.decamelizeKeysIfNeeded(data.value.error.details[0]));
+            }
+            else {
+                googleAdsFailure = new Error(data?.value?.error?.message ?? defaultErrorMessage, { cause: data?.value?.error ?? data?.value });
+            }
+        });
+        // Must always reject.
+        await new Promise((_, reject) => {
+            pipeline.on("end", () => reject(googleAdsFailure));
+            pipeline.on("error", (err) => reject(err));
+        });
+    }
+    /**
+     * @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
+     */
+    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;
+                    });
+                },
+            });
+            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 },
+                });
+            },
+        };
+    }
+    prepareGoogleAdsServicePostRequestArgs(functionName, accessToken, extra) {
+        return {
+            method: "POST",
+            url: `https://googleads.googleapis.com/${googleAdsVersion}/customers/${this.customerOptions.customer_id}/googleAds:${functionName}`,
+            headers: {
+                Authorization: `Bearer ${accessToken}`,
+                ...this.callHeaders,
+            },
+            ...extra,
+        };
+    }
+    decamelizeKeysIfNeeded(input) {
+        if (this.clientOptions.disable_parsing) {
+            return input;
+        }
+        return decamelizeKeys(input);
+    }
+    gaqlQueryStringIncludesLimit(gaqlQuery) {
+        return gaqlQuery.toLowerCase().includes("limit ");
+    }
+    generateTooManyRowsError() {
+        return new Error(`Exceeded the maximum number of rows set by "max_reporting_rows" (${this.clientOptions.max_reporting_rows}).`);
+    }
+}

package/build/esm/hooks.d.ts

@@ -0,0 +1,160 @@
+import { errors, services } from "./protos/index.js";
+import { CustomerCredentials, MutateOperation, ReportOptions, RequestOptions, MutateOptions } from "./types.js";
+export type BaseRequestHookArgs = {
+    credentials: CustomerCredentials;
+    query: string;
+    reportOptions?: ReportOptions;
+};
+export type BaseMutationHookArgs = {
+    credentials: CustomerCredentials;
+    method: `${keyof typeof services}.${string}`;
+} & (// Mutation was executed with customer.mutateResources
+{
+    mutations: MutateOperation<any>[];
+    isServiceCall: false;
+} | {
+    mutation: any;
+    isServiceCall: true;
+});
+export type BaseServiceHookArgs = {
+    credentials: CustomerCredentials;
+    method: `${keyof typeof services}.${string}`;
+    requestOptions: any;
+};
+type StartHookArgs<T = RequestOptions | MutateOptions | any, A = void> = {
+    cancel: A extends void ? () => void : (args?: A) => void;
+    editOptions: (options: Partial<T>) => void;
+};
+type ErrorHookArgs = {
+    error: errors.GoogleAdsFailure | Error;
+};
+type EndHookArgs<T = services.IGoogleAdsRow[] | services.MutateGoogleAdsResponse> = {
+    response?: T;
+    resolve: (args: any) => void;
+};
+type HookArgs = StartHookArgs | ErrorHookArgs | EndHookArgs;
+type RequestHook<H extends HookArgs> = (a: BaseRequestHookArgs & H) => void;
+type MutationHook<H extends HookArgs> = (a: BaseMutationHookArgs & H) => void;
+type ServiceHook<H extends HookArgs> = (a: BaseServiceHookArgs & H) => void;
+export type OnQueryStart = RequestHook<StartHookArgs<RequestOptions, any>>;
+export type OnQueryError = RequestHook<ErrorHookArgs>;
+export type OnQueryEnd = RequestHook<EndHookArgs<services.IGoogleAdsRow[]>>;
+export type OnStreamStart = RequestHook<StartHookArgs<RequestOptions, void>>;
+export type OnStreamError = RequestHook<ErrorHookArgs>;
+export type OnMutationStart = MutationHook<StartHookArgs<MutateOptions, any>>;
+export type OnMutationError = MutationHook<ErrorHookArgs>;
+export type OnMutationEnd = MutationHook<EndHookArgs<services.MutateGoogleAdsResponse>>;
+export type OnServiceStart = ServiceHook<StartHookArgs<any, any>>;
+export type OnServiceError = ServiceHook<ErrorHookArgs>;
+export type OnServiceEnd = ServiceHook<EndHookArgs<any>>;
+export interface Hooks {
+    /**
+     * @description Hook called before execution of a query in the `query` and `report` methods
+     * @params `{ credentials, query, reportOptions, cancel, editOptions }`
+     * @param credentials customer id, login customer id, linked customer id
+     * @param query gaql
+     * @param reportOptions
+     * @param cancel utility function for cancelling the query. if an argument is provided then the query will return this argument
+     * @param editOptions utility function for editing the request options. any request option keys that are passed will be changed
+     */
+    onQueryStart?: OnQueryStart;
+    /**
+     * @description Hook called upon a query throwing an error in the `query` and `report` methods
+     * @params `{ credentials, query, reportOptions, error }`
+     * @param credentials customer id, login customer id, linked customer id
+     * @param query gaql
+     * @param reportOptions
+     * @param error google ads error
+     */
+    onQueryError?: OnQueryError;
+    /**
+     * @description Hook called after successful execution of a query in the `query` and `report` methods
+     * @params `{ credentials, query, reportOptions, response, resolve }`
+     * @param credentials customer id, login customer id, linked customer id
+     * @param query gaql
+     * @param reportOptions
+     * @param response results of the query, not available on reportStream
+     * @param resolve utility function for returning an alternative value from the query
+     */
+    onQueryEnd?: OnQueryEnd;
+    /**
+     * @description Hook called before execution of a stream in the `reportStream` and `reportStreamRaw` methods
+     * @params `{ credentials, query, reportOptions, cancel, editOptions }`
+     * @param credentials customer id, login customer id, linked customer id
+     * @param query gaql
+     * @param reportOptions
+     * @param cancel utility function for cancelling the stream
+     * @param editOptions utility function for editing the request options. any request option keys that are passed will be changed
+     */
+    onStreamStart?: OnStreamStart;
+    /**
+     * @description Hook called upon a stream throwing an error in the `reportStream` method. Will not be called for an error in `reportStreamRaw`
+     * @params `{ credentials, query, reportOptions, error }`
+     * @param credentials customer id, login customer id, linked customer id
+     * @param query gaql
+     * @param reportOptions
+     * @param error google ads error
+     */
+    onStreamError?: OnStreamError;
+    /**
+     * @description Hook called before execution of a mutation
+     * @params `{ credentials, mutations, cancel, editOptions }`
+     * @param credentials customer id, login customer id, linked customer id
+     * @param mutations
+     * @param cancel utility function for cancelling the mutation. if an argument is provided then the query/report will return this argument
+     * @param editOptions utility function for editing the mutate options. any mutate option keys that are passed will be changed
+     */
+    onMutationStart?: OnMutationStart;
+    /**
+     * @description Hook called upon a mutation throwing an error
+     * @params `{ credentials, mutations, error }`
+     * @param credentials customer id, login customer id, linked customer id
+     * @param mutations
+     * @param error google ads error
+     */
+    onMutationError?: OnMutationError;
+    /**
+     * @description Hook called after successful execution of a mutation
+     * @params `{ credentials, mutations, response, resolve }`
+     * @param credentials customer id, login customer id, linked customer id
+     * @param mutations
+     * @param response results of the mutation
+     * @param resolve utility function for returning an alternative value from the mutation
+     */
+    onMutationEnd?: OnMutationEnd;
+    /**
+     * @description Hook called before execution of a service
+     * @params `{ credentials, method, requestOptions }`
+     * @param credentials customer id, login customer id, linked customer id
+     * @param method
+     * @param cancel utility function for cancelling the service. if an argument is provided then the service will return this argument
+     * @param editOptions utility function for editing the service options. any service option keys that are passed will be changed
+     */
+    onServiceStart?: OnServiceStart;
+    /**
+     * @description Hook called upon a service throwing an error
+     * @params `{ credentials, method, error }`
+     * @param credentials customer id, login customer id, linked customer id
+     * @param method
+     * @param error google ads error
+     */
+    onServiceError?: OnServiceError;
+    /**
+     * @description Hook called after successful execution of a service
+     * @params `{ credentials, method, response, resolve }`
+     * @param credentials customer id, login customer id, linked customer id
+     * @param method
+     * @param response results of the service
+     * @param resolve utility function for returning an alternative value from the service
+     */
+    onServiceEnd?: OnServiceEnd;
+}
+export type HookedCancellation = {
+    cancelled: boolean;
+    res?: any;
+};
+export type HookedResolution = {
+    resolved: boolean;
+    res?: any;
+};
+export {};

package/build/esm/hooks.js

@@ -0,0 +1 @@
+export {};

package/build/esm/index.d.ts

@@ -0,0 +1,9 @@
+export { Client as GoogleAdsApi, ClientOptions } from "./client.js";
+export { common, enums, fields, errors, resources, services, longrunning, protobuf, } from "./protos/index.js";
+export { fromMicros, toMicros } from "./utils.js";
+export { googleAdsVersion } from "./version.js";
+export { parse } from "./parser.js";
+export * as ResourceNames from "./protos/autogen/resourceNames.js";
+export { CustomerOptions, ReportOptions, MutateOperation, Constraint, Constraints, } from "./types.js";
+export { Hooks, OnQueryStart, OnQueryError, OnQueryEnd, OnStreamStart, OnStreamError, OnMutationStart, OnMutationError, OnMutationEnd, OnServiceStart, OnServiceError, OnServiceEnd, } from "./hooks.js";
+export { Customer } from "./customer.js";

package/build/esm/index.js

@@ -0,0 +1,10 @@
+// Core library client
+export { Client as GoogleAdsApi } from "./client.js";
+// Compiled proto types
+export { common, enums, fields, errors, resources, services, longrunning, protobuf, } from "./protos/index.js";
+// Util functions
+export { fromMicros, toMicros } from "./utils.js";
+export { googleAdsVersion } from "./version.js";
+export { parse } from "./parser.js";
+export * as ResourceNames from "./protos/autogen/resourceNames.js";
+export { Customer } from "./customer.js";

package/build/esm/package.json

@@ -0,0 +1 @@
+{"type":"module"}