@squidcloud/client 1.0.168 → 1.0.169

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

@@ -0,0 +1,14 @@
+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;
+}

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

@@ -0,0 +1,53 @@
+import { SquidDocIdObj } from './document.public-types';
+interface BaseMutation {
+    type: MutationType;
+    squidDocIdObj: SquidDocIdObj;
+}
+/** A mutation on a document. */
+export type Mutation<T = any> = UpdateMutation<T> | InsertMutation<T> | DeleteMutation;
+/** The mutation type. */
+export type MutationType = 'insert' | 'update' | 'delete';
+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.public-context.d.ts

@@ -0,0 +1,7 @@
+import { ClientId } from './communication.public-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.public-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/pagination.public-types.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 {};

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

@@ -0,0 +1,137 @@
+import { FieldSort, Operator, Query, SimpleCondition } from './query.public-types';
+import { DeepRecord, FieldOf, PartialBy, Paths } from './typescript.public-types';
+import { CollectionName, DocumentData } from './document.public-types';
+import { IntegrationId } from './communication.public-types';
+export declare class QueryContext<T extends DocumentData = any> {
+    readonly query: Query<T>;
+    private readonly parsedConditions;
+    /**
+     * The ID of the integration being queried.
+     */
+    get integrationId(): IntegrationId;
+    /**
+     * The name of the collection being queried.
+     */
+    get collectionName(): CollectionName;
+    /**
+     * The query limit if one exists, -1 otherwise.
+     */
+    get limit(): number;
+    /**
+     * Verifies that the query's sort order aligns with the provided field sorts. The fields specified in the `sorts`
+     * parameter must appear in the exact order at the beginning of the query's sort sequence. The query can include
+     * additional fields in its sort order, but only after the specified sorts.
+     *
+     * @param sorts An array of field sorts.
+     * @returns Whether the query's sorts matches the provided field sorts.
+     */
+    sortedBy(sorts: Array<PartialBy<FieldSort<T>, 'asc'>>): boolean;
+    /**
+     * Verifies that the query's sort order exactly matches the provided field sorts. The fields specified in the
+     * `sorts` parameter must appear in the exact order in the query's sort sequence. No additional sorts may be present
+     * in the query.
+     *
+     * @param sorts An array of field sorts.
+     * @returns Whether the query's sorts exactly match the provided field sorts.
+     */
+    sortedByExact(sorts: Array<PartialBy<FieldSort<T>, 'asc'>>): boolean;
+    /**
+     * Verifies that the query is a subquery of the specified condition. A subquery is defined as a query that evaluates
+     * to a subset of the results that would be obtained by applying the parent condition. The subquery may also include
+     * additional conditions, as these only narrow the result set.
+     *
+     * @param fieldName The name of the field for the condition.
+     * @param operator The operator of the condition.
+     * @param value The value of the condition.
+     * @returns Whether the query is a subquery of the parent condition.
+     */
+    isSubqueryOf<F extends Paths<T>, O extends AllOperators>(fieldName: F, operator: O, value: GenericValue<T, F, O> | null): boolean;
+    /**
+     * Verifies that the query is a subquery of the specified condition. A subquery is defined as a query that evaluates
+     * to a subset of the results that would be obtained by applying the parent condition. The subquery may also include
+     * additional conditions, as these only narrow the result set.
+     *
+     * @param condition The condition to validate.
+     * @returns Whether the query is a subquery of the parent condition.
+     */
+    isSubqueryOfCondition(condition: GeneralCondition<T>): boolean;
+    /**
+     * Verifies that the query is a subquery of the specified conditions. A subquery is defined as a query that evaluates
+     * to a subset of the results that would be obtained by applying the parent conditions. The subquery may also include
+     * additional conditions, as these only narrow the result set.
+     *
+     * @param conditions The conditions to validate.
+     * @returns Whether the query includes subquery of the parent conditions.
+     */
+    isSubqueryOfConditions(conditions: GeneralConditions<T>): boolean;
+    /**
+     * Verifies that the query is a subquery of the specified query. A subquery is defined as a query that evaluates
+     * to a subset of the results that obtained for the parent query, including sorts and limits.
+     *
+     * @param query The query to validate.
+     * @returns Whether the query is a subquery of the parent query.
+     */
+    isSubqueryOfQuery(query: Query<T>): boolean;
+    /**
+     * Returns all conditions that apply to any of the specified field names. This method
+     * provides a convenient way to retrieve all conditions that involve a specific set of fields.
+     *
+     * @param fieldNames The field names for which to retrieve conditions.
+     * @returns An array of conditions that involve any of the specified field names.
+     */
+    getConditionsFor<K extends Paths<T>>(...fieldNames: Array<K>): ContextConditions<T, K>;
+    /**
+     * Returns all conditions that apply to the specified field name. This method provides
+     * a convenient way to retrieve all conditions that involve a specific field.
+     *
+     * @param fieldName The field name for which to retrieve conditions.
+     * @returns An array of conditions that involve the specified field name.
+     */
+    getConditionsForField<K extends Paths<T>>(fieldName: K): ContextConditions<T>;
+    /**
+     * Returns true if the given document can be a result of the query.
+     * The method does not account for limit and sort order.
+     */
+    documentMatchesQuery(doc: DocumentData): boolean;
+    /**
+     * Compares a condition against a given operator and value to determine if the
+     * provided condition is a subset of the operator and value. A condition is
+     * considered a subset if all values that satisfy (return true for) the
+     * condition also satisfy the operator and value.
+     *
+     * This is done using the underlying CompareTable, which provides a comparison
+     * function for each operator pair, or undefined if the comparison would
+     * always be false, regardless of the values.
+     */
+    private evaluateSubset;
+    private evaluateIncludes;
+    private parseConditions;
+}
+/** A list of context conditions */
+export type ContextConditions<Doc extends DocumentData = any, F extends Paths<Doc> = Paths<Doc>> = Array<ContextCondition<Doc, F>>;
+/** A Context condition - a condition that replaces multiple '==' or '!=' conditions with 'in' and 'not in'. */
+type ContextCondition<Doc extends DocumentData = any, F extends Paths<Doc> = Paths<Doc>> = InContextCondition<Doc, F> | NotInContextCondition<Doc, F> | OtherContextCondition<Doc, F>;
+interface InContextCondition<Doc extends DocumentData = any, F extends Paths<Doc> = Paths<Doc>> extends SimpleCondition<Doc, F, 'in'> {
+    operator: 'in';
+    value: Array<FieldOf<DeepRecord<Doc>, Paths<Doc>> | any>;
+}
+interface NotInContextCondition<Doc extends DocumentData = any, F extends Paths<Doc> = Paths<Doc>> extends SimpleCondition<Doc, F, 'not in'> {
+    operator: 'not in';
+    value: Array<FieldOf<DeepRecord<Doc>, Paths<Doc>> | any>;
+}
+interface OtherContextCondition<Doc extends DocumentData = any, F extends Paths<Doc> = Paths<Doc>> extends SimpleCondition<Doc, F, Exclude<ContextOperator, 'in' | 'not in'>> {
+    operator: Exclude<ContextOperator, 'in' | 'not in'>;
+    value: FieldOf<DeepRecord<Doc>, Paths<Doc>> | any;
+}
+/** A condition that includes the 'in' and 'not in' operators. */
+interface GeneralCondition<Doc extends DocumentData = any, F extends Paths<Doc> = Paths<Doc>> extends SimpleCondition<Doc, F, AllOperators> {
+    operator: AllOperators;
+    value: any;
+}
+/** A list of general conditions. */
+type GeneralConditions<Doc extends DocumentData = any, F extends Paths<Doc> = Paths<Doc>> = Array<GeneralCondition<Doc, F>>;
+type ContextOperator = Exclude<Operator, '==' | '!='> | 'in' | 'not in';
+type AllOperators = Operator | 'in' | 'not in';
+/** A generic value that can exist in a query. */
+type GenericValue<Doc = any, F extends Paths<Doc> = Paths<Doc>, O extends AllOperators = any> = O extends 'in' ? Array<DeepRecord<Doc>[F]> | null : O extends 'not in' ? Array<DeepRecord<Doc>[F]> | null : DeepRecord<Doc>[F] | null;
+export {};

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

