@squidcloud/local-backend 1.0.159 → 1.0.161

package/dist/internal-common/src/public-types/integration.public-types.d.ts

@@ -0,0 +1,62 @@
+export declare enum IntegrationCategory {
+    'database' = "database",
+    'queue' = "queue",
+    'api' = "api",
+    'observability' = "observability",
+    'crm' = "crm",
+    'auth' = "auth",
+    'ai' = "ai"
+}
+export declare enum IntegrationType {
+    'built_in_db' = "built_in_db",
+    'mongo' = "mongo",
+    'mysql' = "mysql",
+    'mssql' = "mssql",
+    'postgres' = "postgres",
+    'cockroach' = "cockroach",
+    'api' = "api",
+    'graphql' = "graphql",
+    'snowflake' = "snowflake",
+    'datadog' = "datadog",
+    'newrelic' = "newrelic",
+    'auth0' = "auth0",
+    'jwt_rsa' = "jwt_rsa",
+    'jwt_hmac' = "jwt_hmac",
+    'ai_chatbot' = "ai_chatbot",
+    'cognito' = "cognito",
+    'okta' = "okta",
+    'descope' = "descope",
+    'kafka' = "kafka",
+    'confluent' = "confluent",
+    'built_in_queue' = "built_in_queue",
+    'algolia' = "algolia",
+    'elastic_observability' = "elastic_observability",
+    'elastic_search' = "elastic_search",
+    'elastic_enterprise_search' = "elastic_enterprise_search",
+    'sentry' = "sentry",
+    'sap_hana' = "sap_hana",
+    'salesforce_crm' = "salesforce_crm",
+    'documentdb' = "documentdb",
+    'dynamodb' = "dynamodb",
+    'cassandra' = "cassandra",
+    'clickhouse' = "clickhouse",
+    'alloydb' = "alloydb",
+    'spanner' = "spanner",
+    'db2' = "db2",
+    'mariadb' = "mariadb",
+    'oracledb' = "oracledb",
+    'pinot' = "pinot",
+    'redis' = "redis",
+    'xata' = "xata",
+    'azure_sql' = "azure_sql",
+    'azure_postgresql' = "azure_postgresql",
+    'azure_cosmosdb' = "azure_cosmosdb",
+    'firestore' = "firestore",
+    'bigquery' = "bigquery",
+    'cloudsql' = "cloudsql"
+}
+export declare enum IntegrationSchemaType {
+    'data' = "data",
+    'api' = "api",
+    'graphql' = "graphql"
+}

package/dist/internal-common/src/public-types/integration.public-types.js

