@replit/connectors/src/resources/top-level.ts

The official TypeScript library for the Replit API

// File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.

import * as TopLevelAPI from './top-level';
import { OffsetPagination, type OffsetPaginationParams } from '../core/pagination';

export type ListConnectionsResponsesOffsetPagination = OffsetPagination<ListConnectionsResponse>;

export type ListConnectorConfigsResponsesOffsetPagination = OffsetPagination<ListConnectorConfigsResponse>;

export type ListConnectorsResponsesOffsetPagination = OffsetPagination<ListConnectorsResponse>;

export type ListConnnectorConfigsResponsesOffsetPagination = OffsetPagination<ListConnnectorConfigsResponse>;

export type ListCustomersResponsesOffsetPagination = OffsetPagination<ListCustomersResponse>;

export type ListEventsResponsesOffsetPagination = OffsetPagination<ListEventsResponse>;

export interface Connector {
  name: string;

  auth_type?: 'BASIC' | 'OAUTH1' | 'OAUTH2' | 'OAUTH2CC' | 'API_KEY' | 'CUSTOM';

  display_name?: string;

  has_openint_credentials?: boolean;

  logo_url?: string;

  openint_allowed_scopes?: Array<string>;

  openint_default_scopes?: Array<string>;

  platforms?: Array<'web' | 'mobile' | 'desktop' | 'local' | 'cloud'>;

  required_scopes?: Array<string>;

  schemas?: Connector.Schemas;

  scopes?: Array<Connector.Scope>;

  stage?: 'alpha' | 'beta' | 'ga' | 'hidden';

  webhook_registration_input?: unknown;
}

export namespace Connector {
  export interface Schemas {
    connect_input?: unknown;

    connect_output?: unknown;

    connection_settings?: unknown;

    connector_config?: unknown;

    integration_data?: unknown;

    pre_connect_input?: unknown;

    public_connection_settings?: unknown;

    webhook_events?: unknown;

    webhook_registration_input?: unknown;
  }

  export interface Scope {
    scope: string;

    description?: string;

    display_name?: string;
  }
}

export interface Integration {
  id: string;

  connector_name:
    | 'acme-apikey'
    | 'acme-oauth2'
    | 'agentmail'
    | 'apollo'
    | 'asana'
    | 'bigquery'
    | 'bitbucket'
    | 'bitbucket-source-control'
    | 'box'
    | 'calendly'
    | 'clickup'
    | 'confluence'
    | 'custom-mcp'
    | 'databricks'
    | 'databricks-m2m'
    | 'discord'
    | 'dropbox'
    | 'figma'
    | 'github'
    | 'github-source-control'
    | 'gitlab-source-control'
    | 'google-calendar'
    | 'google-docs'
    | 'google-drive'
    | 'google-mail'
    | 'google-sheet'
    | 'google-slides'
    | 'hubspot'
    | 'instagram'
    | 'jira'
    | 'linear'
    | 'monday'
    | 'notion'
    | 'onedrive'
    | 'outlook'
    | 'plaid'
    | 'postgres'
    | 'resend'
    | 'salesforce'
    | 'sendgrid'
    | 'sharepoint'
    | 'slack'
    | 'slack-agent'
    | 'slack-agent-builder'
    | 'slack-deployed-agent'
    | 'snowflake'
    | 'spotify'
    | 'stripe'
    | 'stripe-agent-sandbox'
    | 'todoist'
    | 'twilio'
    | 'workato'
    | 'youtube'
    | 'zendesk'
    | 'zoom';

  created_at: string;

  external: string | number | boolean | { [key: string]: unknown } | Array<unknown> | null;

  name: string;

  standard: string | number | boolean | { [key: string]: unknown } | Array<unknown> | null;

  updated_at: string;

  auth_type?: string | null;

  category?: string | null;

  logo_url?: string | null;

  platforms?: Array<'web' | 'mobile' | 'desktop'> | null;

  stage?: 'alpha' | 'beta' | 'ga' | null;

  version?: string | null;
}

export interface AssignConnectionResponse {
  /**
   * The id of the connection, starts with `conn_`
   */
  id: string;

  assignments?: Array<AssignConnectionResponse.Assignment>;
}

export namespace AssignConnectionResponse {
  export interface Assignment {
    repl_id: string;

    webhook_url?: string;
  }
}

export interface CheckConnectionResponse {
  id: string;

  health_check_result?: { [key: string]: unknown } | null;

  status?: 'healthy' | 'disconnected' | 'error' | 'manual' | 'unknown' | null;

  status_message?: string | null;
}

export type ConnectorRpcResponse = { [key: string]: unknown };

/**
 * The connection details
 */
