@squidcloud/client 1.0.166 → 1.0.168

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

@@ -1,50 +0,0 @@
-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/internal-common/src/public-types/integration.public-types.d.ts

@@ -1,61 +0,0 @@
-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",
-    '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/integrations/ai_chatbot.types.d.ts

@@ -1,32 +0,0 @@
-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/api.types.d.ts

@@ -1,81 +0,0 @@
-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/auth.types.d.ts

@@ -1,54 +0,0 @@
-import { BaseIntegrationConfig } from './schemas';
-import { IntegrationType } from '../integration.public-types';
-export interface Auth0IntegrationConfig extends BaseIntegrationConfig {
-    type: IntegrationType.auth0;
-    configuration: {
-        /** Auth0 domain. Used to build JWKS URL (https://$domain/.well-known/jwks.json) to check the JWT token signature.*/
-        domain: string;
-        /**
-         * The Auth0 audience is a parameter that ensures the JWT token is intended for the specific backend being accessed.
-         *
-         * Note: the audience for the web-app auth token is equal to the Auth0 web client id: it means that the web app
-         * client is a target audience for the JWT token. Such JWT tokens (ID tokens) should not be sent to the backend:
-         * backend calls should use another kind of JWT tokens (access tokens) issued by Auth0 for the backends.
-         */
-        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/database.types.d.ts

@@ -1,206 +0,0 @@
-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 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 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;
-}
-export interface MySqlIntegrationConfiguration {
-    connectionOptions: MySqlConnectionOptions;
-}
-export interface BigQueryIntegrationConfiguration {
-    connectionOptions: BigQueryConnectionOptions;
-}
-export interface OracleIntegrationConfiguration {
-    connectionOptions: OracleConnectionOptions;
-}
-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 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;
-}
-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;
-}
-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/observability.types.d.ts

@@ -1,24 +0,0 @@
-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/queue-types.d.ts

@@ -1,40 +0,0 @@
-import { IntegrationType } from '../integration.public-types';
-import { BaseIntegrationConfig, QueueIntegrationTypes } from './schemas';
-export type QueueIntegrationType = (typeof QueueIntegrationTypes)[number];
-export interface BaseQueueIntegrationConfig extends BaseIntegrationConfig {
-    type: QueueIntegrationType;
-}
-export interface KafkaConnectionSecretOptions {
-    password?: string;
-}
-export interface KafkaConnectionOptions {
-    secrets?: KafkaConnectionSecretOptions;
-    username?: string;
-    bootstrapServers: string;
-}
-export interface KafkaIntegrationConfiguration {
-    connectionOptions: KafkaConnectionOptions;
-}
-export interface KafkaIntegrationConfig extends BaseQueueIntegrationConfig {
-    type: IntegrationType.kafka;
-    configuration: KafkaIntegrationConfiguration;
-}
-export interface ConfluentIntegrationConfig extends BaseQueueIntegrationConfig {
-    type: IntegrationType.confluent;
-    configuration: KafkaIntegrationConfiguration;
-}
-export interface BuiltInQueueIntegrationConfig extends BaseQueueIntegrationConfig {
-    type: IntegrationType.built_in_queue;
-}
-export interface TestKafkaConnectionRequest {
-    type: IntegrationType.kafka;
-    configuration: {
-        connectionOptions: KafkaConnectionOptions;
-    };
-}
-export interface TestConfluentConnectionRequest {
-    type: IntegrationType.confluent;
-    configuration: {
-        connectionOptions: KafkaConnectionOptions;
-    };
-}

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

