@squidcloud/client 1.0.101 → 1.0.103

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

@@ -1 +1,66 @@
-export {};
+import { IntegrationSchemaType } from './integrations';
+export declare const UpsertIntegrationSchemaRequestSchema: {
+    type: string;
+    required: string[];
+    properties: {
+        id: {
+            type: string;
+            nullable: boolean;
+        };
+        type: {
+            type: string;
+            nullable: boolean;
+        };
+        schema: {
+            oneOf: ({
+                type: string;
+                required: string[];
+                properties: {
+                    type: {
+                        const: IntegrationSchemaType;
+                    };
+                    collections: {
+                        type: string;
+                        nullable: boolean;
+                    };
+                    baseUrl?: undefined;
+                    endpoints?: undefined;
+                    introspection?: undefined;
+                };
+            } | {
+                type: string;
+                required: string[];
+                properties: {
+                    type: {
+                        const: IntegrationSchemaType;
+                    };
+                    baseUrl: {
+                        type: string;
+                        nullable: boolean;
+                    };
+                    endpoints: {
+                        type: string;
+                        nullable: boolean;
+                    };
+                    collections?: undefined;
+                    introspection?: undefined;
+                };
+            } | {
+                type: string;
+                required: string[];
+                properties: {
+                    type: {
+                        const: IntegrationSchemaType;
+                    };
+                    introspection: {
+                        type: string;
+                        nullable: boolean;
+                    };
+                    collections?: undefined;
+                    baseUrl?: undefined;
+                    endpoints?: undefined;
+                };
+            })[];
+        };
+    };
+};

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

@@ -1,5 +1,5 @@
 import { AppId, EnvironmentId, IntegrationId } from './communication.types';
-import { AiAssistantConfiguration, GraphQLConnectionOptions, IntegrationAiAssistantSchema, IntegrationApiSchema, IntegrationDataSchema, IntegrationGraphQLSchema, IntegrationType, MongoConnectionOptions, MssqlConnectionOptions, MySqlConnectionOptions, OpenApiDiscoveryOptions, OracleConnectionOptions, PostgresConnectionOptions, SnowflakeConnectionOptions } from './integrations';
+import { AuthIntegrationType, DatabaseIntegrationType, IntegrationConfig, IntegrationConfigTypes, IntegrationSchema, IntegrationSchemaKeys, IntegrationSchemaTypes, IntegrationType, IntegrationTypeWithConfig } from './integrations';
 /** A type alias for a string that represents a webhook. */
 export type WebhookId = string;
 /** A type alias for a string that represents a named query. */
@@ -96,81 +96,6 @@ export declare enum CronExpression {
     MONDAY_TO_FRIDAY_AT_10PM = "0 0 22 * * 1-5",
     MONDAY_TO_FRIDAY_AT_11PM = "0 0 23 * * 1-5"
 }
