@rnsk/toolkits 0.0.8 → 0.0.9

package/dist/toolkits/google-analytics/tools/admin.js

@@ -0,0 +1,238 @@
+// @ts-nocheck
+import { tool } from 'ai';
+import { z } from 'zod';
+import { ADMIN_V1BETA, gaGet, gaPost, gaRequest, googleAnalyticsTokenField, normalizeProperty, paginationSchema, } from './client.js';
+export const getAccount = tool({
+    description: 'Gets a single account by resource name. Confirm the name (accounts/{id}) via listAccountsV1Beta first.',
+    inputSchema: z.object({
+        googleAnalyticsToken: googleAnalyticsTokenField,
+        name: z.string().describe("Account 'accounts/{id}'"),
+    }),
+    execute: async ({ googleAnalyticsToken, name }) => {
+        try {
+            return await gaGet(googleAnalyticsToken, ADMIN_V1BETA, name);
+        }
+        catch (error) {
+            return { error: 'Error getting account', message: error instanceof Error ? error.message : 'Unknown error' };
+        }
+    },
+});
+export const listAccountsV1Beta = tool({
+    description: 'Lists all accounts accessible to the caller (v1beta). Soft-deleted accounts are excluded unless showDeleted is set.',
+    inputSchema: z.object({
+        googleAnalyticsToken: googleAnalyticsTokenField,
+        ...paginationSchema,
+        showDeleted: z.boolean().optional().describe('Include soft-deleted accounts'),
+    }),
+    execute: async ({ googleAnalyticsToken, pageSize, pageToken, showDeleted }) => {
+        try {
+            const result = await gaRequest(googleAnalyticsToken, ADMIN_V1BETA, '/accounts', {
+                pageSize, pageToken, showDeleted,
+            });
+            if (!result.ok)
+                return { error: 'Failed to list accounts', details: result.error };
+            return result.data;
+        }
+        catch (error) {
+            return { error: 'Error listing accounts', message: error instanceof Error ? error.message : 'Unknown error' };
+        }
+    },
+});
+export const listAccountSummaries = tool({
+    description: 'Lists high-level summaries of all accessible accounts and their properties without fetching full details.',
+    inputSchema: z.object({
+        googleAnalyticsToken: googleAnalyticsTokenField,
+        ...paginationSchema,
+    }),
+    execute: async ({ googleAnalyticsToken, pageSize, pageToken }) => {
+        try {
+            const result = await gaRequest(googleAnalyticsToken, ADMIN_V1BETA, '/accountSummaries', { pageSize, pageToken });
+            if (!result.ok)
+                return { error: 'Failed to list account summaries', details: result.error };
+            return result.data;
+        }
+        catch (error) {
+            return { error: 'Error listing account summaries', message: error instanceof Error ? error.message : 'Unknown error' };
+        }
+    },
+});
+export const provisionAccountTicket = tool({
+    description: 'Provisions an account ticket for creating a new account. Returns a ticket the user accepts via Terms of Service at redirectUri.',
+    inputSchema: z.object({
+        googleAnalyticsToken: googleAnalyticsTokenField,
+        account: z.object({
+            displayName: z.string().describe('Human-readable account name'),
+            regionCode: z.string().describe("Business country as CLDR region code, e.g. 'US'"),
+        }).describe('Account details to create'),
+        redirectUri: z.string().describe('Redirect URI (registered in Cloud Console) after ToS acceptance'),
+    }),
+    execute: async ({ googleAnalyticsToken, account, redirectUri }) => gaPost(googleAnalyticsToken, ADMIN_V1BETA, 'accounts:provisionAccountTicket', { account, redirectUri }, undefined, 'provision account ticket'),
+});
+export const getProperty = tool({
+    description: 'Gets a single GA4 property (display name, time zone, currency, settings) by resource name.',
+    inputSchema: z.object({
+        googleAnalyticsToken: googleAnalyticsTokenField,
+        name: z.string().describe("Property 'properties/{id}'"),
+    }),
+    execute: async ({ googleAnalyticsToken, name }) => {
+        try {
+            return await gaGet(googleAnalyticsToken, ADMIN_V1BETA, name);
+        }
+        catch (error) {
+            return { error: 'Error getting property', message: error instanceof Error ? error.message : 'Unknown error' };
+        }
+    },
+});
+export const listPropertiesFiltered = tool({
+    description: "Lists GA4 properties by filter ('parent:accounts/123', 'ancestor:accounts/123', or 'firebase_project:...'). Preferred over the deprecated unfiltered list.",
+    inputSchema: z.object({
+        googleAnalyticsToken: googleAnalyticsTokenField,
+        filter: z.string().describe("Filter, e.g. 'parent:accounts/123' or 'ancestor:accounts/123'"),
+        ...paginationSchema,
+        showDeleted: z.boolean().optional().describe('Include soft-deleted properties'),
+    }),
+    execute: async ({ googleAnalyticsToken, filter, pageSize, pageToken, showDeleted }) => {
+        try {
+            const result = await gaRequest(googleAnalyticsToken, ADMIN_V1BETA, '/properties', {
+                filter, pageSize, pageToken, showDeleted,
+            });
+            if (!result.ok)
+                return { error: 'Failed to list properties', details: result.error };
+            return result.data;
+        }
+        catch (error) {
+            return { error: 'Error listing properties', message: error instanceof Error ? error.message : 'Unknown error' };
+        }
+    },
+});
+export const updateProperty = tool({
+    description: 'Updates a property (displayName, timeZone, currencyCode). Only updateMask fields change — use snake_case names or "*" for full replace.',
+    inputSchema: z.object({
+        googleAnalyticsToken: googleAnalyticsTokenField,
+        name: z.string().describe("Property 'properties/{id}'"),
+        updateMask: z.string().describe("Fields to update, e.g. 'display_name,time_zone' or '*'"),
+        displayName: z.string().max(100).optional(),
+        timeZone: z.string().optional().describe("IANA time zone, e.g. 'America/Los_Angeles'"),
+        currencyCode: z.string().optional().describe("ISO 4217 code, e.g. 'USD'"),
+        industryCategory: z.string().optional(),
+        propertyType: z.enum(['PROPERTY_TYPE_UNSPECIFIED', 'PROPERTY_TYPE_ORDINARY', 'PROPERTY_TYPE_SUBPROPERTY', 'PROPERTY_TYPE_ROLLUP']).optional(),
+        parent: z.string().optional().describe("Logical parent 'accounts/{id}' or 'properties/{id}'"),
+    }),
+    execute: async ({ googleAnalyticsToken, name, updateMask, ...fields }) => {
+        try {
+            const body = { name };
+            const keyMap = {
+                displayName: 'displayName', timeZone: 'timeZone', currencyCode: 'currencyCode',
+                industryCategory: 'industryCategory', propertyType: 'propertyType', parent: 'parent',
+            };
+            for (const [k, v] of Object.entries(fields)) {
+                if (v !== undefined && keyMap[k])
+                    body[keyMap[k]] = v;
+            }
+            const result = await gaRequest(googleAnalyticsToken, ADMIN_V1BETA, `/${name}`, {
+                method: 'PATCH', query: { updateMask }, body,
+            });
+            if (!result.ok)
+                return { error: 'Failed to update property', details: result.error };
+            return result.data;
+        }
+        catch (error) {
+            return { error: 'Error updating property', message: error instanceof Error ? error.message : 'Unknown error' };
+        }
+    },
+});
+export const createRollupProperty = tool({
+    description: 'Creates a roll-up property aggregating multiple GA4 source properties into one view.',
+    inputSchema: z.object({
+        googleAnalyticsToken: googleAnalyticsTokenField,
+        account: z.string().describe("Parent account 'accounts/{id}'"),
+        displayName: z.string().describe('Display name for the roll-up property'),
+        timeZone: z.string().describe("IANA time zone, e.g. 'America/Los_Angeles'"),
+        sourceProperties: z.array(z.string()).optional().describe("Source properties, e.g. ['properties/123']"),
+    }),
+    execute: async ({ googleAnalyticsToken, account, displayName, timeZone, sourceProperties }) => {
+        const body = { account, displayName, timeZone };
+        if (sourceProperties)
+            body.sourceProperties = sourceProperties;
+        return gaPost(googleAnalyticsToken, ADMIN_V1BETA, 'properties:createRollupProperty', body, undefined, 'create roll-up property');
+    },
+});
+export const getPropertyQuotasSnapshot = tool({
+    description: 'Gets property quota usage by category (core, funnel, realtime snapshots). Data can lag real consumption — treat as approximate.',
+    inputSchema: z.object({
+        googleAnalyticsToken: googleAnalyticsTokenField,
+        property: z.string().describe("Property 'properties/{id}' (bare ID accepted)"),
+    }),
+    execute: async ({ googleAnalyticsToken, property }) => {
+        try {
+            const result = await gaRequest(googleAnalyticsToken, ADMIN_V1BETA, `/${normalizeProperty(property)}:getPropertyQuotasSnapshot`);
+            if (!result.ok)
+                return { error: 'Failed to get property quotas snapshot', details: result.error };
+            return result.data;
+        }
+        catch (error) {
+            return { error: 'Error getting property quotas snapshot', message: error instanceof Error ? error.message : 'Unknown error' };
+        }
+    },
+});
+export const getAttributionSettings = tool({
+    description: 'Gets attribution configuration (models, lookback windows, conversion export) for a property.',
+    inputSchema: z.object({
+        googleAnalyticsToken: googleAnalyticsTokenField,
+        name: z.string().describe("Attribution settings 'properties/{id}/attributionSettings'"),
+    }),
+    execute: async ({ googleAnalyticsToken, name }) => {
+        try {
+            return await gaGet(googleAnalyticsToken, ADMIN_V1BETA, name);
+        }
+        catch (error) {
+            return { error: 'Error getting attribution settings', message: error instanceof Error ? error.message : 'Unknown error' };
+        }
+    },
+});
+export const getDataRetentionSettings = tool({
+    description: 'Gets event-level and user-level data retention durations and reset settings for a property.',
+    inputSchema: z.object({
+        googleAnalyticsToken: googleAnalyticsTokenField,
+        name: z.string().describe("Retention settings 'properties/{id}/dataRetentionSettings'"),
+    }),
+    execute: async ({ googleAnalyticsToken, name }) => {
+        try {
+            return await gaGet(googleAnalyticsToken, ADMIN_V1BETA, name);
+        }
+        catch (error) {
+            return { error: 'Error getting data retention settings', message: error instanceof Error ? error.message : 'Unknown error' };
+        }
+    },
+});
+export const getDataSharingSettings = tool({
+    description: 'Gets data-sharing configuration for an account (support, sales, product sharing flags).',
+    inputSchema: z.object({
+        googleAnalyticsToken: googleAnalyticsTokenField,
+        name: z.string().describe("Sharing settings 'accounts/{id}/dataSharingSettings'"),
+    }),
+    execute: async ({ googleAnalyticsToken, name }) => {
+        try {
+            return await gaGet(googleAnalyticsToken, ADMIN_V1BETA, name);
+        }
+        catch (error) {
+            return { error: 'Error getting data sharing settings', message: error instanceof Error ? error.message : 'Unknown error' };
+        }
+    },
+});
+export const getGoogleSignalsSettings = tool({
+    description: 'Gets Google Signals configuration (enabled state, consent status) for a property.',
+    inputSchema: z.object({
+        googleAnalyticsToken: googleAnalyticsTokenField,
+        name: z.string().describe("Signals settings 'properties/{id}/googleSignalsSettings'"),
+    }),
+    execute: async ({ googleAnalyticsToken, name }) => {
+        try {
+            return await gaGet(googleAnalyticsToken, ADMIN_V1BETA, name);
+        }
+        catch (error) {
+            return { error: 'Error getting Google Signals settings', message: error instanceof Error ? error.message : 'Unknown error' };
+        }
+    },
+});
+//# sourceMappingURL=admin.js.map

