@osdk/foundry.ontologies 2.51.0 → 2.53.0

package/CHANGELOG.md

@@ -1,5 +1,29 @@
 # @osdk/foundry.ontologies
 
+## 2.53.0
+
+### Minor Changes
+
+- 085010e: Regenerate Platform SDKs
+
+### Patch Changes
+
+- Updated dependencies [085010e]
+  - @osdk/foundry.core@2.53.0
+  - @osdk/foundry.geo@2.53.0
+
+## 2.52.0
+
+### Minor Changes
+
+- 61dbb74: regenerate platform sdk
+
+### Patch Changes
+
+- Updated dependencies [61dbb74]
+  - @osdk/foundry.core@2.52.0
+  - @osdk/foundry.geo@2.52.0
+
 ## 2.51.0
 
 ### Minor Changes

package/build/browser/_components.d.ts

@@ -336,8 +336,16 @@ export type Aggregation = ({
  */
 export type AggregationAccuracy = "ACCURATE" | "APPROXIMATE";
 /**
- * Log Safety: SAFE
- */
+   * Specifies the accuracy requirement for aggregation results.
+
+REQUIRE_ACCURATE: Only return results if they are guaranteed to be accurate. If accuracy cannot be
+guaranteed (e.g., due to a low maxGroupCount relative to distinct values), the request will fail
+with an AggregationAccuracyNotSupported error.
+ALLOW_APPROXIMATE: Allow approximate results when exact computation is not feasible. This is the
+default behavior if not specified.
+   *
+   * Log Safety: SAFE
+   */
 export type AggregationAccuracyRequest = "REQUIRE_ACCURATE" | "ALLOW_APPROXIMATE";
 /**
    * Divides objects into groups according to an interval. Note that this grouping applies only on date types.
@@ -352,11 +360,13 @@ export interface AggregationDurationGrouping {
 /**
    * Divides objects into groups according to an interval. Note that this grouping applies only on date and timestamp types.
 When grouping by YEARS, QUARTERS, MONTHS, or WEEKS, the value must be set to 1.
+Either field or propertyIdentifier must be supplied, but not both.
    *
    * Log Safety: UNSAFE
    */
 export interface AggregationDurationGroupingV2 {
-    field: PropertyApiName;
+    field?: PropertyApiName;
+    propertyIdentifier?: PropertyIdentifier;
     value: number;
     unit: TimeUnit;
 }
@@ -370,12 +380,14 @@ export interface AggregationExactGrouping {
     maxGroupCount?: number;
 }
 /**
- * Divides objects into groups according to an exact value.
- *
- * Log Safety: UNSAFE
- */
+   * Divides objects into groups according to an exact value.
+Either field or propertyIdentifier must be supplied, but not both.
+   *
+   * Log Safety: UNSAFE
+   */
 export interface AggregationExactGroupingV2 {
-    field: PropertyApiName;
+    field?: PropertyApiName;
+    propertyIdentifier?: PropertyIdentifier;
     maxGroupCount?: number;
     defaultValue?: string;
     includeNullValues?: boolean;
@@ -390,12 +402,14 @@ export interface AggregationFixedWidthGrouping {
     fixedWidth: number;
 }
 /**
- * Divides objects into groups with the specified width.
- *
- * Log Safety: UNSAFE
- */
+   * Divides objects into groups with the specified width.
+Either field or propertyIdentifier must be supplied, but not both.
+   *
+   * Log Safety: UNSAFE
+   */
 export interface AggregationFixedWidthGroupingV2 {
-    field: PropertyApiName;
+    field?: PropertyApiName;
+    propertyIdentifier?: PropertyIdentifier;
     fixedWidth: number;
 }
 /**
@@ -497,12 +511,14 @@ export interface AggregationRangesGrouping {
     ranges: Array<AggregationRange>;
 }
 /**
- * Divides objects into groups according to specified ranges.
- *
- * Log Safety: UNSAFE
- */
+   * Divides objects into groups according to specified ranges.
+Either field or propertyIdentifier must be supplied, but not both.
+   *
+   * Log Safety: UNSAFE
+   */
 export interface AggregationRangesGroupingV2 {
-    field: PropertyApiName;
+    field?: PropertyApiName;
+    propertyIdentifier?: PropertyIdentifier;
     ranges: Array<AggregationRangeV2>;
 }
 /**
@@ -661,22 +677,26 @@ export interface ApproximateDistinctAggregation {
     name?: AggregationMetricName;
 }
 /**
- * Computes an approximate number of distinct values for the provided field.
- *
- * Log Safety: UNSAFE
- */
+   * Computes an approximate number of distinct values for the provided field.
+Either field or propertyIdentifier must be supplied, but not both.
+   *
+   * Log Safety: UNSAFE
+   */
 export interface ApproximateDistinctAggregationV2 {
-    field: PropertyApiName;
+    field?: PropertyApiName;
+    propertyIdentifier?: PropertyIdentifier;
     name?: AggregationMetricName;
     direction?: OrderByDirection;
 }
 /**
- * Computes the approximate percentile value for the provided field. Requires Object Storage V2.
- *
- * Log Safety: UNSAFE
- */
+   * Computes the approximate percentile value for the provided field. Requires Object Storage V2.
+Either field or propertyIdentifier must be supplied, but not both.
+   *
+   * Log Safety: UNSAFE
+   */
 export interface ApproximatePercentileAggregationV2 {
-    field: PropertyApiName;
+    field?: PropertyApiName;
+    propertyIdentifier?: PropertyIdentifier;
     name?: AggregationMetricName;
     approximatePercentile: number;
     direction?: OrderByDirection;
@@ -828,12 +848,14 @@ export interface AvgAggregation {
     name?: AggregationMetricName;
 }
 /**
- * Computes the average value for the provided field.
- *
- * Log Safety: UNSAFE
- */
+   * Computes the average value for the provided field.
+Either field or propertyIdentifier must be supplied, but not both.
+   *
+   * Log Safety: UNSAFE
+   */
 export interface AvgAggregationV2 {
-    field: PropertyApiName;
+    field?: PropertyApiName;
+    propertyIdentifier?: PropertyIdentifier;
     name?: AggregationMetricName;
     direction?: OrderByDirection;
 }
@@ -1600,12 +1622,15 @@ export interface ErrorComputingSecurity {
  */
 export type ErrorName = LooselyBrandedString<"ErrorName">;
 /**
- * Computes an exact number of distinct values for the provided field. May be slower than an approximate distinct aggregation. Requires Object Storage V2.
- *
- * Log Safety: UNSAFE
- */
+   * Computes an exact number of distinct values for the provided field. May be slower than an approximate
+distinct aggregation. Requires Object Storage V2.
+Either field or propertyIdentifier must be supplied, but not both.
+   *
+   * Log Safety: UNSAFE
+   */
 export interface ExactDistinctAggregationV2 {
-    field: PropertyApiName;
+    field?: PropertyApiName;
+    propertyIdentifier?: PropertyIdentifier;
     name?: AggregationMetricName;
     direction?: OrderByDirection;
 }
@@ -2729,12 +2754,14 @@ export interface MaxAggregation {
     name?: AggregationMetricName;
 }
 /**
- * Computes the maximum value for the provided field.
- *
- * Log Safety: UNSAFE
- */
+   * Computes the maximum value for the provided field.
+Either field or propertyIdentifier must be supplied, but not both.
+   *
+   * Log Safety: UNSAFE
+   */
 export interface MaxAggregationV2 {
-    field: PropertyApiName;
+    field?: PropertyApiName;
+    propertyIdentifier?: PropertyIdentifier;
     name?: AggregationMetricName;
     direction?: OrderByDirection;
 }
@@ -2764,12 +2791,14 @@ export interface MinAggregation {
     name?: AggregationMetricName;
 }
 /**
- * Computes the minimum value for the provided field.
- *
- * Log Safety: UNSAFE
- */
+   * Computes the minimum value for the provided field.
+Either field or propertyIdentifier must be supplied, but not both.
+   *
+   * Log Safety: UNSAFE
+   */
 export interface MinAggregationV2 {
-    field: PropertyApiName;
+    field?: PropertyApiName;
+    propertyIdentifier?: PropertyIdentifier;
     name?: AggregationMetricName;
     direction?: OrderByDirection;
 }
@@ -4654,7 +4683,27 @@ export interface RegexConstraint {
 }
 /**
    * Returns objects where the specified field matches the regex pattern provided. This applies to the non-analyzed
-form of text fields and supports standard regex syntax of dot (.), star(*) and question mark(?).
+form of text fields. Supported operators:
+
+. matches any character.
+? repeats the previous character 0 or 1 times.
++ repeats the previous character 1 or more times.
+* repeats the previous character 0 or more times.
+{} defines the minimum and maximum number of times the preceding character can repeat. {2} means the
+previous character must repeat only twice, {2,} means the previous character must repeat at least twice,
+and {2,4} means the previous character must repeat between 2-4 times.
+| is the OR operator.
+() forms a group within an expression such that the group can be treated as a single character.
+[] matches a single one of the characters contained inside the brackets, meaning [abc] matches a, b or
+c. Unless - is the first character or escaped with \ (in which case it is treated as a normal character),
+- can be used inside the bracket to create a range of characters, meaning [a-c] matches a, b, or c.
+If the character sequence inside the brackets begins with ^, the set of characters is negated, meaning
+[^abc] does not match a, b, or c. Otherwise, ^ is treated as a normal character.
+" creates groups of string literals.
+\ is used as an escape character. However, \d and \D match digit and non-digit characters respectively, \s
+and \S match whitespace and non whitespace characters respectively, and \w and \W match word and non word
+characters respectively.
+
 Either field or propertyIdentifier can be supplied, but not both.
    *
    * Log Safety: UNSAFE
@@ -5474,12 +5523,14 @@ export interface SumAggregation {
     name?: AggregationMetricName;
 }
 /**
- * Computes the sum of values for the provided field.
- *
- * Log Safety: UNSAFE
- */
+   * Computes the sum of values for the provided field.
+Either field or propertyIdentifier must be supplied, but not both.
+   *
+   * Log Safety: UNSAFE
+   */
 export interface SumAggregationV2 {
-    field: PropertyApiName;
+    field?: PropertyApiName;
+    propertyIdentifier?: PropertyIdentifier;
     name?: AggregationMetricName;
     direction?: OrderByDirection;
 }