@rnsk/toolkits 0.0.7 → 0.0.8

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

@@ -0,0 +1,102 @@
+// @ts-nocheck
+import { z } from 'zod';
+export const GOOGLE_ADS_API_BASE = 'https://googleads.googleapis.com';
+export const GOOGLE_ADS_API_VERSION = 'v23';
+export const googleAdsTokenField = z.string().describe('The Google Ads OAuth access token (Bearer)');
+export const developerTokenField = z
+    .string()
+    .describe('Google Ads developer token from the API Center (sent as developer-token header)');
+export const customerIdField = z
+    .string()
+    .optional()
+    .describe('Target Google Ads customer ID; hyphens and spaces are stripped. For MCC workflows pass the child/sub-account ID.');
+export const loginCustomerIdField = z
+    .string()
+    .optional()
+    .describe('Manager (MCC) customer ID sent as login-customer-id header. Omit for direct accounts.');
+export function normalizeCustomerId(id) {
+    return (id ?? '').replace(/[-\s]/g, '');
+}
+function buildHeaders(googleAdsToken, developerToken, loginCustomerId) {
+    const headers = {
+        Authorization: `Bearer ${googleAdsToken}`,
+        'developer-token': developerToken,
+        'Content-Type': 'application/json',
+    };
+    const loginId = normalizeCustomerId(loginCustomerId);
+    if (loginId)
+        headers['login-customer-id'] = loginId;
+    return headers;
+}
+export async function adsRequest(googleAdsToken, developerToken, path, options) {
+    const response = await fetch(`${GOOGLE_ADS_API_BASE}${path}`, {
+        method: options?.method ?? 'GET',
+        headers: buildHeaders(googleAdsToken, developerToken, options?.loginCustomerId),
+        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 } };
+    }
+    const data = await response.json().catch(() => ({}));
+    return { ok: true, data };
+}
+function toCamelKey(key) {
+    return key.replace(/_([a-z0-9])/g, (_, c) => c.toUpperCase());
+}
+export function toGoogleAdsJson(value) {
+    if (Array.isArray(value))
+        return value.map(toGoogleAdsJson);
+    if (value && typeof value === 'object') {
+        const out = {};
+        for (const [k, v] of Object.entries(value)) {
+            out[toCamelKey(k)] = toGoogleAdsJson(v);
+        }
+        return out;
+    }
+    return value;
+}
+export async function adsMutate(googleAdsToken, developerToken, resource, opts) {
+    const customerId = normalizeCustomerId(opts.customerId);
+    if (!customerId)
+        return { ok: false, error: { message: 'customerId is required' } };
+    const body = {
+        operations: toGoogleAdsJson(opts.operations),
+    };
+    if (opts.validateOnly !== undefined)
+        body.validateOnly = opts.validateOnly;
+    if (opts.partialFailure !== undefined)
+        body.partialFailure = opts.partialFailure;
+    if (opts.responseContentType !== undefined)
+        body.responseContentType = opts.responseContentType;
+    return adsRequest(googleAdsToken, developerToken, `/${GOOGLE_ADS_API_VERSION}/customers/${customerId}/${resource}:mutate`, { method: 'POST', body, loginCustomerId: opts.loginCustomerId });
+}
+export async function adsSearchStream(googleAdsToken, developerToken, opts) {
+    const customerId = normalizeCustomerId(opts.customerId);
+    if (!customerId)
+        return { ok: false, error: { message: 'customerId is required' } };
+    const body = { query: opts.query };
+    if (opts.summaryRowSetting)
+        body.summaryRowSetting = opts.summaryRowSetting;
+    return adsRequest(googleAdsToken, developerToken, `/${GOOGLE_ADS_API_VERSION}/customers/${customerId}/googleAds:searchStream`, { method: 'POST', body, loginCustomerId: opts.loginCustomerId });
+}
+export function collectStreamRows(data) {
+    const rows = [];
+    let requestId;
+    let summaryRow;
+    const batches = Array.isArray(data) ? data : [data];
+    for (const batch of batches) {
+        const b = batch;
+        if (typeof b?.requestId === 'string' && !requestId)
+            requestId = b.requestId;
+        for (const r of b?.results ?? [])
+            rows.push(r);
+        if (b?.summaryRow && !summaryRow)
+            summaryRow = b.summaryRow;
+    }
+    return { rows, requestId, summaryRow };
+}
+//# sourceMappingURL=client.js.map

