@squidcloud/client 1.0.145-beta → 1.0.146-beta

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

@@ -0,0 +1,154 @@
+/**
+ * Name of metrics publicly provided by the system.
+ * - Metrics suffixed by '_time' are 'gauge' metrics.
+ * - Metrics suffixed by '_count' are 'count' metrics.
+ * All Squid metrics starts with `squid_` prefix.
+ */
+export declare const SQUID_METRIC_NAMES: readonly ["squid_functionExecution_count", "squid_functionExecution_time"];
+/** Name of a built-in Squid metric ('squid_functionExecution_count' or 'squid_functionExecution_time'). */
+export type SquidMetricName = (typeof SQUID_METRIC_NAMES)[number];
+/** Aggregation function used in metric queries (e.g., 'sum', 'max', 'median'). */
+export declare const METRIC_FUNCTIONS: readonly ["sum", "max", "min", "average", "median", "p95", "p99", "count"];
+/** Aggregation function used in metric queries (e.g., 'sum', 'max', 'median'). */
+export type MetricFunction = (typeof METRIC_FUNCTIONS)[number];
+/** Defines source of the metric: reported by user or automatically collected by the system (Squid). */
+export declare const METRIC_DOMAIN: readonly ["user", "squid"];
+/** Domain of the metric: 'user' for custom metrics, 'squid' for built-in system metrics. */
+export type MetricDomain = (typeof METRIC_DOMAIN)[number];
+/** Defines how to align data points in a metric query interval. */
+export declare const METRIC_INTERVAL_ALIGNMENT: readonly ["align-by-start-time", "align-by-end-time"];
+/** Indicates how to align per-point periods in metric queries. */
+export type MetricIntervalAlignment = (typeof METRIC_INTERVAL_ALIGNMENT)[number];
+/** Common parameters shared by all metric query requests. */
+export interface QueryMetricsRequestCommon {
+    /** Kind of the metrics (domain) to query. */
+    domain: MetricDomain;
+    /** Start of the queried interval. Must be an integer value. */
+    periodStartSeconds: number;
+    /** End of the queried interval. Must be an integer value. */
+    periodEndSeconds: number;
+    /**
+     * Time interval per point. Must be less than  periodEndSeconds - periodStartSeconds.
+     * Set to 0 or keep undefined to have only 1 value in the result.
+     */
+    pointIntervalSeconds?: number;
+    /**
+     * Specifies the alignment of the per-point interval.
+     * Default: 'align-by-start-time'
+     */
+    pointIntervalAlignment?: MetricIntervalAlignment;
+    /** Aggregation functions that maps multiple points per point region to a single point value. */
+    fn: MetricFunction | Array<MetricFunction>;
+    /**
+     * If there is no data in the specified region this value will be used to fill the gap.
+     * Default: null.
+     */
+    fillValue?: number | null;
+    /**
+     * Tag filters.
+     * TODO: add operations to exclude tags: !=, !contains...
+     */
+    tagFilter?: Record<string, string>;
+    /**
+     * A mapping of known tag values that must be present in the response groups.
+     *
+     * This ensures that the result will include groups for all specified tag values,
+     * even if there is no data for some values in the database.
+     *
+     * Example: Consider a tag 'isError' with two possible values: '0' and '1'.
+     * When 'tagDomains' contains `{'isError': ['0', '1']}`, the result will include
+     * groups for both 'isError: 0' and 'isError: 1'. If the database lacks data for
+     * 'isError: 1', the points in this group will be set to 'fillValue' (default is 'null').
+     *
+     * The tags in the new groups will be copied from the existing resultGroups,
+     * along with one of the tag domain values.
+     *
+     * @property {Record<string, string[]>} tagDomains - A record where each key is a tag name and
+     * each value is an array of possible values for that tag. Should only contain tags listed in 'groupByTags' field.
+     */
+    tagDomains?: Record<string, string[]>;
+    /** List of ordered tag names for a 'GROUP BY'. */
+    groupByTags?: string[];
+    /** The results will be ordered by the specified tags (ORDER BY). */
+    orderByTags?: string[];
+    /**
+     * Specifies what result will be returned if there were no records found in the database.
+     * In this case the 'resultGroups' array will be empty (default), or can be filled with a default
+     * values if 'return-result-group-with-default-values' is specified.
+     * The generated result group will have 'tagValues' set to empty strings.
+     *
+     * May be useful to get a ready-to-render array with no additional post-processing required.
+     *
+     * Note: 'tagDomains' can provide similar functionality when set of tag values is defined: multiple result groups
+     * will be filled with default values. There is no need to use this option if 'tagDomains' is used.
+     *
+     * Default: 'return-no-result-groups'
+     */
+    noDataBehavior?: 'return-no-result-groups' | 'return-result-group-with-default-values';
+}
+/**
+ * Request structure for querying user-defined metrics.
+ * @category Metrics
+ */
+export interface QueryUserMetricsRequest<NameType extends string = string> extends QueryMetricsRequestCommon {
+    /** Specifies the user domain for custom metrics. */
+    domain: 'user';
+    /** Name of the user-defined metric to query. */
+    name: NameType;
+}
+/**
+ * Request structure for querying built-in Squid metrics.
+ * @category Metrics
+ */
+export interface QuerySquidMetricsRequest<NameType extends SquidMetricName = SquidMetricName> extends QueryMetricsRequestCommon {
+    /** Specifies the squid domain for built-in system metrics. */
+    domain: 'squid';
+    /** Name of the built-in Squid metric to query. */
+    name: NameType;
+}
+/** A request to query metrics, either Squid or user-defined, depending on the domain and metric name. */
+export type QueryMetricsRequest<NameType extends string = string> = QuerySquidMetricsRequest<NameType extends SquidMetricName ? NameType : SquidMetricName> | QueryUserMetricsRequest<NameType>;
+/**
+ * Every result point is a list of [timestamp, values...],
+ * where list of values are defined by the list of functions in the request.
+ * If there is no data for the point 'null' is used as a 'value'.
+ * The timestamp is always equal to the point period start date and is measured in Unix epoch seconds.
+ */
+export type QueryMetricsResultPoint = [number, ...(number | null)[]];
+/** A group of metric results that share the same tag values. */
+export interface QueryMetricsResultGroup {
+    /** Values of the tags in the group. The tags are ordered the same way as in request.groupByTags collection. */
+    tagValues: string[];
+    /** List of result points for the group. */
+    points: Array<QueryMetricsResultPoint>;
+}
+/** Common structure for metric query responses. */
+export interface QueryMetricsResponseCommon {
+    /**
+     * Result of the metrics query.
+     * Contains only 1 element if `groupByTags` are empty, otherwise contains multiple results grouped by tags.
+     */
+    resultGroups: Array<QueryMetricsResultGroup>;
+}
+/**
+ * Response for a user-defined metric query.
+ * @category Metrics
+ */
+export interface QueryUserMetricsResponse<NameType extends string = string> extends QueryMetricsResponseCommon {
+    /** Specifies the user domain for custom metrics. */
+    domain: 'user';
+    /** Name of the queried user-defined metric. */
+    metricName: NameType;
+}
+/**
+ * A single metric response for 'SquidMetricsRequest'.
+ * @category Metrics
+ */
+export interface QuerySquidMetricsResponse<NameType extends SquidMetricName> extends QueryMetricsResponseCommon {
+    /** Specifies the squid domain for built-in system metrics. */
+    domain: 'squid';
+    /** Name of the queried built-in Squid metric. */
+    metricName: NameType;
+}
+/** Final normalized response for a metrics query, required fields guaranteed. */
+export type QueryMetricsResponse<NameType extends string = string> = Required<QuerySquidMetricsResponse<NameType extends SquidMetricName ? NameType : SquidMetricName> | QueryUserMetricsResponse<NameType>>;

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

