@nangohq/types 0.71.13 → 0.72.0

package/dist/analytics/catalogue.d.ts

@@ -0,0 +1,700 @@
+import * as z from 'zod';
+import type { AgentSessionMetaTool, AgentSessionToolSearchHit } from '../agent/session.js';
+import type { CliTelemetryCommand } from '../cli/api.js';
+import type { HTTP_METHOD } from '../nangoYaml/index.js';
+import type { GrowthAddonState } from '../plans/http.api.js';
+import type { UsageMetric } from '../usage/index.js';
+import type { AnalyticsSurface } from './taxonomy.js';
+export interface AnalyticsEventDefinition {
+    surface: AnalyticsSurface;
+    insight: string;
+    fires: string;
+    properties: z.ZodType;
+}
+/** Senders add `surface`, and the server adds `is_production` when it knows the environment. `properties` lists the rest. */
+export declare const analyticsEventCatalogue: {
+    readonly 'billing:usage_update': {
+        readonly surface: "web";
+        readonly insight: "Which Usage page controls people use, and which metrics and dimensions they break usage down by";
+        readonly fires: "When someone changes the month, a breakdown, a filter or a series on the Usage page";
+        readonly properties: z.ZodUnion<readonly [z.ZodObject<{
+            change: z.ZodLiteral<"month">;
+            direction: z.ZodEnum<{
+                previous: "previous";
+                next: "next";
+            }>;
+        }, z.core.$strip>, z.ZodObject<{
+            change: z.ZodEnum<{
+                filter: "filter";
+                group: "group";
+            }>;
+            metric: z.ZodType<UsageMetric, unknown, z.core.$ZodTypeInternals<UsageMetric, unknown>>;
+            dimension: z.ZodType<"environment_id" | "source" | "success" | "connection_id" | "integration_id" | "function_name" | "function_type" | "model", unknown, z.core.$ZodTypeInternals<"environment_id" | "source" | "success" | "connection_id" | "integration_id" | "function_name" | "function_type" | "model", unknown>>;
+        }, z.core.$strip>, z.ZodObject<{
+            change: z.ZodEnum<{
+                group_clear: "group_clear";
+                filter_clear: "filter_clear";
+                series_isolate: "series_isolate";
+                series_toggle: "series_toggle";
+            }>;
+            metric: z.ZodType<UsageMetric, unknown, z.core.$ZodTypeInternals<UsageMetric, unknown>>;
+        }, z.core.$strip>, z.ZodObject<{
+            change: z.ZodLiteral<"legacy_metrics">;
+            is_legacy_metrics_shown: z.ZodBoolean;
+        }, z.core.$strip>]>;
+    };
+    readonly 'billing:filter_button_click': {
+        readonly surface: "web";
+        readonly insight: "How often people look for a breakdown filter, and on which metric";
+        readonly fires: "When someone opens the breakdown filter on a usage chart";
+        readonly properties: z.ZodObject<{
+            metric: z.ZodType<UsageMetric, unknown, z.core.$ZodTypeInternals<UsageMetric, unknown>>;
+        }, z.core.$strip>;
+    };
+    readonly 'billing:copy_button_click': {
+        readonly surface: "web";
+        readonly insight: "How often people copy a breakdown value out of a usage chart, and for which metric and dimension";
+        readonly fires: "When someone copies a breakdown value on a usage chart";
+        readonly properties: z.ZodObject<{
+            metric: z.ZodType<UsageMetric, unknown, z.core.$ZodTypeInternals<UsageMetric, unknown>>;
+            dimension: z.ZodType<"environment_id" | "source" | "success" | "connection_id" | "integration_id" | "function_name" | "function_type" | "model", unknown, z.core.$ZodTypeInternals<"environment_id" | "source" | "success" | "connection_id" | "integration_id" | "function_name" | "function_type" | "model", unknown>>;
+        }, z.core.$strip>;
+    };
+    readonly 'billing:open_link_click': {
+        readonly surface: "web";
+        readonly insight: "How often a usage breakdown leads people to the integration or connection behind it";
+        readonly fires: "When someone opens the item behind a breakdown value on a usage chart";
+        readonly properties: z.ZodObject<{
+            metric: z.ZodType<UsageMetric, unknown, z.core.$ZodTypeInternals<UsageMetric, unknown>>;
+            dimension: z.ZodType<"environment_id" | "source" | "success" | "connection_id" | "integration_id" | "function_name" | "function_type" | "model", unknown, z.core.$ZodTypeInternals<"environment_id" | "source" | "success" | "connection_id" | "integration_id" | "function_name" | "function_type" | "model", unknown>>;
+        }, z.core.$strip>;
+    };
+    readonly 'billing:invoice_link_click': {
+        readonly surface: "web";
+        readonly insight: "How often accounts open their invoices from Billing & Usage";
+        readonly fires: "When someone opens an invoice from the Billing page";
+        readonly properties: z.ZodRecord<z.ZodString, z.ZodNever>;
+    };
+    readonly 'billing:portal_link_click': {
+        readonly surface: "web";
+        readonly insight: "How often accounts need the billing portal";
+        readonly fires: "When someone opens the billing portal from the Usage page";
+        readonly properties: z.ZodRecord<z.ZodString, z.ZodNever>;
+    };
+    readonly 'billing:upgrade_button_click': {
+        readonly surface: "web";
+        readonly insight: "How many accounts start an upgrade from a plan card, the first step of the upgrade funnel";
+        readonly fires: "When someone clicks to upgrade on a plan card";
+        readonly properties: z.ZodRecord<z.ZodString, z.ZodNever>;
+    };
+    readonly 'billing:addon_button_click': {
+        readonly surface: "web";
+        readonly insight: "How many accounts act on the Growth add-on, split by whether they already have it";
+        readonly fires: "When someone clicks the Growth add-on action on the Billing page";
+        readonly properties: z.ZodObject<{
+            addon_state: z.ZodType<GrowthAddonState, unknown, z.core.$ZodTypeInternals<GrowthAddonState, unknown>>;
+        }, z.core.$strip>;
+    };
+    readonly 'billing:payment_method_button_click': {
+        readonly surface: "web";
+        readonly insight: "How many accounts start adding a payment method";
+        readonly fires: "When someone clicks to add a payment method on the Billing page";
+        readonly properties: z.ZodRecord<z.ZodString, z.ZodNever>;
+    };
+    readonly 'billing:overdue_alert_link_click': {
+        readonly surface: "web";
+        readonly insight: "Whether the overdue-invoice alert gets accounts to look at their invoices";
+        readonly fires: "When someone follows the overdue-invoice alert in the sidebar";
+        readonly properties: z.ZodRecord<z.ZodString, z.ZodNever>;
+    };
+    readonly 'billing:plan_submit': {
+        readonly surface: "server";
+        readonly insight: "Which plan changes accounts ask for, including downgrades that take effect later";
+        readonly fires: "After the server accepts a plan change requested in the dashboard";
+        readonly properties: z.ZodObject<{
+            previous_plan: z.ZodString;
+            plan: z.ZodString;
+            previous_has_growth_addon: z.ZodBoolean;
+            has_growth_addon: z.ZodBoolean;
+            is_downgrade: z.ZodBoolean;
+        }, z.core.$strip>;
+    };
+    readonly 'billing:plan_update': {
+        readonly surface: "server";
+        readonly insight: "How many accounts upgrade and downgrade each month, counted when the change takes effect";
+        readonly fires: "After an account's plan changes in our database";
+        readonly properties: z.ZodObject<{
+            previous_plan: z.ZodString;
+            plan: z.ZodString;
+            previous_has_growth_addon: z.ZodBoolean;
+            has_growth_addon: z.ZodBoolean;
+            is_downgrade: z.ZodBoolean;
+            is_scheduled: z.ZodBoolean;
+        }, z.core.$strip>;
+    };
+    readonly 'playground:playground_view': {
+        readonly surface: "web";
+        readonly insight: "How many accounts open the API Playground each week, and from where";
+        readonly fires: "When the Playground opens";
+        readonly properties: z.ZodObject<{
+            source: z.ZodEnum<{
+                function: "function";
+                connection: "connection";
+                integration: "integration";
+            }>;
+        }, z.core.$strip>;
+    };
+    readonly 'playground:run_start': {
+        readonly surface: "web";
+        readonly insight: "How many Playground runs accounts start, and on which functions";
+        readonly fires: "When someone runs a function in the Playground";
+        readonly properties: z.ZodObject<{
+            function_type: z.ZodString;
+            integration: z.ZodString;
+            is_run_again: z.ZodBoolean;
+        }, z.core.$strip>;
+    };
+    readonly 'playground:run_complete': {
+        readonly surface: "web";
+        readonly insight: "How often Playground runs succeed, and how long they take";
+        readonly fires: "When a Playground run returns a result or an error";
+        readonly properties: z.ZodObject<{
+            function_type: z.ZodString;
+            integration: z.ZodString;
+            is_success: z.ZodBoolean;
+            run_state: z.ZodString;
+            run_duration_ms: z.ZodNumber;
+        }, z.core.$strip>;
+    };
+    readonly 'playground:run_cancel': {
+        readonly surface: "web";
+        readonly insight: "How often people give up on a Playground run before it finishes";
+        readonly fires: "When someone cancels a running Playground run";
+        readonly properties: z.ZodObject<{
+            function_type: z.ZodString;
+            integration: z.ZodString;
+        }, z.core.$strip>;
+    };
+    readonly 'playground:approval_view': {
+        readonly surface: "web";
+        readonly insight: "How many changes the Agent Playground agent asks people to approve, and on which tools";
+        readonly fires: "When an Agent Playground reply finishes waiting for the user to approve a tool call";
+        readonly properties: z.ZodObject<{
+            chat_id: z.ZodString;
+            agent_session_id: z.ZodOptional<z.ZodString>;
+            tool_name: z.ZodString;
+            integration: z.ZodOptional<z.ZodString>;
+            http_method: z.ZodOptional<z.ZodString>;
+        }, z.core.$strip>;
+    };
+    readonly 'playground:approval_button_click': {
+        readonly surface: "web";
+        readonly insight: "How often people approve or deny the changes the Agent Playground agent asks for";
+        readonly fires: "When someone clicks Approve or Deny on a tool call in the Agent Playground";
+        readonly properties: z.ZodObject<{
+            is_approved: z.ZodBoolean;
+            chat_id: z.ZodString;
+            agent_session_id: z.ZodOptional<z.ZodString>;
+            tool_name: z.ZodString;
+            integration: z.ZodOptional<z.ZodString>;
+            http_method: z.ZodOptional<z.ZodString>;
+        }, z.core.$strip>;
+    };
+    readonly 'playground:integration_create': {
+        readonly surface: "server";
+        readonly insight: "How often an Agent Playground starter can't run because its integration can't be set up, and for which provider";
+        readonly fires: "When an Agent Playground starter creates its integration, reuses one, or can't set one up";
+        readonly properties: z.ZodUnion<readonly [z.ZodObject<{
+            provider: z.ZodString;
+            is_existing: z.ZodBoolean;
+            is_success: z.ZodLiteral<true>;
+        }, z.core.$strip>, z.ZodObject<{
+            provider: z.ZodString;
+            is_existing: z.ZodBoolean;
+            is_success: z.ZodLiteral<false>;
+            error_code: z.ZodType<"missing_credentials" | "not_created", unknown, z.core.$ZodTypeInternals<"missing_credentials" | "not_created", unknown>>;
+        }, z.core.$strip>]>;
+    };
+    readonly 'playground:agent_turn_complete': {
+        readonly surface: "server";
+        readonly insight: "What the Agent Playground costs per account, how often turns fail or get stopped, and whether first chats start from a starter";
+        readonly fires: "When an Agent Playground turn finishes, fails or is stopped";
+        readonly properties: z.ZodObject<{
+            agent_session_id: z.ZodString;
+            chat_id: z.ZodOptional<z.ZodString>;
+            environment_id: z.ZodNumber;
+            is_first_turn: z.ZodBoolean;
+            starter_provider: z.ZodOptional<z.ZodString>;
+            is_success: z.ZodBoolean;
+            error_code: z.ZodOptional<z.ZodString>;
+            is_stopped: z.ZodBoolean;
+            model: z.ZodOptional<z.ZodString>;
+            step_count: z.ZodNumber;
+            input_tokens: z.ZodNumber;
+            cache_read_tokens: z.ZodNumber;
+            cache_write_tokens: z.ZodNumber;
+            output_tokens: z.ZodNumber;
+            reasoning_tokens: z.ZodNumber;
+            cost_usd: z.ZodOptional<z.ZodNumber>;
+        }, z.core.$strip>;
+    };
+    readonly 'onboarding:connect_button_click': {
+        readonly surface: "web";
+        readonly insight: "How many accounts start the Getting Started flow by connecting GitHub";
+        readonly fires: "When someone clicks to connect GitHub on the Getting Started page";
+        readonly properties: z.ZodRecord<z.ZodString, z.ZodNever>;
+    };
+    readonly 'onboarding:connection_create': {
+        readonly surface: "web";
+        readonly insight: "How many accounts that start Getting Started get through the GitHub connect flow";
+        readonly fires: "When the GitHub connection on the Getting Started page is created";
+        readonly properties: z.ZodRecord<z.ZodString, z.ZodNever>;
+    };
+    readonly 'onboarding:run_complete': {
+        readonly surface: "web";
+        readonly insight: "How many accounts run the Getting Started code snippet, and how often it fails";
+        readonly fires: "When the Getting Started code snippet returns a result or an error";
+        readonly properties: z.ZodObject<{
+            is_success: z.ZodBoolean;
+        }, z.core.$strip>;
+    };
+    readonly 'onboarding:create_button_click': {
+        readonly surface: "web";
+        readonly insight: "How many accounts finish Getting Started and go on to set up their own integration";
+        readonly fires: "When someone clicks to set up their own integration at the end of Getting Started";
+        readonly properties: z.ZodRecord<z.ZodString, z.ZodNever>;
+    };
+    readonly 'connections:create_button_click': {
+        readonly surface: "web";
+        readonly insight: "How many people start creating a connection, and for which provider";
+        readonly fires: "When someone starts creating a connection from the dashboard or the Agent Playground";
+        readonly properties: z.ZodObject<{
+            provider: z.ZodString;
+            is_playground: z.ZodOptional<z.ZodBoolean>;
+        }, z.core.$strip>;
+    };
+    readonly 'connections:share_link_button_click': {
+        readonly surface: "web";
+        readonly insight: "How often people hand connection setup to an end user instead of doing it themselves";
+        readonly fires: "When someone copies a connect link to share";
+        readonly properties: z.ZodObject<{
+            provider: z.ZodString;
+        }, z.core.$strip>;
+    };
+    readonly 'connections:connection_create': {
+        readonly surface: "web";
+        readonly insight: "Which integrations fail most often during auth started from the dashboard or the Agent Playground";
+        readonly fires: "When a connect flow started from the dashboard or the Agent Playground finishes";
+        readonly properties: z.ZodUnion<readonly [z.ZodObject<{
+            provider: z.ZodString;
+            is_legacy_flow: z.ZodBoolean;
+            is_playground: z.ZodOptional<z.ZodBoolean>;
+            is_success: z.ZodLiteral<true>;
+        }, z.core.$strip>, z.ZodObject<{
+            provider: z.ZodString;
+            is_legacy_flow: z.ZodBoolean;
+            is_playground: z.ZodOptional<z.ZodBoolean>;
+            is_success: z.ZodLiteral<false>;
+            error_code: z.ZodString;
+        }, z.core.$strip>]>;
+    };
+    readonly 'connections:connection_delete': {
+        readonly surface: "server";
+        readonly insight: "How many accounts manage connections from the dashboard each week";
+        readonly fires: "After someone deletes a connection from the dashboard";
+        readonly properties: z.ZodRecord<z.ZodString, z.ZodNever>;
+    };
+    readonly 'integrations:integration_create': {
+        readonly surface: "server";
+        readonly insight: "How many accounts create integrations each week, from where, and whether they use Nango's developer app or fill in their own credentials";
+        readonly fires: "After an integration is created from the dashboard, the API, the management MCP or an Agent Playground starter";
+        readonly properties: z.ZodObject<{
+            provider: z.ZodString;
+            is_playground: z.ZodBoolean;
+            source: z.ZodEnum<{
+                api: "api";
+                mcp: "mcp";
+                playground: "playground";
+                dashboard: "dashboard";
+            }>;
+            is_shared_credentials: z.ZodBoolean;
+            has_missing_fields: z.ZodBoolean;
+        }, z.core.$strip>;
+    };
+    readonly 'integrations:filter_update': {
+        readonly surface: "web";
+        readonly insight: "How often people search their integrations list, and how often the search finds nothing";
+        readonly fires: "When someone stops typing in the integrations list search";
+        readonly properties: z.ZodObject<{
+            filter: z.ZodEnum<{
+                search: "search";
+            }>;
+            result_count: z.ZodNumber;
+        }, z.core.$strip>;
+    };
+    readonly 'integrations:create_page_view': {
+        readonly surface: "web";
+        readonly insight: "How many accounts open a provider's setup form, and how many leave it without creating an integration, split by whether Nango has a developer app for it";
+        readonly fires: "When a provider's create integration form loads";
+        readonly properties: z.ZodObject<{
+            provider: z.ZodString;
+            has_shared_credentials: z.ZodBoolean;
+        }, z.core.$strip>;
+    };
+    readonly 'integrations:integration_update': {
+        readonly surface: "server";
+        readonly insight: "How many accounts change integration settings from the dashboard each week";
+        readonly fires: "After someone saves an integration's settings in the dashboard";
+        readonly properties: z.ZodObject<{
+            provider: z.ZodString;
+        }, z.core.$strip>;
+    };
+    readonly 'integrations:integration_delete': {
+        readonly surface: "server";
+        readonly insight: "How many accounts delete integrations from the dashboard each week";
+        readonly fires: "After someone deletes an integration from the dashboard";
+        readonly properties: z.ZodObject<{
+            provider: z.ZodString;
+        }, z.core.$strip>;
+    };
+    readonly 'environments:environment_update': {
+        readonly surface: "server";
+        readonly insight: "How many accounts change environment settings each week, and which section";
+        readonly fires: "After someone saves environment settings, webhooks, variables or secret keys in the dashboard";
+        readonly properties: z.ZodObject<{
+            section: z.ZodEnum<{
+                webhooks: "webhooks";
+                settings: "settings";
+                variables: "variables";
+                api_keys: "api_keys";
+            }>;
+        }, z.core.$strip>;
+    };
+    readonly 'team:user_invite': {
+        readonly surface: "server";
+        readonly insight: "How many accounts invite teammates each week";
+        readonly fires: "After someone invites people to the account from the dashboard";
+        readonly properties: z.ZodObject<{
+            role: z.ZodString;
+            invite_count: z.ZodNumber;
+        }, z.core.$strip>;
+    };
+    readonly 'team:user_update': {
+        readonly surface: "server";
+        readonly insight: "How many accounts change their teammates' roles each week";
+        readonly fires: "After someone changes a teammate's role";
+        readonly properties: z.ZodObject<{
+            previous_role: z.ZodString;
+            role: z.ZodString;
+        }, z.core.$strip>;
+    };
+    readonly 'team:user_remove': {
+        readonly surface: "server";
+        readonly insight: "How many accounts remove teammates each week";
+        readonly fires: "After someone removes a teammate from the account";
+        readonly properties: z.ZodRecord<z.ZodString, z.ZodNever>;
+    };
+    readonly 'functions:sync_command_submit': {
+        readonly surface: "server";
+        readonly insight: "How many accounts run, pause or resume their connections' syncs from the dashboard each week";
+        readonly fires: "After the dashboard sends a command to a sync and the server accepts it";
+        readonly properties: z.ZodObject<{
+            command: z.ZodEnum<{
+                pause: "pause";
+                run: "run";
+                cancel: "cancel";
+                full_resync: "full_resync";
+                resume: "resume";
+            }>;
+        }, z.core.$strip>;
+    };
+    readonly 'functions:function_view': {
+        readonly surface: "web";
+        readonly insight: "How many accounts browse an integration's functions, and whether they look at catalog templates or functions they already deployed";
+        readonly fires: "When someone opens a function's details from the list on an integration's Functions tab";
+        readonly properties: z.ZodObject<{
+            provider: z.ZodString;
+            function_type: z.ZodString;
+            is_deployed: z.ZodBoolean;
+        }, z.core.$strip>;
+    };
+    readonly 'functions:deploy_create': {
+        readonly surface: "server";
+        readonly insight: "How many accounts deploy functions each week, from where, and whether they deploy templates or their own code";
+        readonly fires: "After the server accepts a function deployment from the CLI, the API, the dashboard or the management MCP";
+        readonly properties: z.ZodObject<{
+            source: z.ZodEnum<{
+                api: "api";
+                mcp: "mcp";
+                cli: "cli";
+                dashboard: "dashboard";
+            }>;
+            is_template: z.ZodBoolean;
+            function_count: z.ZodNumber;
+        }, z.core.$strip>;
+    };
+    readonly 'logs:filter_update': {
+        readonly surface: "web";
+        readonly insight: "How many accounts search or filter their logs each week, and with which filter";
+        readonly fires: "When someone searches the logs or changes a logs filter";
+        readonly properties: z.ZodObject<{
+            filter: z.ZodEnum<{
+                type: "type";
+                connection: "connection";
+                integration: "integration";
+                agent_session: "agent_session";
+                search: "search";
+                script: "script";
+                status: "status";
+                period: "period";
+            }>;
+        }, z.core.$strip>;
+    };
+    readonly 'logs:operation_view': {
+        readonly surface: "web";
+        readonly insight: "How many accounts open a log operation each week";
+        readonly fires: "When someone opens an operation from the logs list";
+        readonly properties: z.ZodRecord<z.ZodString, z.ZodNever>;
+    };
+    readonly 'auth:account_create': {
+        readonly surface: "server";
+        readonly insight: "Weekly signups and first website sources. Permitted advertising_* fields feed ad-platform conversion destinations.";
+        readonly fires: "After a signup creates a new account, whichever way the person signed up";
+        readonly properties: z.ZodObject<{
+            acquisition_utm_source: z.ZodOptional<z.ZodString>;
+            acquisition_utm_medium: z.ZodOptional<z.ZodString>;
+            acquisition_utm_campaign: z.ZodOptional<z.ZodString>;
+            acquisition_utm_content: z.ZodOptional<z.ZodString>;
+            acquisition_utm_term: z.ZodOptional<z.ZodString>;
+            acquisition_referring_domain: z.ZodOptional<z.ZodString>;
+            acquisition_landing_path: z.ZodOptional<z.ZodString>;
+            advertising_consent_method: z.ZodOptional<z.ZodEnum<{
+                explicit: "explicit";
+                implied: "implied";
+            }>>;
+            advertising_consent_timestamp: z.ZodOptional<z.ZodString>;
+            advertising_oppref_click_timestamp: z.ZodOptional<z.ZodString>;
+            advertising_fbc: z.ZodOptional<z.ZodString>;
+            advertising_oppref: z.ZodOptional<z.ZodString>;
+        }, z.core.$strip>;
+    };
+    readonly 'auth:user_create': {
+        readonly surface: "server";
+        readonly insight: "How many users join each week, and how: password or Google, new account or invite";
+        readonly fires: "After a user is created, including users who join through an invite";
+        readonly properties: z.ZodObject<{
+            method: z.ZodEnum<{
+                password: "password";
+                google: "google";
+            }>;
+        }, z.core.$strip>;
+    };
+    readonly 'auth:join_request_submit': {
+        readonly surface: "web";
+        readonly insight: "How many new users ask to join an existing account instead of creating their own";
+        readonly fires: "When someone asks to join an account found for their email domain";
+        readonly properties: z.ZodRecord<z.ZodString, z.ZodNever>;
+    };
+    readonly 'auth:two_factor_start': {
+        readonly surface: "web";
+        readonly insight: "How many users start setting up two-factor authentication";
+        readonly fires: "When someone starts setting up two-factor authentication";
+        readonly properties: z.ZodRecord<z.ZodString, z.ZodNever>;
+    };
+    readonly 'auth:two_factor_complete': {
+        readonly surface: "web";
+        readonly insight: "How many users finish two-factor enrolment, and why the code check fails";
+        readonly fires: "When the two-factor code is checked at the end of enrolment";
+        readonly properties: z.ZodUnion<readonly [z.ZodObject<{
+            is_success: z.ZodLiteral<true>;
+        }, z.core.$strip>, z.ZodObject<{
+            is_success: z.ZodLiteral<false>;
+            error_code: z.ZodString;
+        }, z.core.$strip>]>;
+    };
+    readonly 'auth:two_factor_cancel': {
+        readonly surface: "web";
+        readonly insight: "At which step people abandon two-factor enrolment";
+        readonly fires: "When someone closes two-factor enrolment before finishing";
+        readonly properties: z.ZodObject<{
+            step: z.ZodEnum<{
+                scan: "scan";
+                save: "save";
+            }>;
+        }, z.core.$strip>;
+    };
+    readonly 'auth:two_factor_remove': {
+        readonly surface: "web";
+        readonly insight: "How many users turn two-factor authentication off again";
+        readonly fires: "After two-factor authentication is turned off";
+        readonly properties: z.ZodRecord<z.ZodString, z.ZodNever>;
+    };
+    readonly 'auth:recovery_codes_generate': {
+        readonly surface: "web";
+        readonly insight: "How often users replace their two-factor recovery codes";
+        readonly fires: "After new recovery codes are generated";
+        readonly properties: z.ZodRecord<z.ZodString, z.ZodNever>;
+    };
+    readonly 'auth:download_button_click': {
+        readonly surface: "web";
+        readonly insight: "Whether users save their recovery codes by downloading them";
+        readonly fires: "When someone downloads their recovery codes";
+        readonly properties: z.ZodObject<{
+            flow: z.ZodEnum<{
+                enroll: "enroll";
+                regenerate: "regenerate";
+            }>;
+        }, z.core.$strip>;
+    };
+    readonly 'auth:copy_button_click': {
+        readonly surface: "web";
+        readonly insight: "Whether users save the secrets the dashboard shows only once: recovery codes and new API keys";
+        readonly fires: "When someone copies recovery codes or a new API key secret";
+        readonly properties: z.ZodUnion<readonly [z.ZodObject<{
+            copied_item: z.ZodLiteral<"recovery_codes">;
+            flow: z.ZodEnum<{
+                enroll: "enroll";
+                regenerate: "regenerate";
+            }>;
+        }, z.core.$strip>, z.ZodObject<{
+            copied_item: z.ZodLiteral<"api_key_secret">;
+        }, z.core.$strip>]>;
+    };
+    readonly 'auth:password_update': {
+        readonly surface: "web";
+        readonly insight: "How often users change their password";
+        readonly fires: "After a password change is saved";
+        readonly properties: z.ZodRecord<z.ZodString, z.ZodNever>;
+    };
+    readonly 'auth:api_keys_link_click': {
+        readonly surface: "web";
+        readonly insight: "How people find account API keys";
+        readonly fires: "When someone opens API keys from the profile menu";
+        readonly properties: z.ZodRecord<z.ZodString, z.ZodNever>;
+    };
+    readonly 'auth:api_key_create': {
+        readonly surface: "web";
+        readonly insight: "How many accounts create account API keys";
+        readonly fires: "After an account API key is created";
+        readonly properties: z.ZodRecord<z.ZodString, z.ZodNever>;
+    };
+    readonly 'auth:api_key_delete': {
+        readonly surface: "web";
+        readonly insight: "How often account API keys are deleted, as a sign they get rotated";
+        readonly fires: "After an account API key is deleted";
+        readonly properties: z.ZodRecord<z.ZodString, z.ZodNever>;
+    };
+    readonly 'audit:export_complete': {
+        readonly surface: "web";
+        readonly insight: "How many accounts export their audit trail, and how often exports hit the row limit";
+        readonly fires: "When an audit trail export finishes or fails";
+        readonly properties: z.ZodUnion<readonly [z.ZodObject<{
+            is_success: z.ZodLiteral<true>;
+            is_truncated: z.ZodBoolean;
+        }, z.core.$strip>, z.ZodObject<{
+            is_success: z.ZodLiteral<false>;
+            error_code: z.ZodString;
+        }, z.core.$strip>]>;
+    };
+    readonly 'functions:command_start': {
+        readonly surface: "cli";
+        readonly insight: "Which CLI commands do people run, and how often?";
+        readonly fires: "Before a CLI command runs";
+        readonly properties: z.ZodObject<{
+            command: z.ZodType<CliTelemetryCommand, unknown, z.core.$ZodTypeInternals<CliTelemetryCommand, unknown>>;
+            is_device_ephemeral: z.ZodOptional<z.ZodBoolean>;
+        }, z.core.$strip>;
+    };
+    readonly 'agents:session_start': {
+        readonly surface: "server";
+        readonly insight: "How many accounts create agent sessions each week, and which meta tools they turn on";
+        readonly fires: "After an agent session is created";
+        readonly properties: z.ZodObject<{
+            integration_count: z.ZodNumber;
+            is_tool_search_enabled: z.ZodBoolean;
+            is_execute_enabled: z.ZodBoolean;
+            is_proxy_enabled: z.ZodBoolean;
+            is_create_connection_enabled: z.ZodBoolean;
+            agent_session_id: z.ZodString;
+            is_playground: z.ZodBoolean;
+        }, z.core.$strip>;
+    };
+    readonly 'agents:session_end': {
+        readonly surface: "server";
+        readonly insight: "How long do agent sessions last?";
+        readonly fires: "After an agent session is terminated. Expired sessions send nothing";
+        readonly properties: z.ZodObject<{
+            session_duration_ms: z.ZodNumber;
+            agent_session_id: z.ZodString;
+            is_playground: z.ZodBoolean;
+        }, z.core.$strip>;
+    };
+    readonly 'agents:tool_call_complete': {
+        readonly surface: "server";
+        readonly insight: "Which tools do agents call most, and which fail most often?";
+        readonly fires: "When a tool call in an agent session returns";
+        readonly properties: z.ZodObject<{
+            tool_name: z.ZodOptional<z.ZodString>;
+            meta_tool: z.ZodOptional<z.ZodType<AgentSessionMetaTool, unknown, z.core.$ZodTypeInternals<AgentSessionMetaTool, unknown>>>;
+            is_pinned: z.ZodOptional<z.ZodBoolean>;
+            integration_id: z.ZodOptional<z.ZodString>;
+            underlying_error_code: z.ZodOptional<z.ZodString>;
+            is_mcp_tool: z.ZodOptional<z.ZodBoolean>;
+            is_success: z.ZodBoolean;
+            log_operation_id: z.ZodOptional<z.ZodString>;
+            error_code: z.ZodOptional<z.ZodString>;
+            agent_session_id: z.ZodString;
+            is_playground: z.ZodBoolean;
+        }, z.core.$strip>;
+    };
+    readonly 'agents:proxy_request_complete': {
+        readonly surface: "server";
+        readonly insight: "Which integration APIs agents call through the proxy, and how often those requests fail";
+        readonly fires: "When a proxy request from an agent session returns";
+        readonly properties: z.ZodObject<{
+            integration_id: z.ZodOptional<z.ZodString>;
+            http_method: z.ZodOptional<z.ZodType<HTTP_METHOD, unknown, z.core.$ZodTypeInternals<HTTP_METHOD, unknown>>>;
+            provider: z.ZodOptional<z.ZodString>;
+            http_status: z.ZodOptional<z.ZodNumber>;
+            provider_error_code: z.ZodOptional<z.ZodString>;
+            is_success: z.ZodBoolean;
+            log_operation_id: z.ZodOptional<z.ZodString>;
+            error_code: z.ZodOptional<z.ZodString>;
+            meta_tool: z.ZodLiteral<"nango_proxy">;
+            agent_session_id: z.ZodString;
+            is_playground: z.ZodBoolean;
+        }, z.core.$strip>;
+    };
+    readonly 'agents:tool_search_complete': {
+        readonly surface: "server";
+        readonly insight: "How often does tool search return a tool the agent then uses?";
+        readonly fires: "When a tool search in an agent session returns";
+        readonly properties: z.ZodObject<{
+            query: z.ZodOptional<z.ZodString>;
+            match_count: z.ZodNumber;
+            related_count: z.ZodNumber;
+            top_match_confidence: z.ZodOptional<z.ZodNumber>;
+            matches: z.ZodArray<z.ZodCustom<AgentSessionToolSearchHit, AgentSessionToolSearchHit>>;
+            related: z.ZodArray<z.ZodCustom<AgentSessionToolSearchHit, AgentSessionToolSearchHit>>;
+            is_success: z.ZodBoolean;
+            log_operation_id: z.ZodOptional<z.ZodString>;
+            error_code: z.ZodOptional<z.ZodString>;
+            meta_tool: z.ZodLiteral<"nango_tool_search">;
+            agent_session_id: z.ZodString;
+            is_playground: z.ZodBoolean;
+        }, z.core.$strip>;
+    };
+};
+type AnalyticsEventCatalogue = typeof analyticsEventCatalogue;
+type AnalyticsEventKey = keyof AnalyticsEventCatalogue;
+export type AnalyticsEventNameFor<S extends AnalyticsSurface> = {
+    [E in AnalyticsEventKey]: S extends AnalyticsEventCatalogue[E]['surface'] ? E : never;
+}[AnalyticsEventKey];
+export type AnalyticsEventProperties<E extends AnalyticsEventKey> = z.infer<AnalyticsEventCatalogue[E]['properties']>;
+export type AnalyticsEventPropertiesInput<E extends AnalyticsEventKey> = Record<never, never> extends AnalyticsEventProperties<E> ? {
+    eventProperties?: AnalyticsEventProperties<E>;
+} : {
+    eventProperties: AnalyticsEventProperties<E>;
+};
+export type AnalyticsEventPropertiesArgs<E extends AnalyticsEventKey> = Record<never, never> extends AnalyticsEventProperties<E> ? [properties?: AnalyticsEventProperties<E>] : [properties: AnalyticsEventProperties<E>];
+export {};