@@ -1,70 +0,0 @@
-import { AiChatbotIntegrationConfig } from './ai_chatbot.types';
-import { GraphQLIntegrationConfig, HttpApiIntegrationConfig, IntegrationApiSchema, IntegrationGraphQLSchema } from './api.types';
-import { Auth0IntegrationConfig, CognitoIntegrationConfig, DescopeIntegrationConfig, JwtHmacIntegrationConfig, JwtRsaIntegrationConfig, OktaIntegrationConfig } from './auth.types';
-import { BaseDatabaseIntegrationConfig, BigQueryIntegrationConfig, CockroachIntegrationConfig, IntegrationDataSchema, InternalIntegrationConfig, MongoIntegrationConfig, MssqlIntegrationConfig, MySqlIntegrationConfig, OracleIntegrationConfig, PostgresIntegrationConfig, SnowflakeIntegrationConfig } from './database.types';
-import { DatadogIntegrationConfig, NewRelicIntegrationConfig } from './observability.types';
-import { IntegrationSchemaType, IntegrationType } from '../integration.public-types';
-import { BuiltInQueueIntegrationConfig, ConfluentIntegrationConfig, KafkaIntegrationConfig } from './queue-types';
-import { IntegrationId } from '../communication.public-types';
-export interface IntegrationConfigTypes {
-    [IntegrationType.built_in_db]: InternalIntegrationConfig;
-    [IntegrationType.mongo]: MongoIntegrationConfig;
-    [IntegrationType.mysql]: MySqlIntegrationConfig;
-    [IntegrationType.bigquery]: BigQueryIntegrationConfig;
-    [IntegrationType.oracledb]: OracleIntegrationConfig;
-    [IntegrationType.mssql]: MssqlIntegrationConfig;
-    [IntegrationType.postgres]: PostgresIntegrationConfig;
-    [IntegrationType.cockroach]: CockroachIntegrationConfig;
-    [IntegrationType.snowflake]: SnowflakeIntegrationConfig;
-    [IntegrationType.api]: HttpApiIntegrationConfig;
-    [IntegrationType.graphql]: GraphQLIntegrationConfig;
-    [IntegrationType.datadog]: DatadogIntegrationConfig;
-    [IntegrationType.newrelic]: NewRelicIntegrationConfig;
-    [IntegrationType.auth0]: Auth0IntegrationConfig;
-    [IntegrationType.jwt_rsa]: JwtRsaIntegrationConfig;
-    [IntegrationType.jwt_hmac]: JwtHmacIntegrationConfig;
-    [IntegrationType.ai_chatbot]: AiChatbotIntegrationConfig;
-    [IntegrationType.cognito]: CognitoIntegrationConfig;
-    [IntegrationType.okta]: OktaIntegrationConfig;
-    [IntegrationType.kafka]: KafkaIntegrationConfig;
-    [IntegrationType.confluent]: ConfluentIntegrationConfig;
-    [IntegrationType.built_in_queue]: BuiltInQueueIntegrationConfig;
-    [IntegrationType.descope]: DescopeIntegrationConfig;
-}
-export interface IntegrationSchemaTypes {
-    [IntegrationType.built_in_db]: IntegrationDataSchema;
-    [IntegrationType.mongo]: IntegrationDataSchema;
-    [IntegrationType.mysql]: IntegrationDataSchema;
-    [IntegrationType.oracledb]: IntegrationDataSchema;
-    [IntegrationType.bigquery]: IntegrationDataSchema;
-    [IntegrationType.mssql]: IntegrationDataSchema;
-    [IntegrationType.postgres]: IntegrationDataSchema;
-    [IntegrationType.cockroach]: IntegrationDataSchema;
-    [IntegrationType.snowflake]: IntegrationDataSchema;
-    [IntegrationType.api]: IntegrationApiSchema;
-    [IntegrationType.graphql]: IntegrationGraphQLSchema;
-}
-export type IntegrationTypeWithConfig = keyof IntegrationConfigTypes;
-export type IntegrationSchemaKeys = keyof IntegrationSchemaTypes;
-export type IntegrationConfig = IntegrationConfigTypes[IntegrationTypeWithConfig];
-export type IntegrationSchema = IntegrationSchemaTypes[IntegrationSchemaKeys];
-export declare const DatabaseIntegrationTypes: readonly [IntegrationType.built_in_db, IntegrationType.mongo, IntegrationType.mysql, IntegrationType.bigquery, IntegrationType.mssql, IntegrationType.postgres, IntegrationType.cockroach, IntegrationType.snowflake, IntegrationType.oracledb];
-export type DatabaseIntegrationType = (typeof DatabaseIntegrationTypes)[number];
-export type DatabaseIntegrationConfig = IntegrationConfigTypes[DatabaseIntegrationType];
-export declare const AuthIntegrationTypes: readonly [IntegrationType.auth0, IntegrationType.jwt_rsa, IntegrationType.jwt_hmac, IntegrationType.cognito, IntegrationType.okta, IntegrationType.descope];
-export declare const QueueIntegrationTypes: readonly [IntegrationType.built_in_queue, IntegrationType.kafka, IntegrationType.confluent];
-export type AuthIntegrationType = (typeof AuthIntegrationTypes)[number];
-export type AuthIntegrationConfig = IntegrationConfigTypes[AuthIntegrationType];
-export declare function isDataIntegrationType(type: unknown): type is DatabaseIntegrationType;
-export declare function isDataIntegration(integration: unknown): integration is BaseDatabaseIntegrationConfig;
-export declare function isAuthIntegrationType(type: unknown): type is AuthIntegrationType;
-export declare function isAuthIntegration(integration: unknown): integration is AuthIntegrationConfig;
-export interface BaseIntegrationConfig {
-    id: IntegrationId;
-    type: IntegrationTypeWithConfig;
-    creationDate?: Date;
-    updateDate?: Date;
-}
-export interface BaseIntegrationSchema {
-    type: IntegrationSchemaType;
-}

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

@@ -1,14 +0,0 @@
-import { Paths } from './typescript.public-types';
-import { BeforeAndAfterDocs } from './document.public-types';
-import { Mutation, MutationType } from './mutation.public-types';
-/** The mutation context that will be provided to the security function. */
-export declare class MutationContext<T = any> {
-    readonly mutation: Mutation<T>;
-    readonly beforeAndAfterDocs: BeforeAndAfterDocs<T>;
-    readonly serverTimeStamp: Date;
-    getMutationType(): MutationType;
-    get before(): T | undefined;
-    get after(): T | undefined;
-    /** Returns true if the mutation affects the provided path. */
-    affectsPath(path: Paths<T>): boolean;
-}