@@ -0,0 +1,64 @@
+import { CollectionName, DocumentData, FieldName } from './document.public-types';
+import { Paths } from './typescript.public-types';
+import { ClientRequestId } from './communication.public-types';
+/**
+ * An alias for a join result. This is used to disambiguate fields in the result.
+ */
+export type Alias = string;
+/**
+ * A join condition.
+ * The join conditions defines the alias for the left side of the join and the field names to join on.
+ */
+export interface JoinCondition {
+    leftAlias: Alias;
+    left: FieldName;
+    right: FieldName;
+    isInner: boolean;
+}
+/** A list of query conditions. */
+export type Condition<Doc extends DocumentData = any> = SimpleCondition<Doc> | CompositeCondition<Doc>;
+export type Conditions<Doc extends DocumentData = any> = Array<Condition<Doc>>;
+/** A single field query condition. */
+export interface SimpleCondition<Doc extends DocumentData = any, F extends Paths<Doc> = Paths<Doc>, MyOperator = Operator> {
+    fieldName: F;
+    operator: MyOperator;
+    value: any;
+}
+/**
+ * A composite fields query condition.
+ * Just a list of simple conditions with specific set of operators. It should be
+ * evaluated this way:
+ * If A, B, C are the conditions and A` = A with '==' operator:
+ * A || (A' && B) || (A' && B' && C)
+ */
+export interface CompositeCondition<Doc extends DocumentData = any> {
+    fields: Array<SimpleCondition<Doc, Paths<Doc>, CompositeConditionOperator>>;
+}
+export declare function isSimpleCondition(condition: Condition): condition is SimpleCondition;
+type CompositeConditionOperator = '>=' | '<=' | '>' | '<';
+/** An operator in a query condition. */
+export type Operator = '==' | '!=' | CompositeConditionOperator | 'like' | 'not like' | 'like_cs' | 'not like_cs';
+/** A definition of a sort by a filed. */
+export interface FieldSort<Doc> {
+    fieldName: FieldName<Doc>;
+    asc: boolean;
+}
+/** A query object. */
+export interface Query<Doc extends DocumentData = any> {
+    collectionName: CollectionName;
+    integrationId: string;
+    conditions: Conditions<Doc>;
+    sortOrder: Array<FieldSort<Doc>>;
+    limit: number;
+    limitBy?: {
+        limit: number;
+        fields: Array<FieldName<Doc>>;
+        reverseSort: boolean;
+    };
+}
+export interface QueryRegisterRequest {
+    clientRequestId: ClientRequestId;
+    query: Query;
+    parentClientRequestId: ClientRequestId;
+}
+export {};

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