@@ -0,0 +1,69 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.IntegrationSchemaType = exports.IntegrationType = exports.IntegrationCategory = void 0;
+var IntegrationCategory;
+(function (IntegrationCategory) {
+    IntegrationCategory["database"] = "database";
+    IntegrationCategory["queue"] = "queue";
+    IntegrationCategory["api"] = "api";
+    IntegrationCategory["observability"] = "observability";
+    IntegrationCategory["crm"] = "crm";
+    IntegrationCategory["auth"] = "auth";
+    IntegrationCategory["ai"] = "ai";
+})(IntegrationCategory || (exports.IntegrationCategory = IntegrationCategory = {}));
+var IntegrationType;
+(function (IntegrationType) {
+    IntegrationType["built_in_db"] = "built_in_db";
+    IntegrationType["mongo"] = "mongo";
+    IntegrationType["mysql"] = "mysql";
+    IntegrationType["mssql"] = "mssql";
+    IntegrationType["postgres"] = "postgres";
+    IntegrationType["cockroach"] = "cockroach";
+    IntegrationType["api"] = "api";
+    IntegrationType["graphql"] = "graphql";
+    IntegrationType["snowflake"] = "snowflake";
+    IntegrationType["datadog"] = "datadog";
+    IntegrationType["newrelic"] = "newrelic";
+    IntegrationType["auth0"] = "auth0";
+    IntegrationType["jwt_rsa"] = "jwt_rsa";
+    IntegrationType["jwt_hmac"] = "jwt_hmac";
+    IntegrationType["ai_chatbot"] = "ai_chatbot";
+    IntegrationType["cognito"] = "cognito";
+    IntegrationType["okta"] = "okta";
+    IntegrationType["descope"] = "descope";
+    IntegrationType["kafka"] = "kafka";
+    IntegrationType["confluent"] = "confluent";
+    IntegrationType["built_in_queue"] = "built_in_queue";
+    IntegrationType["algolia"] = "algolia";
+    IntegrationType["elastic_observability"] = "elastic_observability";
+    IntegrationType["elastic_search"] = "elastic_search";
+    IntegrationType["elastic_enterprise_search"] = "elastic_enterprise_search";
+    IntegrationType["sentry"] = "sentry";
+    IntegrationType["sap_hana"] = "sap_hana";
+    IntegrationType["salesforce_crm"] = "salesforce_crm";
+    IntegrationType["documentdb"] = "documentdb";
+    IntegrationType["dynamodb"] = "dynamodb";
+    IntegrationType["cassandra"] = "cassandra";
+    IntegrationType["clickhouse"] = "clickhouse";
+    IntegrationType["alloydb"] = "alloydb";
+    IntegrationType["spanner"] = "spanner";
+    IntegrationType["db2"] = "db2";
+    IntegrationType["mariadb"] = "mariadb";
+    IntegrationType["oracledb"] = "oracledb";
+    IntegrationType["pinot"] = "pinot";
+    IntegrationType["redis"] = "redis";
+    IntegrationType["xata"] = "xata";
+    IntegrationType["azure_sql"] = "azure_sql";
+    IntegrationType["azure_postgresql"] = "azure_postgresql";
+    IntegrationType["azure_cosmosdb"] = "azure_cosmosdb";
+    IntegrationType["firestore"] = "firestore";
+    IntegrationType["bigquery"] = "bigquery";
+    IntegrationType["cloudsql"] = "cloudsql";
+})(IntegrationType || (exports.IntegrationType = IntegrationType = {}));
+var IntegrationSchemaType;
+(function (IntegrationSchemaType) {
+    IntegrationSchemaType["data"] = "data";
+    IntegrationSchemaType["api"] = "api";
+    IntegrationSchemaType["graphql"] = "graphql";
+})(IntegrationSchemaType || (exports.IntegrationSchemaType = IntegrationSchemaType = {}));
+//# sourceMappingURL=integration.public-types.js.map