@@ -0,0 +1,9 @@
+/** Represents a standardized HTTP response in OpenAPI format. */
+export interface OpenApiResponse {
+    /** HTTP headers returned in the response. */
+    headers: Record<string, any>;
+    /** Body content of the response. */
+    body: any;
+    /** HTTP status code of the response. */
+    statusCode: number;
+}

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

@@ -0,0 +1,113 @@
+import { CollectionName, DocumentData, FieldName } from './document.public-types';
+import { Paths } from './typescript.public-types';
+/**
+ * An alias for a join result. This is used to disambiguate fields in the result.
+ * @category Database
+ */
+export type Alias = string;
+/**
+ * A join condition defining how two tables are related in a database query.
+ * The join conditions specify the alias for the left side of the join and the field names to join on.
+ * @category Database
+ */
+export interface JoinCondition {
+    /** The alias of the left table in the join operation. */
+    leftAlias: Alias;
+    /** The field name from the left table to join on. */
+    left: FieldName;
+    /** The field name from the right table to join on. */
+    right: FieldName;
+    /** Indicates whether the join is an inner join (true) or outer join (false). */
+    isInner: boolean;
+}
+/**
+ * A list of query conditions.
+ * @category Database
+ */
+export type Condition<Doc extends DocumentData = any> = SimpleCondition<Doc> | CompositeCondition<Doc>;
+/**
+ * A list of query conditions.
+ * @category Database
+ */
+export type Conditions<Doc extends DocumentData = any> = Array<Condition<Doc>>;
+/**
+ * A single field query condition for filtering database records.
+ * @category Database
+ */
+export interface SimpleCondition<Doc extends DocumentData = any, F extends Paths<Doc> = Paths<Doc>, MyOperator = Operator> {
+    /** The field name to apply the condition to. */
+    fieldName: F;
+    /** The operator to use for comparing the field value. */
+    operator: MyOperator;
+    /** The value to compare against the field. */
+    value: any;
+}
+/**
+ * A composite fields query condition combining multiple simple conditions.
+ * 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)
+ * @category Database
+ */
+export interface CompositeCondition<Doc extends DocumentData = any> {
+    /** An array of simple conditions with restricted operators for composite evaluation. */
+    fields: Array<SimpleCondition<Doc, Paths<Doc>, CompositeConditionOperator>>;
+}
+type CompositeConditionOperator = '>=' | '<=' | '>' | '<';
+/**
+ * The list of operators related to arrays.
+ * @category Database
+ */
+export declare const ARRAY_OPERATORS: readonly ["in", "not in", "array_includes_some", "array_includes_all", "array_not_includes"];
+/**
+ * The list of all operators.
+ * @category Database
+ */
+export declare const ALL_OPERATORS: readonly ["in", "not in", "array_includes_some", "array_includes_all", "array_not_includes", "==", "!=", ">=", "<=", ">", "<", "like", "not like", "like_cs", "not like_cs"];
+/**
+ * An operator in a query condition.
+ * @category Database
+ */
+export type Operator = (typeof ALL_OPERATORS)[number];
+/**
+ * A definition of a sort order by a field in a database query.
+ * @category Database
+ */
+export interface FieldSort<Doc> {
+    /** The name of the field to sort by. */
+    fieldName: FieldName<Doc>;
+    /** Indicates whether the sort is ascending (true) or descending (false). */
+    asc: boolean;
+}
+/**
+ * A query object defining a database retrieval operation.
+ * @category Database
+ */
+export interface Query<Doc extends DocumentData = any> {
+    /** The full collection path such as "c1" or "c1/d1/c2". */
+    collectionName: CollectionName;
+    /** The ID of the integration associated with the query. */
+    integrationId: string;
+    /** An array of conditions to filter the query results. */
+    conditions: Conditions<Doc>;
+    /** An array of field sort definitions to order the results. */
+    sortOrder: Array<FieldSort<Doc>>;
+    /** The maximum number of records to return. */
+    limit: number;
+    /** Optional configuration to limit results by specific fields with custom sorting. */
+    limitBy?: LimitBy<Doc>;
+}
+/**
+ * A configuration object used to apply additional field-based limits to a query.
+ * @category Database
+ */
+export interface LimitBy<Doc extends DocumentData = any> {
+    /** The maximum number of records to return for this limit configuration. */
+    limit: number;
+    /** The fields to apply the limit to. */
+    fields: Array<FieldName<Doc>>;
+    /** Indicates whether to reverse the sort order for this limit. */
+    reverseSort: boolean;
+}
+export {};

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