package/dist/toolkits/google-ads/tools/create-callout-asset.d.ts

@@ -0,0 +1,23 @@
+export declare const createCalloutAsset: import("ai").Tool<{
+    googleAdsToken: string;
+    developerToken: string;
+    callout: {
+        calloutText: string;
+        startDate?: string | undefined;
+        endDate?: string | undefined;
+        adScheduleTargets?: {
+            dayOfWeek: "MONDAY" | "TUESDAY" | "WEDNESDAY" | "THURSDAY" | "FRIDAY" | "SATURDAY" | "SUNDAY";
+            startHour: number;
+            startMinute: "ZERO" | "FIFTEEN" | "THIRTY" | "FORTY_FIVE";
+            endHour: number;
+            endMinute: "ZERO" | "FIFTEEN" | "THIRTY" | "FORTY_FIVE";
+        }[] | undefined;
+    };
+    name?: string | undefined;
+    customerId?: string | undefined;
+    loginCustomerId?: string | undefined;
+    validateOnly?: boolean | undefined;
+    partialFailure?: boolean | undefined;
+    responseContentType?: "RESOURCE_NAME_ONLY" | "MUTABLE_RESOURCE" | undefined;
+}, any>;
+//# sourceMappingURL=create-callout-asset.d.ts.map

package/dist/toolkits/google-ads/tools/create-callout-asset.js

@@ -0,0 +1,62 @@
+// @ts-nocheck
+import { tool } from 'ai';
+import { z } from 'zod';
+import { adsMutate, customerIdField, developerTokenField, googleAdsTokenField, loginCustomerIdField, } from './client.js';
+const scheduleSchema = z.object({
+    dayOfWeek: z.enum(['MONDAY', 'TUESDAY', 'WEDNESDAY', 'THURSDAY', 'FRIDAY', 'SATURDAY', 'SUNDAY']).describe('Day when the callout is shown'),
+    startHour: z.number().min(0).max(23),
+    startMinute: z.enum(['ZERO', 'FIFTEEN', 'THIRTY', 'FORTY_FIVE']),
+    endHour: z.number().min(0).max(24),
+    endMinute: z.enum(['ZERO', 'FIFTEEN', 'THIRTY', 'FORTY_FIVE']),
+});
+export const createCalloutAsset = tool({
+    description: 'Creates an immutable account asset containing a validated callout. Associate the returned resource with mutateCustomerAssets using field_type CALLOUT; cleanup removes that association (assets cannot be deleted).',
+    inputSchema: z.object({
+        googleAdsToken: googleAdsTokenField,
+        developerToken: developerTokenField,
+        callout: z.object({
+            calloutText: z.string().min(1).max(25).describe('Callout text, up to 25 characters'),
+            startDate: z.string().optional().describe('First eligible date YYYY-MM-DD'),
+            endDate: z.string().optional().describe('Last eligible date YYYY-MM-DD'),
+            adScheduleTargets: z.array(scheduleSchema).max(42).optional().describe('Weekly serving intervals, at most six per day'),
+        }),
+        name: z.string().optional().describe('Optional internal name for the immutable asset'),
+        validateOnly: z.boolean().optional().describe('Validate without applying changes'),
+        partialFailure: z.boolean().optional().describe('Valid ops succeed even if others fail'),
+        responseContentType: z.enum(['RESOURCE_NAME_ONLY', 'MUTABLE_RESOURCE']).optional().describe('How much of each mutated resource to return'),
+        customerId: customerIdField,
+        loginCustomerId: loginCustomerIdField,
+    }),
+    execute: async ({ googleAdsToken, developerToken, callout, name, validateOnly, partialFailure, responseContentType, customerId, loginCustomerId }) => {
+        try {
+            const calloutAsset = { calloutText: callout.calloutText };
+            if (callout.startDate)
+                calloutAsset.startDate = callout.startDate;
+            if (callout.endDate)
+                calloutAsset.endDate = callout.endDate;
+            if (callout.adScheduleTargets)
+                calloutAsset.adScheduleTargets = callout.adScheduleTargets;
+            const create = { calloutAsset };
+            if (name)
+                create.name = name;
+            const result = await adsMutate(googleAdsToken, developerToken, 'assets', {
+                customerId,
+                loginCustomerId,
+                operations: [{ create }],
+                validateOnly,
+                partialFailure,
+                responseContentType,
+            });
+            if (!result.ok)
+                return { error: 'Failed to create callout asset', details: result.error };
+            return result.data;
+        }
+        catch (error) {
+            return {
+                error: 'Error creating callout asset',
+                message: error instanceof Error ? error.message : 'Unknown error',
+            };
+        }
+    },
+});
+//# sourceMappingURL=create-callout-asset.js.map