package/dist/internal-common/src/public-types/integration.public-types.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"integration.public-types.js","sourceRoot":"","sources":["../../../../../internal-common/src/public-types/integration.public-types.ts"],"names":[],"mappings":";;;AAAA,IAAY,mBAQX;AARD,WAAY,mBAAmB;IAC7B,4CAAuB,CAAA;IACvB,sCAAiB,CAAA;IACjB,kCAAa,CAAA;IACb,sDAAiC,CAAA;IACjC,kCAAa,CAAA;IACb,oCAAe,CAAA;IACf,gCAAW,CAAA;AACb,CAAC,EARW,mBAAmB,mCAAnB,mBAAmB,QAQ9B;AAED,IAAY,eAgDX;AAhDD,WAAY,eAAe;IACzB,8CAA6B,CAAA;IAC7B,kCAAiB,CAAA;IACjB,kCAAiB,CAAA;IACjB,kCAAiB,CAAA;IACjB,wCAAuB,CAAA;IACvB,0CAAyB,CAAA;IACzB,8BAAa,CAAA;IACb,sCAAqB,CAAA;IACrB,0CAAyB,CAAA;IACzB,sCAAqB,CAAA;IACrB,wCAAuB,CAAA;IACvB,kCAAiB,CAAA;IACjB,sCAAqB,CAAA;IACrB,wCAAuB,CAAA;IACvB,4CAA2B,CAAA;IAC3B,sCAAqB,CAAA;IACrB,gCAAe,CAAA;IACf,sCAAqB,CAAA;IACrB,kCAAiB,CAAA;IACjB,0CAAyB,CAAA;IACzB,oDAAmC,CAAA;IAEnC,sCAAqB,CAAA;IACrB,kEAAiD,CAAA;IACjD,oDAAmC,CAAA;IACnC,0EAAyD,CAAA;IACzD,oCAAmB,CAAA;IACnB,wCAAuB,CAAA;IACvB,oDAAmC,CAAA;IACnC,4CAA2B,CAAA;IAC3B,wCAAuB,CAAA;IACvB,0CAAyB,CAAA;IACzB,4CAA2B,CAAA;IAC3B,sCAAqB,CAAA;IACrB,sCAAqB,CAAA;IACrB,8BAAa,CAAA;IACb,sCAAqB,CAAA;IACrB,wCAAuB,CAAA;IACvB,kCAAiB,CAAA;IACjB,kCAAiB,CAAA;IACjB,gCAAe,CAAA;IACf,0CAAyB,CAAA;IACzB,wDAAuC,CAAA;IACvC,oDAAmC,CAAA;IACnC,0CAAyB,CAAA;IACzB,wCAAuB,CAAA;IACvB,wCAAuB,CAAA;AACzB,CAAC,EAhDW,eAAe,+BAAf,eAAe,QAgD1B;AAED,IAAY,qBAIX;AAJD,WAAY,qBAAqB;IAC/B,sCAAe,CAAA;IACf,oCAAa,CAAA;IACb,4CAAqB,CAAA;AACvB,CAAC,EAJW,qBAAqB,qCAArB,qBAAqB,QAIhC"}

package/dist/internal-common/src/public-types/integrations/ai_chatbot.types.d.ts

@@ -0,0 +1,32 @@
+import { BaseIntegrationConfig } from './schemas';
+import { AiModelName } from '../ai-chatbot.public-types';
+import { IntegrationType } from '../integration.public-types';
+import { IntegrationId } from '../communication.public-types';
+export interface AiChatbotIntegrationConfig extends BaseIntegrationConfig {
+    type: IntegrationType.ai_chatbot;
+    configuration: AiChatbotConfiguration;
+}
+export type AiChatbotConfiguration = {
+    apiKey?: string;
+};
+export type AiChatbotProfileMetadata = {
+    modelName: AiModelName;
+    isPublic: boolean;
+    strictContext: boolean;
+    instructions: Record<string, string>;
+};
+export type AiChatbotContextMetadata = {
+    title: string;
+    text: string;
+    preview: boolean;
+    sizeBytes?: number;
+};
+export interface AiChatbotProfile extends AiChatbotProfileMetadata {
+    contexts: Record<string, AiChatbotContextMetadata>;
+}
+export interface AiChatbotProfiles {
+    profiles: Record<string, AiChatbotProfile>;
+}
+export interface GetAiChatbotProfilesRequest {
+    integrationId: IntegrationId;
+}

package/dist/internal-common/src/public-types/integrations/ai_chatbot.types.js

@@ -0,0 +1,3 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=ai_chatbot.types.js.map

package/dist/internal-common/src/public-types/integrations/ai_chatbot.types.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"ai_chatbot.types.js","sourceRoot":"","sources":["../../../../../../internal-common/src/public-types/integrations/ai_chatbot.types.ts"],"names":[],"mappings":""}

package/dist/internal-common/src/public-types/integrations/api.types.d.ts

