terse-types 0.0.1

package/dist/DonatedState.d.ts

@@ -0,0 +1,4 @@
+export declare abstract class DonatedState {
+    abstract readonly stateType: string;
+    toJSON(): Record<string, unknown>;
+}

package/dist/DonatedState.js

@@ -0,0 +1,12 @@
+export class DonatedState {
+    toJSON() {
+        const result = { stateType: this.stateType };
+        for (const key of Object.keys(this)) {
+            const value = this[key];
+            if (typeof value !== "function") {
+                result[key] = value;
+            }
+        }
+        return result;
+    }
+}

package/dist/Entities.d.ts

@@ -0,0 +1,7 @@
+export declare enum EntityType {
+    TICKET = "ticket",
+    COMMENT = "comment",
+    USER = "user",
+    ACTION_EVENT = "action_event",
+    RUN_HISTORY_ACTION = "run_history_action"
+}

package/dist/Entities.js

@@ -0,0 +1,8 @@
+export var EntityType;
+(function (EntityType) {
+    EntityType["TICKET"] = "ticket";
+    EntityType["COMMENT"] = "comment";
+    EntityType["USER"] = "user";
+    EntityType["ACTION_EVENT"] = "action_event";
+    EntityType["RUN_HISTORY_ACTION"] = "run_history_action";
+})(EntityType || (EntityType = {}));

package/dist/FrontendRoutes.json

@@ -0,0 +1,28 @@
+{
+    "APP": "/app",
+    "OAUTH": {
+        "SUCCESS": "/oauth/success",
+        "ERROR": "/oauth/error"
+    },
+    "ONBOARD": "/onboard",
+    "AGENTS": {
+        "LIST": "/app/agents",
+        "SETUP": "/app/agents/setup",
+        "NEW": "/app/agents/new",
+        "NEW_WITH_TEMPLATE": "/app/agents/new/template/:templateId",
+        "BY_ID": "/app/agents/:id",
+        "HISTORY": "/app/agents/:id?tab=history",
+        "IMPROVEMENTS": "/app/agents/:id?tab=improvements",
+        "ALERTS": "/app/agents/:id?tab=setup&section=alerts",
+        "RUN_HISTORY": "/app/agents/:id?tab=history&runId=:runId"
+    },
+    "INTEGRATIONS": "/app/integrations",
+    "ACTIVITY": "/app/activity",
+    "STATS": "/app/stats",
+    "NOTIFICATIONS": "/app/notifications",
+    "PROFILE": "/app/profile",
+    "USER_MANAGEMENT": "/app/profile?tab=users",
+    "ORGANIZATIONS": {
+        "CREATE": "/app/organizations/create"
+    }
+}

package/dist/FrontendRoutesBuilder.d.ts

@@ -0,0 +1,30 @@
+/** Query param added when redirecting from Home/AgentBuilderLayout chat to agent page; AgentSetupTab clears session when present */
+export declare const FROM_SETUP_CHAT_PARAM = "fromSetupChat";
+export declare const FrontendRoutes: {
+    APP: string;
+    OAUTH: {
+        SUCCESS: string;
+        ERROR: string;
+    };
+    ONBOARD: string;
+    AGENTS: {
+        LIST: string;
+        SETUP: string;
+        NEW: string;
+        NEW_WITH_TEMPLATE: string;
+        BY_ID: string;
+        HISTORY: string;
+        IMPROVEMENTS: string;
+        ALERTS: string;
+        RUN_HISTORY: string;
+    };
+    INTEGRATIONS: string;
+    ACTIVITY: string;
+    STATS: string;
+    NOTIFICATIONS: string;
+    PROFILE: string;
+    USER_MANAGEMENT: string;
+    ORGANIZATIONS: {
+        CREATE: string;
+    };
+};

package/dist/FrontendRoutesBuilder.js

