@squidcloud/backend 1.0.0

package/dist/common/src/application.types.d.ts

@@ -0,0 +1,120 @@
+import { ApplicationBundleData, ServiceFunctionName } from './bundle-data.types';
+import { AppId, IntegrationId } from './communication.types';
+import { CollectionName } from './document.types';
+import { ApiEndpoint, ApiEndpointId, GraphQLConnectionOptions, Integration, IntegrationDataSchema, IntegrationGraphQLSchema, IntegrationType, MongoConnectionSecretOptions, MssqlConnectionSecretOptions, MySqlConnectionSecretOptions, PostgresConnectionSecretOptions } from './integration.types';
+export type WebhookId = string;
+export type QueryName = string;
+export type TriggerId = string;
+export type SchedulerId = string;
+export type CronExpression = string;
+export type OpenIdProviderType = 'auth0';
+export type CodeUrl = string;
+export interface TriggerConfig {
+    integrationId: IntegrationId;
+    collectionName: CollectionName;
+    functionName: ServiceFunctionName;
+}
+export interface SchedulerConfig {
+    functionName: ServiceFunctionName;
+    cronExpression: CronExpression;
+}
+export interface WebhookConfig {
+    functionName: ServiceFunctionName;
+}
+export interface OpenIdProvider {
+    providerType: OpenIdProviderType;
+    clientId: string;
+    domain: string;
+}
+export interface Application {
+    appId: AppId;
+    createdAt: Date;
+    updatedAt: Date;
+    allowedHosts: string[];
+    openIdProvider?: OpenIdProvider;
+    integrations: Record<IntegrationId, Integration>;
+    bundleMetadata?: ApplicationBundleData;
+}
+export interface UpdateOpenIdProviderRequest {
+    openIdProvider: OpenIdProvider;
+}
+export interface CreateApplicationResponse {
+    appId: AppId;
+}
+export type UpsertIntegrationRequest = UpsertMongoDbIntegrationRequest | UpsertMssqlIntegrationRequest | UpsertMySqlIntegrationRequest | UpsertPostgresIntegrationRequest | UpsertCockroachIntegrationRequest | UpsertGraphQLIntegrationRequest | UpsertApiIntegrationRequest;
+interface BaseUpsertIntegrationRequest {
+    id: IntegrationId;
+    type: IntegrationType;
+    secured?: boolean;
+}
+interface BaseUpsertDataIntegrationRequest extends BaseUpsertIntegrationRequest {
+    supportsExternalChanges?: boolean;
+}
+export interface UpsertMongoDbIntegrationRequest extends BaseUpsertDataIntegrationRequest {
+    type: IntegrationType.mongo;
+    schema?: IntegrationDataSchema;
+    configuration: {
+        connectionOptions: {
+            secrets: MongoConnectionSecretOptions;
+            ssl?: {
+                certificateFile: string;
+                validate: boolean;
+            };
+        };
+    };
+}
+export interface UpsertMySqlIntegrationRequest extends BaseUpsertDataIntegrationRequest {
+    type: IntegrationType.mysql;
+    schema?: IntegrationDataSchema;
+    configuration: {
+        connectionOptions: {
+            secrets: MySqlConnectionSecretOptions;
+        };
+    };
+}
+export interface UpsertMssqlIntegrationRequest extends BaseUpsertDataIntegrationRequest {
+    type: IntegrationType.mssql;
+    schema?: IntegrationDataSchema;
+    configuration: {
+        connectionOptions: {
+            secrets: MssqlConnectionSecretOptions;
+        };
+    };
+}
+export interface UpsertPostgresIntegrationRequest extends BaseUpsertDataIntegrationRequest {
+    type: IntegrationType.postgres;
+    schema?: IntegrationDataSchema;
+    configuration: {
+        connectionOptions: {
+            secrets: PostgresConnectionSecretOptions;
+        };
+    };
+}
+export interface UpsertCockroachIntegrationRequest extends BaseUpsertDataIntegrationRequest {
+    type: IntegrationType.cockroach;
+    schema?: IntegrationDataSchema;
+    configuration: {
+        connectionOptions: {
+            secrets: PostgresConnectionSecretOptions;
+        };
+    };
+}
+export interface UpsertGraphQLIntegrationRequest extends BaseUpsertIntegrationRequest {
+    type: IntegrationType.graphql;
+    schema?: IntegrationGraphQLSchema;
+    configuration: {
+        connectionOptions: GraphQLConnectionOptions;
+    };
+}
+export interface UpsertApiIntegrationRequest extends BaseUpsertIntegrationRequest {
+    type: IntegrationType.api;
+    baseUrl: string;
+    endpoints: Record<ApiEndpointId, ApiEndpoint>;
+}
+export interface DeleteIntegrationRequest {
+    integrationId: IntegrationId;
+}
+export interface UpdateAllowedHostsRequest {
+    allowedHosts: string[];
+}
+export {};