@@ -0,0 +1,5 @@
+/**
+ * The list of supported Squid regions.
+ */
+export declare const SUPPORTED_SQUID_REGIONS: readonly ["us-east-1.aws"];
+export type SupportedSquidRegion = (typeof SUPPORTED_SQUID_REGIONS)[number];

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

@@ -0,0 +1,46 @@
+import { JSONSchema } from 'json-schema-typed';
+type ConvertDeep<T extends JSONSchema> = Exclude<T, boolean> & {
+    properties?: Record<string, ConvertDeep<JSONSchema>>;
+    patternProperties?: Record<string, ConvertDeep<JSONSchema>>;
+    nullable?: boolean;
+    /**
+     * The default value will be applied (default to 'empty'):
+     * 'always' - no matter what the client sent, both on update and insert. In case of readOnly - applies only on insert.
+     * 'empty' - only if the value of the field is empty (undefined)
+     * 'updateOrEmpty' - no matter what the client sent, updating the record will use the default value
+     */
+    applyDefaultValueOn?: 'always' | 'empty' | 'updateOrEmpty';
+    isDate?: boolean;
+    isJSON?: boolean;
+    /**
+     * Applies to the top level schema, a record in a nested object, or a regular property.
+     * Basically, whether this property can participate in an insert mutation.
+     */
+    insertable?: boolean;
+    /** Applies to the top level schema or a record in a nested object. */
+    deletable?: boolean;
+};
+export type PropertySchema = ConvertDeep<JSONSchema>;
+export type TopLevelPropertySchema = PropertySchema & {
+    primaryKey?: boolean;
+    /**
+     * Whether the property is computed based on other properties or some formula.
+     * If true, readonly also needs to be true and this field should not be part of an insert statement.
+     */
+    isComputed?: boolean;
+    /**
+     * Whether the default value generated by the database. CURRENT_DATE is something generated by the database vs
+     * 'Hello' which is a constant.
+     */
+    isDefaultComputed?: boolean;
+    /**
+     * The database data type that is represented by this property. This is often different from the actual property
+     * type, with is a Javascript primitive. For example, for a SMALLINT the dataType would be 'smallint', but the type
+     * would be 'integer'.
+     */
+    dataType?: string;
+};
+export type CollectionSchema = Omit<ConvertDeep<JSONSchema>, 'properties'> & {
+    properties?: Record<string, TopLevelPropertySchema>;
+};
+export {};

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