package/dist/toolkits/google-ads/tools/create-customer-list.d.ts

@@ -0,0 +1,9 @@
+export declare const createCustomerList: import("ai").Tool<{
+    name: string;
+    googleAdsToken: string;
+    developerToken: string;
+    description?: string | undefined;
+    customerId?: string | undefined;
+    loginCustomerId?: string | undefined;
+}, any>;
+//# sourceMappingURL=create-customer-list.d.ts.map

package/dist/toolkits/google-ads/tools/create-customer-list.js

@@ -0,0 +1,42 @@
+// @ts-nocheck
+import { tool } from 'ai';
+import { z } from 'zod';
+import { adsMutate, customerIdField, developerTokenField, googleAdsTokenField, loginCustomerIdField, } from './client.js';
+export const createCustomerList = tool({
+    description: 'Creates a customer list (UserList audience/remarketing list, not an account). Email-based lists must comply with Ads policies and consent laws; membership and targeting eligibility take hours to propagate.',
+    inputSchema: z.object({
+        googleAdsToken: googleAdsTokenField,
+        developerToken: developerTokenField,
+        name: z.string().describe('Name of the customer list (UserList)'),
+        description: z.string().optional().describe('Description of the customer list'),
+        customerId: customerIdField,
+        loginCustomerId: loginCustomerIdField,
+    }),
+    execute: async ({ googleAdsToken, developerToken, name, description, customerId, loginCustomerId }) => {
+        try {
+            const create = {
+                name,
+                crmBasedUserList: {},
+                membershipStatus: 'OPEN',
+            };
+            if (description)
+                create.description = description;
+            const result = await adsMutate(googleAdsToken, developerToken, 'userLists', {
+                customerId,
+                loginCustomerId,
+                operations: [{ create }],
+            });
+            if (!result.ok)
+                return { error: 'Failed to create customer list', details: result.error };
+            const data = result.data;
+            return { resourceName: data.results?.[0]?.resourceName, ...result.data };
+        }
+        catch (error) {
+            return {
+                error: 'Error creating customer list',
+                message: error instanceof Error ? error.message : 'Unknown error',
+            };
+        }
+    },
+});
+//# sourceMappingURL=create-customer-list.js.map

package/dist/toolkits/google-ads/tools/get-campaign-by-id.d.ts

@@ -0,0 +1,32 @@
+export declare const getCampaignById: import("ai").Tool<{
+    id: string;
+    googleAdsToken: string;
+    developerToken: string;
+    customerId?: string | undefined;
+    loginCustomerId?: string | undefined;
+}, {
+    error: string;
+    details?: undefined;
+    result?: undefined;
+    requestId?: undefined;
+    message?: undefined;
+} | {
+    error: string;
+    details: any;
+    result?: undefined;
+    requestId?: undefined;
+    message?: undefined;
+} | {
+    result: Record<string, unknown>;
+    requestId: string | undefined;
+    error?: undefined;
+    details?: undefined;
+    message?: undefined;
+} | {
+    error: string;
+    message: string;
+    details?: undefined;
+    result?: undefined;
+    requestId?: undefined;
+}>;
+//# sourceMappingURL=get-campaign-by-id.d.ts.map

package/dist/toolkits/google-ads/tools/get-campaign-by-id.js