package/dist/common/src/backend-function.schemas.d.ts

@@ -0,0 +1,3 @@
+import { JSONSchemaType } from 'ajv';
+import { ExecuteBackendFunctionRequest } from './backend-function.types';
+export declare const ExecuteBackendFunctionRequestSchema: JSONSchemaType<ExecuteBackendFunctionRequest>;

package/dist/common/src/backend-function.types.d.ts

@@ -0,0 +1,7 @@
+import { ClientId, ClientRequestId } from './communication.types';
+export interface ExecuteBackendFunctionRequest {
+    functionName: string;
+    paramsArrayStr: string;
+    clientRequestId: ClientRequestId;
+    clientId: ClientId;
+}

package/dist/common/src/bundle-api.types.d.ts

@@ -0,0 +1,86 @@
+import { ActionType } from './bundle-data.types';
+import { DocType, FullDocIdStr, UserFacingDocType } from './document.types';
+import { ApiEndpoint, ApiEndpointId, ApiIntegration } from './integration.types';
+import { Mutation, MutationType } from './mutation.types';
+import { RunContext } from './context.types';
+import { Logger } from './logger.types';
+import { SecretKey } from './secret.types';
+import { QueryContext } from './query';
+import { MutationContext } from './mutation.context';
+export type DocHash = string;
+export type SecurityResponse = {
+    docsToHash: Record<FullDocIdStr, DocHash | undefined>;
+    rulesPassed: true;
+} | {
+    rulesPassed: false;
+};
+export interface ServiceConfig {
+    context: RunContext;
+    logger: Logger;
+    secrets: Record<SecretKey, any>;
+    backendApiKey: string;
+}
+export type SecureDatabaseAction<T extends ActionType> = T extends 'all' ? () => boolean | Promise<boolean> : T extends 'read' ? (request?: SecureDatabaseReadRequest) => boolean | Promise<boolean> : (request?: SecureDatabaseWriteRequest) => boolean | Promise<boolean>;
+export interface SecureDatabaseReadRequest<T = any> {
+    queryContext: QueryContext<T>;
+}
+export interface SecureDatabaseWriteRequest<T extends UserFacingDocType = any> {
+    mutationContext: MutationContext<T>;
+}
+export type SecureApiAction = (request?: SecureApiRequest) => boolean | Promise<boolean>;
+export interface SecureApiRequest {
+    endpointId: ApiEndpointId;
+    endpoint: ApiEndpoint;
+    apiIntegration: ApiIntegration;
+    request: Record<string, any>;
+    serverUrlOverride: string | undefined;
+}
+export type SecureExecutableAction = (request?: SecureExecutableRequest) => boolean | Promise<boolean>;
+export interface SecureExecutableRequest {
+    params: any[];
+}
+export type SecureNamedQueryAction = (request?: SecureNamedQueryRequest) => boolean | Promise<boolean>;
+export interface SecureNamedQueryRequest {
+    params: Record<string, any>;
+}
+export type SecureGraphQLAction = (request?: SecureGraphQLRequest) => boolean | Promise<boolean>;
+export interface SecureGraphQLRequest {
+    isGraphiQL: boolean;
+    query?: string;
+    operationName?: string;
+    variables?: string | Record<string, any>;
+}
+export type TransformDatabaseAction<T extends ActionType> = T extends 'read' ? (request?: TransformDatabaseReadRequest) => TransformDatabaseReadResponse | Promise<TransformDatabaseReadResponse> : (request?: TransformDatabaseWriteRequest) => TransformDatabaseWriteResponse | Promise<TransformDatabaseWriteResponse>;
+export interface TransformDatabaseReadRequest {
+    documents: Array<DocType>;
+}
+export interface TransformDatabaseWriteRequest {
+    mutations: Array<Mutation>;
+}
+export type TransformDatabaseReadResponse = Array<DocType>;
+export type TransformDatabaseWriteResponse = Array<Mutation>;
+export type ExecutableAction = (...args: any[]) => any;
+export type TriggerAction = (request?: TriggerRequest) => void | Promise<void>;
+export interface TriggerRequest<T extends UserFacingDocType = any> {
+    fullDocId: FullDocIdStr;
+    mutationType: MutationType;
+    docBefore?: T;
+    docAfter?: T;
+}
+export type SchedulerAction = () => void | Promise<void>;
+export type WebhookAction = (request?: WebhookRequest) => any;
+export interface WebhookRequest {
+    body: any;
+    queryParams: Record<string, string>;
+    headers: Record<string, string>;
+    files: Array<SquidFile>;
+}
+export interface SquidFile {
+    data: Uint8Array;
+    fieldName: string;
+    mimetype: string;
+    originalName: string;
+    size: number;
+    encoding?: string;
+}
+export type ActionMethodDecorator<U> = <T extends U>(target: Object, propertyName: string, descriptor: TypedPropertyDescriptor<T>) => TypedPropertyDescriptor<T>;

