@squidcloud/client 1.0.159 → 1.0.160

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

@@ -0,0 +1,275 @@
+import { BaseIntegrationConfig, BaseIntegrationSchema, DatabaseIntegrationType } from './schemas';
+import { CollectionSchema } from '../../schema/schema.types';
+import { CollectionName } from '../document.types';
+import { IntegrationSchemaType, IntegrationType } from '../integration-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/observability.types.d.ts

@@ -0,0 +1,24 @@
+import { BaseIntegrationConfig } from './schemas';
+import { IntegrationType } from '../integration-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

@@ -0,0 +1,40 @@
+import { IntegrationType } from '../integration-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

@@ -0,0 +1,79 @@
+import { AiChatbotIntegrationConfig } from './ai_chatbot.types';
+import { GraphQLIntegrationConfig, HttpApiIntegrationConfig, IntegrationApiSchema, IntegrationGraphQLSchema, TestGraphQLDataConnectionRequest } from './api.types';
+import { Auth0IntegrationConfig, CognitoIntegrationConfig, DescopeIntegrationConfig, JwtHmacIntegrationConfig, JwtRsaIntegrationConfig, OktaIntegrationConfig } from './auth.types';
+import { BaseDatabaseIntegrationConfig, BigQueryIntegrationConfig, CockroachIntegrationConfig, IntegrationDataSchema, InternalIntegrationConfig, MongoIntegrationConfig, MssqlIntegrationConfig, MySqlIntegrationConfig, OracleIntegrationConfig, PinotIntegrationConfig, PostgresIntegrationConfig, SnowflakeIntegrationConfig, TestDataConnectionRequest } from './database.types';
+import { DatadogIntegrationConfig, NewRelicIntegrationConfig } from './observability.types';
+import { IntegrationId } from '../communication.types';
+import { IntegrationSchemaType, IntegrationType } from '../integration-types';
+import { BuiltInQueueIntegrationConfig, ConfluentIntegrationConfig, KafkaIntegrationConfig, TestConfluentConnectionRequest, TestKafkaConnectionRequest } from './queue-types';
+export interface IntegrationConfigTypes {
+    [IntegrationType.built_in_db]: InternalIntegrationConfig;
+    [IntegrationType.mongo]: MongoIntegrationConfig;
+    [IntegrationType.mysql]: MySqlIntegrationConfig;
+    [IntegrationType.bigquery]: BigQueryIntegrationConfig;
+    [IntegrationType.oracledb]: OracleIntegrationConfig;
+    [IntegrationType.pinot]: PinotIntegrationConfig;
+    [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.pinot]: 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, IntegrationType.pinot];
+export type DatabaseIntegrationType = (typeof DatabaseIntegrationTypes)[number];
+export type DatabaseIntegrationConfig = IntegrationConfigTypes[DatabaseIntegrationType];
+export declare const ApiIntegrationTypes: readonly [IntegrationType.api, IntegrationType.graphql];
+export declare const ObservabilityIntegrationTypes: readonly [IntegrationType.datadog, IntegrationType.newrelic];
+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 ApiIntegrationType = (typeof ApiIntegrationTypes)[number];
+export type ApiIntegrationConfig = IntegrationConfigTypes[ApiIntegrationType];
+export type ObservabilityIntegrationType = (typeof ObservabilityIntegrationTypes)[number];
+export type ObservabilityIntegrationConfig = IntegrationConfigTypes[ObservabilityIntegrationType];
+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: any): integration is BaseDatabaseIntegrationConfig;
+export declare function isAuthIntegrationType(type: IntegrationType): type is AuthIntegrationType;
+export declare function isAuthIntegration(integration: any): integration is AuthIntegrationConfig;
+export interface BaseIntegrationConfig {
+    id: IntegrationId;
+    type: IntegrationTypeWithConfig;
+    creationDate: Date;
+    updateDate: Date;
+}
+export interface BaseIntegrationSchema {
+    type: IntegrationSchemaType;
+}
+export type TestConnectionRequest = TestDataConnectionRequest | TestGraphQLDataConnectionRequest | TestKafkaConnectionRequest | TestConfluentConnectionRequest;

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

@@ -0,0 +1,21 @@
+export type LoggerContext = Record<string, any>;
+export interface Logger {
+    trace(message: string, context?: LoggerContext): void;
+    debug(message: string, context?: LoggerContext): void;
+    info(message: string, context?: LoggerContext): void;
+    warn(message: string, context?: LoggerContext): void;
+    error(message: string, context?: LoggerContext): void;
+    log(record: LogRecord): void;
+}
+export declare enum LogLevel {
+    TRACE = "trace",
+    DEBUG = "debug",
+    INFO = "info",
+    WARN = "warn",
+    ERROR = "error"
+}
+export interface LogRecord {
+    level?: LogLevel;
+    message?: string;
+    [key: string]: any;
+}

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

@@ -0,0 +1 @@
+export type MetricType = 'count' | 'gauge';

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

@@ -0,0 +1,14 @@
+import { Mutation, MutationType } from './mutation.types';
+import { BeforeAndAfterDocs } from './document.types';
+import { Paths } from './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;
+}

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