package/dist/toolkits/google-analytics/tools/audiences.d.ts

@@ -0,0 +1,81 @@
+export declare const getAudience: import("ai").Tool<{
+    googleAnalyticsToken: string;
+    propertyId: string;
+    audienceId: string;
+}, any>;
+export declare const listAudiences: import("ai").Tool<{
+    parent: string;
+    googleAnalyticsToken: string;
+    pageToken?: string | undefined;
+    pageSize?: number | undefined;
+}, any>;
+export declare const createAudienceExport: import("ai").Tool<{
+    parent: string;
+    audience: string;
+    googleAnalyticsToken: string;
+    dimensions?: {
+        dimensionName: string;
+    }[] | undefined;
+}, any>;
+export declare const getAudienceExport: import("ai").Tool<{
+    name: string;
+    googleAnalyticsToken: string;
+}, any>;
+export declare const listAudienceExports: import("ai").Tool<{
+    parent: string;
+    googleAnalyticsToken: string;
+    pageToken?: string | undefined;
+    pageSize?: number | undefined;
+}, any>;
+export declare const queryAudienceExport: import("ai").Tool<{
+    name: string;
+    googleAnalyticsToken: string;
+    limit?: number | undefined;
+    offset?: number | undefined;
+}, any>;
+export declare const createAudienceList: import("ai").Tool<{
+    parent: string;
+    dimensions: {
+        dimensionName: string;
+    }[];
+    audience: string;
+    googleAnalyticsToken: string;
+    webhookNotification?: Record<string, any> | undefined;
+}, any>;
+export declare const getAudienceList: import("ai").Tool<{
+    name: string;
+    googleAnalyticsToken: string;
+}, any>;
+export declare const listAudienceLists: import("ai").Tool<{
+    parent: string;
+    googleAnalyticsToken: string;
+    pageToken?: string | undefined;
+    pageSize?: number | undefined;
+}, any>;
+export declare const queryAudienceList: import("ai").Tool<{
+    name: string;
+    googleAnalyticsToken: string;
+    limit?: number | undefined;
+    offset?: number | undefined;
+}, any>;
+export declare const createRecurringAudienceList: import("ai").Tool<{
+    parent: string;
+    dimensions: {
+        dimensionName: string;
+    }[];
+    audience: string;
+    googleAnalyticsToken: string;
+    webhookNotification?: Record<string, any> | undefined;
+    activeDaysRemaining?: number | undefined;
+}, any>;
+export declare const getRecurringAudienceList: import("ai").Tool<{
+    name: string;
+    googleAnalyticsToken: string;
+}, any>;
+export declare const listRecurringAudienceLists: import("ai").Tool<{
+    parent: string;
+    googleAnalyticsToken: string;
+    pageToken?: string | undefined;
+    pageSize?: number | undefined;
+}, any>;
+//# sourceMappingURL=audiences.d.ts.map