package/dist/common/src/bundle-data.types.d.ts

@@ -0,0 +1,45 @@
+import { QueryName, SchedulerConfig, SchedulerId, TriggerConfig, TriggerId, WebhookConfig, WebhookId } from './application.types';
+import { IntegrationId } from './communication.types';
+import { CollectionName } from './document.types';
+import { ApiEndpointId } from './integration.types';
+export type ActionType = 'read' | 'write' | 'update' | 'insert' | 'delete' | 'all';
+export type ServiceName = string;
+export type FunctionName = string;
+export type ServiceFunctionName = `${ServiceName}:${FunctionName}`;
+export interface ApplicationBundleData {
+    databases: Record<IntegrationId, DatabaseMetadata>;
+    apis: Record<ApiEndpointId, ApiMetadata>;
+    graphql: Record<IntegrationId, GraphQLMetadata>;
+    executables: Record<FunctionName, ExecutableMetadata>;
+    triggers: Record<TriggerId, TriggerConfig>;
+    schedulers: Record<SchedulerId, SchedulerConfig>;
+    webhooks: Record<WebhookId, WebhookConfig>;
+    namedQueries: Record<IntegrationId, Record<QueryName, NamedQueryMetadata>>;
+}
+export interface DatabaseMetadata {
+    collections: Record<CollectionName, CollectionMetadata>;
+    security?: Record<ActionType, Array<ServiceFunctionName>>;
+    transform?: Record<ActionType, DatabaseTransformMetadata>;
+}
+export interface CollectionMetadata {
+    security?: Record<ActionType, Array<ServiceFunctionName>>;
+    transform?: Record<ActionType, DatabaseTransformMetadata>;
+}
+export interface DatabaseTransformMetadata {
+    serviceFunction: ServiceFunctionName;
+}
+export interface ExecutableMetadata {
+    security?: Array<ServiceFunctionName>;
+    serviceFunction: ServiceFunctionName;
+}
+export interface NamedQueryMetadata {
+    security?: Array<ServiceFunctionName>;
+    queryString: string;
+}
+export interface ApiMetadata {
+    security: Array<ServiceFunctionName>;
+}
+interface GraphQLMetadata {
+    security: Array<ServiceFunctionName>;
+}
+export {};