@@ -0,0 +1,53 @@
+import { SquidDocIdObj } from './document.types';
+/** A mutation on a document. */
+export type Mutation<T = any> = UpdateMutation<T> | InsertMutation<T> | DeleteMutation;
+/** The mutation type. */
+export type MutationType = 'insert' | 'update' | 'delete';
+interface BaseMutation {
+    type: MutationType;
+    squidDocIdObj: SquidDocIdObj;
+}
+export interface DeleteMutation extends BaseMutation {
+    type: 'delete';
+}
+export interface UpdateMutation<T = any> extends BaseMutation {
+    type: 'update';
+    /** The updated properties */
+    properties: {
+        [key in keyof T & string]?: Array<PropertyMutation<T[key]>>;
+    };
+}
+export interface InsertMutation<T = any> extends BaseMutation {
+    type: 'insert';
+    /** The inserted document */
+    properties: T;
+}
+/** A representation of a single property update */
+export type PropertyMutation<Value = any> = ApplyNumericFnPropertyMutation | ApplyStringFnPropertyMutation | ValueUpdatePropertyMutation<Value> | RemovePropertyMutation;
+/** A value update property mutation */
+export interface ValueUpdatePropertyMutation<Value = any> {
+    type: 'update';
+    value: Value;
+}
+/** Applying a numeric function to a property */
+export interface ApplyNumericFnPropertyMutation {
+    type: 'applyNumericFn';
+    fn: 'increment';
+    value: number;
+}
+/** A property update that removes a property from a document */
+export interface RemovePropertyMutation {
+    type: 'removeProperty';
+}
+interface ApplyExtendString {
+    type: 'applyStringFn';
+    fn: 'extendString';
+    value: string;
+}
+interface ApplyTrimString {
+    type: 'applyStringFn';
+    fn: 'trim';
+}
+/** A property mutation that modifies a string */
+export type ApplyStringFnPropertyMutation = ApplyExtendString | ApplyTrimString;
+export {};

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

@@ -0,0 +1,7 @@
+import { ClientId } from './communication.types';
+/** The context provided to the secure native query function. */
+export declare class NativeQueryContext {
+    readonly query: string;
+    readonly params: Record<string, any>;
+    readonly clientId: ClientId;
+}

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

@@ -0,0 +1,16 @@
+export type NativeQueryRequestType = 'relational' | 'mongo';
+interface BaseNativeQueryRequest {
+    type: NativeQueryRequestType;
+}
+export interface RelationalNativeQueryRequest extends BaseNativeQueryRequest {
+    type: 'relational';
+    query: string;
+    params: Record<string, any>;
+}
+export interface MongoNativeQueryRequest extends BaseNativeQueryRequest {
+    type: 'mongo';
+    collectionName: string;
+    aggregationPipeline: Array<any | undefined>;
+}
+export type NativeQueryRequest = RelationalNativeQueryRequest | MongoNativeQueryRequest;
+export {};

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

@@ -0,0 +1 @@
+export {};

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

@@ -0,0 +1,62 @@
+import { Observable } from 'rxjs';
+/** The state of a pagination. */
+export interface PaginationState<ReturnType> {
+    /** The page data. */
+    data: Array<ReturnType>;
+    /** Whether there is a next page. */
+    hasNext: boolean;
+    /** Whether there is a previous page. */
+    hasPrev: boolean;
+}
+/** Pagination options */
+export interface PaginationOptions {
+    /** Whether to show real-time updates. Defaults to true. */
+    subscribe: boolean;
+    /** The number of items in a page. Defaults to 100. */
+    pageSize: number;
+}
+interface InternalState<ReturnType> {
+    data: ReturnType[];
+    extractedData: any[];
+    numBefore: number;
+    numAfter: number;
+}
+export declare class Pagination<ReturnType> {
+    private readonly options;
+    private internalStateObserver;
+    private firstElement;
+    private readonly isDestroyed;
+    private templateSnapshotEmitter;
+    private snapshotSubject;
+    private onFirstPage;
+    private navigatingToLastPage;
+    private lastElement;
+    private goToFirstPage;
+    private static compareValues;
+    private compare;
+    private dataReceived;
+    private doNewQuery;
+    private waitForInternalState;
+    private internalStateToState;
+    /** Unsubscribes from the pagination. */
+    unsubscribe(): void;
+    prevInternal(internalState: InternalState<ReturnType>): void;
+    /** Returns a promise that resolves when the previous page of data is available. */
+    prev(): Promise<PaginationState<ReturnType>>;
+    /** Returns a promise that resolves when the next page of data is available. */
+    next(): Promise<PaginationState<ReturnType>>;
+    /** Returns a promise that resolves when the page data is available. */
+    waitForData(): Promise<PaginationState<ReturnType>>;
+    /** Returns an observable that emits the current state of the pagination. */
+    observeState(): Observable<PaginationState<ReturnType>>;
+    /** Jumps to the first page of the pagination. */
+    first(): Promise<PaginationState<ReturnType>>;
+    /** Refreshes the current page of the pagination. */
+    refreshPage(): Promise<PaginationState<ReturnType>>;
+    /**
+     * Jumps to the last page of the pagination. This page will always have the last <pageSize> elements of the
+     * underlying query, regardless of whether the total document count is evenly divisible by the page size.
+     */
+    last(): Promise<PaginationState<ReturnType>>;
+}
+export {};