package/dist/toolkits/google-analytics/tools/audiences.js

@@ -0,0 +1,190 @@
+// @ts-nocheck
+import { tool } from 'ai';
+import { z } from 'zod';
+import { ADMIN_V1ALPHA, ADMIN_V1BETA, DATA_V1ALPHA, gaGet, gaList, gaPost, googleAnalyticsTokenField, normalizeProperty, paginationSchema, } from './client.js';
+const audienceDimension = z.object({
+    dimensionName: z.string().describe("Dimension API name, e.g. 'deviceId', 'userId', 'city', 'country'"),
+});
+const propertyField = z.string().describe("GA4 property 'properties/{id}' (bare numeric ID accepted)");
+export const getAudience = tool({
+    description: 'Gets a single audience configuration (membership criteria, filter clauses) by property + audience ID.',
+    inputSchema: z.object({
+        googleAnalyticsToken: googleAnalyticsTokenField,
+        propertyId: z.string().describe("Property ID ('123456789' or 'properties/123456789')"),
+        audienceId: z.string().describe("Numeric audience ID, e.g. '11228260226'"),
+    }),
+    execute: async ({ googleAnalyticsToken, propertyId, audienceId }) => {
+        try {
+            return await gaGet(googleAnalyticsToken, ADMIN_V1BETA, `${normalizeProperty(propertyId)}/audiences/${audienceId}`);
+        }
+        catch (error) {
+            return { error: 'Error getting audience', message: error instanceof Error ? error.message : 'Unknown error' };
+        }
+    },
+});
+export const listAudiences = tool({
+    description: 'Lists audience configurations on a property. Audiences created before 2020 may not be supported.',
+    inputSchema: z.object({
+        googleAnalyticsToken: googleAnalyticsTokenField,
+        parent: propertyField,
+        ...paginationSchema,
+    }),
+    execute: async ({ googleAnalyticsToken, parent, pageSize, pageToken }) => gaList(googleAnalyticsToken, ADMIN_V1BETA, normalizeProperty(parent), 'audiences', { pageSize, pageToken }, 'list audiences'),
+});
+export const createAudienceExport = tool({
+    description: 'Exports a snapshot of users in an audience (async long-running operation). Poll getAudienceExport, then queryAudienceExport for rows.',
+    inputSchema: z.object({
+        googleAnalyticsToken: googleAnalyticsTokenField,
+        parent: propertyField,
+        audience: z.string().describe("Audience 'properties/{id}/audiences/{audienceId}'"),
+        dimensions: z.array(audienceDimension).optional().describe('Dimensions to include in the export rows'),
+    }),
+    execute: async ({ googleAnalyticsToken, parent, audience, dimensions }) => {
+        const body = { audience };
+        if (dimensions)
+            body.dimensions = dimensions;
+        return gaPost(googleAnalyticsToken, ADMIN_V1ALPHA, `${normalizeProperty(parent)}/audienceExports`, body, undefined, 'create audience export');
+    },
+});
+export const getAudienceExport = tool({
+    description: 'Gets audience-export metadata/state after creation.',
+    inputSchema: z.object({
+        googleAnalyticsToken: googleAnalyticsTokenField,
+        name: z.string().describe("Export 'properties/{id}/audienceExports/{exportId}'"),
+    }),
+    execute: async ({ googleAnalyticsToken, name }) => {
+        try {
+            return await gaGet(googleAnalyticsToken, ADMIN_V1ALPHA, name);
+        }
+        catch (error) {
+            return { error: 'Error getting audience export', message: error instanceof Error ? error.message : 'Unknown error' };
+        }
+    },
+});
+export const listAudienceExports = tool({
+    description: 'Lists audience exports for a property to find and reuse existing exports.',
+    inputSchema: z.object({
+        googleAnalyticsToken: googleAnalyticsTokenField,
+        parent: propertyField,
+        ...paginationSchema,
+    }),
+    execute: async ({ googleAnalyticsToken, parent, pageSize, pageToken }) => gaList(googleAnalyticsToken, ADMIN_V1ALPHA, normalizeProperty(parent), 'audienceExports', { pageSize, pageToken }, 'list audience exports'),
+});
+export const queryAudienceExport = tool({
+    description: 'Retrieves rows from an audience export. Use after the export operation completes.',
+    inputSchema: z.object({
+        googleAnalyticsToken: googleAnalyticsTokenField,
+        name: z.string().describe("Export 'properties/{id}/audienceExports/{exportId}'"),
+        limit: z.number().min(1).optional(),
+        offset: z.number().min(0).optional(),
+    }),
+    execute: async ({ googleAnalyticsToken, name, limit, offset }) => {
+        const body = {};
+        if (limit !== undefined)
+            body.limit = limit;
+        if (offset !== undefined)
+            body.offset = offset;
+        return gaPost(googleAnalyticsToken, DATA_V1ALPHA, `${name}:query`, body, undefined, 'query audience export');
+    },
+});
+export const createAudienceList = tool({
+    description: 'Creates an audience list snapshot (async operation). At least one dimension is required. Poll getAudienceList, then queryAudienceList.',
+    inputSchema: z.object({
+        googleAnalyticsToken: googleAnalyticsTokenField,
+        parent: propertyField,
+        audience: z.string().describe("Audience 'properties/{id}/audiences/{audienceId}'"),
+        dimensions: z.array(audienceDimension).min(1).describe('At least one dimension is required'),
+        webhookNotification: z.record(z.any()).optional(),
+    }),
+    execute: async ({ googleAnalyticsToken, parent, audience, dimensions, webhookNotification }) => {
+        const body = { audience, dimensions };
+        if (webhookNotification)
+            body.webhookNotification = webhookNotification;
+        return gaPost(googleAnalyticsToken, ADMIN_V1ALPHA, `${normalizeProperty(parent)}/audienceLists`, body, undefined, 'create audience list');
+    },
+});
+export const getAudienceList = tool({
+    description: 'Gets audience-list metadata/state after creation.',
+    inputSchema: z.object({
+        googleAnalyticsToken: googleAnalyticsTokenField,
+        name: z.string().describe("Audience list 'properties/{id}/audienceLists/{listId}'"),
+    }),
+    execute: async ({ googleAnalyticsToken, name }) => {
+        try {
+            return await gaGet(googleAnalyticsToken, ADMIN_V1ALPHA, name);
+        }
+        catch (error) {
+            return { error: 'Error getting audience list', message: error instanceof Error ? error.message : 'Unknown error' };
+        }
+    },
+});
+export const listAudienceLists = tool({
+    description: 'Lists audience lists for a property to find and reuse existing lists.',
+    inputSchema: z.object({
+        googleAnalyticsToken: googleAnalyticsTokenField,
+        parent: propertyField,
+        ...paginationSchema,
+    }),
+    execute: async ({ googleAnalyticsToken, parent, pageSize, pageToken }) => gaList(googleAnalyticsToken, ADMIN_V1ALPHA, normalizeProperty(parent), 'audienceLists', { pageSize, pageToken }, 'list audience lists'),
+});
+export const queryAudienceList = tool({
+    description: 'Retrieves rows from an audience list. Use after the list operation completes.',
+    inputSchema: z.object({
+        googleAnalyticsToken: googleAnalyticsTokenField,
+        name: z.string().describe("Audience list 'properties/{id}/audienceLists/{listId}'"),
+        limit: z.number().min(1).optional(),
+        offset: z.number().min(0).optional(),
+    }),
+    execute: async ({ googleAnalyticsToken, name, limit, offset }) => {
+        const body = {};
+        if (limit !== undefined)
+            body.limit = limit;
+        if (offset !== undefined)
+            body.offset = offset;
+        return gaPost(googleAnalyticsToken, DATA_V1ALPHA, `${name}:query`, body, undefined, 'query audience list');
+    },
+});
+export const createRecurringAudienceList = tool({
+    description: 'Creates a recurring audience list that auto-generates fresh lists daily. Reduces quota-token consumption vs repeated one-off lists.',
+    inputSchema: z.object({
+        googleAnalyticsToken: googleAnalyticsTokenField,
+        parent: propertyField,
+        audience: z.string().describe("Audience 'properties/{id}/audiences/{audienceId}'"),
+        dimensions: z.array(audienceDimension).min(1).describe('At least one dimension is required'),
+        activeDaysRemaining: z.number().min(1).optional().describe('Days the recurring list stays active'),
+        webhookNotification: z.record(z.any()).optional(),
+    }),
+    execute: async ({ googleAnalyticsToken, parent, audience, dimensions, activeDaysRemaining, webhookNotification }) => {
+        const body = { audience, dimensions };
+        if (activeDaysRemaining !== undefined)
+            body.activeDaysRemaining = activeDaysRemaining;
+        if (webhookNotification)
+            body.webhookNotification = webhookNotification;
+        return gaPost(googleAnalyticsToken, ADMIN_V1ALPHA, `${normalizeProperty(parent)}/recurringAudienceLists`, body, undefined, 'create recurring audience list');
+    },
+});
+export const getRecurringAudienceList = tool({
+    description: 'Gets a recurring audience list, including the resource name of the most recent generated list.',
+    inputSchema: z.object({
+        googleAnalyticsToken: googleAnalyticsTokenField,
+        name: z.string().describe("Recurring list 'properties/{id}/recurringAudienceLists/{listId}'"),
+    }),
+    execute: async ({ googleAnalyticsToken, name }) => {
+        try {
+            return await gaGet(googleAnalyticsToken, ADMIN_V1ALPHA, name);
+        }
+        catch (error) {
+            return { error: 'Error getting recurring audience list', message: error instanceof Error ? error.message : 'Unknown error' };
+        }
+    },
+});
+export const listRecurringAudienceLists = tool({
+    description: 'Lists recurring audience lists for a property.',
+    inputSchema: z.object({
+        googleAnalyticsToken: googleAnalyticsTokenField,
+        parent: propertyField,
+        ...paginationSchema,
+    }),
+    execute: async ({ googleAnalyticsToken, parent, pageSize, pageToken }) => gaList(googleAnalyticsToken, ADMIN_V1ALPHA, normalizeProperty(parent), 'recurringAudienceLists', { pageSize, pageToken }, 'list recurring audience lists'),
+});
+//# sourceMappingURL=audiences.js.map