package/dist/common/src/communication.types.d.ts

@@ -0,0 +1,4 @@
+export type AppId = string;
+export type IntegrationId = string;
+export type ClientId = string;
+export type ClientRequestId = string;

package/dist/common/src/context.types.d.ts

@@ -0,0 +1,22 @@
+export type AuthType = 'Bearer' | 'ApiKey';
+export interface AuthWithBearer {
+    type: 'Bearer';
+    userId: string;
+    expiration: number;
+    attributes: Record<string, any>;
+}
+export interface AuthWithApiKey {
+    type: 'ApiKey';
+    apiKey: string;
+}
+export type Auth = AuthWithBearer | AuthWithApiKey;
+export interface AuthToken {
+    type: AuthType;
+    token: string;
+}
+export interface RunContext {
+    appId: string;
+    sourceIp?: string;
+    headers?: Record<string, any>;
+    auth?: Auth;
+}

package/dist/common/src/document.types.d.ts

@@ -0,0 +1,29 @@
+import { IntegrationId } from './communication.types';
+export type FieldName<T = any> = string & keyof T;
+export type PrimitiveFieldType = string | number | boolean | null;
+export type FieldType = PrimitiveFieldType | Array<FieldType> | {
+    [key: string]: FieldType;
+};
+export type DocId = string;
+export type DocIdObj = Record<FieldName, any>;
+export type CollectionName = string;
+export type DocTimestamp = number;
+export interface FullDocId {
+    collectionName: CollectionName;
+    docId: DocId;
+    integrationId: IntegrationId;
+}
+export interface BeforeAndAfterDocs<T = DocType> {
+    before: T | undefined;
+    after: T | undefined;
+}
+export type FullDocIdStr = string;
+export interface DocType {
+    __docId__: DocId;
+    __ts__: DocTimestamp;
+    [fieldName: string]: FieldType | undefined;
+}
+export type UserFacingDocType = Record<FieldName, any | undefined>;
+export declare function parseFullDocId(fullDocIdStr: FullDocIdStr): FullDocId;
+export declare function getFullDocIdStr(fullDocId: FullDocId): FullDocIdStr;
+export declare function getFullDocIdStr(docId: DocId, collectionName: CollectionName, integrationId: IntegrationId): FullDocIdStr;

package/dist/common/src/graphql.types.d.ts

@@ -0,0 +1,8 @@
+import { IntrospectionQuery } from 'graphql';
+export { ExecutionResult, IntrospectionQuery } from 'graphql';
+export interface GraphQLRequest {
+    operationName?: string;
+    query?: string;
+    variables?: string | Record<string, any>;
+}
+export declare const EmptyIntrospection: IntrospectionQuery;

package/dist/common/src/http-status.enum.d.ts

@@ -0,0 +1,50 @@
+export declare enum HttpStatus {
+    CONTINUE = 100,
+    SWITCHING_PROTOCOLS = 101,
+    PROCESSING = 102,
+    EARLYHINTS = 103,
+    OK = 200,
+    CREATED = 201,
+    ACCEPTED = 202,
+    NON_AUTHORITATIVE_INFORMATION = 203,
+    NO_CONTENT = 204,
+    RESET_CONTENT = 205,
+    PARTIAL_CONTENT = 206,
+    AMBIGUOUS = 300,
+    MOVED_PERMANENTLY = 301,
+    FOUND = 302,
+    SEE_OTHER = 303,
+    NOT_MODIFIED = 304,
+    TEMPORARY_REDIRECT = 307,
+    PERMANENT_REDIRECT = 308,
+    BAD_REQUEST = 400,
+    UNAUTHORIZED = 401,
+    PAYMENT_REQUIRED = 402,
+    FORBIDDEN = 403,
+    NOT_FOUND = 404,
+    METHOD_NOT_ALLOWED = 405,
+    NOT_ACCEPTABLE = 406,
+    PROXY_AUTHENTICATION_REQUIRED = 407,
+    REQUEST_TIMEOUT = 408,
+    CONFLICT = 409,
+    GONE = 410,
+    LENGTH_REQUIRED = 411,
+    PRECONDITION_FAILED = 412,
+    PAYLOAD_TOO_LARGE = 413,
+    URI_TOO_LONG = 414,
+    UNSUPPORTED_MEDIA_TYPE = 415,
+    REQUESTED_RANGE_NOT_SATISFIABLE = 416,
+    EXPECTATION_FAILED = 417,
+    I_AM_A_TEAPOT = 418,
+    MISDIRECTED = 421,
+    UNPROCESSABLE_ENTITY = 422,
+    FAILED_DEPENDENCY = 424,
+    PRECONDITION_REQUIRED = 428,
+    TOO_MANY_REQUESTS = 429,
+    INTERNAL_SERVER_ERROR = 500,
+    NOT_IMPLEMENTED = 501,
+    BAD_GATEWAY = 502,
+    SERVICE_UNAVAILABLE = 503,
+    GATEWAY_TIMEOUT = 504,
+    HTTP_VERSION_NOT_SUPPORTED = 505
+}