@@ -0,0 +1,4 @@
+/** The list of regions in Squid. */
+export declare const SQUID_REGIONS: readonly ["us-east-1.aws", "ap-south-1.aws", "us-central1.gcp"];
+/** Region type used by Squid. */
+export type SquidRegion = (typeof SQUID_REGIONS)[number];

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

@@ -0,0 +1,43 @@
+import { ServiceFunctionName } from './backend.public-types';
+/**
+ * Configuration for a scheduled task in the platform.
+ * @category Platform
+ */
+export interface SchedulerConfig {
+    /** The name of the service function to be executed on the schedule. */
+    functionName: ServiceFunctionName;
+    /** The cron expression defining the schedule timing. */
+    cronExpression: string;
+    /** Indicates whether the scheduler should run exclusively, preventing overlaps. */
+    exclusive: boolean;
+}
+/**
+ * Information about a scheduler instance in the platform.
+ * @category Platform
+ */
+export interface SchedulerInfo {
+    /** The unique identifier for the scheduler. */
+    schedulerId: string;
+    /** The configuration details for the scheduler. */
+    config: SchedulerConfig;
+    /** Indicates whether the scheduler is currently enabled. */
+    enabled: boolean;
+}
+/**
+ * Options for updating an existing scheduler in the platform.
+ * @category Platform
+ */
+export interface UpdateSchedulerOptions {
+    /** The unique identifier of the scheduler to update. */
+    schedulerId: string;
+    /** Optional flag to enable or disable the scheduler. */
+    enabled?: boolean;
+}
+/**
+ * Request structure for updating multiple schedulers in the platform.
+ * @category Platform
+ */
+export interface UpdateSchedulersRequest {
+    /** An array of scheduler update options. */
+    schedulers: UpdateSchedulerOptions[];
+}

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