export type CreateConnectionResponse =
  | CreateConnectionResponse.ConnectorAcmeApikeyDiscriminatedConnectionData
  | CreateConnectionResponse.ConnectorAcmeOauth2DiscriminatedConnectionData
  | CreateConnectionResponse.ConnectorAgentmailDiscriminatedConnectionData
  | CreateConnectionResponse.ConnectorAsanaDiscriminatedConnectionData
  | CreateConnectionResponse.ConnectorBigqueryDiscriminatedConnectionData
  | CreateConnectionResponse.ConnectorBitbucketSourceControlDiscriminatedConnectionData
  | CreateConnectionResponse.ConnectorBitbucketDiscriminatedConnectionData
  | CreateConnectionResponse.ConnectorBoxDiscriminatedConnectionData
  | CreateConnectionResponse.ConnectorCalendlyDiscriminatedConnectionData
  | CreateConnectionResponse.ConnectorClickupDiscriminatedConnectionData
  | CreateConnectionResponse.ConnectorConfluenceDiscriminatedConnectionData
  | CreateConnectionResponse.ConnectorDatabricksDiscriminatedConnectionData
  | CreateConnectionResponse.ConnectorDiscordDiscriminatedConnectionData
  | CreateConnectionResponse.ConnectorDropboxDiscriminatedConnectionData
  | CreateConnectionResponse.ConnectorFigmaDiscriminatedConnectionData
  | CreateConnectionResponse.ConnectorGitHubSourceControlDiscriminatedConnectionData
  | CreateConnectionResponse.ConnectorGitHubDiscriminatedConnectionData
  | CreateConnectionResponse.ConnectorGitlabSourceControlDiscriminatedConnectionData
  | CreateConnectionResponse.ConnectorGoogleCalendarDiscriminatedConnectionData
  | CreateConnectionResponse.ConnectorGoogleDocsDiscriminatedConnectionData
  | CreateConnectionResponse.ConnectorGoogleDriveDiscriminatedConnectionData
  | CreateConnectionResponse.ConnectorGoogleMailDiscriminatedConnectionData
  | CreateConnectionResponse.ConnectorGoogleSheetDiscriminatedConnectionData
  | CreateConnectionResponse.ConnectorGoogleSlidesDiscriminatedConnectionData
  | CreateConnectionResponse.ConnectorHubspotDiscriminatedConnectionData
  | CreateConnectionResponse.ConnectorInstagramDiscriminatedConnectionData
  | CreateConnectionResponse.ConnectorJiraDiscriminatedConnectionData
  | CreateConnectionResponse.ConnectorLinearDiscriminatedConnectionData
  | CreateConnectionResponse.ConnectorMondayDiscriminatedConnectionData
  | CreateConnectionResponse.ConnectorNotionDiscriminatedConnectionData
  | CreateConnectionResponse.ConnectorOnedriveDiscriminatedConnectionData
  | CreateConnectionResponse.ConnectorOutlookDiscriminatedConnectionData
  | CreateConnectionResponse.ConnectorSalesforceDiscriminatedConnectionData
  | CreateConnectionResponse.ConnectorSharepointDiscriminatedConnectionData
  | CreateConnectionResponse.ConnectorSlackDeployedAgentDiscriminatedConnectionData
  | CreateConnectionResponse.ConnectorSlackDiscriminatedConnectionData
  | CreateConnectionResponse.ConnectorSnowflakeDiscriminatedConnectionData
  | CreateConnectionResponse.ConnectorSpotifyDiscriminatedConnectionData
  | CreateConnectionResponse.ConnectorTodoistDiscriminatedConnectionData
  | CreateConnectionResponse.ConnectorYoutubeDiscriminatedConnectionData
  | CreateConnectionResponse.ConnectorZendeskDiscriminatedConnectionData
  | CreateConnectionResponse.ConnectorZoomDiscriminatedConnectionData
  | CreateConnectionResponse.ConnectorApolloDiscriminatedConnectionData
  | CreateConnectionResponse.ConnectorCustomMcpDiscriminatedConnectionData
  | CreateConnectionResponse.ConnectorDatabricksM2mDiscriminatedConnectionData
  | CreateConnectionResponse.ConnectorPlaidDiscriminatedConnectionData
  | CreateConnectionResponse.ConnectorPostgresDiscriminatedConnectionData
  | CreateConnectionResponse.ConnectorResendDiscriminatedConnectionData
  | CreateConnectionResponse.ConnectorSendgridDiscriminatedConnectionData
  | CreateConnectionResponse.ConnectorSlackAgentDiscriminatedConnectionData
  | CreateConnectionResponse.ConnectorSlackAgentBuilderDiscriminatedConnectionData
  | CreateConnectionResponse.ConnectorStripeDiscriminatedConnectionData
  | CreateConnectionResponse.ConnectorStripeAgentSandboxDiscriminatedConnectionData
  | CreateConnectionResponse.ConnectorTwilioDiscriminatedConnectionData
  | CreateConnectionResponse.ConnectorWorkatoDiscriminatedConnectionData;

export namespace CreateConnectionResponse {
  export interface ConnectorAcmeApikeyDiscriminatedConnectionData {
    connector_name: 'acme-apikey';

    id?: string;

    connector?: TopLevelAPI.Connector;

    connector_config_id?: string | null;

    created_at?: string;

    customer_id?: string | null;

    disabled?: boolean | null;

    display_name?: string | null;

    environment?: 'production' | 'development';

    health_check_result?: ConnectorAcmeApikeyDiscriminatedConnectionData.HealthCheckResult | null;

    integration?: TopLevelAPI.Integration;

    integration_id?: string | null;

    /**
     * JSON object can can be used to associate arbitrary metadata to avoid needing a
     * separate 1-1 table just for simple key values in your application. During
     * updates this object will be shallowly merged
     */
    metadata?: { [key: string]: unknown } | null;

    public_settings?: unknown;

    settings?: ConnectorAcmeApikeyDiscriminatedConnectionData.Settings;

    status?: 'healthy' | 'disconnected' | 'error' | 'manual' | 'unknown' | null;

    status_message?: string | null;

    updated_at?: string;

    webhook_config?: string | number | boolean | { [key: string]: unknown } | Array<unknown> | null;

    webhook_configured_at?: string | null;

    webhook_identifier?: string | null;
  }

  export namespace ConnectorAcmeApikeyDiscriminatedConnectionData {
    export interface HealthCheckResult {
      checked_at: string;

      field_validations?: { [key: string]: HealthCheckResult.FieldValidations };
    }

    export namespace HealthCheckResult {
      export interface FieldValidations {
        status: 'valid' | 'invalid';

        error?: string;
      }
    }

    export interface Settings {
      api_key: string;
    }
  }

  export interface ConnectorAcmeOauth2DiscriminatedConnectionData {
    connector_name: 'acme-oauth2';

    id?: string;

    connector?: TopLevelAPI.Connector;

    connector_config_id?: string | null;

    created_at?: string;

    customer_id?: string | null;

    disabled?: boolean | null;

    display_name?: string | null;

    environment?: 'production' | 'development';

    health_check_result?: ConnectorAcmeOauth2DiscriminatedConnectionData.HealthCheckResult | null;

