terse-types 0.0.1

package/dist/Configs.d.ts

@@ -0,0 +1,628 @@
+import * as z from "zod";
+import { IntegrationType } from "./Integrations.js";
+export declare enum ConfigType {
+    GMAIL = "gmail",
+    GMAIL_OUTPUT = "gmail_output",
+    GMAIL_DRAFT_OUTPUT = "gmail_draft_output",
+    FIGMA = "figma",
+    SLACK = "slack",
+    SLACK_OUTPUT = "slack_output",
+    NOTION = "notion",
+    LINEAR_INPUT = "linear_input",
+    LINEAR_OUTPUT = "linear_output",
+    GITHUB = "github",
+    JIRA = "jira",
+    CONFLUENCE = "confluence",
+    POSTHOG = "POSTHOG",
+    DATADOG = "DATADOG",
+    TIME_TRIGGER = "time_trigger",
+    LAUNCHDARKLY = "launchdarkly",
+    TERSE = "terse",
+    WORKOS_INPUT = "workos_input",
+    WORKOS_OUTPUT = "workos_output",
+    ATTIO_OUTPUT = "attio_output",
+    SNOWFLAKE_OUTPUT = "snowflake_output"
+}
+export declare const configTypeEnum: z.ZodEnum<typeof ConfigType>;
+export interface ConfigDetails {
+    configType: ConfigType;
+    name: string;
+    description: string;
+    integrationType: IntegrationType;
+    isInput: boolean;
+    isOutput: boolean;
+}
+export declare const GmailConfigMetadata: {
+    readonly configType: ConfigType.GMAIL;
+    readonly name: "Gmail";
+    readonly description: "Monitor incoming emails";
+    readonly integrationType: IntegrationType.GMAIL;
+    readonly isInput: true;
+    readonly isOutput: false;
+};
+export declare const FigmaConfigMetadata: {
+    readonly configType: ConfigType.FIGMA;
+    readonly name: "Figma";
+    readonly description: "Monitor design changes in Figma files";
+    readonly integrationType: IntegrationType.FIGMA;
+    readonly isInput: true;
+    readonly isOutput: false;
+};
+export declare const SlackConfigMetadata: {
+    readonly configType: ConfigType.SLACK;
+    readonly name: "Slack";
+    readonly description: "Monitor messages in Slack channels or DMs";
+    readonly integrationType: IntegrationType.SLACK;
+    readonly isInput: true;
+    readonly isOutput: false;
+};
+export declare const SlackOutputConfigMetadata: {
+    readonly configType: ConfigType.SLACK_OUTPUT;
+    readonly name: "Slack";
+    readonly description: "Send messages to Slack channels, group DMs, or direct messages";
+    readonly integrationType: IntegrationType.SLACK;
+    readonly isInput: false;
+    readonly isOutput: true;
+};
+export declare const GmailOutputConfigMetadata: {
+    readonly configType: ConfigType.GMAIL_OUTPUT;
+    readonly name: "Gmail";
+    readonly description: "Send emails via Gmail";
+    readonly integrationType: IntegrationType.GMAIL;
+    readonly isInput: false;
+    readonly isOutput: true;
+};
+export declare const GmailDraftOutputConfigMetadata: {
+    readonly configType: ConfigType.GMAIL_DRAFT_OUTPUT;
+    readonly name: "Gmail Draft";
+    readonly description: "Create draft emails in Gmail";
+    readonly integrationType: IntegrationType.GMAIL;
+    readonly isInput: false;
+    readonly isOutput: true;
+};
+export declare const NotionConfigMetadata: {
+    readonly configType: ConfigType.NOTION;
+    readonly name: "Notion";
+    readonly description: "Update and monitor Notion pages and databases";
+    readonly integrationType: IntegrationType.NOTION;
+    readonly isInput: false;
+    readonly isOutput: true;
+};
+export declare const LinearInputConfigMetadata: {
+    readonly configType: ConfigType.LINEAR_INPUT;
+    readonly name: "Linear";
+    readonly description: "Monitor Linear issues";
+    readonly integrationType: IntegrationType.LINEAR;
+    readonly isInput: true;
+    readonly isOutput: false;
+};
+export declare const LinearOutputConfigMetadata: {
+    readonly configType: ConfigType.LINEAR_OUTPUT;
+    readonly name: "Linear";
+    readonly description: "Update Linear issues";
+    readonly integrationType: IntegrationType.LINEAR;
+    readonly isInput: false;
+    readonly isOutput: true;
+};
+export declare const GitHubConfigMetadata: {
+    readonly configType: ConfigType.GITHUB;
+    readonly name: "GitHub";
+    readonly description: "Monitor and read Github repositories";
+    readonly integrationType: IntegrationType.GITHUB;
+    readonly isInput: true;
+    readonly isOutput: true;
+};
+export declare const JiraConfigMetadata: {
+    readonly configType: ConfigType.JIRA;
+    readonly name: "Jira";
+    readonly description: "Monitor and update Jira issues";
+    readonly integrationType: IntegrationType.ATLASSIAN;
+    readonly isInput: true;
+    readonly isOutput: true;
+};
+export declare const ConfluenceConfigMetadata: {
+    readonly configType: ConfigType.CONFLUENCE;
+    readonly name: "Confluence";
+    readonly description: "Update Confluence pages";
+    readonly integrationType: IntegrationType.ATLASSIAN;
+    readonly isInput: false;
+    readonly isOutput: true;
+};
+export declare const PosthogConfigMetadata: {
+    readonly configType: ConfigType.POSTHOG;
+    readonly name: "Posthog";
+    readonly description: "Track user events";
+    readonly integrationType: IntegrationType.POSTHOG;
+    readonly isInput: false;
+    readonly isOutput: true;
+};
+export declare const DatadogConfigMetadata: {
+    readonly configType: ConfigType.DATADOG;
+    readonly name: "Datadog";
+    readonly description: "Search logs in Datadog";
+    readonly integrationType: IntegrationType.DATADOG;
+    readonly isInput: false;
+    readonly isOutput: true;
+};
+export declare const TimeTriggerConfigMetadata: {
+    readonly configType: ConfigType.TIME_TRIGGER;
+    readonly name: "Time Trigger";
+    readonly description: "Run on a schedule (daily, weekly, etc.)";
+    readonly integrationType: IntegrationType.CRON_JOB;
+    readonly isInput: true;
+    readonly isOutput: false;
+};
+export declare const LaunchDarklyConfigMetadata: {
+    readonly configType: ConfigType.LAUNCHDARKLY;
+    readonly name: "LaunchDarkly";
+    readonly description: "Query feature flags";
+    readonly integrationType: IntegrationType.LAUNCHDARKLY;
+    readonly isInput: false;
+    readonly isOutput: true;
+};
+export declare const TerseConfigMetadata: {
+    readonly configType: ConfigType.TERSE;
+    readonly name: "Terse Skills";
+    readonly description: "Built-in capabilities like web search (always available to agents)";
+    readonly integrationType: IntegrationType.TERSE;
+    readonly isInput: false;
+    readonly isOutput: true;
+};
+export declare const WorkOSInputConfigMetadata: {
+    readonly configType: ConfigType.WORKOS_INPUT;
+    readonly name: "WorkOS";
+    readonly description: "Trigger on user signup, deletion, or membership changes in your app";
+    readonly integrationType: IntegrationType.WORKOS;
+    readonly isInput: true;
+    readonly isOutput: false;
+};
+export declare const WorkOSOutputConfigMetadata: {
+    readonly configType: ConfigType.WORKOS_OUTPUT;
+    readonly name: "WorkOS";
+    readonly description: "Fetch and search users from your WorkOS account";
+    readonly integrationType: IntegrationType.WORKOS;
+    readonly isInput: false;
+    readonly isOutput: true;
+};
+export declare const AttioOutputConfigMetadata: {
+    readonly configType: ConfigType.ATTIO_OUTPUT;
+    readonly name: "Attio";
+    readonly description: "Add and update contacts in Attio";
+    readonly integrationType: IntegrationType.ATTIO;
+    readonly isInput: false;
+    readonly isOutput: true;
+};
+export declare const SnowflakeOutputConfigMetadata: {
+    readonly configType: ConfigType.SNOWFLAKE_OUTPUT;
+    readonly name: "Snowflake";
+    readonly description: "Run read-only queries against Snowflake data warehouses";
+    readonly integrationType: IntegrationType.SNOWFLAKE;
+    readonly isInput: false;
+    readonly isOutput: true;
+};
+export type ConfigDetailsMap = Record<ConfigType, ConfigDetails>;
+export declare const CONFIG_DETAILS: ConfigDetailsMap;
+export declare enum SlackEventType {
+    MESSAGE = "message",
+    APP_MENTION = "app_mention",
+    REACTION_ADDED = "reaction_added"
+}
+export declare enum GitHubEventType {
+    PUSH = "push",
+    PR_OPENED = "pull_request.opened",
+    PR_MERGED = "pull_request.merged",
+    PR_CLOSED = "pull_request.closed",
+    PR_SYNCHRONIZE = "pull_request.synchronize"
+}
+export declare enum LinearEventType {
+    ISSUE_CREATED = "issue.created",
+    ISSUE_UPDATED = "issue.updated",
+    COMMENT_CREATED = "comment.created"
+}
+export declare enum JiraEventType {
+    ISSUE_CREATED = "issue.created",
+    ISSUE_UPDATED = "issue.updated"
+}
+export declare enum FigmaEventType {
+    FILE_COMMENT = "file_comment"
+}
+export declare enum GmailEventType {
+    EMAIL_RECEIVED = "email.received"
+}
+export declare enum WorkOSEventType {
+    USER_CREATED = "user.created",
+    USER_UPDATED = "user.updated",
+    USER_DELETED = "user.deleted",
+    ORGANIZATION_CREATED = "organization.created",
+    ORGANIZATION_MEMBERSHIP_CREATED = "organization_membership.created",
+    ORGANIZATION_MEMBERSHIP_UPDATED = "organization_membership.updated",
+    ORGANIZATION_MEMBERSHIP_DELETED = "organization_membership.deleted",
+    INVITATION_CREATED = "invitation.created",
+    INVITATION_ACCEPTED = "invitation.accepted",
+    INVITATION_RESENT = "invitation.resent",
+    INVITATION_REVOKED = "invitation.revoked"
+}
+export declare const ConfigInstanceSchema: z.ZodObject<{
+    integrationId: z.ZodString;
+    integrationType: z.ZodEnum<typeof IntegrationType>;
+    configType: z.ZodEnum<typeof ConfigType>;
+}, z.core.$strip>;
+export type ConfigInstanceType = z.infer<typeof ConfigInstanceSchema>;
+export type ConfigInstance = ConfigInstanceType & ConfigBehavior;
+export type ConfigBehavior = {
+    isComplete(): boolean;
+    formatForAgent(): string;
+};
+declare abstract class BaseConfigInstance<TIntegrationType extends IntegrationType, TConfigType extends ConfigType, TIntegrationId extends string = string> implements ConfigInstance, ConfigBehavior {
+    readonly integrationId: TIntegrationId;
+    readonly integrationType: TIntegrationType;
+    readonly configType: TConfigType;
+    constructor(integrationId: TIntegrationId, integrationType: TIntegrationType, configType: TConfigType);
+    abstract isComplete(): boolean;
+    abstract formatForAgent(): string;
+}
+export declare const GmailConfigSchema: z.ZodObject<{
+    integrationId: z.ZodString;
+    integrationType: z.ZodLiteral<IntegrationType.GMAIL>;
+    configType: z.ZodLiteral<ConfigType.GMAIL>;
+    eventTypes: z.ZodOptional<z.ZodArray<z.ZodEnum<typeof GmailEventType>>>;
+}, z.core.$strip>;
+export type GmailConfigData = z.infer<typeof GmailConfigSchema>;
+export type GmailConfigInstance = GmailConfigData & ConfigBehavior;
+export declare class GmailConfig extends BaseConfigInstance<IntegrationType.GMAIL, ConfigType.GMAIL> implements GmailConfigInstance {
+    eventTypes?: GmailEventType[] | undefined;
+    constructor(integrationId: string, eventTypes?: GmailEventType[] | undefined);
+    isComplete(): boolean;
+    formatForAgent(): string;
+}
+export declare const FigmaConfigSchema: z.ZodObject<{
+    integrationId: z.ZodString;
+    integrationType: z.ZodLiteral<IntegrationType.FIGMA>;
+    configType: z.ZodLiteral<ConfigType.FIGMA>;
+    fileKey: z.ZodString;
+    fileName: z.ZodString;
+    teamId: z.ZodString;
+    eventTypes: z.ZodOptional<z.ZodArray<z.ZodEnum<typeof FigmaEventType>>>;
+}, z.core.$strip>;
+export type FigmaConfigData = z.infer<typeof FigmaConfigSchema>;
+export type FigmaConfigInstance = FigmaConfigData & ConfigBehavior;
+export declare class FigmaConfig extends BaseConfigInstance<IntegrationType.FIGMA, ConfigType.FIGMA> implements FigmaConfigInstance {
+    fileKey: string;
+    fileName: string;
+    teamId: string;
+    eventTypes?: FigmaEventType[] | undefined;
+    constructor(integrationId: string, fileKey: string, fileName: string, teamId: string, eventTypes?: FigmaEventType[] | undefined);
+    isComplete(): boolean;
+    formatForAgent(): string;
+}
+export declare const SlackConfigSchema: z.ZodObject<{
+    integrationId: z.ZodString;
+    integrationType: z.ZodLiteral<IntegrationType.SLACK>;
+    configType: z.ZodLiteral<ConfigType.SLACK>;
+    channelId: z.ZodOptional<z.ZodString>;
+    channelName: z.ZodOptional<z.ZodString>;
+    listenToUserDms: z.ZodDefault<z.ZodBoolean>;
+    userIds: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    eventTypes: z.ZodOptional<z.ZodArray<z.ZodEnum<typeof SlackEventType>>>;
+}, z.core.$strip>;
+export type SlackConfigData = z.infer<typeof SlackConfigSchema>;
+export type SlackConfigInstance = SlackConfigData & ConfigBehavior;
+export declare class SlackConfig extends BaseConfigInstance<IntegrationType.SLACK, ConfigType.SLACK> implements SlackConfigInstance {
+    channelId?: string | undefined;
+    channelName?: string | undefined;
+    listenToUserDms: boolean;
+    userIds?: string[] | undefined;
+    eventTypes?: SlackEventType[] | undefined;
+    constructor(integrationId: string, channelId?: string | undefined, channelName?: string | undefined, listenToUserDms?: boolean, userIds?: string[] | undefined, eventTypes?: SlackEventType[] | undefined);
+    isComplete(): boolean;
+    formatForAgent(): string;
+}
+export declare const SlackOutputConfigSchema: z.ZodObject<{
+    integrationId: z.ZodString;
+    integrationType: z.ZodLiteral<IntegrationType.SLACK>;
+    configType: z.ZodLiteral<ConfigType.SLACK_OUTPUT>;
+    channelId: z.ZodOptional<z.ZodString>;
+    channelName: z.ZodOptional<z.ZodString>;
+    userIds: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    userNames: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    listenToUserDms: z.ZodDefault<z.ZodBoolean>;
+}, z.core.$strip>;
+export type SlackOutputConfigData = z.infer<typeof SlackOutputConfigSchema>;
+export type SlackOutputConfigInstance = SlackOutputConfigData & ConfigBehavior;
+export declare class SlackOutputConfig extends BaseConfigInstance<IntegrationType.SLACK, ConfigType.SLACK_OUTPUT> implements SlackOutputConfigInstance {
+    channelId?: string | undefined;
+    channelName?: string | undefined;
+    userIds?: string[] | undefined;
+    userNames?: string[] | undefined;
+    listenToUserDms: boolean;
+    constructor(integrationId: string, channelId?: string | undefined, channelName?: string | undefined, userIds?: string[] | undefined, userNames?: string[] | undefined, listenToUserDms?: boolean);
+    isComplete(): boolean;
+    formatForAgent(): string;
+}
+export declare const GmailOutputConfigSchema: z.ZodObject<{
+    integrationId: z.ZodString;
+    integrationType: z.ZodLiteral<IntegrationType.GMAIL>;
+    configType: z.ZodLiteral<ConfigType.GMAIL_OUTPUT>;
+}, z.core.$strip>;
+export type GmailOutputConfigData = z.infer<typeof GmailOutputConfigSchema>;
+export type GmailOutputConfigInstance = GmailOutputConfigData & ConfigBehavior;
+export declare class GmailOutputConfig extends BaseConfigInstance<IntegrationType.GMAIL, ConfigType.GMAIL_OUTPUT> implements GmailOutputConfigInstance {
+    constructor(integrationId: string);
+    isComplete(): boolean;
+    formatForAgent(): string;
+}
+export declare const GmailDraftOutputConfigSchema: z.ZodObject<{
+    integrationId: z.ZodString;
+    integrationType: z.ZodLiteral<IntegrationType.GMAIL>;
+    configType: z.ZodLiteral<ConfigType.GMAIL_DRAFT_OUTPUT>;
+}, z.core.$strip>;
+export type GmailDraftOutputConfigData = z.infer<typeof GmailDraftOutputConfigSchema>;
+export type GmailDraftOutputConfigInstance = GmailDraftOutputConfigData & ConfigBehavior;
+export declare class GmailDraftOutputConfig extends BaseConfigInstance<IntegrationType.GMAIL, ConfigType.GMAIL_DRAFT_OUTPUT> implements GmailDraftOutputConfigInstance {
+    constructor(integrationId: string);
+    isComplete(): boolean;
+    formatForAgent(): string;
+}
+export declare const NotionConfigSchema: z.ZodObject<{
+    integrationId: z.ZodString;
+    integrationType: z.ZodLiteral<IntegrationType.NOTION>;
+    configType: z.ZodLiteral<ConfigType.NOTION>;
+    databaseIds: z.ZodDefault<z.ZodArray<z.ZodString>>;
+    databaseNames: z.ZodDefault<z.ZodArray<z.ZodString>>;
+    pageIds: z.ZodDefault<z.ZodArray<z.ZodString>>;
+    pageNames: z.ZodDefault<z.ZodArray<z.ZodString>>;
+}, z.core.$strip>;
+export type NotionConfigData = z.infer<typeof NotionConfigSchema>;
+export type NotionConfigInstance = NotionConfigData & ConfigBehavior;
+export declare class NotionConfig extends BaseConfigInstance<IntegrationType.NOTION, ConfigType.NOTION> implements NotionConfigInstance {
+    databaseIds: string[];
+    databaseNames: string[];
+    pageIds: string[];
+    pageNames: string[];
+    constructor(integrationId: string, databaseIds?: string[], databaseNames?: string[], pageIds?: string[], pageNames?: string[]);
+    isComplete(): boolean;
+    formatForAgent(): string;
+}
+export declare const LinearInputConfigSchema: z.ZodObject<{
+    integrationId: z.ZodString;
+    integrationType: z.ZodLiteral<IntegrationType.LINEAR>;
+    configType: z.ZodLiteral<ConfigType.LINEAR_INPUT>;
+    projectId: z.ZodOptional<z.ZodString>;
+    projectName: z.ZodOptional<z.ZodString>;
+    eventTypes: z.ZodOptional<z.ZodArray<z.ZodEnum<typeof LinearEventType>>>;
+}, z.core.$strip>;
+export type LinearInputConfigData = z.infer<typeof LinearInputConfigSchema>;
+export type LinearInputConfigInstance = LinearInputConfigData & ConfigBehavior;
+export declare class LinearInputConfig extends BaseConfigInstance<IntegrationType.LINEAR, ConfigType.LINEAR_INPUT> implements LinearInputConfigInstance {
+    projectId?: string | undefined;
+    projectName?: string | undefined;
+    eventTypes?: LinearEventType[] | undefined;
+    constructor(integrationId: string, projectId?: string | undefined, projectName?: string | undefined, eventTypes?: LinearEventType[] | undefined);
+    isComplete(): boolean;
+    formatForAgent(): string;
+}
+export declare const LinearOutputConfigSchema: z.ZodObject<{
+    integrationId: z.ZodString;
+    integrationType: z.ZodLiteral<IntegrationType.LINEAR>;
+    configType: z.ZodLiteral<ConfigType.LINEAR_OUTPUT>;
+    teamId: z.ZodOptional<z.ZodString>;
+    teamName: z.ZodOptional<z.ZodString>;
+    projectId: z.ZodOptional<z.ZodString>;
+    projectName: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+export type LinearOutputConfigData = z.infer<typeof LinearOutputConfigSchema>;
+export type LinearOutputConfigInstance = LinearOutputConfigData & ConfigBehavior;
+export declare class LinearOutputConfig extends BaseConfigInstance<IntegrationType.LINEAR, ConfigType.LINEAR_OUTPUT> implements LinearOutputConfigInstance {
+    teamId?: string | undefined;
+    teamName?: string | undefined;
+    projectId?: string | undefined;
+    projectName?: string | undefined;
+    constructor(integrationId: string, teamId?: string | undefined, teamName?: string | undefined, projectId?: string | undefined, projectName?: string | undefined);
+    isComplete(): boolean;
+    formatForAgent(): string;
+}
+export declare const GitHubConfigSchema: z.ZodObject<{
+    integrationId: z.ZodString;
+    integrationType: z.ZodLiteral<IntegrationType.GITHUB>;
+    configType: z.ZodLiteral<ConfigType.GITHUB>;
+    repositoryIds: z.ZodArray<z.ZodNumber>;
+    eventTypes: z.ZodOptional<z.ZodArray<z.ZodEnum<typeof GitHubEventType>>>;
+}, z.core.$strip>;
+export type GitHubConfigData = z.infer<typeof GitHubConfigSchema>;
+export type GitHubConfigInstance = GitHubConfigData & ConfigBehavior;
+export declare class GitHubConfig extends BaseConfigInstance<IntegrationType.GITHUB, ConfigType.GITHUB> implements GitHubConfigInstance {
+    repositoryIds: number[];
+    eventTypes?: GitHubEventType[] | undefined;
+    constructor(integrationId: string, repositoryIds: number[], eventTypes?: GitHubEventType[] | undefined);
+    isComplete(): boolean;
+    formatForAgent(): string;
+}
+export declare const JiraConfigSchema: z.ZodObject<{
+    integrationId: z.ZodString;
+    integrationType: z.ZodLiteral<IntegrationType.ATLASSIAN>;
+    configType: z.ZodLiteral<ConfigType.JIRA>;
+    projectKey: z.ZodOptional<z.ZodString>;
+    projectId: z.ZodOptional<z.ZodString>;
+    eventTypes: z.ZodOptional<z.ZodArray<z.ZodEnum<typeof JiraEventType>>>;
+}, z.core.$strip>;
+export type JiraConfigData = z.infer<typeof JiraConfigSchema>;
+export type JiraConfigInstance = JiraConfigData & ConfigBehavior;
+export declare class JiraConfig extends BaseConfigInstance<IntegrationType.ATLASSIAN, ConfigType.JIRA> implements JiraConfigInstance {
+    projectKey?: string | undefined;
+    projectId?: string | undefined;
+    eventTypes?: JiraEventType[] | undefined;
+    constructor(integrationId: string, projectKey?: string | undefined, projectId?: string | undefined, eventTypes?: JiraEventType[] | undefined);
+    isComplete(): boolean;
+    formatForAgent(): string;
+}
+export declare const ConfluenceConfigSchema: z.ZodObject<{
+    integrationId: z.ZodString;
+    integrationType: z.ZodLiteral<IntegrationType.ATLASSIAN>;
+    configType: z.ZodLiteral<ConfigType.CONFLUENCE>;
+    spaceName: z.ZodString;
+    spaceId: z.ZodString;
+    pageId: z.ZodString;
+    pageName: z.ZodString;
+}, z.core.$strip>;
+export type ConfluenceConfigData = z.infer<typeof ConfluenceConfigSchema>;
+export type ConfluenceConfigInstance = ConfluenceConfigData & ConfigBehavior;
+export declare class ConfluenceConfig extends BaseConfigInstance<IntegrationType.ATLASSIAN, ConfigType.CONFLUENCE> implements ConfluenceConfigInstance {
+    spaceName: string;
+    spaceId: string;
+    pageId: string;
+    pageName: string;
+    constructor(integrationId: string, spaceName: string, spaceId: string, pageId: string, // Page ID (required for outputs - specific page to write to)
+    pageName: string);
+    isComplete(): boolean;
+    formatForAgent(): string;
+}
+export declare const PosthogConfigSchema: z.ZodObject<{
+    integrationId: z.ZodString;
+    integrationType: z.ZodLiteral<IntegrationType.POSTHOG>;
+    configType: z.ZodLiteral<ConfigType.POSTHOG>;
+    projectId: z.ZodString;
+    projectName: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+export type PosthogConfigData = z.infer<typeof PosthogConfigSchema>;
+export type PosthogConfigInstance = PosthogConfigData & ConfigBehavior;
+export declare class PosthogConfig extends BaseConfigInstance<IntegrationType.POSTHOG, ConfigType.POSTHOG> implements PosthogConfigInstance {
+    projectId: string;
+    projectName?: string | undefined;
+    constructor(integrationId: string, projectId: string, projectName?: string | undefined);
+    isComplete(): boolean;
+    formatForAgent(): string;
+}
+export declare const DatadogConfigSchema: z.ZodObject<{
+    integrationId: z.ZodString;
+    integrationType: z.ZodLiteral<IntegrationType.DATADOG>;
+    configType: z.ZodLiteral<ConfigType.DATADOG>;
+    defaultIndexes: z.ZodDefault<z.ZodArray<z.ZodString>>;
+}, z.core.$strip>;
+export type DatadogConfigData = z.infer<typeof DatadogConfigSchema>;
+export type DatadogConfigInstance = DatadogConfigData & ConfigBehavior;
+export declare class DatadogConfig extends BaseConfigInstance<IntegrationType.DATADOG, ConfigType.DATADOG> implements DatadogConfigInstance {
+    defaultIndexes: string[];
+    constructor(integrationId: string, defaultIndexes?: string[]);
+    isComplete(): boolean;
+    formatForAgent(): string;
+}
+export declare const TimeTriggerConfigSchema: z.ZodObject<{
+    integrationId: z.ZodLiteral<"system">;
+    integrationType: z.ZodLiteral<IntegrationType.CRON_JOB>;
+    configType: z.ZodLiteral<ConfigType.TIME_TRIGGER>;
+    cronExpression: z.ZodString;
+}, z.core.$strip>;
+export type TimeTriggerConfigData = z.infer<typeof TimeTriggerConfigSchema>;
+export type TimeTriggerConfigInstance = TimeTriggerConfigData & ConfigBehavior;
+export declare class TimeTriggerConfig extends BaseConfigInstance<IntegrationType.CRON_JOB, ConfigType.TIME_TRIGGER, "system"> implements TimeTriggerConfigInstance {
+    cronExpression: string;
+    constructor(cronExpression: string);
+    isComplete(): boolean;
+    formatForAgent(): string;
+}
+export declare const LaunchDarklyConfigSchema: z.ZodObject<{
+    integrationId: z.ZodString;
+    integrationType: z.ZodLiteral<IntegrationType.LAUNCHDARKLY>;
+    configType: z.ZodLiteral<ConfigType.LAUNCHDARKLY>;
+    projectKey: z.ZodString;
+    environmentKeys: z.ZodArray<z.ZodString>;
+}, z.core.$strip>;
+export type LaunchDarklyConfigData = z.infer<typeof LaunchDarklyConfigSchema>;
+export type LaunchDarklyConfigInstance = LaunchDarklyConfigData & ConfigBehavior;
+export declare class LaunchDarklyConfig extends BaseConfigInstance<IntegrationType.LAUNCHDARKLY, ConfigType.LAUNCHDARKLY> implements LaunchDarklyConfigInstance {
+    projectKey: string;
+    environmentKeys: string[];
+    constructor(integrationId: string, projectKey: string, environmentKeys: string[]);
+    isComplete(): boolean;
+    formatForAgent(): string;
+}
+export declare const TerseConfigSchema: z.ZodObject<{
+    integrationId: z.ZodLiteral<"system">;
+    integrationType: z.ZodLiteral<IntegrationType.TERSE>;
+    configType: z.ZodLiteral<ConfigType.TERSE>;
+}, z.core.$strip>;
+export type TerseConfigData = z.infer<typeof TerseConfigSchema>;
+export type TerseConfigInstance = TerseConfigData & ConfigBehavior;
+export declare class TerseConfig extends BaseConfigInstance<IntegrationType.TERSE, ConfigType.TERSE, "system"> implements TerseConfigInstance {
+    constructor();
+    isComplete(): boolean;
+    formatForAgent(): string;
+}
+export declare const WorkOSInputConfigSchema: z.ZodObject<{
+    integrationId: z.ZodString;
+    integrationType: z.ZodLiteral<IntegrationType.WORKOS>;
+    configType: z.ZodLiteral<ConfigType.WORKOS_INPUT>;
+    eventTypes: z.ZodDefault<z.ZodArray<z.ZodEnum<typeof WorkOSEventType>>>;
+}, z.core.$strip>;
+export type WorkOSInputConfigData = z.infer<typeof WorkOSInputConfigSchema>;
+export type WorkOSInputConfigInstance = WorkOSInputConfigData & ConfigBehavior;
+export declare class WorkOSInputConfig extends BaseConfigInstance<IntegrationType.WORKOS, ConfigType.WORKOS_INPUT> implements WorkOSInputConfigInstance {
+    eventTypes: WorkOSEventType[];
+    constructor(integrationId: string, eventTypes?: WorkOSEventType[]);
+    isComplete(): boolean;
+    formatForAgent(): string;
+}
+export declare const WorkOSOutputConfigSchema: z.ZodObject<{
+    integrationId: z.ZodString;
+    integrationType: z.ZodLiteral<IntegrationType.WORKOS>;
+    configType: z.ZodLiteral<ConfigType.WORKOS_OUTPUT>;
+}, z.core.$strip>;
+export type WorkOSOutputConfigData = z.infer<typeof WorkOSOutputConfigSchema>;
+export type WorkOSOutputConfigInstance = WorkOSOutputConfigData & ConfigBehavior;
+export declare class WorkOSOutputConfig extends BaseConfigInstance<IntegrationType.WORKOS, ConfigType.WORKOS_OUTPUT> implements WorkOSOutputConfigInstance {
+    constructor(integrationId: string);
+    isComplete(): boolean;
+    formatForAgent(): string;
+}
+export declare const AttioOutputConfigSchema: z.ZodObject<{
+    integrationId: z.ZodString;
+    integrationType: z.ZodLiteral<IntegrationType.ATTIO>;
+    configType: z.ZodLiteral<ConfigType.ATTIO_OUTPUT>;
+    objectSlug: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+export type AttioOutputConfigData = z.infer<typeof AttioOutputConfigSchema>;
+export type AttioOutputConfigInstance = AttioOutputConfigData & ConfigBehavior;
+export declare class AttioOutputConfig extends BaseConfigInstance<IntegrationType.ATTIO, ConfigType.ATTIO_OUTPUT> implements AttioOutputConfigInstance {
+    objectSlug?: string | undefined;
+    constructor(integrationId: string, objectSlug?: string | undefined);
+    isComplete(): boolean;
+    formatForAgent(): string;
+}
+export declare const SnowflakeOutputConfigSchema: z.ZodObject<{
+    integrationId: z.ZodString;
+    integrationType: z.ZodLiteral<IntegrationType.SNOWFLAKE>;
+    configType: z.ZodLiteral<ConfigType.SNOWFLAKE_OUTPUT>;
+}, z.core.$strip>;
+export type SnowflakeOutputConfigData = z.infer<typeof SnowflakeOutputConfigSchema>;
+export type SnowflakeOutputConfigInstance = SnowflakeOutputConfigData & ConfigBehavior;
+export declare class SnowflakeOutputConfig extends BaseConfigInstance<IntegrationType.SNOWFLAKE, ConfigType.SNOWFLAKE_OUTPUT> implements SnowflakeOutputConfigInstance {
+    constructor(integrationId: string);
+    isComplete(): boolean;
+    formatForAgent(): string;
+}
+type EnsureExhaustiveMetadata<T extends Record<ConfigType, new (...args: any[]) => ConfigInstance>> = T;
+export type ConfigMetadataMap = EnsureExhaustiveMetadata<{
+    [ConfigType.GMAIL]: typeof GmailConfig;
+    [ConfigType.FIGMA]: typeof FigmaConfig;
+    [ConfigType.SLACK]: typeof SlackConfig;
+    [ConfigType.SLACK_OUTPUT]: typeof SlackOutputConfig;
+    [ConfigType.GMAIL_OUTPUT]: typeof GmailOutputConfig;
+    [ConfigType.GMAIL_DRAFT_OUTPUT]: typeof GmailDraftOutputConfig;
+    [ConfigType.NOTION]: typeof NotionConfig;
+    [ConfigType.LINEAR_INPUT]: typeof LinearInputConfig;
+    [ConfigType.LINEAR_OUTPUT]: typeof LinearOutputConfig;
+    [ConfigType.GITHUB]: typeof GitHubConfig;
+    [ConfigType.JIRA]: typeof JiraConfig;
+    [ConfigType.CONFLUENCE]: typeof ConfluenceConfig;
+    [ConfigType.POSTHOG]: typeof PosthogConfig;
+    [ConfigType.DATADOG]: typeof DatadogConfig;
+    [ConfigType.TIME_TRIGGER]: typeof TimeTriggerConfig;
+    [ConfigType.LAUNCHDARKLY]: typeof LaunchDarklyConfig;
+    [ConfigType.TERSE]: typeof TerseConfig;
+    [ConfigType.WORKOS_INPUT]: typeof WorkOSInputConfig;
+    [ConfigType.WORKOS_OUTPUT]: typeof WorkOSOutputConfig;
+    [ConfigType.ATTIO_OUTPUT]: typeof AttioOutputConfig;
+    [ConfigType.SNOWFLAKE_OUTPUT]: typeof SnowflakeOutputConfig;
+}>;
+export declare const CONFIG_METADATA: ConfigMetadataMap;
+export {};