@@ -0,0 +1,81 @@
+import { BaseIntegrationConfig, BaseIntegrationSchema } from './schemas';
+import { IntegrationSchemaType, IntegrationType } from '../integration.public-types';
+import { IntrospectionQuery } from '../graphql.public-types';
+import { FieldName } from '../document.public-types';
+export type HttpMethod = 'post' | 'get' | 'delete' | 'patch' | 'put';
+export type ApiEndpointId = string;
+export type ApiParameterLocation = 'query' | 'body' | 'header' | 'path';
+export type ApiResponseParameterLocation = 'header' | 'body';
+export type ApiInjectionParameterLocation = 'header' | 'query';
+export type FieldPath = string;
+export type IntegrationApiEndpoints = Record<ApiEndpointId, ApiEndpoint>;
+export interface IntegrationGraphQLSchema extends BaseIntegrationSchema {
+    type: IntegrationSchemaType.graphql;
+    introspection: IntrospectionQuery;
+}
+export interface IntegrationApiSchema extends BaseIntegrationSchema {
+    type: IntegrationSchemaType.api;
+    baseUrl: string;
+    endpoints: IntegrationApiEndpoints;
+    injectionSchema?: ApiInjectionSchema;
+}
+export interface ApiRequestField {
+    location: ApiParameterLocation;
+}
+export interface ApiResponseField {
+    location: ApiResponseParameterLocation;
+    path?: FieldPath;
+}
+export type ApiInjectionFieldType = 'secret' | 'regular';
+export interface ApiInjectionField {
+    value: string;
+    type: ApiInjectionFieldType;
+    location: ApiInjectionParameterLocation;
+}
+export interface GraphQLConnectionOptions {
+    baseUrl: string;
+    injectionSchema?: ApiInjectionSchema;
+}
+export type ApiInjectionSchema = Record<FieldName, ApiInjectionField>;
+export interface OpenApiDiscoveryOptions {
+    openApiSpecUrl: string;
+}
+export interface ApiEndpoint {
+    relativePath: string;
+    method: HttpMethod;
+    requestSchema?: Record<FieldName, ApiRequestField>;
+    responseSchema?: Record<FieldPath, ApiResponseField>;
+    injectionSchema?: ApiInjectionSchema;
+}
+export interface HttpApiIntegrationConfig extends BaseIntegrationConfig {
+    type: IntegrationType.api;
+    configuration?: {
+        discoveryOptions: OpenApiDiscoveryOptions;
+    };
+}
+export interface GraphQLIntegrationConfig extends BaseIntegrationConfig {
+    type: IntegrationType.graphql;
+    configuration: {
+        connectionOptions: GraphQLConnectionOptions;
+    };
+}
+export interface DiscoverGraphQLConnectionSchemaRequest {
+    integrationType: IntegrationType.graphql;
+    connectionOptions: GraphQLConnectionOptions;
+}
+export interface DiscoverOpenApiSchemaRequest {
+    integrationType: IntegrationType.api;
+    discoveryOptions: OpenApiDiscoveryOptions;
+}
+export interface TestGraphQLDataConnectionRequest {
+    type: IntegrationType.graphql;
+    configuration: {
+        connectionOptions: GraphQLConnectionOptions;
+    };
+}
+export interface DiscoverGraphQLConnectionSchemaResponse {
+    schema: IntegrationGraphQLSchema;
+}
+export interface DiscoverOpenApiSchemaResponse {
+    schema: IntegrationApiSchema;
+}

package/dist/internal-common/src/public-types/integrations/api.types.js

@@ -0,0 +1,3 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=api.types.js.map

package/dist/internal-common/src/public-types/integrations/api.types.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"api.types.js","sourceRoot":"","sources":["../../../../../../internal-common/src/public-types/integrations/api.types.ts"],"names":[],"mappings":""}

package/dist/internal-common/src/public-types/integrations/auth.types.d.ts