    integration?: TopLevelAPI.Integration;

    integration_id?: string | null;

    /**
     * JSON object can can be used to associate arbitrary metadata to avoid needing a
     * separate 1-1 table just for simple key values in your application. During
     * updates this object will be shallowly merged
     */
    metadata?: { [key: string]: unknown } | null;

    public_settings?: unknown;

    settings?: ConnectorAcmeOauth2DiscriminatedConnectionData.Settings;

    status?: 'healthy' | 'disconnected' | 'error' | 'manual' | 'unknown' | null;

    status_message?: string | null;

    updated_at?: string;

    webhook_config?: string | number | boolean | { [key: string]: unknown } | Array<unknown> | null;

    webhook_configured_at?: string | null;

    webhook_identifier?: string | null;
  }

  export namespace ConnectorAcmeOauth2DiscriminatedConnectionData {
    export interface HealthCheckResult {
      checked_at: string;

      field_validations?: { [key: string]: HealthCheckResult.FieldValidations };
    }

    export namespace HealthCheckResult {
      export interface FieldValidations {
        status: 'valid' | 'invalid';

        error?: string;
      }
    }

    export interface Settings {
      oauth: Settings.OAuth;

      /**
       * Same as oauth.credentials.access_token, but more convenient to access. Optional
       * for backward compatibility until we remove the oauth field
       */
      access_token?: string;
    }

    export namespace Settings {
      export interface OAuth {
        created_at?: string;

        /**
         * Output of the postConnect hook for oauth2 connectors
         */
        credentials?: OAuth.Credentials;

        last_fetched_at?: string;

        metadata?: { [key: string]: unknown } | null;

        updated_at?: string;
      }

      export namespace OAuth {
        /**
         * Output of the postConnect hook for oauth2 connectors
         */
        export interface Credentials {
          access_token: string;

          /**
           * Client ID used for the connection
           */
          client_id?: string;

          expires_at?: string;

          expires_in?: number;

          raw?: { [key: string]: unknown };

          refresh_token?: string;

          scope?: string;

          token_type?: string;
        }
      }
    }
  }

  export interface ConnectorAgentmailDiscriminatedConnectionData {
    connector_name: 'agentmail';

    id?: string;

    connector?: TopLevelAPI.Connector;

    connector_config_id?: string | null;

    created_at?: string;

    customer_id?: string | null;

    disabled?: boolean | null;

    display_name?: string | null;

    environment?: 'production' | 'development';

    health_check_result?: ConnectorAgentmailDiscriminatedConnectionData.HealthCheckResult | null;

    integration?: TopLevelAPI.Integration;

    integration_id?: string | null;

    /**
     * JSON object can can be used to associate arbitrary metadata to avoid needing a
     * separate 1-1 table just for simple key values in your application. During
     * updates this object will be shallowly merged
     */
    metadata?: { [key: string]: unknown } | null;

    public_settings?: unknown;

    settings?: ConnectorAgentmailDiscriminatedConnectionData.Settings;

    status?: 'healthy' | 'disconnected' | 'error' | 'manual' | 'unknown' | null;

    status_message?: string | null;

    updated_at?: string;

    webhook_config?: string | number | boolean | { [key: string]: unknown } | Array<unknown> | null;

    webhook_configured_at?: string | null;

    webhook_identifier?: string | null;
  }

  export namespace ConnectorAgentmailDiscriminatedConnectionData {
    export interface HealthCheckResult {
      checked_at: string;

      field_validations?: { [key: string]: HealthCheckResult.FieldValidations };
    }

    export namespace HealthCheckResult {
      export interface FieldValidations {
        status: 'valid' | 'invalid';

        error?: string;
      }
    }

    export interface Settings {
      api_key: string;
    }
  }

  export interface ConnectorAsanaDiscriminatedConnectionData {
    connector_name: 'asana';

    id?: string;

    connector?: TopLevelAPI.Connector;

    connector_config_id?: string | null;

    created_at?: string;

    customer_id?: string | null;

    disabled?: boolean | null;

    display_name?: string | null;

    environment?: 'production' | 'development';

    health_check_result?: ConnectorAsanaDiscriminatedConnectionData.HealthCheckResult | null;

    integration?: TopLevelAPI.Integration;

    integration_id?: string | null;

    /**
     * JSON object can can be used to associate arbitrary metadata to avoid needing a
     * separate 1-1 table just for simple key values in your application. During
     * updates this object will be shallowly merged
     */
    metadata?: { [key: string]: unknown } | null;

    public_settings?: unknown;

    settings?: ConnectorAsanaDiscriminatedConnectionData.Settings;

    status?: 'healthy' | 'disconnected' | 'error' | 'manual' | 'unknown' | null;

    status_message?: string | null;

    updated_at?: string;

    webhook_config?: string | number | boolean | { [key: string]: unknown } | Array<unknown> | null;

    webhook_configured_at?: string | null;

    webhook_identifier?: string | null;
  }

  export namespace ConnectorAsanaDiscriminatedConnectionData {
    export interface HealthCheckResult {
      checked_at: string;

      field_validations?: { [key: string]: HealthCheckResult.FieldValidations };
    }

    export namespace HealthCheckResult {
      export interface FieldValidations {
        status: 'valid' | 'invalid';

        error?: string;
      }
    }

    export interface Settings {
      oauth: Settings.OAuth;

      /**
       * Same as oauth.credentials.access_token, but more convenient to access. Optional
       * for backward compatibility until we remove the oauth field
       */
      access_token?: string;
    }

    export namespace Settings {
      export interface OAuth {
        created_at?: string;

        /**
         * Output of the postConnect hook for oauth2 connectors
         */
        credentials?: OAuth.Credentials;

        last_fetched_at?: string;

        metadata?: { [key: string]: unknown } | null;

        updated_at?: string;
      }