@@ -1,54 +1,54 @@
-import { JSONSchema } from 'json-schema-typed';
-export type FieldPlaceholder = '__SQUID_SERVER_TIMESTAMP__' | '__SQUID_CLIENT_IP__' | '__SQUID_USER_ID__' | '__SQUID_API_KEY__';
-export type BasicFieldType = 'string' | 'integer' | 'number' | 'boolean' | 'map' | 'array' | 'any';
-export type CustomFieldType = 'date' | 'json' | 'objectId';
-export type SupportedFieldType = BasicFieldType | CustomFieldType;
-export declare const SUPPORTED_FIELD_TYPES_ARRAY: Array<SupportedFieldType>;
-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 filed 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 declare function compileSchema<S extends CollectionSchema>(schema: S): any;
-export declare function validateSchema<S extends CollectionSchema>(schema: S, data: any, updatedPaths?: Array<string>, dataBefore?: any): void;
-export declare function findMatchingPropertiesForKey<S extends CollectionSchema | PropertySchema>(schema: S, key: string): Array<PropertySchema>;
-export {};
+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;
+};
+/** Extended JSON schema for a single property, supporting nested structures and Squid-specific metadata. */
+export type PropertySchema = ConvertDeep<JSONSchema>;
+/** Extended JSON schema for a top-level property, including database-related metadata. */
+export type TopLevelPropertySchema = PropertySchema & {
+    /** Marks the property as a primary key. */
+    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;
+    /**
+     * This indicates that although the field exists on the db, it should be ignored by squid.
+     */
+    hidden?: boolean;
+};
+/** Schema for a full collection, allowing partial property definitions with extended metadata. */
+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,51 @@
+/**
+ * A type alias for an ApiKey.
+ * @category Secret
+ */
+export type ApiKey = string;
+/**
+ * The secret key, an alias for a string.
+ * @category Secret
+ */
+export type SecretKey = string;
+/**
+ * The secret value.
+ * @category Secret
+ */
+export type SecretValue = string | number | boolean;
+/**
+ * Metadata for a secret, including its key and last updated timestamp.
+ * @category Secret
+ */
+export interface SecretMetadata {
+    /** The key identifying the secret. */
+    key: SecretKey;
+    /** The timestamp (in milliseconds) when the secret was last updated. */
+    lastUpdated: number;
+}
+/**
+ * A secret entry combining metadata with a typed value.
+ * @category Secret
+ */
+export interface SecretEntry<T extends SecretValue = SecretValue> extends SecretMetadata {
+    /** The value of the secret, constrained to the specified type. */
+    value: T;
+}
+/**
+ * An API key entry combining metadata with a string value.
+ * @category Secret
+ */
+export interface ApiKeyEntry extends SecretMetadata {
+    /** The string value of the API key. */
+    value: string;
+}
+/**
+ * A request structure for setting a secret with a key-value pair.
+ * @category Secret
+ */
+export interface SetSecretRequestEntry {
+    /** The key identifying the secret to set. */
+    key: SecretKey;
+    /** The value to assign to the secret. */
+    value: SecretValue;
+}

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