package/dist/common/src/index.d.ts

@@ -0,0 +1,40 @@
+export * from './api.types';
+export * from './application.schemas';
+export * from './application.types';
+export * from './backend-function.schemas';
+export * from './backend-function.types';
+export * from './named-query.schemas';
+export * from './named-query.types';
+export * from './bundle-api.types';
+export * from './bundle-data.types';
+export * from './communication.types';
+export * from './context.types';
+export * from './document.types';
+export * from './graphql.types';
+export * from './http-status.enum';
+export * from './integration.types';
+export * from './logger.types';
+export * from './mutation.schemas';
+export * from './mutation.types';
+export * from './mutation.context';
+export * from './metrics.types';
+export * from './metrics.schemas';
+export * from './query';
+export * from './query.schemas';
+export * from './query.types';
+export * from './schema/schema.types';
+export * from './secret.schemas';
+export * from './secret.types';
+export * from './socket.schemas';
+export * from './socket.types';
+export * from './time-units';
+export * from './trigger.types';
+export * from './types';
+export * from './utils/array';
+export * from './utils/assert';
+export * from './utils/lock.manager';
+export * from './utils/object';
+export * from './utils/serialization';
+export * from './utils/validation';
+export * from './utils/error';
+export * from './utils/url';

package/dist/common/src/integration.types.d.ts