@@ -0,0 +1,38 @@
+// @ts-nocheck
+import { tool } from 'ai';
+import { z } from 'zod';
+import { adsSearchStream, collectStreamRows, customerIdField, developerTokenField, googleAdsTokenField, loginCustomerIdField, normalizeCustomerId, } from './client.js';
+export const getCampaignById = tool({
+    description: 'Returns details of a Google Ads campaign by ID. Requires the correct customer_id — missing or mismatched IDs return empty results.',
+    inputSchema: z.object({
+        googleAdsToken: googleAdsTokenField,
+        developerToken: developerTokenField,
+        id: z.string().describe('Numeric ID of the campaign to retrieve'),
+        customerId: customerIdField,
+        loginCustomerId: loginCustomerIdField,
+    }),
+    execute: async ({ googleAdsToken, developerToken, id, customerId, loginCustomerId }) => {
+        try {
+            if (!/^\d+$/.test(id))
+                return { error: 'id must be a numeric campaign ID' };
+            const cid = normalizeCustomerId(customerId);
+            const result = await adsSearchStream(googleAdsToken, developerToken, {
+                customerId,
+                loginCustomerId,
+                query: `SELECT campaign.id, campaign.name, campaign.status, campaign.advertising_channel_type, campaign.advertising_channel_sub_type, campaign.start_date, campaign.end_date, campaign.campaign_budget, campaign.bidding_strategy, campaign.network_settings FROM campaign WHERE campaign.id = ${id} LIMIT 1`,
+            });
+            if (!result.ok)
+                return { error: 'Failed to get campaign', details: result.error };
+            const { rows, requestId } = collectStreamRows(result.data);
+            void cid;
+            return { result: rows[0] ?? {}, requestId };
+        }
+        catch (error) {
+            return {
+                error: 'Error getting campaign',
+                message: error instanceof Error ? error.message : 'Unknown error',
+            };
+        }
+    },
+});
+//# sourceMappingURL=get-campaign-by-id.js.map

package/dist/toolkits/google-ads/tools/get-campaign-by-name.d.ts

@@ -0,0 +1,32 @@
+export declare const getCampaignByName: import("ai").Tool<{
+    name: string;
+    googleAdsToken: string;
+    developerToken: string;
+    customerId?: string | undefined;
+    loginCustomerId?: string | undefined;
+}, {
+    error: string;
+    details?: undefined;
+    result?: undefined;
+    requestId?: undefined;
+    message?: undefined;
+} | {
+    error: string;
+    details: any;
+    result?: undefined;
+    requestId?: undefined;
+    message?: undefined;
+} | {
+    result: Record<string, unknown>;
+    requestId: string | undefined;
+    error?: undefined;
+    details?: undefined;
+    message?: undefined;
+} | {
+    error: string;
+    message: string;
+    details?: undefined;
+    result?: undefined;
+    requestId?: undefined;
+}>;
+//# sourceMappingURL=get-campaign-by-name.d.ts.map

package/dist/toolkits/google-ads/tools/get-campaign-by-name.js