@@ -0,0 +1,60 @@
+import { DocumentData } from './document.public-types';
+import { Alias, JoinCondition, Query } from './query.public-types';
+/**
+ * Represents a simple serialized query structure for database operations.
+ * @category Database
+ */
+export type SerializedSimpleQuery = {
+    /** Specifies that this is a simple query type. */
+    type: 'simple';
+    /** The query object defining the database operation. */
+    query: Query;
+    /** Indicates whether references should be dereferenced during query execution. */
+    dereference: boolean;
+};
+/**
+ * Represents a serialized join query structure for database operations with multiple table relationships.
+ * @category Database
+ */
+export type SerializedJoinQuery = {
+    /** Specifies that this is a join query type. */
+    type: 'join';
+    /** Specifies if the results should be grouped by the root alias. */
+    grouped: boolean;
+    /** Indicates whether references should be dereferenced during query execution. */
+    dereference: boolean;
+    /** The root table configuration for the join operation. */
+    root: RootTableDetails;
+    /** A mapping of aliases to their dependent aliases, defining the join order from left to right. */
+    leftToRight: Record<Alias, Alias[]>;
+    /** A mapping of aliases to their corresponding queries for joined tables. */
+    joins: Record<Alias, Query<DocumentData>>;
+    /** A mapping of aliases to their join conditions. */
+    joinConditions: Record<Alias, JoinCondition>;
+};
+/**
+ * Configuration details for the root table used in a join query.
+ * The root table serves as the entry point for evaluating joined data across multiple tables.
+ * @category Database
+ */
+export interface RootTableDetails {
+    /** The alias for the root table in the join operation. */
+    alias: Alias;
+    /** The query object defining the root table's operation. */
+    query: Query;
+}
+/**
+ * Represents a serialized merged query structure combining multiple queries for database operations.
+ * @category Database
+ */
+export type SerializedMergedQuery = {
+    /** Specifies that this is a merged query type. */
+    type: 'merged';
+    /** An array of serialized queries to be merged. */
+    queries: Array<SerializedQuery>;
+};
+/**
+ * A union type representing all possible serialized query structures for database operations.
+ * @category Database
+ */
+export type SerializedQuery = SerializedSimpleQuery | SerializedJoinQuery | SerializedMergedQuery;

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

@@ -0,0 +1,4 @@
+/** Squid client connection state. Can be 'CONNECTED', 'DISCONNECTED', or 'REMOVED'. */
+export declare const CLIENT_CONNECTION_STATES: readonly ["CONNECTED", "DISCONNECTED", "REMOVED"];
+/** Squid client connection state. */
+export type ClientConnectionState = (typeof CLIENT_CONNECTION_STATES)[number];

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

@@ -1,14 +1,20 @@
-export interface Type<T> extends Function {
-    new (...args: any[]): T;
-}
-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 {};
+/** Makes the specified keys in a type optional, leaving the rest unchanged. */
+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];
+/**
+ * Recursively flattens all keys of a type into dot notation paths up to a fixed depth.
+ * Used to map deeply nested fields with their access paths.
+ */
+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];
+/** Gets the union of keys from a union of object types. */
+export type UnionKeys<T> = T extends any ? keyof T : never;
+/** Extracts the type of specific field `K` from a union of object types `T`. */
+export type FieldOf<T, K extends UnionKeys<T>> = Extract<T, Record<K, any>>[K];
+/** All possible deeply nested field paths of a type, joined by dot notation. */
+export type Paths<T> = UnionKeys<DeepRecord<T>>;
+export {};