@@ -0,0 +1,247 @@
+import { IntegrationId } from './communication.types';
+import { FieldName } from './document.types';
+import { IntrospectionQuery } from './graphql.types';
+import { CollectionSchema } from './schema/schema.types';
+export interface MongoConnectionSecretOptions {
+    password?: string;
+}
+export interface MongoConnectionOptions {
+    secrets: MongoConnectionSecretOptions;
+    connectionString: string;
+    user?: string;
+    replicaSet?: string;
+    ssl?: {
+        certificateFile: string;
+        validate: boolean;
+    };
+    maxPoolSize?: number;
+    minPoolSize?: number;
+    socketTimeoutMS?: number;
+    serverSelectionTimeoutMS?: number;
+    keepAlive?: boolean;
+    directConnection?: boolean;
+}
+export interface MySqlConnectionSecretOptions {
+    password: string;
+}
+export interface MssqlConnectionSecretOptions {
+    password: string;
+}
+export interface PostgresConnectionSecretOptions {
+    password: string;
+    sslCertificate?: string;
+}
+export interface MySqlConnectionOptions {
+    secrets: MySqlConnectionSecretOptions;
+    host: string;
+    user: string;
+    database: string;
+    connectionLimit?: number;
+}
+export interface MssqlConnectionOptions {
+    secrets: MssqlConnectionSecretOptions;
+    host: string;
+    user: string;
+    schema: string;
+    database: string;
+    connectionLimit?: number;
+    sslEnabled?: boolean;
+}
+export interface PostgresConnectionOptions {
+    host: string;
+    user: string;
+    database: string;
+    schema?: string;
+    sslEnabled?: boolean;
+    secrets: PostgresConnectionSecretOptions;
+}
+export interface GraphQLConnectionOptions {
+    baseUrl: string;
+}
+export declare enum IntegrationType {
+    'internal' = "internal",
+    'mongo' = "mongo",
+    'mysql' = "mysql",
+    'mssql' = "mssql",
+    'postgres' = "postgres",
+    'cockroach' = "cockroach",
+    'api' = "api",
+    'graphql' = "graphql"
+}
+export type DataIntegration = MySqlIntegration | MssqlIntegration | MongoIntegration | InternalIntegration | PostgresIntegration | CockroachIntegration;
+export type Integration = DataIntegration | ApiIntegration | GraphQLIntegration;
+type TableName = string;
+export interface IntegrationDataSchema {
+    collections: Record<TableName, CollectionSchema>;
+}
+export interface IntegrationGraphQLSchema {
+    introspection: IntrospectionQuery;
+}
+export type IntegrationSchema = IntegrationDataSchema | IntegrationGraphQLSchema;
+interface BaseIntegration {
+    id: IntegrationId;
+    type: IntegrationType;
+    creationDate: Date;
+    updateDate: Date;
+    secured: boolean;
+}
+export interface BaseDataIntegration extends BaseIntegration {
+    schema?: IntegrationDataSchema;
+    supportsExternalChanges: boolean;
+}
+export declare function isDataIntegration(integration: any): integration is BaseDataIntegration;
+export type HttpMethod = 'post' | 'get' | 'delete' | 'patch' | 'put';
+export type ApiEndpointId = string;
+export type ApiParameterLocation = 'query' | 'body' | 'header' | 'path';
+export type FieldPath = string;
+export interface ApiRequestField {
+    paramLocation?: ApiParameterLocation;
+    fieldNameInRequest?: FieldName;
+}
+export interface ApiResponseField {
+    paramLocation: 'body' | 'header';
+    fieldPathInResponse?: FieldPath;
+}
+export interface ApiEndpoint {
+    relativePath: string;
+    method: HttpMethod;
+    requestSchema?: Record<FieldName, ApiRequestField>;
+    responseSchema?: Record<FieldPath, ApiResponseField>;
+}
+export interface ApiIntegration extends BaseIntegration {
+    type: IntegrationType.api;
+    baseUrl: string;
+    endpoints: Record<ApiEndpointId, ApiEndpoint>;
+}
+export interface GraphQLIntegration extends BaseIntegration {
+    type: IntegrationType.graphql;
+    schema?: IntegrationGraphQLSchema;
+    configuration: {
+        connectionOptions: GraphQLConnectionOptions;
+    };
+}
+export interface MySqlIntegrationConfiguration {
+    connectionOptions: MySqlConnectionOptions;
+}
+export interface MssqlIntegrationConfiguration {
+    connectionOptions: MssqlConnectionOptions;
+}
+export interface PostgresIntegrationConfiguration {
+    connectionOptions: PostgresConnectionOptions;
+}
+export interface MongoIntegrationConfiguration {
+    connectionOptions: MongoConnectionOptions;
+}
+export interface MySqlIntegration extends BaseDataIntegration {
+    type: IntegrationType.mysql;
+    configuration: MySqlIntegrationConfiguration;
+    schema: IntegrationDataSchema;
+    supportsExternalChanges: true;
+}
+export interface MssqlIntegration extends BaseDataIntegration {
+    type: IntegrationType.mssql;
+    configuration: MssqlIntegrationConfiguration;
+    schema: IntegrationDataSchema;
+    supportsExternalChanges: true;
+}
+export interface BasePostgresIntegration extends BaseDataIntegration {
+    type: IntegrationType.postgres | IntegrationType.cockroach;
+    configuration: PostgresIntegrationConfiguration;
+    schema: IntegrationDataSchema;
+}
+export interface PostgresIntegration extends BasePostgresIntegration {
+    type: IntegrationType.postgres;
+    supportsExternalChanges: true;
+}
+export interface CockroachIntegration extends BasePostgresIntegration {
+    type: IntegrationType.cockroach;
+    supportsExternalChanges: false;
+}
+export interface InternalIntegration extends BaseDataIntegration {
+    type: IntegrationType.internal;
+}
+export interface MongoIntegration extends BaseDataIntegration {
+    type: IntegrationType.mongo;
+    configuration: MongoIntegrationConfiguration;
+    supportsExternalChanges: true;
+}
+export interface InternalIntegration extends BaseDataIntegration {
+    type: IntegrationType.internal;
+}
+export interface TestDataConnectionResponse {
+    success: boolean;
+    errorMessage?: string;
+}
+interface TestMongoDataConnectionRequest {
+    type: IntegrationType.mongo;
+    configuration: {
+        connectionOptions: MongoConnectionOptions;
+    };
+}
+interface TestMysqlDataConnectionRequest {
+    type: IntegrationType.mysql;
+    configuration: {
+        connectionOptions: MySqlConnectionOptions;
+    };
+}
+interface TestMssqlDataConnectionRequest {
+    type: IntegrationType.mssql;
+    configuration: {
+        connectionOptions: MssqlConnectionOptions;
+    };
+}
+interface TestPostgresDataConnectionRequest {
+    type: IntegrationType.postgres;
+    configuration: {
+        connectionOptions: PostgresConnectionOptions;
+    };
+}
+interface TestCockroachDataConnectionRequest {
+    type: IntegrationType.cockroach;
+    configuration: {
+        connectionOptions: PostgresConnectionOptions;
+    };
+}
+export type TestDataConnectionRequest = TestMongoDataConnectionRequest | TestMysqlDataConnectionRequest | TestMssqlDataConnectionRequest | TestCockroachDataConnectionRequest | TestPostgresDataConnectionRequest;
+export interface DiscoverDataConnectionSchemaResponse {
+    schema: IntegrationDataSchema;
+}
+export interface DiscoverGraphQLConnectionSchemaResponse {
+    schema: IntegrationGraphQLSchema;
+}
+interface DiscoverMongoDataConnectionSchemaRequest {
+    integrationType: IntegrationType.mongo;
+    connectionOptions: MongoConnectionOptions;
+}
+interface DiscoverInternalDataConnectionSchemaRequest {
+    integrationType: IntegrationType.internal;
+}
+interface DiscoverMysqlDataConnectionSchemaRequest {
+    integrationType: IntegrationType.mysql;
+    connectionOptions: MySqlConnectionOptions;
+}
+interface DiscoverMssqlDataConnectionSchemaRequest {
+    integrationType: IntegrationType.mssql;
+    connectionOptions: MssqlConnectionOptions;
+}
+export interface DiscoverGraphQLConnectionSchemaRequest {
+    integrationType: IntegrationType.graphql;
+    connectionOptions: GraphQLConnectionOptions;
+}
+interface DiscoverPostgresDataConnectionSchemaRequest {
+    integrationType: IntegrationType.postgres;
+    connectionOptions: PostgresConnectionOptions;
+}
+interface DiscoverCockroachDataConnectionSchemaRequest {
+    integrationType: IntegrationType.cockroach;
+    connectionOptions: PostgresConnectionOptions;
+}
+export type DiscoverDataConnectionSchemaRequest = DiscoverMongoDataConnectionSchemaRequest | DiscoverInternalDataConnectionSchemaRequest | DiscoverMysqlDataConnectionSchemaRequest | DiscoverMssqlDataConnectionSchemaRequest | DiscoverCockroachDataConnectionSchemaRequest | DiscoverPostgresDataConnectionSchemaRequest;
+export interface DiscoverOpenApiEndpointsRequest {
+    openApiSpecUrl: string;
+}
+export interface DiscoverOpenApiEndpointsResponse {
+    baseUrl: string;
+    endpoints: Record<ApiEndpointId, ApiEndpoint>;
+}
+export {};