@@ -0,0 +1,13 @@
+/**
+ * Frontend route path constants
+ *
+ * These constants standardize frontend route paths across the application,
+ * preventing magic strings and making refactoring easier.
+ *
+ * Dynamic routes use route objects with both React Router patterns and URL builders
+ * to ensure consistency across navigation calls and route definitions.
+ */
+import frontendRoutes from "./FrontendRoutes.json" with { type: "json" };
+/** Query param added when redirecting from Home/AgentBuilderLayout chat to agent page; AgentSetupTab clears session when present */
+export const FROM_SETUP_CHAT_PARAM = "fromSetupChat";
+export const FrontendRoutes = frontendRoutes;

package/dist/Integrations.d.ts

@@ -0,0 +1,254 @@
+import * as z from "zod";
+export declare enum IntegrationType {
+    GITHUB = "github",
+    GMAIL = "gmail",
+    LINEAR = "linear",
+    ATLASSIAN = "atlassian",
+    SLACK = "slack",
+    NOTION = "notion",
+    FIGMA = "figma",
+    TERSE = "terse",
+    POSTHOG = "posthog",
+    DATADOG = "datadog",
+    CRON_JOB = "cron_job",
+    LAUNCHDARKLY = "launchdarkly",
+    WORKOS = "workos",
+    ATTIO = "attio",
+    SNOWFLAKE = "snowflake"
+}
+export declare const integrationTypeEnum: z.ZodEnum<typeof IntegrationType>;
+export interface IntegrationDetails {
+    type: IntegrationType;
+    name: string;
+    description: string;
+    isInput?: boolean;
+    isOutput?: boolean;
+}
+export declare const GmailIntegrationMetadata: {
+    readonly type: IntegrationType.GMAIL;
+    readonly name: "Gmail";
+    readonly description: "Monitor incoming emails";
+    readonly isInput: true;
+    readonly isOutput: false;
+};
+export declare const NotionIntegrationMetadata: {
+    readonly type: IntegrationType.NOTION;
+    readonly name: "Notion";
+    readonly description: "Update living documents";
+    readonly isInput: false;
+    readonly isOutput: true;
+};
+export declare const LinearIntegrationMetadata: {
+    readonly type: IntegrationType.LINEAR;
+    readonly name: "Linear";
+    readonly description: "Update tasks in Linear";
+    readonly isInput: false;
+    readonly isOutput: true;
+};
+export declare const SlackIntegrationMetadata: {
+    readonly type: IntegrationType.SLACK;
+    readonly name: "Slack";
+    readonly description: "Send and receive messages in Slack (channels, group DMs, and DMs). Triggers can use user token to read your DMs; skills can send to channels or users with either token.";
+    readonly isInput: true;
+    readonly isOutput: true;
+};
+export declare const FigmaIntegrationMetadata: {
+    readonly type: IntegrationType.FIGMA;
+    readonly name: "Figma";
+    readonly description: "Trigger on Figma file comments (does not support file edits or design changes)";
+    readonly isInput: true;
+    readonly isOutput: false;
+};
+export declare const AtlassianIntegrationMetadata: {
+    readonly type: IntegrationType.ATLASSIAN;
+    readonly name: "Atlassian";
+    readonly description: "Update documents in Atlassian";
+    readonly isInput: true;
+    readonly isOutput: false;
+};
+export declare const GithubIntegrationMetadata: {
+    readonly type: IntegrationType.GITHUB;
+    readonly name: "Github";
+    readonly description: "Update repositories in Github";
+    readonly isInput: true;
+    readonly isOutput: true;
+};
+export declare const TerseIntegrationMetadata: {
+    readonly type: IntegrationType.TERSE;
+    readonly name: "Terse";
+    readonly description: "Platform tools";
+    readonly isInput: false;
+    readonly isOutput: false;
+};
+export declare const PosthogIntegrationMetadata: {
+    readonly type: IntegrationType.POSTHOG;
+    readonly name: "Posthog";
+    readonly description: "Update events in Posthog";
+    readonly isInput: false;
+    readonly isOutput: true;
+};
+export declare const DatadogIntegrationMetadata: {
+    readonly type: IntegrationType.DATADOG;
+    readonly name: "Datadog";
+    readonly description: "Search logs in Datadog";
+    readonly isInput: false;
+    readonly isOutput: true;
+};
+export declare const CronJobIntegrationMetadata: {
+    readonly type: IntegrationType.CRON_JOB;
+    readonly name: "Scheduled Jobs";
+    readonly description: "System integration for time-based triggers";
+    readonly isInput: true;
+    readonly isOutput: false;
+};
+export declare const LaunchDarklyIntegrationMetadata: {
+    readonly type: IntegrationType.LAUNCHDARKLY;
+    readonly name: "LaunchDarkly";
+    readonly description: "Track feature flags";
+    readonly isInput: false;
+    readonly isOutput: true;
+};
+export declare const WorkOSIntegrationMetadata: {
+    readonly type: IntegrationType.WORKOS;
+    readonly name: "WorkOS";
+    readonly description: "Trigger on user lifecycle events and fetch/search users from your WorkOS account";
+    readonly isInput: true;
+    readonly isOutput: true;
+};
+export declare const AttioIntegrationMetadata: {
+    readonly type: IntegrationType.ATTIO;
+    readonly name: "Attio";
+    readonly description: "Add and update contacts in Attio";
+    readonly isInput: false;
+    readonly isOutput: true;
+};
+export declare const SnowflakeIntegrationMetadata: {
+    readonly type: IntegrationType.SNOWFLAKE;
+    readonly name: "Snowflake";
+    readonly description: "Run read-only queries against Snowflake data warehouses";
+    readonly isInput: false;
+    readonly isOutput: true;
+};
+export type IntegrationMetadataMap = Record<IntegrationType, IntegrationDetails>;
+export declare const INTEGRATION_METADATA: IntegrationMetadataMap;
+export declare const IntegrationInstanceSchema: z.ZodObject<{
+    id: z.ZodString;
+}, z.core.$strip>;
+export type IntegrationInstance = z.infer<typeof IntegrationInstanceSchema>;
+export interface SlackInstallationOptions {
+    isBotUser: boolean;
+}
+export type NoInstallationOptions = Record<string, never>;
+export type AdditionalStateParams = Record<string, string>;
+type EnsureExhaustiveInstallationOptions<T extends Record<IntegrationType, NoInstallationOptions | SlackInstallationOptions>> = T;
+export type IntegrationInstallationOptions = EnsureExhaustiveInstallationOptions<{
+    [IntegrationType.SLACK]: SlackInstallationOptions;
+    [IntegrationType.GMAIL]: NoInstallationOptions;
+    [IntegrationType.NOTION]: NoInstallationOptions;
+    [IntegrationType.LINEAR]: NoInstallationOptions;
+    [IntegrationType.ATLASSIAN]: NoInstallationOptions;
+    [IntegrationType.GITHUB]: NoInstallationOptions;
+    [IntegrationType.FIGMA]: NoInstallationOptions;
+    [IntegrationType.TERSE]: NoInstallationOptions;
+    [IntegrationType.POSTHOG]: NoInstallationOptions;
+    [IntegrationType.DATADOG]: NoInstallationOptions;
+    [IntegrationType.CRON_JOB]: NoInstallationOptions;
+    [IntegrationType.LAUNCHDARKLY]: NoInstallationOptions;
+    [IntegrationType.WORKOS]: NoInstallationOptions;
+    [IntegrationType.ATTIO]: NoInstallationOptions;
+    [IntegrationType.SNOWFLAKE]: NoInstallationOptions;
+}>;
+export type InstallationOptionsFor<T extends IntegrationType> = IntegrationInstallationOptions[T];
+export declare const SlackIntegrationSchema: z.ZodObject<{
+    id: z.ZodString;
+    teamId: z.ZodOptional<z.ZodString>;
+    teamName: z.ZodOptional<z.ZodString>;
+    isBotUser: z.ZodOptional<z.ZodBoolean>;
+}, z.core.$strip>;
+export type SlackIntegration = z.infer<typeof SlackIntegrationSchema>;
+export declare const GmailIntegrationSchema: z.ZodObject<{
+    id: z.ZodString;
+    email: z.ZodEmail;
+    historyId: z.ZodOptional<z.ZodString>;
+    watchExpiration: z.ZodOptional<z.ZodDate>;
+}, z.core.$strip>;
+export type GmailIntegration = z.infer<typeof GmailIntegrationSchema>;
+export declare const FigmaIntegrationSchema: z.ZodObject<{
+    id: z.ZodString;
+    handle: z.ZodString;
+    figma_user_id: z.ZodString;
+    token_expiry: z.ZodDate;
+}, z.core.$strip>;
+export type FigmaIntegration = z.infer<typeof FigmaIntegrationSchema>;
+export declare const NotionIntegrationSchema: z.ZodObject<{
+    id: z.ZodString;
+    workspaceId: z.ZodOptional<z.ZodString>;
+    workspaceName: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+export type NotionIntegration = z.infer<typeof NotionIntegrationSchema>;
+export declare const AtlassianIntegrationSchema: z.ZodObject<{
+    id: z.ZodString;
+    baseUrl: z.ZodURL;
+    email: z.ZodEmail;
+    siteName: z.ZodOptional<z.ZodString>;
+    projectKey: z.ZodOptional<z.ZodString>;
+    projectName: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+export type AtlassianIntegration = z.infer<typeof AtlassianIntegrationSchema>;
+export declare const GithubIntegrationSchema: z.ZodObject<{
+    id: z.ZodString;
+    installation_id: z.ZodNumber;
+    account_name: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+export type GithubIntegration = z.infer<typeof GithubIntegrationSchema>;
+export declare const LinearIntegrationSchema: z.ZodObject<{
+    id: z.ZodString;
+    workspaceName: z.ZodString;
+}, z.core.$strip>;
+export type LinearIntegration = z.infer<typeof LinearIntegrationSchema>;
+export declare const PosthogIntegrationSchema: z.ZodObject<{
+    id: z.ZodString;
+    email: z.ZodOptional<z.ZodEmail>;
+    orgName: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+export type PosthogIntegration = z.infer<typeof PosthogIntegrationSchema>;
+export declare const LaunchDarklyIntegrationSchema: z.ZodObject<{
+    id: z.ZodString;
+    email: z.ZodOptional<z.ZodEmail>;
+    tokenName: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+export type LaunchDarklyIntegration = z.infer<typeof LaunchDarklyIntegrationSchema>;
+export declare const DatadogIntegrationSchema: z.ZodObject<{
+    id: z.ZodString;
+    region: z.ZodString;
+}, z.core.$strip>;
+export type DatadogIntegration = z.infer<typeof DatadogIntegrationSchema>;
+export declare const WorkOSIntegrationSchema: z.ZodObject<{
+    id: z.ZodString;
+    webhookUrl: z.ZodString;
+    environment: z.ZodEnum<{
+        live: "live";
+        test: "test";
+    }>;
+}, z.core.$strip>;
+export type WorkOSIntegration = z.infer<typeof WorkOSIntegrationSchema>;
+export declare const AttioIntegrationSchema: z.ZodObject<{
+    id: z.ZodString;
+    workspaceName: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+export type AttioIntegration = z.infer<typeof AttioIntegrationSchema>;
+export declare const SnowflakeIntegrationSchema: z.ZodObject<{
+    id: z.ZodString;
+    accountIdentifier: z.ZodString;
+    username: z.ZodString;
+    warehouse: z.ZodString;
+    databaseName: z.ZodOptional<z.ZodString>;
+    schemaName: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+export type SnowflakeIntegration = z.infer<typeof SnowflakeIntegrationSchema>;
+export declare const IntegrationWithStatusSchema: z.ZodObject<{
+    integrationType: z.ZodEnum<typeof IntegrationType>;
+    isActive: z.ZodBoolean;
+}, z.core.$strip>;
+export type IntegrationWithStatus = z.infer<typeof IntegrationWithStatusSchema>;
+export {};

package/dist/Integrations.js

@@ -0,0 +1,210 @@
+import * as z from "zod";
+// IMPORTANT: CHANGE THIS FOR NEW INTEGRATIONS. SHOULD MATCH PRISMA ENUM
+export var IntegrationType;
+(function (IntegrationType) {
+    IntegrationType["GITHUB"] = "github";
+    IntegrationType["GMAIL"] = "gmail";
+    IntegrationType["LINEAR"] = "linear";
+    IntegrationType["ATLASSIAN"] = "atlassian";
+    IntegrationType["SLACK"] = "slack";
+    IntegrationType["NOTION"] = "notion";
+    IntegrationType["FIGMA"] = "figma";
+    IntegrationType["TERSE"] = "terse";
+    IntegrationType["POSTHOG"] = "posthog";
+    IntegrationType["DATADOG"] = "datadog";
+    IntegrationType["CRON_JOB"] = "cron_job";
+    IntegrationType["LAUNCHDARKLY"] = "launchdarkly";
+    IntegrationType["WORKOS"] = "workos";
+    IntegrationType["ATTIO"] = "attio";
+    IntegrationType["SNOWFLAKE"] = "snowflake";
+})(IntegrationType || (IntegrationType = {}));
+export const integrationTypeEnum = z.enum(IntegrationType);
+// Metadata objects - using const objects instead of classes
+export const GmailIntegrationMetadata = {
+    type: IntegrationType.GMAIL,
+    name: "Gmail",
+    description: "Monitor incoming emails",
+    isInput: true,
+    isOutput: false
+};
+export const NotionIntegrationMetadata = {
+    type: IntegrationType.NOTION,
+    name: "Notion",
+    description: "Update living documents",
+    isInput: false,
+    isOutput: true
+};
+export const LinearIntegrationMetadata = {
+    type: IntegrationType.LINEAR,
+    name: "Linear",
+    description: "Update tasks in Linear",
+    isInput: false,
+    isOutput: true
+};
+export const SlackIntegrationMetadata = {
+    type: IntegrationType.SLACK,
+    name: "Slack",
+    description: "Send and receive messages in Slack (channels, group DMs, and DMs). Triggers can use user token to read your DMs; skills can send to channels or users with either token.",
+    isInput: true,
+    isOutput: true
+};
+export const FigmaIntegrationMetadata = {
+    type: IntegrationType.FIGMA,
+    name: "Figma",
+    description: "Trigger on Figma file comments (does not support file edits or design changes)",
+    isInput: true,
+    isOutput: false
+};
+export const AtlassianIntegrationMetadata = {
+    type: IntegrationType.ATLASSIAN,
+    name: "Atlassian",
+    description: "Update documents in Atlassian",
+    isInput: true,
+    isOutput: false
+};
+export const GithubIntegrationMetadata = {
+    type: IntegrationType.GITHUB,
+    name: "Github",
+    description: "Update repositories in Github",
+    isInput: true,
+    isOutput: true
+};
+export const TerseIntegrationMetadata = {
+    type: IntegrationType.TERSE,
+    name: "Terse",
+    description: "Platform tools",
+    isInput: false,
+    isOutput: false
+};
+export const PosthogIntegrationMetadata = {
+    type: IntegrationType.POSTHOG,
+    name: "Posthog",
+    description: "Update events in Posthog",
+    isInput: false,
+    isOutput: true
+};
+export const DatadogIntegrationMetadata = {
+    type: IntegrationType.DATADOG,
+    name: "Datadog",
+    description: "Search logs in Datadog",
+    isInput: false,
+    isOutput: true
+};
+export const CronJobIntegrationMetadata = {
+    type: IntegrationType.CRON_JOB,
+    name: "Scheduled Jobs",
+    description: "System integration for time-based triggers",
+    isInput: true,
+    isOutput: false
+};
+export const LaunchDarklyIntegrationMetadata = {
+    type: IntegrationType.LAUNCHDARKLY,
+    name: "LaunchDarkly",
+    description: "Track feature flags",
+    isInput: false,
+    isOutput: true
+};
+export const WorkOSIntegrationMetadata = {
+    type: IntegrationType.WORKOS,
+    name: "WorkOS",
+    description: "Trigger on user lifecycle events and fetch/search users from your WorkOS account",
+    isInput: true,
+    isOutput: true
+};
+export const AttioIntegrationMetadata = {
+    type: IntegrationType.ATTIO,
+    name: "Attio",
+    description: "Add and update contacts in Attio",
+    isInput: false,
+    isOutput: true
+};
+export const SnowflakeIntegrationMetadata = {
+    type: IntegrationType.SNOWFLAKE,
+    name: "Snowflake",
+    description: "Run read-only queries against Snowflake data warehouses",
+    isInput: false,
+    isOutput: true
+};
+export const INTEGRATION_METADATA = {
+    [IntegrationType.GMAIL]: GmailIntegrationMetadata,
+    [IntegrationType.NOTION]: NotionIntegrationMetadata,
+    [IntegrationType.LINEAR]: LinearIntegrationMetadata,
+    [IntegrationType.ATLASSIAN]: AtlassianIntegrationMetadata,
+    [IntegrationType.SLACK]: SlackIntegrationMetadata,
+    [IntegrationType.GITHUB]: GithubIntegrationMetadata,
+    [IntegrationType.FIGMA]: FigmaIntegrationMetadata,
+    [IntegrationType.TERSE]: TerseIntegrationMetadata,
+    [IntegrationType.POSTHOG]: PosthogIntegrationMetadata,
+    [IntegrationType.DATADOG]: DatadogIntegrationMetadata,
+    [IntegrationType.CRON_JOB]: CronJobIntegrationMetadata,
+    [IntegrationType.LAUNCHDARKLY]: LaunchDarklyIntegrationMetadata,
+    [IntegrationType.WORKOS]: WorkOSIntegrationMetadata,
+    [IntegrationType.ATTIO]: AttioIntegrationMetadata,
+    [IntegrationType.SNOWFLAKE]: SnowflakeIntegrationMetadata
+};
+// MARK: Integration Details
+export const IntegrationInstanceSchema = z.object({
+    id: z.string()
+});
+export const SlackIntegrationSchema = IntegrationInstanceSchema.extend({
+    teamId: z.string().optional(),
+    teamName: z.string().optional(),
+    isBotUser: z.boolean().optional()
+});
+export const GmailIntegrationSchema = IntegrationInstanceSchema.extend({
+    email: z.email(),
+    historyId: z.string().optional(),
+    watchExpiration: z.date().optional()
+});
+export const FigmaIntegrationSchema = IntegrationInstanceSchema.extend({
+    handle: z.string(),
+    figma_user_id: z.string(),
+    token_expiry: z.date()
+});
+export const NotionIntegrationSchema = IntegrationInstanceSchema.extend({
+    workspaceId: z.string().optional(),
+    workspaceName: z.string().optional()
+});
+export const AtlassianIntegrationSchema = IntegrationInstanceSchema.extend({
+    baseUrl: z.url(),
+    email: z.email(),
+    siteName: z.string().optional(),
+    projectKey: z.string().optional(),
+    projectName: z.string().optional()
+});
+export const GithubIntegrationSchema = IntegrationInstanceSchema.extend({
+    installation_id: z.number(),
+    account_name: z.string().optional()
+});
+export const LinearIntegrationSchema = IntegrationInstanceSchema.extend({
+    workspaceName: z.string()
+});
+export const PosthogIntegrationSchema = IntegrationInstanceSchema.extend({
+    email: z.email().optional(),
+    orgName: z.string().optional()
+});
+export const LaunchDarklyIntegrationSchema = IntegrationInstanceSchema.extend({
+    email: z.email().optional(),
+    tokenName: z.string().optional()
+});
+export const DatadogIntegrationSchema = IntegrationInstanceSchema.extend({
+    region: z.string()
+});
+export const WorkOSIntegrationSchema = IntegrationInstanceSchema.extend({
+    webhookUrl: z.string(),
+    environment: z.enum(["live", "test"])
+});
+export const AttioIntegrationSchema = IntegrationInstanceSchema.extend({
+    workspaceName: z.string().optional()
+});
+export const SnowflakeIntegrationSchema = IntegrationInstanceSchema.extend({
+    accountIdentifier: z.string(),
+    username: z.string(),
+    warehouse: z.string(),
+    databaseName: z.string().optional(),
+    schemaName: z.string().optional()
+});
+export const IntegrationWithStatusSchema = z.object({
+    integrationType: integrationTypeEnum,
+    isActive: z.boolean()
+});

package/dist/InvalidationKeys.d.ts

@@ -0,0 +1,52 @@
+import { GetRunHistoryParams } from "./RunHistoryTypes.js";
+import type { StatsInterval } from "./types.js";
+export declare const currentUserKey: () => readonly [string];
+export declare const userOrganizationsKey: () => readonly [string];
+export declare const widgetTokenKey: () => readonly [string];
+export declare const integrationsKey: () => readonly [string];
+export declare const notificationDestinationsKey: () => readonly [string];
+export declare const apiTokensKey: () => readonly [string];
+export declare const notificationSettingsKey: () => readonly [string];
+export declare const sentNotificationsKey: () => readonly [string];
+export declare const pendingApprovalsKey: () => readonly [string];
+export declare const slackChannelsKey: (integrationId: string | null | undefined) => readonly [string, string] | null;
+export declare const slackUsersKey: (integrationId: string | null | undefined) => readonly [string, string] | null;
+export declare const notionResourcesKey: (integrationId: string | null | undefined) => readonly [string, string] | null;
+export declare const posthogIntegrationsKey: () => readonly [string];
+export declare const launchdarklyIntegrationsKey: () => readonly [string];
+export declare const datadogIntegrationsKey: () => readonly [string];
+export declare const githubRepositoriesKey: (installationId: number | null | undefined) => readonly [string, number] | null;
+export declare const confluenceResourcesKey: (integrationId: string | null | undefined) => readonly [string, string] | null;
+export declare const jiraResourcesKey: (integrationId: string | null | undefined) => readonly [string, string] | null;
+export declare const linearTeamsKey: (integrationId: string | null | undefined) => readonly [string, string] | null;
+export declare const gmailIntegrationsKey: () => readonly [string];
+export declare const atlassianIntegrationsKey: () => readonly [string];
+export declare const figmaIntegrationsKey: () => readonly [string];
+export declare const githubIntegrationsKey: () => readonly [string];
+export declare const linearIntegrationsKey: () => readonly [string];
+export declare const notionIntegrationsKey: () => readonly [string];
+export declare const slackIntegrationsKey: () => readonly [string];
+export declare const workosIntegrationsKey: () => readonly [string];
+export declare const attioIntegrationsKey: () => readonly [string];
+export declare const snowflakeIntegrationsKey: () => readonly [string];
+export declare const attioObjectsKey: (integrationId: string | null | undefined) => readonly [string, string] | null;
+export declare const allRunHistoryKey: (params?: GetRunHistoryParams) => readonly [string, string] | readonly [string];
+export declare const runHistoryKey: (agentId: string, params?: GetRunHistoryParams) => readonly [string, string, string] | readonly [string, string];
+export declare const recentAgentsKey: (limit?: number) => readonly [string, number] | readonly [string];
+export declare const statsKey: (timezone: string, interval?: StatsInterval) => readonly [string, string] | readonly [string, string, StatsInterval];
+export type AgentListArgs = {
+    page?: number;
+    limit?: number;
+    isActive?: boolean;
+    search?: string;
+};
+export declare const agentListKey: ({ page, limit, isActive, search }?: AgentListArgs) => readonly [string, AgentListArgs];
+export declare const agentDetailKey: (id: string | null) => readonly [string, {
+    id: string;
+}] | null;
+export declare const agentImprovementsKey: (agentId: string | null) => readonly [string, {
+    agentId: string;
+}] | null;
+export declare const builderChatHistoryKey: (sessionId: string | null | undefined) => readonly [string, string] | null;
+export declare const orgLogoKey: (organizationId: string | null | undefined) => readonly [string, string] | null;
+export declare const userByIdKey: (userId: string | null | undefined) => readonly [string, string] | null;