package/dist/toolkits/google-analytics/tools/client.d.ts

@@ -0,0 +1,47 @@
+import { z } from 'zod';
+export declare const ADMIN_V1BETA = "https://analyticsadmin.googleapis.com/v1beta";
+export declare const ADMIN_V1ALPHA = "https://analyticsadmin.googleapis.com/v1alpha";
+export declare const DATA_V1BETA = "https://analyticsdata.googleapis.com/v1beta";
+export declare const DATA_V1ALPHA = "https://analyticsdata.googleapis.com/v1alpha";
+export declare const googleAnalyticsTokenField: z.ZodString;
+export declare function buildQuery(params: Record<string, string | number | boolean | undefined>): string;
+export declare function gaRequest(googleAnalyticsToken: string, base: string, path: string, options?: {
+    method?: string;
+    query?: Record<string, string | number | boolean | undefined>;
+    body?: unknown;
+}): Promise<{
+    ok: false;
+    error: any;
+    data?: undefined;
+} | {
+    ok: true;
+    data: any;
+    error?: undefined;
+}>;
+export declare function gaGet(token: string, base: string, name: string, query?: Record<string, string | number | boolean | undefined>): Promise<any>;
+export declare function gaPost(token: string, base: string, path: string, body?: unknown, query?: Record<string, string | number | boolean | undefined>, action?: string): Promise<any>;
+export declare function gaList(token: string, base: string, parent: string, resource: string, options?: {
+    pageSize?: number;
+    pageToken?: string;
+    extra?: Record<string, string | number | boolean | undefined>;
+}, action?: string): Promise<any>;
+export declare function normalizeProperty(property: string): string;
+export declare const paginationSchema: {
+    pageSize: z.ZodOptional<z.ZodNumber>;
+    pageToken: z.ZodOptional<z.ZodString>;
+};
+export declare const namedMetric: z.ZodObject<{
+    name: z.ZodString;
+}, "strip", z.ZodUnknown, z.objectOutputType<{
+    name: z.ZodString;
+}, z.ZodUnknown, "strip">, z.objectInputType<{
+    name: z.ZodString;
+}, z.ZodUnknown, "strip">>;
+export declare const namedDimension: z.ZodObject<{
+    name: z.ZodString;
+}, "strip", z.ZodUnknown, z.objectOutputType<{
+    name: z.ZodString;
+}, z.ZodUnknown, "strip">, z.objectInputType<{
+    name: z.ZodString;
+}, z.ZodUnknown, "strip">>;
+//# sourceMappingURL=client.d.ts.map