@@ -0,0 +1,16 @@
+/** A type alias for an ApiKey. */
+export type ApiKey = string;
+/** The secret key, an alias for a string. */
+export type SecretKey = string;
+/** The secret value. */
+export type SecretValue = string | number | boolean;
+export interface SecretMetadata {
+    key: SecretKey;
+    lastUpdated: number;
+}
+export interface SecretEntry<T extends SecretValue = SecretValue> extends SecretMetadata {
+    value: T;
+}
+export interface ApiKeyEntry extends SecretMetadata {
+    value: string;
+}

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

@@ -0,0 +1,24 @@
+import { DocumentData } from './document.public-types';
+import { Alias, JoinCondition, Query } from './query.public-types';
+export type SerializedSimpleQuery = {
+    type: 'simple';
+    query: Query;
+    dereference: boolean;
+};
+export type SerializedJoinQuery = {
+    type: 'join';
+    grouped: boolean;
+    dereference: boolean;
+    root: {
+        alias: Alias;
+        query: Query;
+    };
+    leftToRight: Record<Alias, Alias[]>;
+    joins: Record<Alias, Query<DocumentData>>;
+    joinConditions: Record<Alias, JoinCondition>;
+};
+export type SerializedMergedQuery = {
+    type: 'merged';
+    queries: Array<SerializedQuery>;
+};
+export type SerializedQuery = SerializedSimpleQuery | SerializedJoinQuery | SerializedMergedQuery;

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

@@ -0,0 +1,5 @@
+export declare enum ClientConnectionState {
+    CONNECTED = "CONNECTED",
+    DISCONNECTED = "DISCONNECTED",
+    REMOVED = "REMOVED"
+}

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

@@ -0,0 +1,10 @@
+import { IntegrationId } from './communication.public-types';
+export interface TopicReadContext {
+    integrationId: IntegrationId;
+    topicName: string;
+}
+export interface TopicWriteContext<T> {
+    integrationId: IntegrationId;
+    topicName: string;
+    messages: Array<T>;
+}

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

@@ -0,0 +1,15 @@
+export interface Type<T> extends Function {
+    new (...args: any[]): T;
+}
+export type PartialBy<T, K extends keyof T> = Omit<T, K> & Partial<Pick<T, K>>;
+type PropertiesWithPrefix<Prefix extends string> = {
+    [key in `${Prefix}${string}`]: any;
+};
+type Pred = [0, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9];
+export type DeepRecord<T, RemainingDepth extends number & keyof Pred = 5, Prefix extends string = ''> = RemainingDepth extends 0 ? PropertiesWithPrefix<Prefix> : {
+    [k in keyof T]-?: k extends string | number ? Record<`${Prefix}${k}`, T[k]> | (Required<T>[k] extends any[] ? never : Required<T>[k] extends object ? DeepRecord<Required<T>[k], Pred[RemainingDepth], `${Prefix}${k}.`> : never) : never;
+}[keyof T];
+export type UnionKeys<T> = T extends any ? keyof T : never;
+export type FieldOf<T, K extends UnionKeys<T>> = Extract<T, Record<K, any>>[K];
+export type Paths<T> = UnionKeys<DeepRecord<T>>;
+export {};

package/dist/internal-common/src/public-utils/id-utils.d.ts

@@ -0,0 +1,6 @@
+/** Generates a UUID-style ID. */
+export declare function generateId(): string;
+/** Default length if ID produced by `generateShortId`. */
+export declare const DEFAULT_SHORT_ID_LENGTH = 18;
+/** Generates an ID of the given `length` using lowercase latin letters and digits.. */
+export declare function generateShortId(length?: number): string;

package/dist/internal-common/src/types/ai-assistant.types.d.ts

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

package/dist/internal-common/src/types/ai-chatbot.types.d.ts

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

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

@@ -0,0 +1,2 @@
+/** The query parameters of an API call. */
+export type ApiQueryParams = Record<string, string | number | boolean>;

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

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

package/dist/internal-common/src/types/backend-run.types.d.ts

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

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

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

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

@@ -0,0 +1 @@
+export type ChatId = string;

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

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

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

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

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

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

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

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