@@ -0,0 +1,46 @@
+import { BaseIntegrationConfig } from './schemas';
+import { IntegrationType } from '../integration.public-types';
+export interface Auth0IntegrationConfig extends BaseIntegrationConfig {
+    type: IntegrationType.auth0;
+    configuration: {
+        domain: string;
+        clientId: string;
+    };
+}
+export interface CognitoIntegrationConfig extends BaseIntegrationConfig {
+    type: IntegrationType.cognito;
+    configuration: {
+        region: string;
+        userPoolId: string;
+        appClientId: string;
+    };
+}
+export interface OktaIntegrationConfig extends BaseIntegrationConfig {
+    type: IntegrationType.okta;
+    configuration: {
+        domain: string;
+        clientId: string;
+    };
+}
+export interface JwtRsaIntegrationConfig extends BaseIntegrationConfig {
+    type: IntegrationType.jwt_rsa;
+    configuration: {
+        jwksUri: string;
+        validations?: {
+            aud?: string;
+            iss?: string;
+        };
+    };
+}
+export interface JwtHmacIntegrationConfig extends BaseIntegrationConfig {
+    type: IntegrationType.jwt_hmac;
+    configuration: {
+        verifyUri?: string;
+    };
+}
+export interface DescopeIntegrationConfig extends BaseIntegrationConfig {
+    type: IntegrationType.descope;
+    configuration: {
+        projectId: string;
+    };
+}

package/dist/internal-common/src/public-types/integrations/auth.types.js

@@ -0,0 +1,3 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=auth.types.js.map

package/dist/internal-common/src/public-types/integrations/auth.types.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"auth.types.js","sourceRoot":"","sources":["../../../../../../internal-common/src/public-types/integrations/auth.types.ts"],"names":[],"mappings":""}

package/dist/internal-common/src/public-types/integrations/database.types.d.ts