-interface BaseUpsertDataIntegrationRequest extends BaseUpsertIntegrationRequest {
-    supportsExternalChanges?: boolean;
-}
-export interface UpsertInternalIntegrationRequest extends BaseUpsertDataIntegrationRequest {
-    type: IntegrationType.built_in_db;
-    schema?: IntegrationDataSchema;
-}
-export interface UpsertMongoDbIntegrationRequest extends BaseUpsertDataIntegrationRequest {
-    type: IntegrationType.mongo;
-    schema?: IntegrationDataSchema;
-    configuration: {
-        connectionOptions: MongoConnectionOptions;
-    };
-}
-export interface UpsertMySqlIntegrationRequest extends BaseUpsertDataIntegrationRequest {
-    type: IntegrationType.mysql;
-    schema?: IntegrationDataSchema;
-    configuration: {
-        connectionOptions: MySqlConnectionOptions;
-    };
-}
-export interface UpsertOracleIntegrationRequest extends BaseUpsertDataIntegrationRequest {
-    type: IntegrationType.oracledb;
-    schema?: IntegrationDataSchema;
-    configuration: {
-        connectionOptions: OracleConnectionOptions;
-    };
-}
-export interface UpsertMssqlIntegrationRequest extends BaseUpsertDataIntegrationRequest {
-    type: IntegrationType.mssql;
-    schema?: IntegrationDataSchema;
-    configuration: {
-        connectionOptions: MssqlConnectionOptions;
-    };
-}
-export interface UpsertPostgresIntegrationRequest extends BaseUpsertDataIntegrationRequest {
-    type: IntegrationType.postgres;
-    schema?: IntegrationDataSchema;
-    configuration: {
-        connectionOptions: PostgresConnectionOptions;
-    };
-}
-export interface UpsertCockroachIntegrationRequest extends BaseUpsertDataIntegrationRequest {
-    type: IntegrationType.cockroach;
-    schema?: IntegrationDataSchema;
-    configuration: {
-        connectionOptions: PostgresConnectionOptions;
-    };
-}
-export interface UpsertSnowflakeIntegrationRequest extends BaseUpsertDataIntegrationRequest {
-    type: IntegrationType.snowflake;
-    schema?: IntegrationDataSchema;
-    configuration: {
-        connectionOptions: SnowflakeConnectionOptions;
-    };
-}
-export interface UpsertGraphQLIntegrationRequest extends BaseUpsertIntegrationRequest {
-    type: IntegrationType.graphql;
-    schema?: IntegrationGraphQLSchema;
-    configuration: {
-        connectionOptions: GraphQLConnectionOptions;
-    };
-}
-export interface UpsertApiIntegrationRequest extends BaseUpsertIntegrationRequest {
-    type: IntegrationType.api;
-    schema?: IntegrationApiSchema;
-    configuration?: {
-        discoveryOptions: OpenApiDiscoveryOptions;
-    };
-}
-export interface UpsertAiAssistantIntegrationRequest extends BaseUpsertIntegrationRequest {
-    type: IntegrationType.ai_assistant;
-    schema?: IntegrationAiAssistantSchema;
-    configuration: AiAssistantConfiguration;
-}
 export interface DeleteIntegrationRequest {
     integrationId: IntegrationId;
 }
@@ -181,4 +106,35 @@ export interface CreateEnvironmentRequest {
     sourceAppId: AppId;
     environmentId: EnvironmentId;
 }
+interface BaseUpsertIntegrationRequest<T extends IntegrationTypeWithConfig, C extends IntegrationConfig> {
+    id: IntegrationId;
+    type: T;
+    config: Partial<C>;
+}
+type ConfigurationTypes = {
+    [K in IntegrationTypeWithConfig]: IntegrationConfigTypes[K];
+};
+type UpsertIntegrationRequests = {
+    [K in IntegrationTypeWithConfig]: BaseUpsertIntegrationRequest<K, ConfigurationTypes[K]>;
+};
+export type UpsertDataIntegrationRequest = UpsertIntegrationRequests[DatabaseIntegrationType];
+export type UpsertGraphQLIntegrationRequest = UpsertIntegrationRequests[IntegrationType.graphql];
+export type UpsertApiIntegrationRequest = UpsertIntegrationRequests[IntegrationType.api];
+export type UpsertAiAssistantIntegrationRequest = UpsertIntegrationRequests[IntegrationType.ai_assistant];
+export type UpsertAuthIntegrationRequest = UpsertIntegrationRequests[AuthIntegrationType];
+interface BaseUpsertIntegrationSchemaRequest<T extends IntegrationType, S extends IntegrationSchema> {
+    id: IntegrationId;
+    type: T;
+    schema: S;
+}
+type SchemaTypes = {
+    [K in IntegrationSchemaKeys]: IntegrationSchemaTypes[K];
+};
+type UpsertIntegrationSchemaRequests = {
+    [K in IntegrationSchemaKeys]: BaseUpsertIntegrationSchemaRequest<K, SchemaTypes[K]>;
+};
+export type UpsertIntegrationSchemaRequest = UpsertDataIntegrationSchemaRequest | UpsertGraphQLIntegrationSchemaRequest | UpsertApiIntegrationSchemaRequest;
+export type UpsertDataIntegrationSchemaRequest = UpsertIntegrationSchemaRequests[DatabaseIntegrationType];
+export type UpsertGraphQLIntegrationSchemaRequest = UpsertIntegrationSchemaRequests[IntegrationType.graphql];
+export type UpsertApiIntegrationSchemaRequest = UpsertIntegrationSchemaRequests[IntegrationType.api];
 export {};

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