package/dist/internal-common/src/types/secret.types.d.ts

@@ -0,0 +1,11 @@
+import { SecretKey, SecretValue } from '../public-types/secret.public-types';
+export type SetSecretEntry = {
+    key: SecretKey;
+    value?: SecretValue;
+};
+export declare const BACKEND_API_KEY = "_BACKEND_API_KEY";
+export declare const APP_API_KEY = "APP_API_KEY";
+export interface SetSecretRequestEntry {
+    key: SecretKey;
+    value: SecretValue;
+}

package/dist/internal-common/src/types/socket.types.d.ts

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

package/dist/internal-common/src/utils/array.d.ts

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

package/dist/internal-common/src/utils/assert.d.ts

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

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

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

package/dist/internal-common/src/utils/http.d.ts

@@ -0,0 +1,2 @@
+export declare function getApplicationUrl(regionPrefix: string, appId: string, path: string): string;
+export declare function getApplicationHttpHeaders(regionPrefix: string, appId: string): Record<string, string>;

package/dist/internal-common/src/utils/lock.manager.d.ts

@@ -0,0 +1,14 @@
+type LockMutex = string;
+/**
+ * A simple lock manager that locks a list of mutexes.
+ * When locking a list of mutexes, the lock will start only when all the mutexes are available - preventing partial lock
+ * and potential deadlocks.
+ */
+export declare class LockManager {
+    private readonly locks;
+    lock(...mutexes: LockMutex[]): Promise<void>;
+    release(...mutexes: LockMutex[]): void;
+    canGetLock(...mutexes: LockMutex[]): boolean;
+    lockSync(...mutexes: LockMutex[]): void;
+}
+export {};

package/dist/internal-common/src/utils/object.d.ts

@@ -0,0 +1,5 @@
+export declare function getInPath(obj: Readonly<Record<string, unknown>>, path: string, delimiter?: string): any;
+export declare function setInPath(obj: object, path: string, value: unknown, delimiter?: string): void;
+export declare function deleteInPath(obj: object, path: string, delimiter?: string): void;
+export declare function replaceKeyInMap<K, T>(map: Map<K, T | undefined>, a: K, b: K): void;
+export declare function replaceKeyInRecord<K extends keyof any, T>(record: Record<K, T>, a: K, b: K): void;

package/dist/internal-common/src/utils/serialization.d.ts

@@ -0,0 +1,5 @@
+export declare function normalizeJsonAsString(json: unknown): string;
+export declare function serializeObj(obj: unknown): string;
+export declare function deserializeObj<T = any>(str: string): T;
+export declare function encodeValueForMapping(value: unknown): string;
+export declare function decodeValueForMapping(encodedString: string): any;

package/dist/internal-common/src/utils/validation.d.ts

@@ -0,0 +1,24 @@
+import { HttpStatus } from '../public-types/http-status.enum';
+export type StatusCode = HttpStatus.BAD_REQUEST | HttpStatus.NOT_FOUND | HttpStatus.FORBIDDEN | HttpStatus.UNAUTHORIZED | HttpStatus.CONFLICT;
+export declare class ValidationError extends Error {
+    readonly statusCode: StatusCode;
+    readonly details?: any;
+    constructor(error: string, statusCode: StatusCode, details?: Record<string, any>);
+}
+export declare function isValidId(id: unknown): boolean;
+export declare function validateId(id: unknown, message: string): void;
+export declare function validateFieldSort(fieldSort: unknown): void;
+export declare function validateMutations(mutations: unknown): void;
+export declare function validateQueryLimit(limit: unknown): void;
+/** Returns true if the value is not an empty string (undefined/null are considered empty). */
+export declare function isNotEmpty(value: string | undefined | null): value is string;
+/**
+ * All type names returned by 'typeof' supported by JavaScript:
+ * {@link https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Operators/typeof}.
+ * and a few other supported types.
+ */
+export type JavascriptTypeName = 'undefined' | 'object' | 'boolean' | 'number' | 'bigint' | 'string' | 'symbol' | 'function';
+/** Returns true if 'typeof' of the 'value' is 'type' or 'type[]'. */
+export declare function isRightType(value: unknown, type: JavascriptTypeName): boolean;
+/** Returns true if 'obj' has only keys listed in the 'keys'. Object can't be an array. */
+export declare function hasOnlyKeys(obj: object, keys: string[]): boolean;

package/dist/internal-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 {};