@@ -0,0 +1,275 @@
+import { BaseIntegrationConfig, BaseIntegrationSchema, DatabaseIntegrationType } from './schemas';
+import { IntegrationSchemaType, IntegrationType } from '../integration.public-types';
+import { CollectionName } from '../document.public-types';
+import { CollectionSchema } from '../schema.public-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 BigQueryConnectionSecretOptions {
+    privateKey: string;
+}
+export interface OracleConnectionSecretOptions {
+    password: string;
+}
+export interface PinotConnectionSecretOptions {
+    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;
+    sslEnabled?: boolean;
+}
+export interface BigQueryConnectionOptions {
+    secrets: BigQueryConnectionSecretOptions;
+    projectId: string;
+    datasetId: string;
+    email: string;
+}
+export interface OracleConnectionOptions {
+    secrets: OracleConnectionSecretOptions;
+    host: string;
+    user: string;
+    database: string;
+    connectionLimit?: number;
+}
+export interface PinotConnectionOptions {
+    secrets: PinotConnectionSecretOptions;
+    brokerUrl: string;
+    controllerUrl: string;
+    user?: string;
+    connectionLimit?: number;
+}
+export interface MssqlConnectionOptions {
+    secrets: MssqlConnectionSecretOptions;
+    host: string;
+    user: string;
+    schemas: string;
+    database: string;
+    connectionLimit?: number;
+    sslEnabled?: boolean;
+}
+export interface PostgresConnectionOptions {
+    host: string;
+    user: string;
+    database: string;
+    schema?: string;
+    sslEnabled?: boolean;
+    secrets: PostgresConnectionSecretOptions;
+}
+export interface SnowflakeConnectionSecretOptions {
+    password: string;
+}
+export interface SnowflakeConnectionOptions {
+    secrets: SnowflakeConnectionSecretOptions;
+    account: string;
+    username: string;
+    database: string;
+    schema: string;
+    warehouse: string;
+    role: string;
+}
+type TableName = string;
+export interface IntegrationDataSchema extends BaseIntegrationSchema {
+    type: IntegrationSchemaType.data;
+    collections: Record<TableName, CollectionSchema>;
+}
+export interface BaseDatabaseIntegrationConfig extends BaseIntegrationConfig {
+    type: DatabaseIntegrationType;
+    supportsExternalChanges: boolean;
+}
+export interface MySqlIntegrationConfiguration {
+    connectionOptions: MySqlConnectionOptions;
+}
+export interface BigQueryIntegrationConfiguration {
+    connectionOptions: BigQueryConnectionOptions;
+}
+export interface OracleIntegrationConfiguration {
+    connectionOptions: OracleConnectionOptions;
+}
+export interface PinotIntegrationConfiguration {
+    connectionOptions: PinotConnectionOptions;
+}
+export interface MssqlIntegrationConfiguration {
+    connectionOptions: MssqlConnectionOptions;
+}
+export interface PostgresIntegrationConfiguration {
+    connectionOptions: PostgresConnectionOptions;
+}
+export interface MongoIntegrationConfiguration {
+    connectionOptions: MongoConnectionOptions;
+}
+export interface SnowflakeIntegrationConfiguration {
+    connectionOptions: SnowflakeConnectionOptions;
+}
+export interface MySqlIntegrationConfig extends BaseDatabaseIntegrationConfig {
+    type: IntegrationType.mysql;
+    configuration: MySqlIntegrationConfiguration;
+}
+export interface BigQueryIntegrationConfig extends BaseDatabaseIntegrationConfig {
+    type: IntegrationType.bigquery;
+    configuration: BigQueryIntegrationConfiguration;
+}
+export interface OracleIntegrationConfig extends BaseDatabaseIntegrationConfig {
+    type: IntegrationType.oracledb;
+    configuration: OracleIntegrationConfiguration;
+}
+export interface PinotIntegrationConfig extends BaseDatabaseIntegrationConfig {
+    type: IntegrationType.pinot;
+    configuration: PinotIntegrationConfiguration;
+}
+export interface MssqlIntegrationConfig extends BaseDatabaseIntegrationConfig {
+    type: IntegrationType.mssql;
+    configuration: MssqlIntegrationConfiguration;
+}
+export interface BasePostgresIntegration extends BaseDatabaseIntegrationConfig {
+    type: IntegrationType.postgres | IntegrationType.cockroach;
+    configuration: PostgresIntegrationConfiguration;
+}
+export interface PostgresIntegrationConfig extends BasePostgresIntegration {
+    type: IntegrationType.postgres;
+}
+export interface CockroachIntegrationConfig extends BasePostgresIntegration {
+    type: IntegrationType.cockroach;
+    supportsExternalChanges: false;
+}
+export interface InternalIntegrationConfig extends BaseDatabaseIntegrationConfig {
+    type: IntegrationType.built_in_db;
+}
+export interface MongoIntegrationConfig extends BaseDatabaseIntegrationConfig {
+    type: IntegrationType.mongo;
+    configuration: MongoIntegrationConfiguration;
+}
+export interface SnowflakeIntegrationConfig extends BaseDatabaseIntegrationConfig {
+    type: IntegrationType.snowflake;
+    configuration: SnowflakeIntegrationConfiguration;
+    supportsExternalChanges: false;
+}
+interface TestMongoDataConnectionRequest {
+    type: IntegrationType.mongo;
+    configuration: {
+        connectionOptions: MongoConnectionOptions;
+    };
+}
+interface TestMysqlDataConnectionRequest {
+    type: IntegrationType.mysql;
+    configuration: {
+        connectionOptions: MySqlConnectionOptions;
+    };
+}
+interface TestBigQueryDataConnectionRequest {
+    type: IntegrationType.bigquery;
+    configuration: {
+        connectionOptions: BigQueryConnectionOptions;
+    };
+}
+interface TestOracleDataConnectionRequest {
+    type: IntegrationType.oracledb;
+    configuration: {
+        connectionOptions: OracleConnectionOptions;
+    };
+}
+interface TestMssqlDataConnectionRequest {
+    type: IntegrationType.mssql;
+    configuration: {
+        connectionOptions: MssqlConnectionOptions;
+    };
+}
+interface TestPostgresDataConnectionRequest {
+    type: IntegrationType.postgres;
+    configuration: {
+        connectionOptions: PostgresConnectionOptions;
+    };
+}
+interface TestSnowflakeDataConnectionRequest {
+    type: IntegrationType.snowflake;
+    configuration: {
+        connectionOptions: SnowflakeConnectionOptions;
+    };
+}
+interface TestCockroachDataConnectionRequest {
+    type: IntegrationType.cockroach;
+    configuration: {
+        connectionOptions: PostgresConnectionOptions;
+    };
+}
+export type TestDataConnectionRequest = TestMongoDataConnectionRequest | TestMysqlDataConnectionRequest | TestBigQueryDataConnectionRequest | TestOracleDataConnectionRequest | TestMssqlDataConnectionRequest | TestCockroachDataConnectionRequest | TestPostgresDataConnectionRequest | TestSnowflakeDataConnectionRequest;
+export interface CollectionReadiness {
+    hasPermissions: boolean;
+    grantPermissionsCommands: string[];
+    replicationEnabled: boolean;
+    enableReplicationCommands: string[];
+}
+export interface DiscoverDataConnectionSchemaResponse {
+    schema: IntegrationDataSchema;
+    collectionReadiness: Record<CollectionName, CollectionReadiness>;
+}
+interface DiscoverMongoDataConnectionSchemaRequest {
+    integrationType: IntegrationType.mongo;
+    connectionOptions: MongoConnectionOptions;
+}
+interface DiscoverInternalDataConnectionSchemaRequest {
+    integrationType: IntegrationType.built_in_db;
+}
+interface DiscoverMysqlDataConnectionSchemaRequest {
+    integrationType: IntegrationType.mysql;
+    connectionOptions: MySqlConnectionOptions;
+}
+interface DiscoverBigQueryDataConnectionSchemaRequest {
+    integrationType: IntegrationType.bigquery;
+    connectionOptions: BigQueryConnectionOptions;
+}
+interface DiscoverOracleDataConnectionSchemaRequest {
+    integrationType: IntegrationType.oracledb;
+    connectionOptions: OracleConnectionOptions;
+}
+interface DiscoverMssqlDataConnectionSchemaRequest {
+    integrationType: IntegrationType.mssql;
+    connectionOptions: MssqlConnectionOptions;
+}
+interface DiscoverPostgresDataConnectionSchemaRequest {
+    integrationType: IntegrationType.postgres;
+    connectionOptions: PostgresConnectionOptions;
+}
+interface DiscoverSnowflakeDataConnectionSchemaRequest {
+    integrationType: IntegrationType.snowflake;
+    connectionOptions: SnowflakeConnectionOptions;
+}
+interface DiscoverCockroachDataConnectionSchemaRequest {
+    integrationType: IntegrationType.cockroach;
+    connectionOptions: PostgresConnectionOptions;
+}
+export interface TestDataConnectionResponse {
+    success: boolean;
+    errorMessage?: string;
+}
+export type DiscoverDataConnectionSchemaRequest = DiscoverMongoDataConnectionSchemaRequest | DiscoverInternalDataConnectionSchemaRequest | DiscoverMysqlDataConnectionSchemaRequest | DiscoverBigQueryDataConnectionSchemaRequest | DiscoverOracleDataConnectionSchemaRequest | DiscoverMssqlDataConnectionSchemaRequest | DiscoverCockroachDataConnectionSchemaRequest | DiscoverPostgresDataConnectionSchemaRequest | DiscoverSnowflakeDataConnectionSchemaRequest;
+export {};