package/dist/toolkits/google-analytics/tools/client.js

@@ -0,0 +1,74 @@
+// @ts-nocheck
+import { z } from 'zod';
+export const ADMIN_V1BETA = 'https://analyticsadmin.googleapis.com/v1beta';
+export const ADMIN_V1ALPHA = 'https://analyticsadmin.googleapis.com/v1alpha';
+export const DATA_V1BETA = 'https://analyticsdata.googleapis.com/v1beta';
+export const DATA_V1ALPHA = 'https://analyticsdata.googleapis.com/v1alpha';
+export const googleAnalyticsTokenField = z.string().describe('Google Analytics OAuth access token (Bearer)');
+export function buildQuery(params) {
+    const search = new URLSearchParams();
+    for (const [key, value] of Object.entries(params)) {
+        if (value !== undefined)
+            search.set(key, String(value));
+    }
+    const qs = search.toString();
+    return qs ? `?${qs}` : '';
+}
+export async function gaRequest(googleAnalyticsToken, base, path, options) {
+    const url = `${base}${path.startsWith('/') ? path : `/${path}`}${buildQuery(options?.query ?? {})}`;
+    const headers = { Authorization: `Bearer ${googleAnalyticsToken}` };
+    if (options?.body !== undefined)
+        headers['Content-Type'] = 'application/json';
+    const response = await fetch(url, {
+        method: options?.method ?? 'GET',
+        headers,
+        body: options?.body !== undefined ? JSON.stringify(options.body) : undefined,
+    });
+    if (!response.ok) {
+        const details = await response.json().catch(() => ({}));
+        return { ok: false, error: details };
+    }
+    if (response.status === 204)
+        return { ok: true, data: { success: true } };
+    return { ok: true, data: await response.json().catch(() => ({})) };
+}
+export async function gaGet(token, base, name, query) {
+    const result = await gaRequest(token, base, `/${name}`, { query });
+    if (!result.ok)
+        return { error: 'Failed to fetch resource', details: result.error };
+    return result.data;
+}
+export async function gaPost(token, base, path, body, query, action = 'perform action') {
+    try {
+        const result = await gaRequest(token, base, `/${path}`, { method: 'POST', body: body ?? {}, query });
+        if (!result.ok)
+            return { error: `Failed to ${action}`, details: result.error };
+        return result.data;
+    }
+    catch (error) {
+        return { error: `Error while trying to ${action}`, message: error instanceof Error ? error.message : 'Unknown error' };
+    }
+}
+export async function gaList(token, base, parent, resource, options, action = 'list resources') {
+    try {
+        const result = await gaRequest(token, base, `/${parent}/${resource}`, {
+            query: { pageSize: options?.pageSize, pageToken: options?.pageToken, ...options?.extra },
+        });
+        if (!result.ok)
+            return { error: `Failed to ${action}`, details: result.error };
+        return result.data;
+    }
+    catch (error) {
+        return { error: `Error while trying to ${action}`, message: error instanceof Error ? error.message : 'Unknown error' };
+    }
+}
+export function normalizeProperty(property) {
+    return property.startsWith('properties/') ? property : `properties/${property}`;
+}
+export const paginationSchema = {
+    pageSize: z.number().min(1).max(200).optional().describe('Max resources per page (default 50, max 200)'),
+    pageToken: z.string().optional().describe('Page token from a previous list call'),
+};
+export const namedMetric = z.object({ name: z.string().describe("Metric API name, e.g. 'activeUsers'") }).catchall(z.unknown());
+export const namedDimension = z.object({ name: z.string().describe("Dimension API name, e.g. 'country'") }).catchall(z.unknown());
+//# sourceMappingURL=client.js.map