      export namespace OAuth {
        /**
         * Output of the postConnect hook for oauth2 connectors
         */
        export interface Credentials {
          access_token: string;

          /**
           * Client ID used for the connection
           */
          client_id?: string;

          expires_at?: string;

          expires_in?: number;

          raw?: { [key: string]: unknown };

          refresh_token?: string;

          scope?: string;

          token_type?: string;
        }
      }
    }
  }

  export interface ConnectorBigqueryDiscriminatedConnectionData {
    connector_name: 'bigquery';

    id?: string;

    connector?: TopLevelAPI.Connector;

    connector_config_id?: string | null;

    created_at?: string;

    customer_id?: string | null;

    disabled?: boolean | null;

    display_name?: string | null;

    environment?: 'production' | 'development';

    health_check_result?: ConnectorBigqueryDiscriminatedConnectionData.HealthCheckResult | null;

    integration?: TopLevelAPI.Integration;

    integration_id?: string | null;

    /**
     * JSON object can can be used to associate arbitrary metadata to avoid needing a
     * separate 1-1 table just for simple key values in your application. During
     * updates this object will be shallowly merged
     */
    metadata?: { [key: string]: unknown } | null;

    public_settings?: unknown;

    settings?: ConnectorBigqueryDiscriminatedConnectionData.Settings;

    status?: 'healthy' | 'disconnected' | 'error' | 'manual' | 'unknown' | null;

    status_message?: string | null;

    updated_at?: string;

    webhook_config?: string | number | boolean | { [key: string]: unknown } | Array<unknown> | null;

    webhook_configured_at?: string | null;

    webhook_identifier?: string | null;
  }

  export namespace ConnectorBigqueryDiscriminatedConnectionData {
    export interface HealthCheckResult {
      checked_at: string;

      field_validations?: { [key: string]: HealthCheckResult.FieldValidations };
    }

    export namespace HealthCheckResult {
      export interface FieldValidations {
        status: 'valid' | 'invalid';

        error?: string;
      }
    }

    export interface Settings {
      oauth: Settings.OAuth;

      /**
       * Your Google Cloud Project ID (e.g., my-project-123). This is required to make
       * API calls to BigQuery.
       */
      project_id: string;

      /**
       * Same as oauth.credentials.access_token, but more convenient to access. Optional
       * for backward compatibility until we remove the oauth field
       */
      access_token?: string;
    }

    export namespace Settings {
      export interface OAuth {
        created_at?: string;

        /**
         * Output of the postConnect hook for oauth2 connectors
         */
        credentials?: OAuth.Credentials;

        last_fetched_at?: string;

        metadata?: { [key: string]: unknown } | null;

        updated_at?: string;
      }

      export namespace OAuth {
        /**
         * Output of the postConnect hook for oauth2 connectors
         */
        export interface Credentials {
          access_token: string;

          /**
           * Client ID used for the connection
           */
          client_id?: string;

          expires_at?: string;

          expires_in?: number;

          raw?: { [key: string]: unknown };

          refresh_token?: string;

          scope?: string;

          token_type?: string;
        }
      }
    }
  }

  export interface ConnectorBitbucketSourceControlDiscriminatedConnectionData {
    connector_name: 'bitbucket-source-control';

    id?: string;

    connector?: TopLevelAPI.Connector;

    connector_config_id?: string | null;

    created_at?: string;

    customer_id?: string | null;

    disabled?: boolean | null;

    display_name?: string | null;

    environment?: 'production' | 'development';

    health_check_result?: ConnectorBitbucketSourceControlDiscriminatedConnectionData.HealthCheckResult | null;

    integration?: TopLevelAPI.Integration;

    integration_id?: string | null;

    /**
     * JSON object can can be used to associate arbitrary metadata to avoid needing a
     * separate 1-1 table just for simple key values in your application. During
     * updates this object will be shallowly merged
     */
    metadata?: { [key: string]: unknown } | null;

    public_settings?: unknown;

    settings?: ConnectorBitbucketSourceControlDiscriminatedConnectionData.Settings;

    status?: 'healthy' | 'disconnected' | 'error' | 'manual' | 'unknown' | null;

    status_message?: string | null;

    updated_at?: string;

    webhook_config?: string | number | boolean | { [key: string]: unknown } | Array<unknown> | null;

    webhook_configured_at?: string | null;

    webhook_identifier?: string | null;
  }

  export namespace ConnectorBitbucketSourceControlDiscriminatedConnectionData {
    export interface HealthCheckResult {
      checked_at: string;

      field_validations?: { [key: string]: HealthCheckResult.FieldValidations };
    }

    export namespace HealthCheckResult {
      export interface FieldValidations {
        status: 'valid' | 'invalid';

        error?: string;
      }
    }

    export interface Settings {
      oauth: Settings.OAuth;

      /**
       * Same as oauth.credentials.access_token, but more convenient to access. Optional
       * for backward compatibility until we remove the oauth field
       */
      access_token?: string;
    }

    export namespace Settings {
      export interface OAuth {
        created_at?: string;

        /**
         * Output of the postConnect hook for oauth2 connectors
         */
        credentials?: OAuth.Credentials;

        last_fetched_at?: string;

        metadata?: { [key: string]: unknown } | null;

        updated_at?: string;
      }

      export namespace OAuth {
        /**
         * Output of the postConnect hook for oauth2 connectors
         */
        export interface Credentials {
          access_token: string;

          /**
           * Client ID used for the connection
           */
          client_id?: string;

          expires_at?: string;

          expires_in?: number;

          raw?: { [key: string]: unknown };

          refresh_token?: string;

          scope?: string;

          token_type?: string;
        }
      }
    }
  }

  export interface ConnectorBitbucketDiscriminatedConnectionData {
    connector_name: 'bitbucket';

    id?: string;

    connector?: TopLevelAPI.Connector;

    connector_config_id?: string | null;

    created_at?: string;

    customer_id?: string | null;

    disabled?: boolean | null;

