@beeuni/sdk 0.1.0

package/dist/core/rest/projects-client/connectors.d.ts

@@ -0,0 +1,721 @@
+export interface ConnectorAction {
+    path: string;
+    name: string;
+    description: string;
+    risk: 'read' | 'write' | 'destructive';
+    inputSchema: Record<string, unknown> | null;
+    outputSchema?: Record<string, unknown> | null;
+}
+export interface ConnectorActionRegistry {
+}
+export type ConnectorArgs<S extends string, A extends string> = S extends keyof ConnectorActionRegistry ? A extends keyof ConnectorActionRegistry[S] ? ConnectorActionRegistry[S][A] extends {
+    args: infer T;
+} ? T : Record<string, unknown> : Record<string, unknown> : Record<string, unknown>;
+export type ConnectorResult<S extends string, A extends string> = S extends keyof ConnectorActionRegistry ? A extends keyof ConnectorActionRegistry[S] ? ConnectorActionRegistry[S][A] extends {
+    result: infer T;
+} ? T : unknown : unknown : unknown;
+export interface ConnectorCatalogEntry {
+    slug: string;
+    name: string;
+    provider: string;
+    status: string;
+    actions: ConnectorAction[];
+    accounts?: ConnectorAccount[];
+    default_account?: string | null;
+}
+export interface ConnectorTool {
+    tool: string;
+    connector: string;
+    action: string;
+    risk: ConnectorAction['risk'];
+    description: string;
+    inputSchema: ConnectorAction['inputSchema'];
+    outputSchema?: ConnectorAction['outputSchema'];
+}
+export interface ConnectorCallResult<T = unknown, O = unknown> {
+    ok: boolean;
+    data?: T;
+    output?: O;
+    binding?: string;
+    upstream_status?: number | null;
+    upstream_error?: string;
+    risk?: ConnectorAction['risk'];
+    status?: string;
+    reason?: string;
+    execution_id?: string | null;
+    retryable?: boolean;
+    approval_url?: string | null;
+    approval_summary?: string | null;
+    approval_instructions?: string | null;
+    account?: {
+        connection_id: string;
+        label: string;
+        owner_type: string;
+    };
+}
+export interface ConnectorAttachmentUploadInput {
+    filename: string;
+    contentType: string;
+    contentDisposition?: 'attachment' | 'inline';
+    contentId?: string;
+    connector?: string;
+}
+export interface ConnectorAttachmentUploadResult {
+    attachment_id: string;
+    filename: string;
+    content_type: string;
+    content_disposition: 'attachment' | 'inline';
+    content_id?: string;
+    size: number;
+    expires_at: string;
+    ref?: {
+        $beeuni_attachment: string;
+    };
+}
+export interface GetConnectorCatalogOptions {
+    slug?: string;
+    includeSchemas?: boolean;
+    includeOutputSchemas?: boolean;
+}
+export declare function getConnectorCatalog(projectId?: string, options?: GetConnectorCatalogOptions): Promise<ConnectorCatalogEntry[]>;
+export declare function listConnectorTools(projectId?: string): Promise<ConnectorTool[]>;
+export declare function searchConnectorTools(projectId: string | undefined, query?: string, options?: {
+    limit?: number;
+}): Promise<ConnectorTool[]>;
+export declare function describeConnectorTool(projectId: string | undefined, tool: string): Promise<ConnectorTool | null>;
+export interface ConnectorAccount {
+    connection_id: string;
+    label: string;
+    owner_type: string;
+    is_default: boolean;
+    connected_as?: string | null;
+}
+export interface ConnectorCallOptions {
+    account?: string | null;
+    approvalContext?: string | null;
+    timeoutMs?: number;
+    signal?: AbortSignal;
+}
+export declare function callConnector<T = unknown>(projectId: string | undefined, tool: string, args?: Record<string, unknown>, options?: ConnectorCallOptions): Promise<ConnectorCallResult<T>>;
+export declare function listConnectorAccounts(projectId: string | undefined, slug: string): Promise<ConnectorAccount[]>;
+export declare function uploadConnectorAttachment(projectId: string | undefined, content: Uint8Array | ArrayBuffer | Blob, input: ConnectorAttachmentUploadInput): Promise<ConnectorAttachmentUploadResult>;
+export type ConnectorAuthorizationStrategy = 'project' | 'user';
+export interface AdminConnector {
+    slug: string;
+    name: string;
+    provider: 'composio' | 'pipedream' | 'mcp' | 'openapi' | 'postman' | 'graphql' | 'http' | 'channel' | 'computer';
+    platform?: 'slack' | 'email' | null;
+    iconUrl?: string | null;
+    status: 'active' | 'disabled' | 'needs_auth' | 'error';
+    credentialMode: 'shared';
+    authorizationStrategy: ConnectorAuthorizationStrategy;
+    requestAuthType?: ConnectorRequestAuthType;
+    sensitive: boolean;
+    actions: ConnectorAction[];
+    authSecret: string | null;
+    secretIdentifier?: string | null;
+    credentialSource?: 'none' | 'stored' | 'project_secret' | 'platform';
+    secretSet: boolean;
+    lastError?: string | null;
+}
+export interface ConnectorsResponse {
+    connectors: AdminConnector[];
+}
+export interface ConnectorSyncResult {
+    synced: number;
+    errors: Array<{
+        slug: string;
+        error: string;
+    }>;
+}
+export type DiscoveredAuthScheme = 'none' | 'bearer' | 'basic' | 'api_key' | 'oauth1' | 'oauth2' | 'openid_connect' | 'mutual_tls' | 'digest' | 'hawk' | 'ntlm' | 'aws_v4' | 'edgegrid' | 'asap' | 'unknown';
+export type ConnectorRequestAuthType = 'none' | 'bearer' | 'basic' | 'custom' | 'api_key' | 'oauth1' | 'hmac' | 'aws_sigv4' | 'mtls';
+export interface ExecutableConnectorAuth {
+    type: ConnectorRequestAuthType;
+    in: 'header' | 'query' | 'cookie';
+    name: string | null;
+    prefix: string | null;
+}
+export interface ConnectorAuthCandidate {
+    id: string;
+    source: string;
+    scheme: DiscoveredAuthScheme;
+    label: string;
+    supported: boolean;
+    requestCount: number;
+    totalRequests: number;
+    placement: 'header' | 'query' | 'cookie' | null;
+    parameterName: string | null;
+    prefix: string | null;
+    parameterNames: string[];
+    variables: string[];
+    oauth?: {
+        authorizationUrl?: string;
+        tokenUrl?: string;
+        refreshUrl?: string;
+        openIdConnectUrl?: string;
+        protectedResourceMetadataUrl?: string;
+        scopes: string[];
+    };
+    executable: ExecutableConnectorAuth | null;
+}
+export interface ConnectorAuthDiscovery {
+    status: 'detected' | 'none' | 'ambiguous' | 'unsupported';
+    recommended: ExecutableConnectorAuth | null;
+    candidates: ConnectorAuthCandidate[];
+    warnings: string[];
+    totalRequests: number;
+    title: string | null;
+}
+interface ConnectionFields {
+    connector_alias: string;
+    owner_type: 'project' | 'agent' | 'member' | 'subject' | 'external';
+    owner_id: string | null;
+    label: string;
+    status: 'active' | 'revoked' | 'error';
+    is_default: boolean;
+    metadata: Record<string, unknown>;
+    connected_as?: string | null;
+    shared_with?: ConnectionShare[];
+    usable?: boolean;
+    authorized?: boolean;
+    tunnel_id?: string | null;
+    machine?: {
+        online: boolean;
+        last_heartbeat_at: string | null;
+        hostname?: string;
+        platform?: string;
+        access?: {
+            mode: 'ask' | 'always' | 'off';
+            granted_until: string | null;
+        } | null;
+    } | null;
+}
+export interface ConnectionShare {
+    grant_id: string;
+    principal_type: 'member' | 'group' | 'project' | 'agent';
+    principal_id: string;
+    label: string;
+    expires_at: string | null;
+}
+export interface Connection extends ConnectionFields {
+    connection_id: string;
+}
+export declare function connectionSharedWithEveryone(connection: Connection): boolean;
+export interface ReconcileConnectionInput {
+    connector_alias: string;
+    owner_type: 'project' | 'agent' | 'member' | 'subject' | 'external';
+    owner_id?: string;
+    label: string;
+    metadata?: Record<string, unknown>;
+}
+export interface ReconcileMemberConnectionInput {
+    connector_alias: string;
+    label: string;
+    metadata?: Record<string, unknown>;
+}
+export interface ConnectionConnectInput {
+    success_redirect_uri?: string;
+    error_redirect_uri?: string;
+}
+export interface OAuth2ClientCredentials {
+    type: 'oauth2_client_credentials';
+    token_url: string;
+    client_id: string;
+    token_endpoint_auth_method: 'none' | 'client_secret_post' | 'client_secret_basic' | 'client_secret_jwt' | 'private_key_jwt';
+    client_secret?: string;
+    private_key?: string;
+    certificate_thumbprint?: string;
+    scopes?: string[];
+    resource?: string;
+    audience?: string;
+    token_params?: Record<string, string>;
+}
+export type OAuth2TokenEndpointAuthMethod = 'none' | 'client_secret_basic' | 'client_secret_post' | 'client_secret_jwt' | 'private_key_jwt';
+export interface OAuth2ApplicationInput {
+    discovery_url?: string;
+    authorization_url?: string;
+    token_url?: string;
+    device_authorization_url?: string;
+    revocation_url?: string;
+    client_id: string;
+    token_endpoint_auth_method: OAuth2TokenEndpointAuthMethod;
+    client_secret?: string;
+    private_key?: string;
+    scopes?: string[];
+    resource?: string;
+    audience?: string;
+    authorization_params?: Record<string, string>;
+    token_params?: Record<string, string>;
+    registration_client_uri?: string;
+    registration_access_token?: string;
+    issuer?: string;
+}
+export interface OAuth2ApplicationView extends Omit<OAuth2ApplicationInput, 'client_secret' | 'private_key' | 'registration_access_token'> {
+    has_client_secret: boolean;
+    has_private_key: boolean;
+}
+export interface OAuth2ResourceDiscovery {
+    resource_url: string;
+    requires_authorization: boolean;
+    resource?: string;
+    resource_name?: string;
+    protected_resource_metadata_url?: string;
+    authorization_server?: string;
+    metadata?: Partial<Omit<OAuth2ApplicationView, 'has_client_secret' | 'has_private_key'>>;
+    registration_endpoint?: string;
+    token_endpoint_auth_methods_supported?: string[];
+    code_challenge_methods_supported?: string[];
+    scopes: string[];
+    warnings: string[];
+}
+export interface OAuth2ResourceDiscoveryInput {
+    resource_url?: string;
+}
+export interface OAuth2ClientRegistrationInput {
+    registration_endpoint: string;
+    issuer?: string;
+    client_name?: string;
+    token_endpoint_auth_methods_supported?: string[];
+    discovery_url?: string;
+    authorization_url?: string;
+    token_url?: string;
+    device_authorization_url?: string;
+    revocation_url?: string;
+    scopes?: string[];
+    resource?: string;
+    audience?: string;
+}
+export interface OAuth2AuthorizationStartInput {
+    scopes?: string[];
+    success_redirect_uri?: string;
+    error_redirect_uri?: string;
+}
+export interface OAuth2AuthorizationStartResult {
+    authorization_url: string;
+    expires_at: string;
+}
+export interface OAuth2DeviceAuthorizationStartInput {
+    scopes?: string[];
+}
+export interface OAuth2DeviceAuthorizationStartResult {
+    session_id: string;
+    user_code: string;
+    verification_uri: string;
+    verification_uri_complete?: string;
+    expires_at: string;
+    interval_seconds: number;
+}
+export interface OAuth2ConnectionStatus {
+    status: 'not_configured' | 'ready' | 'pending' | 'active' | 'error' | 'revoked';
+    expires_at?: string | null;
+    scopes?: string[];
+    error_code?: string | null;
+}
+export type ConnectionCredentialInput = {
+    value: string;
+    kind?: 'secret' | 'connection';
+} | {
+    oauth2: OAuth2ClientCredentials;
+};
+export declare function listConnections(projectId: string): Promise<{
+    connections: Connection[];
+}>;
+export interface ConnectionRoster {
+    connection_id: string;
+    connector_alias: string;
+    owner_type: 'project' | 'agent' | 'member' | 'subject' | 'external';
+    owner_id: string | null;
+    status: 'active' | 'revoked' | 'error';
+}
+export declare function listAllConnections(projectId: string): Promise<{
+    connections: ConnectionRoster[];
+}>;
+export declare function reconcileConnection(projectId: string, input: ReconcileConnectionInput): Promise<Connection>;
+export declare function reconcileMemberConnection(projectId: string, input: ReconcileMemberConnectionInput): Promise<Connection>;
+export declare function updateConnectionCredential(projectId: string, connectionId: string, input: ConnectionCredentialInput): Promise<{
+    ok: true;
+}>;
+export declare function ensureProjectConnectorConnection(projectId: string, slug: string): Promise<{
+    connection_id: string;
+}>;
+export declare function putConnectionOAuth2Application(projectId: string, connectionId: string, input: OAuth2ApplicationInput): Promise<{
+    ok: true;
+}>;
+export declare function getConnectionOAuth2Application(projectId: string, connectionId: string): Promise<{
+    application: OAuth2ApplicationView;
+}>;
+export declare function discoverConnectionOAuth2(projectId: string, connectionId: string, input: {
+    discovery_url: string;
+}): Promise<{
+    metadata: Partial<OAuth2ApplicationView>;
+}>;
+export declare function discoverConnectionOAuth2Resource(projectId: string, connectionId: string, input?: OAuth2ResourceDiscoveryInput): Promise<{
+    discovery: OAuth2ResourceDiscovery;
+}>;
+export declare function registerConnectionOAuth2Client(projectId: string, connectionId: string, input: OAuth2ClientRegistrationInput): Promise<{
+    application: OAuth2ApplicationView;
+}>;
+export declare function startConnectionOAuth2Authorization(projectId: string, connectionId: string, input: OAuth2AuthorizationStartInput): Promise<OAuth2AuthorizationStartResult>;
+export declare function startConnectionOAuth2DeviceAuthorization(projectId: string, connectionId: string, input: OAuth2DeviceAuthorizationStartInput): Promise<OAuth2DeviceAuthorizationStartResult>;
+export declare function pollConnectionOAuth2DeviceAuthorization(projectId: string, connectionId: string, sessionId: string): Promise<OAuth2ConnectionStatus>;
+export declare function getConnectionOAuth2Status(projectId: string, connectionId: string): Promise<OAuth2ConnectionStatus>;
+export declare function revokeConnection(projectId: string, connectionId: string): Promise<{
+    ok: true;
+}>;
+export declare function activateConnection(projectId: string, connectionId: string): Promise<{
+    ok: true;
+}>;
+export declare function setDefaultConnection(projectId: string, connectionId: string): Promise<{
+    ok: true;
+}>;
+export declare function renameConnection(projectId: string, connectionId: string, label: string): Promise<Connection>;
+export declare function addComputerToProject(projectId: string, input: {
+    tunnelId: string;
+    share?: ConnectorConnectOwner;
+}): Promise<Connection>;
+export interface ConnectionSharePrincipal {
+    principal_type: 'user' | 'group' | 'project';
+    principal_id: string;
+}
+export declare function shareConnection(projectId: string, connectionId: string, principals?: ConnectionSharePrincipal[]): Promise<Connection>;
+export type ConnectorConnectProvider = 'composio' | 'pipedream';
+export interface ConnectorConnectResult {
+    provider?: ConnectorConnectProvider;
+    app?: string;
+    connectUrl?: string;
+    redirectUrl?: string;
+    token?: string;
+    expiresAt?: string;
+    requestId?: string;
+    sessionId?: string;
+    connectionId?: string;
+    connected?: boolean;
+    isNoAuth?: boolean;
+}
+export interface ConnectorFinalizeResult {
+    provider?: ConnectorConnectProvider;
+    connected: boolean;
+    accountId?: string;
+    connectionId?: string;
+}
+export interface ConnectorConnectStatus {
+    configured: boolean;
+    provider: ConnectorConnectProvider | null;
+    providers?: ConnectorConnectProvider[];
+}
+export declare function pipedreamConnectConnection(projectId: string, connectionId: string, input?: ConnectionConnectInput): Promise<ConnectorConnectResult>;
+export declare function pipedreamFinalizeConnection(projectId: string, connectionId: string): Promise<ConnectorFinalizeResult>;
+export interface ListConnectorsOptions {
+    includeSchemas?: boolean;
+}
+export declare function listConnectors(projectId: string, options?: ListConnectorsOptions): Promise<ConnectorsResponse>;
+export declare function syncConnectors(projectId: string): Promise<ConnectorSyncResult>;
+export declare function setConnectorCredentialMode(projectId: string, slug: string, mode: 'shared'): Promise<{
+    ok: boolean;
+    sync?: ConnectorSyncResult;
+}>;
+export declare function setConnectorAuthorizationStrategy(projectId: string, slug: string, authorizationStrategy: ConnectorAuthorizationStrategy): Promise<{
+    ok: boolean;
+    sync?: ConnectorSyncResult;
+}>;
+export declare function setConnectorSensitive(projectId: string, slug: string, sensitive: boolean): Promise<{
+    ok: boolean;
+    sync?: ConnectorSyncResult;
+}>;
+export type ConnectorPolicyAction = 'always_run' | 'require_approval' | 'block';
+export interface ConnectorPolicyRule {
+    match: string;
+    action: ConnectorPolicyAction;
+}
+export type ConnectorPolicySource = 'project' | 'connector' | 'risk_default' | 'allow_all';
+export interface ConnectorEffectivePolicy {
+    path: string;
+    action: ConnectorPolicyAction;
+    source: ConnectorPolicySource;
+}
+export declare function getConnectorPolicies(projectId: string, slug: string): Promise<{
+    policies: ConnectorPolicyRule[];
+    effective?: ConnectorEffectivePolicy[];
+    project_policies?: ConnectorPolicyRule[];
+    default_mode?: "risk" | "allow_all";
+}>;
+export declare function setConnectorPolicies(projectId: string, slug: string, policies: ConnectorPolicyRule[]): Promise<{
+    ok: boolean;
+    sync?: ConnectorSyncResult;
+}>;
+export declare function getConnectionPolicies(_projectId: string, _connectionId: string): Promise<{
+    policies: ConnectorPolicyRule[];
+}>;
+export declare function setConnectionPolicies(_projectId: string, _connectionId: string, _policies: ConnectorPolicyRule[]): Promise<{
+    ok: boolean;
+}>;
+export interface ConnectorConfig {
+    slug: string;
+    name: string;
+    provider: AdminConnector['provider'];
+    platform: 'slack' | 'email' | null;
+    credentialMode: 'shared';
+    authorizationStrategy: ConnectorAuthorizationStrategy;
+    app: string | null;
+    account: string | null;
+    url: string | null;
+    transport: 'http' | 'sse' | null;
+    endpoint: string | null;
+    baseUrl: string | null;
+    spec: string | null;
+    tunnelIds?: string[];
+    auth: {
+        type: ConnectorRequestAuthType;
+        in: 'header' | 'query' | 'cookie';
+        name: string | null;
+        prefix: string | null;
+    };
+    headers: Record<string, string>;
+}
+export declare function getConnectorConfig(projectId: string, slug: string): Promise<ConnectorConfig>;
+export declare function setConnectorName(projectId: string, slug: string, name: string): Promise<{
+    ok: boolean;
+    sync?: ConnectorSyncResult;
+}>;
+export type ConnectorConnectOwner = 'project' | 'me';
+export interface ConnectorConnectOptions {
+    owner?: ConnectorConnectOwner;
+    successRedirectUri?: string;
+    errorRedirectUri?: string;
+}
+export declare function connectorConnect(projectId: string, slug: string, options?: ConnectorConnectOptions): Promise<ConnectorConnectResult>;
+export declare const pipedreamConnect: typeof connectorConnect;
+export interface SessionConnectRequest {
+    slug: string;
+    app: string;
+    provider: string;
+    connected: boolean;
+}
+export declare function listSessionConnectRequests(projectId: string, sessionId: string): Promise<SessionConnectRequest[]>;
+export interface ConnectorDraftInput {
+    slug: string;
+    name?: string;
+    provider: AdminConnector['provider'];
+    create_only?: boolean;
+    platform?: 'slack' | 'email';
+    app?: string;
+    account?: string;
+    url?: string;
+    transport?: 'http' | 'sse';
+    endpoint?: string;
+    baseUrl?: string;
+    spec?: string;
+    tunnel_ids?: string[];
+    credential?: 'shared';
+    authorization_strategy?: ConnectorAuthorizationStrategy;
+    auth?: {
+        type?: ConnectorRequestAuthType;
+        in?: 'header' | 'query' | 'cookie';
+        name?: string;
+        prefix?: string;
+    };
+    headers?: Record<string, string>;
+}
+export declare function createConnector(projectId: string, draft: ConnectorDraftInput): Promise<{
+    ok: boolean;
+    sync?: ConnectorSyncResult;
+    authDiscovery?: ConnectorAuthDiscovery;
+}>;
+export declare function discoverConnectorAuth(projectId: string, draft: ConnectorDraftInput): Promise<ConnectorAuthDiscovery>;
+export declare function deleteConnector(projectId: string, slug: string): Promise<{
+    ok: boolean;
+}>;
+export interface PipedreamApp {
+    slug: string;
+    name: string;
+    description: string | null;
+    imgSrc: string | null;
+    authType: string | null;
+    categories: string[];
+    hasActions: boolean;
+    hasTriggers: boolean;
+    featuredWeight: number;
+    directId?: string | null;
+}
+export interface PipedreamCategory {
+    key: string;
+    label: string;
+    count: number;
+}
+export interface PipedreamCatalogQuery {
+    q?: string;
+    category?: string;
+    cursor?: string;
+    limit?: number;
+}
+export interface PipedreamCatalogPage {
+    apps: PipedreamApp[];
+    categories: PipedreamCategory[];
+    total?: number;
+    nextCursor?: string;
+    hasMore: boolean;
+    indexReady?: boolean;
+    excludedNoActions?: number;
+}
+export declare function listPipedreamApps(projectId: string, qOrQuery?: string | PipedreamCatalogQuery, cursor?: string): Promise<PipedreamCatalogPage>;
+export interface PipedreamSection {
+    key: string;
+    label: string;
+    total: number;
+    apps: PipedreamApp[];
+}
+export declare function listPipedreamSections(projectId: string, opts?: {
+    perCategory?: number;
+    maxCategories?: number;
+}): Promise<{
+    sections: PipedreamSection[];
+    categories: PipedreamCategory[];
+    indexReady?: boolean;
+}>;
+export interface ConnectToolkit {
+    slug: string;
+    name: string;
+    logo: string | null;
+    description?: string | null;
+    categories?: string[];
+    isNoAuth: boolean;
+    connected: boolean;
+    directId?: string | null;
+}
+export interface ConnectToolkitsPage {
+    provider: 'composio';
+    toolkits: ConnectToolkit[];
+    total?: number;
+    nextCursor?: string;
+    hasMore: boolean;
+}
+export interface ConnectToolkitsQuery {
+    q?: string;
+    category?: string;
+    cursor?: string;
+    limit?: number;
+}
+export declare function listConnectToolkits(projectId: string, query?: ConnectToolkitsQuery): Promise<ConnectToolkitsPage>;
+export interface ConnectSection {
+    key: string;
+    label: string;
+    total: number;
+    toolkits: ConnectToolkit[];
+}
+export interface ConnectCategory {
+    key: string;
+    label: string;
+    count: number;
+}
+export interface ConnectSectionsPage {
+    provider: 'composio';
+    sections: ConnectSection[];
+    categories: ConnectCategory[];
+}
+export declare function listConnectSections(projectId: string, opts?: {
+    perCategory?: number;
+    maxCategories?: number;
+}): Promise<ConnectSectionsPage>;
+export type DiscoverConnectorKind = 'openapi' | 'mcp' | 'graphql' | 'cli';
+export interface DiscoverConnector {
+    id: string;
+    kind: DiscoverConnectorKind;
+    slug: string;
+    name: string;
+    description: string | null;
+    url: string | null;
+    icon: string | null;
+    domain: string;
+    categories: string[];
+    feeds: string[];
+    popularity: number | null;
+}
+export interface DiscoverConnectorTemplate {
+    provider: 'openapi' | 'postman' | 'mcp' | 'graphql';
+    spec?: string;
+    url?: string;
+    transport?: 'http' | 'sse';
+    endpoint?: string;
+    auth?: {
+        type: 'none' | 'bearer' | 'basic' | 'custom';
+        in: 'header' | 'query';
+        name: string | null;
+        prefix: string | null;
+    };
+}
+export interface DiscoverConnectorVariant {
+    id: string;
+    kind: 'openapi' | 'postman' | 'mcp' | 'graphql' | 'http' | 'cli';
+    name: string;
+    url: string | null;
+    docs: string | null;
+    description: string | null;
+    transports: string[];
+    requiresAuth: boolean;
+    command: string | null;
+    connector: DiscoverConnectorTemplate | null;
+}
+export interface DiscoverConnectorsPage {
+    items: DiscoverConnector[];
+    total: number;
+    nextCursor?: string;
+    hasMore: boolean;
+}
+export interface DiscoverConnectorDetail {
+    item: DiscoverConnector;
+    variants: DiscoverConnectorVariant[];
+}
+export type DiscoverIntegrationKind = DiscoverConnectorKind;
+export type DiscoverIntegration = DiscoverConnector;
+export type DiscoverIntegrationTemplate = DiscoverConnectorTemplate;
+export type DiscoverIntegrationVariant = DiscoverConnectorVariant;
+export type DiscoverIntegrationsPage = DiscoverConnectorsPage;
+export type DiscoverIntegrationDetail = DiscoverConnectorDetail;
+export interface DiscoverConnectorsQuery {
+    q?: string;
+    cursor?: string;
+    category?: string;
+    limit?: number;
+}
+export declare function listDiscoverConnectors(projectId: string, qOrQuery?: string | DiscoverConnectorsQuery, cursor?: string): Promise<DiscoverConnectorsPage>;
+export interface DiscoverSection {
+    key: string;
+    label: string;
+    total: number;
+    items: DiscoverConnector[];
+}
+export interface DiscoverCategory {
+    key: string;
+    label: string;
+    count: number;
+}
+export interface DiscoverSectionsPage {
+    popular: DiscoverConnector[];
+    sections: DiscoverSection[];
+    categories: DiscoverCategory[];
+}
+export declare function listDiscoverSections(projectId: string, opts?: {
+    perCategory?: number;
+    maxCategories?: number;
+}): Promise<DiscoverSectionsPage>;
+export declare function getDiscoverConnector(projectId: string, id: string): Promise<DiscoverConnectorDetail>;
+export declare const listDiscoverIntegrations: typeof listDiscoverConnectors;
+export declare const getDiscoverIntegration: typeof getDiscoverConnector;
+export declare function getConnectStatus(): Promise<ConnectorConnectStatus>;
+export declare function setConnectorCredential(projectId: string, slug: string, credential: string | ConnectionCredentialInput): Promise<{
+    ok: boolean;
+}>;
+export declare function deleteConnectorCredential(projectId: string, slug: string): Promise<{
+    ok: boolean;
+}>;
+export declare function setConnectorSecretBinding(projectId: string, slug: string, secretIdentifier: string | null): Promise<{
+    ok: boolean;
+}>;
+export interface ConnectorFinalizeOptions {
+    owner?: ConnectorConnectOwner;
+    connectionId?: string;
+}
+export declare function connectorFinalize(projectId: string, slug: string, options?: ConnectorFinalizeOptions): Promise<ConnectorFinalizeResult>;
+export declare const pipedreamFinalize: typeof connectorFinalize;
+export {};