package/dist/internal-common/src/public-types/integrations/database.types.js

@@ -0,0 +1,3 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=database.types.js.map

package/dist/internal-common/src/public-types/integrations/database.types.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"database.types.js","sourceRoot":"","sources":["../../../../../../internal-common/src/public-types/integrations/database.types.ts"],"names":[],"mappings":""}

package/dist/internal-common/src/public-types/integrations/observability.types.d.ts

@@ -0,0 +1,24 @@
+import { BaseIntegrationConfig } from './schemas';
+import { IntegrationType } from '../integration.public-types';
+export interface DatadogIntegrationConfig extends BaseIntegrationConfig {
+    type: IntegrationType.datadog;
+    configuration: DatadogIntegrationConfiguration;
+}
+export interface DatadogIntegrationConfiguration {
+    apiKey: string;
+    appKey: string;
+    datadogRegion: DatadogRegion;
+}
+export type DatadogRegion = 'us1' | 'us3' | 'us5' | 'eu1' | 'us1-fed' | 'ap1';
+export interface NewRelicIntegrationConfig extends BaseIntegrationConfig {
+    type: IntegrationType.newrelic;
+    configuration: NewRelicIntegrationConfiguration;
+}
+export declare const datadogRegionMap: Record<DatadogRegion, string>;
+export declare const datadogLogsUrlMap: Record<DatadogRegion, string>;
+export type NewRelicRegion = 'worldwide' | 'eu';
+export interface NewRelicIntegrationConfiguration {
+    apiKey: string;
+    newRelicRegion: NewRelicRegion;
+}
+export declare const newRelicRegionMap: Record<NewRelicRegion, string>;