    display_name?: string | null;

    environment?: 'production' | 'development';

    health_check_result?: ConnectorBitbucketDiscriminatedConnectionData.HealthCheckResult | null;

    integration?: TopLevelAPI.Integration;

    integration_id?: string | null;

    /**
     * JSON object can can be used to associate arbitrary metadata to avoid needing a
     * separate 1-1 table just for simple key values in your application. During
     * updates this object will be shallowly merged
     */
    metadata?: { [key: string]: unknown } | null;

    public_settings?: unknown;

    settings?: ConnectorBitbucketDiscriminatedConnectionData.Settings;

    status?: 'healthy' | 'disconnected' | 'error' | 'manual' | 'unknown' | null;

    status_message?: string | null;

    updated_at?: string;

    webhook_config?: string | number | boolean | { [key: string]: unknown } | Array<unknown> | null;

    webhook_configured_at?: string | null;

    webhook_identifier?: string | null;
  }

  export namespace ConnectorBitbucketDiscriminatedConnectionData {
    export interface HealthCheckResult {
      checked_at: string;

      field_validations?: { [key: string]: HealthCheckResult.FieldValidations };
    }

    export namespace HealthCheckResult {
      export interface FieldValidations {
        status: 'valid' | 'invalid';

        error?: string;
      }
    }

    export interface Settings {
      oauth: Settings.OAuth;

      /**
       * Same as oauth.credentials.access_token, but more convenient to access. Optional
       * for backward compatibility until we remove the oauth field
       */
      access_token?: string;
    }

    export namespace Settings {
      export interface OAuth {
        created_at?: string;

        /**
         * Output of the postConnect hook for oauth2 connectors
         */
        credentials?: OAuth.Credentials;

        last_fetched_at?: string;

        metadata?: { [key: string]: unknown } | null;

        updated_at?: string;
      }

      export namespace OAuth {
        /**
         * Output of the postConnect hook for oauth2 connectors
         */
        export interface Credentials {
          access_token: string;

          /**
           * Client ID used for the connection
           */
          client_id?: string;

          expires_at?: string;

          expires_in?: number;

          raw?: { [key: string]: unknown };

          refresh_token?: string;

          scope?: string;

          token_type?: string;
        }
      }
    }
  }

  export interface ConnectorBoxDiscriminatedConnectionData {
    connector_name: 'box';

    id?: string;

    connector?: TopLevelAPI.Connector;

    connector_config_id?: string | null;

    created_at?: string;

    customer_id?: string | null;

    disabled?: boolean | null;

    display_name?: string | null;

    environment?: 'production' | 'development';

    health_check_result?: ConnectorBoxDiscriminatedConnectionData.HealthCheckResult | null;

    integration?: TopLevelAPI.Integration;

    integration_id?: string | null;

    /**
     * JSON object can can be used to associate arbitrary metadata to avoid needing a
     * separate 1-1 table just for simple key values in your application. During
     * updates this object will be shallowly merged
     */
    metadata?: { [key: string]: unknown } | null;

    public_settings?: unknown;

    settings?: ConnectorBoxDiscriminatedConnectionData.Settings;

    status?: 'healthy' | 'disconnected' | 'error' | 'manual' | 'unknown' | null;

    status_message?: string | null;

    updated_at?: string;

    webhook_config?: string | number | boolean | { [key: string]: unknown } | Array<unknown> | null;

    webhook_configured_at?: string | null;

    webhook_identifier?: string | null;
  }

  export namespace ConnectorBoxDiscriminatedConnectionData {
    export interface HealthCheckResult {
      checked_at: string;

      field_validations?: { [key: string]: HealthCheckResult.FieldValidations };
    }

    export namespace HealthCheckResult {
      export interface FieldValidations {
        status: 'valid' | 'invalid';

        error?: string;
      }
    }

    export interface Settings {
      oauth: Settings.OAuth;

      /**
       * Same as oauth.credentials.access_token, but more convenient to access. Optional
       * for backward compatibility until we remove the oauth field
       */
      access_token?: string;
    }

    export namespace Settings {
      export interface OAuth {
        created_at?: string;

        /**
         * Output of the postConnect hook for oauth2 connectors
         */
        credentials?: OAuth.Credentials;

        last_fetched_at?: string;

        metadata?: { [key: string]: unknown } | null;

        updated_at?: string;
      }

      export namespace OAuth {
        /**
         * Output of the postConnect hook for oauth2 connectors
         */
        export interface Credentials {
          access_token: string;

          /**
           * Client ID used for the connection
           */
          client_id?: string;

          expires_at?: string;

          expires_in?: number;

          raw?: { [key: string]: unknown };

          refresh_token?: string;

          scope?: string;

          token_type?: string;
        }
      }
    }
  }

  export interface ConnectorCalendlyDiscriminatedConnectionData {
    connector_name: 'calendly';

    id?: string;

    connector?: TopLevelAPI.Connector;

    connector_config_id?: string | null;

    created_at?: string;

    customer_id?: string | null;

    disabled?: boolean | null;

    display_name?: string | null;

    environment?: 'production' | 'development';

    health_check_result?: ConnectorCalendlyDiscriminatedConnectionData.HealthCheckResult | null;

    integration?: TopLevelAPI.Integration;

    integration_id?: string | null;

    /**
     * JSON object can can be used to associate arbitrary metadata to avoid needing a
     * separate 1-1 table just for simple key values in your application. During
     * updates this object will be shallowly merged
     */
    metadata?: { [key: string]: unknown } | null;

    public_settings?: unknown;

    settings?: ConnectorCalendlyDiscriminatedConnectionData.Settings;

    status?: 'healthy' | 'disconnected' | 'error' | 'manual' | 'unknown' | null;

    status_message?: string | null;

    updated_at?: string;

    webhook_config?: string | number | boolean | { [key: string]: unknown } | Array<unknown> | null;

    webhook_configured_at?: string | null;