@@ -0,0 +1,37 @@
+// @ts-nocheck
+import { tool } from 'ai';
+import { z } from 'zod';
+import { adsSearchStream, collectStreamRows, customerIdField, developerTokenField, googleAdsTokenField, loginCustomerIdField, } from './client.js';
+export const getCampaignByName = tool({
+    description: 'Retrieves a Google Ads campaign by its exact name using GAQL equality. Requires an active connection with valid customer_id.',
+    inputSchema: z.object({
+        googleAdsToken: googleAdsTokenField,
+        developerToken: developerTokenField,
+        name: z.string().describe('Exact campaign name to match'),
+        customerId: customerIdField,
+        loginCustomerId: loginCustomerIdField,
+    }),
+    execute: async ({ googleAdsToken, developerToken, name, customerId, loginCustomerId }) => {
+        try {
+            if (/['"\\\0\n\r]/.test(name)) {
+                return { error: 'name contains characters that cannot be embedded in a GAQL literal' };
+            }
+            const result = await adsSearchStream(googleAdsToken, developerToken, {
+                customerId,
+                loginCustomerId,
+                query: `SELECT campaign.id, campaign.name, campaign.status, campaign.advertising_channel_type, campaign.start_date, campaign.end_date, campaign.campaign_budget, campaign.network_settings FROM campaign WHERE campaign.name = '${name}' LIMIT 1`,
+            });
+            if (!result.ok)
+                return { error: 'Failed to get campaign', details: result.error };
+            const { rows, requestId } = collectStreamRows(result.data);
+            return { result: rows[0] ?? {}, requestId };
+        }
+        catch (error) {
+            return {
+                error: 'Error getting campaign',
+                message: error instanceof Error ? error.message : 'Unknown error',
+            };
+        }
+    },
+});
+//# sourceMappingURL=get-campaign-by-name.js.map

package/dist/toolkits/google-ads/tools/get-conversion-action-tag-snippets.d.ts

@@ -0,0 +1,28 @@
+export declare const getConversionActionTagSnippets: import("ai").Tool<{
+    googleAdsToken: string;
+    developerToken: string;
+    conversionActionId: string;
+    customerId?: string | undefined;
+    loginCustomerId?: string | undefined;
+}, {
+    error: string;
+    details?: undefined;
+    conversionAction?: undefined;
+    message?: undefined;
+} | {
+    error: string;
+    details: any;
+    conversionAction?: undefined;
+    message?: undefined;
+} | {
+    conversionAction: any;
+    error?: undefined;
+    details?: undefined;
+    message?: undefined;
+} | {
+    error: string;
+    message: string;
+    details?: undefined;
+    conversionAction?: undefined;
+}>;
+//# sourceMappingURL=get-conversion-action-tag-snippets.d.ts.map

package/dist/toolkits/google-ads/tools/get-conversion-action-tag-snippets.js

@@ -0,0 +1,33 @@
+// @ts-nocheck
+import { tool } from 'ai';
+import { z } from 'zod';
+import { GOOGLE_ADS_API_VERSION, adsRequest, customerIdField, developerTokenField, googleAdsTokenField, loginCustomerIdField, normalizeCustomerId, } from './client.js';
+export const getConversionActionTagSnippets = tool({
+    description: 'Retrieves provider-generated website or call conversion tag snippets for a conversion action. Use after creating a conversion action, before installing tags.',
+    inputSchema: z.object({
+        googleAdsToken: googleAdsTokenField,
+        developerToken: developerTokenField,
+        conversionActionId: z.string().regex(/^\d+$/).describe('Numeric conversion action ID'),
+        customerId: customerIdField,
+        loginCustomerId: loginCustomerIdField,
+    }),
+    execute: async ({ googleAdsToken, developerToken, conversionActionId, customerId, loginCustomerId }) => {
+        try {
+            const cid = normalizeCustomerId(customerId);
+            if (!cid)
+                return { error: 'customerId is required' };
+            const result = await adsRequest(googleAdsToken, developerToken, `/${GOOGLE_ADS_API_VERSION}/customers/${cid}/conversionActions/${conversionActionId}`, { loginCustomerId });
+            if (!result.ok) {
+                return { error: 'Failed to get conversion action tag snippets', details: result.error };
+            }
+            return { conversionAction: result.data };
+        }
+        catch (error) {
+            return {
+                error: 'Error getting conversion action tag snippets',
+                message: error instanceof Error ? error.message : 'Unknown error',
+            };
+        }
+    },
+});
+//# sourceMappingURL=get-conversion-action-tag-snippets.js.map

package/dist/toolkits/google-ads/tools/get-customer-lists.d.ts

@@ -0,0 +1,32 @@
+export declare const getCustomerLists: import("ai").Tool<{
+    googleAdsToken: string;
+    developerToken: string;
+    pageToken?: string | undefined;
+    customerId?: string | undefined;
+    loginCustomerId?: string | undefined;
+}, {
+    error: string;
+    details?: undefined;
+    userLists?: undefined;
+    nextPageToken?: undefined;
+    message?: undefined;
+} | {
+    error: string;
+    details: any;
+    userLists?: undefined;
+    nextPageToken?: undefined;
+    message?: undefined;
+} | {
+    userLists: (Record<string, unknown> | undefined)[];
+    nextPageToken: string | undefined;
+    error?: undefined;
+    details?: undefined;
+    message?: undefined;
+} | {
+    error: string;
+    message: string;
+    details?: undefined;
+    userLists?: undefined;
+    nextPageToken?: undefined;
+}>;
+//# sourceMappingURL=get-customer-lists.d.ts.map

package/dist/toolkits/google-ads/tools/get-customer-lists.js

@@ -0,0 +1,41 @@
+// @ts-nocheck
+import { tool } from 'ai';
+import { z } from 'zod';
+import { GOOGLE_ADS_API_VERSION, adsRequest, customerIdField, developerTokenField, googleAdsTokenField, loginCustomerIdField, normalizeCustomerId, } from './client.js';
+export const getCustomerLists = tool({
+    description: 'Lists customer lists (UserList audience/remarketing segments, not accounts) in Google Ads. Review all results before picking one — names may be similar and list IDs differ from account IDs.',
+    inputSchema: z.object({
+        googleAdsToken: googleAdsTokenField,
+        developerToken: developerTokenField,
+        pageToken: z.string().optional().describe('Pagination token from a previous nextPageToken'),
+        customerId: customerIdField,
+        loginCustomerId: loginCustomerIdField,
+    }),
+    execute: async ({ googleAdsToken, developerToken, pageToken, customerId, loginCustomerId }) => {
+        try {
+            const cid = normalizeCustomerId(customerId);
+            if (!cid)
+                return { error: 'customerId is required' };
+            const body = {
+                query: 'SELECT user_list.id, user_list.name, user_list.description, user_list.resource_name FROM user_list',
+            };
+            if (pageToken)
+                body.pageToken = pageToken;
+            const result = await adsRequest(googleAdsToken, developerToken, `/${GOOGLE_ADS_API_VERSION}/customers/${cid}/googleAds:search`, { method: 'POST', body, loginCustomerId });
+            if (!result.ok)
+                return { error: 'Failed to list customer lists', details: result.error };
+            const data = result.data;
+            return {
+                userLists: (data.results ?? []).map((r) => r.userList).filter(Boolean),
+                nextPageToken: data.nextPageToken,
+            };
+        }
+        catch (error) {
+            return {
+                error: 'Error listing customer lists',
+                message: error instanceof Error ? error.message : 'Unknown error',
+            };
+        }
+    },
+});
+//# sourceMappingURL=get-customer-lists.js.map

package/dist/toolkits/google-ads/tools/get-rmf-report.d.ts

@@ -0,0 +1,60 @@
+export declare const getRmfReport: import("ai").Tool<{
+    googleAdsToken: string;
+    developerToken: string;
+    report: "CUSTOMER" | "CAMPAIGN" | "AD_GROUP_AD" | "KEYWORD" | "SEARCH_TERM" | "DYNAMIC_SEARCH_AD_SEARCH_TERM" | "BIDDING_STRATEGY";
+    customerId?: string | undefined;
+    loginCustomerId?: string | undefined;
+    startDate?: string | undefined;
+    endDate?: string | undefined;
+    maxRows?: number | undefined;
+    optionalMetrics?: string[] | undefined;
+}, {
+    error: string;
+    details?: undefined;
+    report?: undefined;
+    dateRange?: undefined;
+    columns?: undefined;
+    requiredColumns?: undefined;
+    optionalMetrics?: undefined;
+    results?: undefined;
+    truncated?: undefined;
+    requestId?: undefined;
+    message?: undefined;
+} | {
+    error: string;
+    details: any;
+    report?: undefined;
+    dateRange?: undefined;
+    columns?: undefined;
+    requiredColumns?: undefined;
+    optionalMetrics?: undefined;
+    results?: undefined;
+    truncated?: undefined;
+    requestId?: undefined;
+    message?: undefined;
+} | {
+    report: "CUSTOMER" | "CAMPAIGN" | "AD_GROUP_AD" | "KEYWORD" | "SEARCH_TERM" | "DYNAMIC_SEARCH_AD_SEARCH_TERM" | "BIDDING_STRATEGY";
+    dateRange: string;
+    columns: string[];
+    requiredColumns: string[];
+    optionalMetrics: string[];
+    results: Record<string, unknown>[];
+    truncated: boolean;
+    requestId: string | undefined;
+    error?: undefined;
+    details?: undefined;
+    message?: undefined;
+} | {
+    error: string;
+    message: string;
+    details?: undefined;
+    report?: undefined;
+    dateRange?: undefined;
+    columns?: undefined;
+    requiredColumns?: undefined;
+    optionalMetrics?: undefined;
+    results?: undefined;
+    truncated?: undefined;
+    requestId?: undefined;
+}>;
+//# sourceMappingURL=get-rmf-report.d.ts.map