@@ -51,3 +51,5 @@ export * from './utils/url';
 export * from './utils/validation';
 export * from './webhook-response';
 export * from './heartbeat.types';
+export * from './utils/global.utils';
+export * from './websocket.impl';

package/dist/common/src/integrations/ai_assistant.types.d.ts

@@ -1,30 +1,24 @@
 import { BaseIntegrationConfig, IntegrationType } from './index';
-import { IntegrationId } from '../communication.types';
 export interface AiAssistantIntegrationConfig extends BaseIntegrationConfig {
     type: IntegrationType.ai_assistant;
     configuration: AiAssistantConfiguration;
-    schema: IntegrationAiAssistantSchema;
 }
 export type AiAssistantConfiguration = {
     apiKey?: string;
 };
-export type AiAssistantProfile = {
+export type AiAssistantProfileMetadata = {
     modelName: string;
     strictContext: boolean;
     instructions: Record<string, string>;
-    contexts: Record<string, AiAssistantContextMetadata>;
 };
 export type AiAssistantContextMetadata = {
     title: string;
     text: string;
     preview: boolean;
 };
-export interface IntegrationAiAssistantSchema {
-    profiles: Record<string, AiAssistantProfile>;
-}
-export interface DiscoverAiAssistantSchemaRequest {
-    integrationId: IntegrationId;
+export interface AiAssistantProfile extends AiAssistantProfileMetadata {
+    contexts: Record<string, AiAssistantContextMetadata>;
 }
-export interface DiscoverAiAssistantSchemaResponse {
-    schema: IntegrationAiAssistantSchema;
+export interface AiAssistantProfiles {
+    profiles: Record<string, AiAssistantProfile>;
 }

package/dist/common/src/integrations/api.types.d.ts

@@ -1,6 +1,6 @@
 import { FieldName } from '../document.types';
 import { IntrospectionQuery } from '../graphql.types';
-import { BaseIntegrationConfig, IntegrationType } from './index';
+import { BaseIntegrationConfig, BaseIntegrationSchema, IntegrationSchemaType, IntegrationType } from './index';
 export type HttpMethod = 'post' | 'get' | 'delete' | 'patch' | 'put';
 export type ApiEndpointId = string;
 export type ApiParameterLocation = 'query' | 'body' | 'header' | 'path';
@@ -8,10 +8,12 @@ export type ApiResponseParameterLocation = 'header' | 'body';
 export type ApiInjectionParameterLocation = 'header' | 'query';
 export type FieldPath = string;
 export type IntegrationApiEndpoints = Record<ApiEndpointId, ApiEndpoint>;
-export interface IntegrationGraphQLSchema {
+export interface IntegrationGraphQLSchema extends BaseIntegrationSchema {
+    type: IntegrationSchemaType.graphql;
     introspection: IntrospectionQuery;
 }
-export interface IntegrationApiSchema {
+export interface IntegrationApiSchema extends BaseIntegrationSchema {
+    type: IntegrationSchemaType.api;
     baseUrl: string;
     endpoints: IntegrationApiEndpoints;
     injectionSchema?: ApiInjectionSchema;
@@ -49,11 +51,9 @@ export interface HttpApiIntegrationConfig extends BaseIntegrationConfig {
     configuration?: {
         discoveryOptions: OpenApiDiscoveryOptions;
     };
-    schema: IntegrationApiSchema;
 }
 export interface GraphQLIntegrationConfig extends BaseIntegrationConfig {
     type: IntegrationType.graphql;
-    schema?: IntegrationGraphQLSchema;
     configuration: {
         connectionOptions: GraphQLConnectionOptions;
     };

package/dist/common/src/integrations/database.types.d.ts

@@ -1,6 +1,6 @@
 import { CollectionName } from '../document.types';
 import { CollectionSchema } from '../schema/schema.types';
-import { BaseIntegrationConfig, DatabaseIntegrationType, IntegrationType } from './index';
+import { BaseIntegrationConfig, BaseIntegrationSchema, DatabaseIntegrationType, IntegrationSchemaType, IntegrationType } from './index';
 export interface MongoConnectionSecretOptions {
     password?: string;
 }
@@ -78,12 +78,12 @@ export interface SnowflakeConnectionOptions {
     role: string;
 }
 type TableName = string;
-export interface IntegrationDataSchema {
+export interface IntegrationDataSchema extends BaseIntegrationSchema {
+    type: IntegrationSchemaType.data;
     collections: Record<TableName, CollectionSchema>;
 }
 export interface BaseDatabaseIntegrationConfig extends BaseIntegrationConfig {
     type: DatabaseIntegrationType;
-    schema?: IntegrationDataSchema;
     supportsExternalChanges: boolean;
 }
 export interface MySqlIntegrationConfiguration {
@@ -107,22 +107,18 @@ export interface SnowflakeIntegrationConfiguration {
 export interface MySqlIntegrationConfig extends BaseDatabaseIntegrationConfig {
     type: IntegrationType.mysql;
     configuration: MySqlIntegrationConfiguration;
-    schema: IntegrationDataSchema;
 }
 export interface OracleIntegrationConfig extends BaseDatabaseIntegrationConfig {
     type: IntegrationType.oracledb;
     configuration: OracleIntegrationConfiguration;
-    schema: IntegrationDataSchema;
 }
 export interface MssqlIntegrationConfig extends BaseDatabaseIntegrationConfig {
     type: IntegrationType.mssql;
     configuration: MssqlIntegrationConfiguration;
-    schema: IntegrationDataSchema;
 }
 export interface BasePostgresIntegration extends BaseDatabaseIntegrationConfig {
     type: IntegrationType.postgres | IntegrationType.cockroach;
     configuration: PostgresIntegrationConfiguration;
-    schema: IntegrationDataSchema;
 }
 export interface PostgresIntegrationConfig extends BasePostgresIntegration {
     type: IntegrationType.postgres;
@@ -141,7 +137,6 @@ export interface MongoIntegrationConfig extends BaseDatabaseIntegrationConfig {
 export interface SnowflakeIntegrationConfig extends BaseDatabaseIntegrationConfig {
     type: IntegrationType.snowflake;
     configuration: SnowflakeIntegrationConfiguration;
-    schema: IntegrationDataSchema;
     supportsExternalChanges: false;
 }
 interface TestMongoDataConnectionRequest {

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

@@ -5,9 +5,9 @@ export * from './database.types';
 export * from './observability.types';
 import { IntegrationId } from '../communication.types';
 import { AiAssistantIntegrationConfig } from './ai_assistant.types';
-import { GraphQLIntegrationConfig, HttpApiIntegrationConfig, TestGraphQLDataConnectionRequest } from './api.types';
+import { GraphQLIntegrationConfig, HttpApiIntegrationConfig, IntegrationApiSchema, IntegrationGraphQLSchema, TestGraphQLDataConnectionRequest } from './api.types';
 import { Auth0IntegrationConfig, CognitoIntegrationConfig, JwtHmacIntegrationConfig, JwtRsaIntegrationConfig, OktaIntegrationConfig } from './auth.types';
-import { BaseDatabaseIntegrationConfig, CockroachIntegrationConfig, InternalIntegrationConfig, MongoIntegrationConfig, MssqlIntegrationConfig, MySqlIntegrationConfig, OracleIntegrationConfig, PostgresIntegrationConfig, SnowflakeIntegrationConfig, TestDataConnectionRequest } from './database.types';
+import { BaseDatabaseIntegrationConfig, CockroachIntegrationConfig, IntegrationDataSchema, InternalIntegrationConfig, MongoIntegrationConfig, MssqlIntegrationConfig, MySqlIntegrationConfig, OracleIntegrationConfig, PostgresIntegrationConfig, SnowflakeIntegrationConfig, TestDataConnectionRequest } from './database.types';
 import { DatadogIntegrationConfig, NewRelicIntegrationConfig } from './observability.types';
 export declare enum IntegrationCategory {
     'database' = "database",
@@ -55,6 +55,11 @@ export declare enum IntegrationType {
     'xata' = "xata",
     'azure_sql' = "azure_sql"
 }
+export declare enum IntegrationSchemaType {
+    'data' = "data",
+    'api' = "api",
+    'graphql' = "graphql"
+}
 export interface IntegrationConfigTypes {
     [IntegrationType.built_in_db]: InternalIntegrationConfig;
     [IntegrationType.mongo]: MongoIntegrationConfig;
@@ -75,6 +80,22 @@ export interface IntegrationConfigTypes {
     [IntegrationType.cognito]: CognitoIntegrationConfig;
     [IntegrationType.okta]: OktaIntegrationConfig;
 }
+export interface IntegrationSchemaTypes {
+    [IntegrationType.built_in_db]: IntegrationDataSchema;
+    [IntegrationType.mongo]: IntegrationDataSchema;
+    [IntegrationType.mysql]: IntegrationDataSchema;
+    [IntegrationType.oracledb]: 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.mssql, IntegrationType.postgres, IntegrationType.cockroach, IntegrationType.snowflake, IntegrationType.oracledb];
 export type DatabaseIntegrationType = (typeof DatabaseIntegrationTypes)[number];
 export type DatabaseIntegrationConfig = IntegrationConfigTypes[DatabaseIntegrationType];
@@ -91,11 +112,13 @@ export declare function isDataIntegrationType(type: IntegrationType): type is Da
 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 type IntegrationConfig = DatabaseIntegrationConfig | ApiIntegrationConfig | ObservabilityIntegrationConfig | AuthIntegrationConfig | AiAssistantIntegrationConfig;
 export interface BaseIntegrationConfig {
     id: IntegrationId;
-    type: IntegrationType;
+    type: IntegrationTypeWithConfig;
     creationDate: Date;
     updateDate: Date;
 }
+export interface BaseIntegrationSchema {
+    type: IntegrationSchemaType;
+}
 export type TestConnectionRequest = TestDataConnectionRequest | TestGraphQLDataConnectionRequest;

package/dist/common/src/query/base-query-builder.d.ts

@@ -2,6 +2,7 @@ import { Observable } from 'rxjs';
 import { DocumentData, FieldName, PrimitiveFieldType } from '../document.types';
 import { Operator } from '../query.types';
 import { SerializedQuery } from './serialized-query.types';
+import { PaginationOptions, Pagination } from './pagination';
 export interface SnapshotEmitter<ReturnType> {
     /**
      * Returns a promise that resolves to the query results.
@@ -144,53 +145,3 @@ export interface HasDereference {
      */
     dereference(): any;
 }
-/** The state of a pagination. */
-export interface PaginationState<ReturnType> {
-    data: Array<ReturnType>;
-    hasNext: boolean;
-    hasPrev: boolean;
-    isLoading: 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;
-}
-/** A query wrapper that provides pagination functionality. */
-export declare class Pagination<ReturnType> {
-    private readonly templateSnapshotEmitter;
-    /**
-     * The first page data - only available when subscribe is true.
-     * It is used for:
-     * 1 - Telling whether there is a previous page
-     * 2 - Used as the data when the current page has less than page size and hasNext = true
-     */
-    private readonly firstPageSnapshotEmitterWrapper;
-    private readonly firstPageDataAvailable;
-    /**
-     * The last page data - only available when subscribe is true. Lazily initialized when calling prev.
-     * It is used for telling whether there is a next result after calling prev.
-     */
-    private lastPageSnapshotEmitterWrapper;
-    private lastPageDataAvailable;
-    private readonly isDestroyed;
-    private readonly destroyedObs;
-    private readonly _observeState;
-    /** The current snapshot emitter wrapper. */
-    private readonly currentPageSnapshotEmitterWrapperSubject;
-    private readonly options;
-    /** Requests the next page. */
-    next(): Promise<PaginationState<ReturnType>>;
-    /** Requests the previous page. */
-    prev(): Promise<PaginationState<ReturnType>>;
-    /** Unsubscribe from the pagination object and from the query. */
-    unsubscribe(): void;
-    /** The current pagination state and data. */
-    observeState(): Observable<PaginationState<ReturnType>>;
-    /** Wait for the data to be available (the isLoading flag to be false). */
-    waitForData(): Promise<PaginationState<ReturnType>>;
-    private createLastPageSnapshotEmitterWrapper;
-    private resetToFirstPageData;
-}

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

@@ -1,3 +1,4 @@
 export * from './query-context';
 export * from './base-query-builder';
 export * from './serialized-query.types';
+export * from './pagination';

package/dist/common/src/query/pagination.d.ts

@@ -0,0 +1,44 @@
+import { Observable } from 'rxjs';
+/** The state of a pagination. */
+export interface PaginationState<ReturnType> {
+    data: Array<ReturnType>;
+    hasNext: boolean;
+    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 lastElement;
+    private readonly isDestroyed;
+    private templateSnapshotEmitter;
+    private snapshotSubject;
+    private onFirstPage;
+    private goToFirstPage;
+    private static compareValues;
+    private compare;
+    dataReceived(data: Array<ReturnType>): Promise<void>;
+    private doNewQuery;
+    private waitForInternalState;
+    private internalStateToState;
+    unsubscribe(): void;
+    prevInternal(internalState: InternalState<ReturnType>): void;
+    prev(): Promise<PaginationState<ReturnType>>;
+    next(): Promise<PaginationState<ReturnType>>;
+    waitForData(): Promise<PaginationState<ReturnType>>;
+    observeState(): Observable<PaginationState<ReturnType>>;
+}
+export {};

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

@@ -50,6 +50,11 @@ export interface Query<Doc extends DocumentData = any> {
     conditions: Conditions<Doc>;
     sortOrder: Array<FieldSort<Doc>>;
     limit: number;
+    limitBy?: {
+        limit: number;
+        fields: Array<FieldName<Doc>>;
+        reverseSort: boolean;
+    };
 }
 export interface QueryRegisterRequest {
     clientRequestId: ClientRequestId;

package/dist/common/src/utils/global.utils.d.ts

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

package/dist/common/src/websocket.impl.d.ts

@@ -0,0 +1,21 @@
+interface Options {
+    maxAttempts?: number;
+    protocols?: string[];
+    onmessage?: (event: any) => void;
+    onopen?: (event: any) => void;
+    onclose?: (event: any) => void;
+    onerror?: (event: any) => void;
+    onreconnect?: (event: any) => void;
+    onmaximum?: (event: any) => void;
+    timeout?: number;
+}
+export interface WebSocketWrapper {
+    open: () => void;
+    reconnect: (e: any) => void;
+    json: (x: any) => void;
+    send: (x: string) => void;
+    close: (x?: number, y?: string) => void;
+    connected: boolean;
+}
+export declare function createWebSocketWrapper(url: string, opts?: Options): WebSocketWrapper;
+export {};