    webhook_identifier?: string | null;
  }

  export namespace ConnectorCalendlyDiscriminatedConnectionData {
    export interface HealthCheckResult {
      checked_at: string;

      field_validations?: { [key: string]: HealthCheckResult.FieldValidations };
    }

    export namespace HealthCheckResult {
      export interface FieldValidations {
        status: 'valid' | 'invalid';

        error?: string;
      }
    }

    export interface Settings {
      oauth: Settings.OAuth;

      /**
       * Same as oauth.credentials.access_token, but more convenient to access. Optional
       * for backward compatibility until we remove the oauth field
       */
      access_token?: string;
    }

    export namespace Settings {
      export interface OAuth {
        created_at?: string;

        /**
         * Output of the postConnect hook for oauth2 connectors
         */
        credentials?: OAuth.Credentials;

        last_fetched_at?: string;

        metadata?: { [key: string]: unknown } | null;

        updated_at?: string;
      }

      export namespace OAuth {
        /**
         * Output of the postConnect hook for oauth2 connectors
         */
        export interface Credentials {
          access_token: string;

          /**
           * Client ID used for the connection
           */
          client_id?: string;

          expires_at?: string;

          expires_in?: number;

          raw?: { [key: string]: unknown };

          refresh_token?: string;

          scope?: string;

          token_type?: string;
        }
      }
    }
  }

  export interface ConnectorClickupDiscriminatedConnectionData {
    connector_name: 'clickup';

    id?: string;

    connector?: TopLevelAPI.Connector;

    connector_config_id?: string | null;

    created_at?: string;

    customer_id?: string | null;

    disabled?: boolean | null;

    display_name?: string | null;

    environment?: 'production' | 'development';

    health_check_result?: ConnectorClickupDiscriminatedConnectionData.HealthCheckResult | null;

    integration?: TopLevelAPI.Integration;

    integration_id?: string | null;

    /**
     * JSON object can can be used to associate arbitrary metadata to avoid needing a
     * separate 1-1 table just for simple key values in your application. During
     * updates this object will be shallowly merged
     */
    metadata?: { [key: string]: unknown } | null;

    public_settings?: unknown;

    settings?: ConnectorClickupDiscriminatedConnectionData.Settings;

    status?: 'healthy' | 'disconnected' | 'error' | 'manual' | 'unknown' | null;

    status_message?: string | null;

    updated_at?: string;

    webhook_config?: string | number | boolean | { [key: string]: unknown } | Array<unknown> | null;

    webhook_configured_at?: string | null;

    webhook_identifier?: string | null;
  }

  export namespace ConnectorClickupDiscriminatedConnectionData {
    export interface HealthCheckResult {
      checked_at: string;

      field_validations?: { [key: string]: HealthCheckResult.FieldValidations };
    }

    export namespace HealthCheckResult {
      export interface FieldValidations {
        status: 'valid' | 'invalid';

        error?: string;
      }
    }

    export interface Settings {
      oauth: Settings.OAuth;

      /**
       * Same as oauth.credentials.access_token, but more convenient to access. Optional
       * for backward compatibility until we remove the oauth field
       */
      access_token?: string;
    }

    export namespace Settings {
      export interface OAuth {
        created_at?: string;

        /**
         * Output of the postConnect hook for oauth2 connectors
         */
        credentials?: OAuth.Credentials;

        last_fetched_at?: string;

        metadata?: { [key: string]: unknown } | null;

        updated_at?: string;
      }

      export namespace OAuth {
        /**
         * Output of the postConnect hook for oauth2 connectors
         */
        export interface Credentials {
          access_token: string;

          /**
           * Client ID used for the connection
           */
          client_id?: string;

          expires_at?: string;

          expires_in?: number;

          raw?: { [key: string]: unknown };

          refresh_token?: string;

          scope?: string;

          token_type?: string;
        }
      }
    }
  }

  export interface ConnectorConfluenceDiscriminatedConnectionData {
    connector_name: 'confluence';

    id?: string;

    connector?: TopLevelAPI.Connector;

    connector_config_id?: string | null;

    created_at?: string;

    customer_id?: string | null;

    disabled?: boolean | null;

    display_name?: string | null;

    environment?: 'production' | 'development';

    health_check_result?: ConnectorConfluenceDiscriminatedConnectionData.HealthCheckResult | null;

    integration?: TopLevelAPI.Integration;

    integration_id?: string | null;

    /**
     * JSON object can can be used to associate arbitrary metadata to avoid needing a
     * separate 1-1 table just for simple key values in your application. During
     * updates this object will be shallowly merged
     */
    metadata?: { [key: string]: unknown } | null;

    public_settings?: unknown;

    settings?: ConnectorConfluenceDiscriminatedConnectionData.Settings;

    status?: 'healthy' | 'disconnected' | 'error' | 'manual' | 'unknown' | null;

    status_message?: string | null;

    updated_at?: string;

    webhook_config?: string | number | boolean | { [key: string]: unknown } | Array<unknown> | null;

    webhook_configured_at?: string | null;

    webhook_identifier?: string | null;
  }

  export namespace ConnectorConfluenceDiscriminatedConnectionData {
    export interface HealthCheckResult {
      checked_at: string;

      field_validations?: { [key: string]: HealthCheckResult.FieldValidations };
    }

    export namespace HealthCheckResult {
      export interface FieldValidations {
        status: 'valid' | 'invalid';

        error?: string;
      }
    }

    export interface Settings {
      oauth: Settings.OAuth;

      /**
       * Your Atlassian site URL (e.g., https://your-domain.atlassian.net)
       */
      site_url: string;

      /**
       * Same as oauth.credentials.access_token, but more convenient to access. Optional
       * for backward compatibility until we remove the oauth field
       */
      access_token?: string;
    }

    export namespace Settings {
      export interface OAuth {
        created_at?: string;