package/dist/internal-common/src/public-types/integrations/observability.types.js

@@ -0,0 +1,24 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.newRelicRegionMap = exports.datadogLogsUrlMap = exports.datadogRegionMap = void 0;
+exports.datadogRegionMap = {
+    us1: 'US1 - East',
+    us3: 'US3 - West',
+    us5: 'US5 - Central',
+    eu1: 'EU1 - Europe',
+    ap1: 'AP1 - Asia',
+    'us1-fed': 'US1-FED (FedRamp)',
+};
+exports.datadogLogsUrlMap = {
+    us1: 'https://http-intake.logs.datadoghq.com',
+    us3: 'https://http-intake.logs.us3.datadoghq.com',
+    us5: 'https://http-intake.logs.us5.datadoghq.com',
+    eu1: 'https://http-intake.logs.datadoghq.eu',
+    ap1: 'https://http-intake.logs.ap1.datadoghq.com',
+    'us1-fed': 'https://http-intake.logs.ddog-gov.com',
+};
+exports.newRelicRegionMap = {
+    worldwide: 'Worldwide',
+    eu: 'Europe',
+};
+//# sourceMappingURL=observability.types.js.map

package/dist/internal-common/src/public-types/integrations/observability.types.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"observability.types.js","sourceRoot":"","sources":["../../../../../../internal-common/src/public-types/integrations/observability.types.ts"],"names":[],"mappings":";;;AAqBa,QAAA,gBAAgB,GAAkC;IAC7D,GAAG,EAAE,YAAY;IACjB,GAAG,EAAE,YAAY;IACjB,GAAG,EAAE,eAAe;IACpB,GAAG,EAAE,cAAc;IACnB,GAAG,EAAE,YAAY;IACjB,SAAS,EAAE,mBAAmB;CAC/B,CAAC;AAEW,QAAA,iBAAiB,GAAkC;IAC9D,GAAG,EAAE,wCAAwC;IAC7C,GAAG,EAAE,4CAA4C;IACjD,GAAG,EAAE,4CAA4C;IACjD,GAAG,EAAE,uCAAuC;IAC5C,GAAG,EAAE,4CAA4C;IACjD,SAAS,EAAE,uCAAuC;CACnD,CAAC;AASW,QAAA,iBAAiB,GAAmC;IAC/D,SAAS,EAAE,WAAW;IACtB,EAAE,EAAE,QAAQ;CACb,CAAC"}