        /**
         * Output of the postConnect hook for oauth2 connectors
         */
        credentials?: OAuth.Credentials;

        last_fetched_at?: string;

        metadata?: { [key: string]: unknown } | null;

        updated_at?: string;
      }

      export namespace OAuth {
        /**
         * Output of the postConnect hook for oauth2 connectors
         */
        export interface Credentials {
          access_token: string;

          /**
           * Client ID used for the connection
           */
          client_id?: string;

          expires_at?: string;

          expires_in?: number;

          raw?: { [key: string]: unknown };

          refresh_token?: string;

          scope?: string;

          token_type?: string;
        }
      }
    }
  }

  export interface ConnectorDatabricksDiscriminatedConnectionData {
    connector_name: 'databricks';

    id?: string;

    connector?: TopLevelAPI.Connector;

    connector_config_id?: string | null;

    created_at?: string;

    customer_id?: string | null;

    disabled?: boolean | null;

    display_name?: string | null;

    environment?: 'production' | 'development';

    health_check_result?: ConnectorDatabricksDiscriminatedConnectionData.HealthCheckResult | null;

    integration?: TopLevelAPI.Integration;

    integration_id?: string | null;

    /**
     * JSON object can can be used to associate arbitrary metadata to avoid needing a
     * separate 1-1 table just for simple key values in your application. During
     * updates this object will be shallowly merged
     */
    metadata?: { [key: string]: unknown } | null;

    public_settings?: unknown;

    settings?: ConnectorDatabricksDiscriminatedConnectionData.Settings;

    status?: 'healthy' | 'disconnected' | 'error' | 'manual' | 'unknown' | null;

    status_message?: string | null;

    updated_at?: string;

    webhook_config?: string | number | boolean | { [key: string]: unknown } | Array<unknown> | null;

    webhook_configured_at?: string | null;

    webhook_identifier?: string | null;
  }

  export namespace ConnectorDatabricksDiscriminatedConnectionData {
    export interface HealthCheckResult {
      checked_at: string;

      field_validations?: { [key: string]: HealthCheckResult.FieldValidations };
    }

    export namespace HealthCheckResult {
      export interface FieldValidations {
        status: 'valid' | 'invalid';

        error?: string;
      }
    }

    export interface Settings {
      /**
       * The HTTP path for your SQL warehouse. To find this, go to your SQL warehouse in
       * Databricks and click the "Connection details" button. Copy the HTTP path value.
       */
      http_path: string;

      oauth: Settings.OAuth;

      /**
       * The server hostname for your SQL warehouse. To find this, go to your SQL
       * warehouse in Databricks and click the "Connection details" button. Copy the
       * Server hostname value.
       */
      server_hostname: string;

      /**
       * Same as oauth.credentials.access_token, but more convenient to access. Optional
       * for backward compatibility until we remove the oauth field
       */
      access_token?: string;
    }

    export namespace Settings {
      export interface OAuth {
        created_at?: string;

        /**
         * Output of the postConnect hook for oauth2 connectors
         */
        credentials?: OAuth.Credentials;

        last_fetched_at?: string;

        metadata?: { [key: string]: unknown } | null;

        updated_at?: string;
      }

      export namespace OAuth {
        /**
         * Output of the postConnect hook for oauth2 connectors
         */
        export interface Credentials {
          access_token: string;

          /**
           * Client ID used for the connection
           */
          client_id?: string;

          expires_at?: string;

          expires_in?: number;

          raw?: { [key: string]: unknown };

          refresh_token?: string;

          scope?: string;

          token_type?: string;
        }
      }
    }
  }

  export interface ConnectorDiscordDiscriminatedConnectionData {
    connector_name: 'discord';

    id?: string;

    connector?: TopLevelAPI.Connector;

    connector_config_id?: string | null;

    created_at?: string;

    customer_id?: string | null;

    disabled?: boolean | null;

    display_name?: string | null;

    environment?: 'production' | 'development';

    health_check_result?: ConnectorDiscordDiscriminatedConnectionData.HealthCheckResult | null;

    integration?: TopLevelAPI.Integration;

    integration_id?: string | null;

    /**
     * JSON object can can be used to associate arbitrary metadata to avoid needing a
     * separate 1-1 table just for simple key values in your application. During
     * updates this object will be shallowly merged
     */
    metadata?: { [key: string]: unknown } | null;

    public_settings?: unknown;

    settings?: ConnectorDiscordDiscriminatedConnectionData.Settings;

    status?: 'healthy' | 'disconnected' | 'error' | 'manual' | 'unknown' | null;

    status_message?: string | null;

    updated_at?: string;

    webhook_config?: string | number | boolean | { [key: string]: unknown } | Array<unknown> | null;

    webhook_configured_at?: string | null;

    webhook_identifier?: string | null;
  }

  export namespace ConnectorDiscordDiscriminatedConnectionData {
    export interface HealthCheckResult {
      checked_at: string;

      field_validations?: { [key: string]: HealthCheckResult.FieldValidations };
    }

    export namespace HealthCheckResult {
      export interface FieldValidations {
        status: 'valid' | 'invalid';

        error?: string;
      }
    }

    export interface Settings {
      oauth: Settings.OAuth;

      /**
       * Same as oauth.credentials.access_token, but more convenient to access. Optional
       * for backward compatibility until we remove the oauth field
       */
      access_token?: string;
    }

    export namespace Settings {
      export interface OAuth {
        created_at?: string;

        /**
         * Output of the postConnect hook for oauth2 connectors
         */
        credentials?: OAuth.Credentials;

        last_fetched_at?: string;

        metadata?: { [key: string]: unknown } | null;

        updated_at?: string;
      }

      export namespace OAuth {
        /**
         * Output of the postConnect hook for oauth2 connectors
         */
        export interface Credentials {
          access_token: string;

          /**
           * Client ID used for the connection
           */
          client_id?: string;

          expires_at?: string;

          expires_in?: number;

          raw?: { [key: string]: unknown };

          refresh_token?: string;

          scope?: string;

          token_type?: string;
        }
      }
    }
  }

  export interface ConnectorDropboxDiscriminatedConnectionData {
    connector_name: 'dropbox';

    id?: string;

    connector?: TopLevelAPI.Connector;

    connector_config_id?: string | null;

    created_at?: string;

    customer_id?: string | null;

    disabled?: boolean | null;

    display_name?: string | null;

    environment?: 'production' | 'development';

    health_check_result?: ConnectorDropboxDiscriminatedConnectionData.HealthCheckResult | null;

    integration?: TopLevelAPI.Integration;

    integration_id?: string | null;

    /**
     * JSON object can can be used to associate arbitrary metadata to avoid needing a
     * separate 1-1 table just for simple key values in your application. During
     * updates this object will be shallowly merged
     */
    metadata?: { [key: string]: unknown } | null;

    public_settings?: unknown;

    settings?: ConnectorDropboxDiscriminatedConnectionData.Settings;

    status?: 'healthy' | 'disconnected' | 'error' | 'manual' | 'unknown' | null;

    status_message?: string | null;

    updated_at?: string;

    webhook_config?: string | number | boolean | { [key: string]: unknown } | Array<unknown> | null;

    webhook_configured_at?: string | null;

    webhook_identifier?: string | null;
  }

  export namespace ConnectorDropboxDiscriminatedConnectionData {
    export interface HealthCheckResult {
      checked_at: string;

      field_validations?: { [key: string]: HealthCheckResult.FieldValidations };
    }

    export namespace HealthCheckResult {
      export interface FieldValidations {
        status: 'valid' | 'invalid';

        error?: string;
      }
    }

    export interface Settings {
      oauth: Settings.OAuth;

      /**
       * Same as oauth.credentials.access_token, but more convenient to access. Optional
       * for backward compatibility until we remove the oauth field
       */
      access_token?: string;
    }

    export namespace Settings {
      export interface OAuth {
        created_at?: string;

        /**
         * Output of the postConnect hook for oauth2 connectors
         */
        credentials?: OAuth.Credentials;

        last_fetched_at?: string;

        metadata?: { [key: string]: unknown } | null;

        updated_at?: string;
      }

      export namespace OAuth {
        /**
         * Output of the postConnect hook for oauth2 connectors
         */
        export interface Credentials {
          access_token: string;

          /**
           * Client ID used for the connection
           */
          client_id?: string;

          expires_at?: string;

          expires_in?: number;

          raw?: { [key: string]: unknown };

          refresh_token?: string;

          scope?: string;

          token_type?: string;
        }
      }
    }
  }

  export interface ConnectorFigmaDiscriminatedConnectionData {
    connector_name: 'figma';

    id?: string;

    connector?: TopLevelAPI.Connector;

    connector_config_id?: string | null;

    created_at?: string;

    customer_id?: string | null;

    disabled?: boolean | null;

    display_name?: string | null;

    environment?: 'production' | 'development';

    health_check_result?: ConnectorFigmaDiscriminatedConnectionData.HealthCheckResult | null;

    integration?: TopLevelAPI.Integration;

    integration_id?: string | null;

    /**
     * JSON object can can be used to associate arbitrary metadata to avoid needing a
     * separate 1-1 table just for simple key values in your application. During
     * updates this object will be shallowly merged
     */
    metadata?: { [key: string]: unknown } | null;

    public_settings?: unknown;

    settings?: ConnectorFigmaDiscriminatedConnectionData.Settings;

    status?: 'healthy' | 'disconnected' | 'error' | 'manual' | 'unknown' | null;

    status_message?: string | null;

    updated_at?: string;

    webhook_config?: string | number | boolean | { [key: string]: unknown } | Array<unknown> | null;

    webhook_configured_at?: string | null;

    webhook_identifier?: string | null;
  }

  export namespace ConnectorFigmaDiscriminatedConnectionData {
    export interface HealthCheckResult {
      checked_at: string;

      field_validations?: { [key: string]: HealthCheckResult.FieldValidations };
    }

    export namespace HealthCheckResult {
      export interface FieldValidations {
        status: 'valid' | 'invalid';

        error?: string;
      }
    }

    export interface Settings {
      oauth: Settings.OAuth;

      /**
       * Same as oauth.credentials.access_token, but more convenient to access. Optional
       * for backward compatibility until we remove the oauth field
       */
      access_token?: string;
    }

    export namespace Settings {
      export interface OAuth {
        created_at?: string;

        /**
         * Output of the postConnect hook for oauth2 connectors
         */
        credentials?: OAuth.Credentials;

        last_fetched_at?: string;

        metadata?: { [key: string]: unknown } | null;

        updated_at?: string;
      }

      export namespace OAuth {
        /**
         * Output of the postConnect hook for oauth2 connectors
         */
        export interface Credentials {
          access_token: string;

          /**
           * Client ID used for the connection
           */
          client_id?: string;

          expires_at?: string;

          expires_in?: number;

          raw?: { [key: string]: unknown };

          refresh_token?: string;

          scope?: string;

          token_type?: string;
        }
      }
    }
  }

  export interface ConnectorGitHubSourceControlDiscriminatedConnectionData {
    connector_name: 'github-source-control';

    id?: string;

    connector?: TopLevelAPI.Connector;

    connector_config_id?: string | null;

    created_at?: string;

    customer_id?: string | null;

    disabled?: boolean | null;

    display_name?: string | null;

    environment?: 'production' | 'development';

    health_check_result?: ConnectorGitHubSourceControlDiscriminatedConnectionData.HealthCheckResult | null;

    integration?: TopLevelAPI.Integration;

    integration_id?: string | null;

    /**
     * JSON object can can be used to associate arbitrary metadata to avoid needing a
     * separate 1-1 table just for simple key values in your application. During
     * updates this object will be shallowly merged
     */
    metadata?: { [key: string]: