@osdk/foundry.ontologies 2.32.0 → 2.34.0

package/build/browser/_components.d.ts

@@ -24,6 +24,38 @@ export interface AbsoluteValuePropertyExpression {
  * Log Safety: UNSAFE
  */
 export type Action = LooselyBrandedString<"Action">;
+/**
+ * A detailed operation for an Action
+ *
+ * Log Safety: UNSAFE
+ */
+export type ActionLogicRule = ({
+    type: "modifyInterface";
+} & ModifyInterfaceLogicRule) | ({
+    type: "createOrModifyObject";
+} & CreateOrModifyObjectLogicRule) | ({
+    type: "modifyObject";
+} & ModifyObjectLogicRule) | ({
+    type: "deleteLink";
+} & DeleteLinkLogicRule) | ({
+    type: "createObject";
+} & CreateObjectLogicRule) | ({
+    type: "createLink";
+} & CreateLinkLogicRule) | ({
+    type: "batchedFunction";
+} & BatchedFunctionLogicRule) | ({
+    type: "createOrModifyObjectV2";
+} & CreateOrModifyObjectLogicRuleV2) | ({
+    type: "deleteInterfaceLink";
+} & DeleteInterfaceLinkLogicRule) | ({
+    type: "deleteObject";
+} & DeleteObjectLogicRule) | ({
+    type: "function";
+} & FunctionLogicRule) | ({
+    type: "createInterfaceLink";
+} & CreateInterfaceLinkLogicRule) | ({
+    type: "createInterface";
+} & CreateInterfaceLogicRule);
 /**
  * Log Safety: SAFE
  */
@@ -124,6 +156,15 @@ endpoint or check the Ontology Manager.
    * Log Safety: UNSAFE
    */
 export type ActionTypeApiName = LooselyBrandedString<"ActionTypeApiName">;
+/**
+ * Returns the full metadata for an Action type in the Ontology.
+ *
+ * Log Safety: UNSAFE
+ */
+export interface ActionTypeFullMetadata {
+    actionType: ActionTypeV2;
+    fullLogicRule: ActionLogicRule;
+}
 /**
  * The unique resource identifier of an action type, useful for interacting with other Foundry APIs.
  *
@@ -193,6 +234,13 @@ export interface AddObjectEdit {
 export interface AddPropertyExpression {
     properties: Array<DerivedPropertyDefinition>;
 }
+/**
+ * Log Safety: UNSAFE
+ */
+export interface Affix {
+    prefix?: PropertyTypeReferenceOrStringConstant;
+    postfix?: PropertyTypeReferenceOrStringConstant;
+}
 /**
  * Log Safety: UNSAFE
  */
@@ -799,6 +847,13 @@ export interface BatchApplyActionResponse {
 export interface BatchApplyActionResponseV2 {
     edits?: BatchActionResults;
 }
+/**
+ * Log Safety: UNSAFE
+ */
+export interface BatchedFunctionLogicRule {
+    objectSetRidInputName: FunctionParameterName;
+    functionRule: FunctionLogicRule;
+}
 /**
  * Log Safety: SAFE
  */
@@ -932,12 +987,38 @@ export interface CountAggregationV2 {
 export interface CountObjectsResponseV2 {
     count?: number;
 }
+/**
+ * Log Safety: UNSAFE
+ */
+export interface CreateInterfaceLinkLogicRule {
+    interfaceTypeApiName: InterfaceTypeApiName;
+    interfaceLinkTypeApiName: InterfaceLinkTypeApiName;
+    sourceObject: ParameterId;
+    targetObject: ParameterId;
+}
+/**
+ * Log Safety: UNSAFE
+ */
+export interface CreateInterfaceLogicRule {
+    interfaceTypeApiName: InterfaceTypeApiName;
+    objectType: ParameterId;
+    sharedPropertyArguments: Record<SharedPropertyTypeApiName, LogicRuleArgument>;
+    structPropertyArguments: Record<SharedPropertyTypeApiName, Record<StructFieldApiName, StructFieldArgument>>;
+}
 /**
  * Log Safety: UNSAFE
  */
 export interface CreateInterfaceObjectRule {
     interfaceTypeApiName: InterfaceTypeApiName;
 }
+/**
+ * Log Safety: UNSAFE
+ */
+export interface CreateLinkLogicRule {
+    linkTypeApiName: LinkTypeApiName;
+    sourceObject: ParameterId;
+    targetObject: ParameterId;
+}
 /**
  * Log Safety: UNSAFE
  */
@@ -947,12 +1028,36 @@ export interface CreateLinkRule {
     aSideObjectTypeApiName: ObjectTypeApiName;
     bSideObjectTypeApiName: ObjectTypeApiName;
 }
+/**
+ * Log Safety: UNSAFE
+ */
+export interface CreateObjectLogicRule {
+    objectTypeApiName: ObjectTypeApiName;
+    propertyArguments: Record<PropertyApiName, LogicRuleArgument>;
+    structPropertyArguments: Record<PropertyApiName, Record<StructFieldApiName, StructFieldArgument>>;
+}
 /**
  * Log Safety: UNSAFE
  */
 export interface CreateObjectRule {
     objectTypeApiName: ObjectTypeApiName;
 }
+/**
+ * Log Safety: UNSAFE
+ */
+export interface CreateOrModifyObjectLogicRule {
+    objectTypeApiName: ObjectTypeApiName;
+    propertyArguments: Record<PropertyApiName, LogicRuleArgument>;
+    structPropertyArguments: Record<PropertyApiName, Record<StructFieldApiName, StructFieldArgument>>;
+}
+/**
+ * Log Safety: UNSAFE
+ */
+export interface CreateOrModifyObjectLogicRuleV2 {
+    objectToModify: ParameterId;
+    propertyArguments: Record<PropertyApiName, LogicRuleArgument>;
+    structPropertyArguments: Record<PropertyApiName, Record<StructFieldApiName, StructFieldArgument>>;
+}
 /**
  * Log Safety: UNSAFE
  */
@@ -965,6 +1070,20 @@ export interface CreateTemporaryObjectSetRequestV2 {
 export interface CreateTemporaryObjectSetResponseV2 {
     objectSetRid: ObjectSetRid;
 }
+/**
+ * Represents the current time argument in a logic rule.
+ *
+ * Log Safety: SAFE
+ */
+export interface CurrentTimeArgument {
+}
+/**
+ * Represents the current user argument in a logic rule.
+ *
+ * Log Safety: SAFE
+ */
+export interface CurrentUserArgument {
+}
 /**
  * A UUID representing a custom type in a given Function.
  *
@@ -1004,6 +1123,57 @@ export type CustomTypeId = LooselyBrandedString<"CustomTypeId">;
    * Log Safety: UNSAFE
    */
 export type DataValue = any;
+/**
+ * Log Safety: UNSAFE
+ */
+export type DatetimeFormat = ({
+    type: "stringFormat";
+} & DatetimeStringFormat) | ({
+    type: "localizedFormat";
+} & DatetimeLocalizedFormat);
+/**
+ * Predefined localized formatting options.
+ *
+ * Log Safety: SAFE
+ */
+export interface DatetimeLocalizedFormat {
+    format: DatetimeLocalizedFormatType;
+}
+/**
+ * Localized date/time format types.
+ *
+ * Log Safety: SAFE
+ */
+export type DatetimeLocalizedFormatType = "DATE_FORMAT_RELATIVE_TO_NOW" | "DATE_FORMAT_DATE" | "DATE_FORMAT_YEAR_AND_MONTH" | "DATE_FORMAT_DATE_TIME" | "DATE_FORMAT_DATE_TIME_SHORT" | "DATE_FORMAT_TIME" | "DATE_FORMAT_ISO_INSTANT";
+/**
+ * A strictly specified date format pattern.
+ *
+ * Log Safety: SAFE
+ */
+export interface DatetimeStringFormat {
+    pattern: string;
+}
+/**
+ * Log Safety: UNSAFE
+ */
+export type DatetimeTimezone = ({
+    type: "static";
+} & DatetimeTimezoneStatic) | ({
+    type: "user";
+} & DatetimeTimezoneUser);
+/**
+ * Log Safety: UNSAFE
+ */
+export interface DatetimeTimezoneStatic {
+    zoneId: PropertyTypeReferenceOrStringConstant;
+}
+/**
+ * The user's local timezone.
+ *
+ * Log Safety: SAFE
+ */
+export interface DatetimeTimezoneUser {
+}
 /**
  * The result of a CipherText decryption. If successful, the plaintext decrypted value will be returned. Otherwise, an error will be thrown.
  *
@@ -1012,6 +1182,15 @@ export type DataValue = any;
 export interface DecryptionResult {
     plaintext?: Plaintext;
 }
+/**
+ * Log Safety: UNSAFE
+ */
+export interface DeleteInterfaceLinkLogicRule {
+    interfaceTypeApiName: InterfaceTypeApiName;
+    interfaceLinkTypeApiName: InterfaceLinkTypeApiName;
+    sourceObject: ParameterId;
+    targetObject: ParameterId;
+}
 /**
  * Log Safety: UNSAFE
  */
@@ -1036,6 +1215,14 @@ export interface DeleteLinkEdit {
     linkType: LinkTypeApiName;
     linkedObjectPrimaryKey: PrimaryKeyValue;
 }
+/**
+ * Log Safety: UNSAFE
+ */
+export interface DeleteLinkLogicRule {
+    linkTypeApiName: LinkTypeApiName;
+    sourceObject: ParameterId;
+    targetObject: ParameterId;
+}
 /**
  * Log Safety: UNSAFE
  */
@@ -1059,6 +1246,12 @@ export interface DeleteObjectEdit {
     objectType: ObjectTypeApiName;
     primaryKey: PropertyValue;
 }
+/**
+ * Log Safety: UNSAFE
+ */
+export interface DeleteObjectLogicRule {
+    objectToDelete: ParameterId;
+}
 /**
  * Log Safety: UNSAFE
  */
@@ -1167,6 +1360,26 @@ export interface DoubleVector {
  * Log Safety: UNSAFE
  */
 export type Duration = LooselyBrandedString<"Duration">;
+/**
+ * Specifies the unit of the input duration value.
+ *
+ * Log Safety: SAFE
+ */
+export type DurationBaseValue = "SECONDS" | "MILLISECONDS";
+/**
+ * Log Safety: UNSAFE
+ */
+export type DurationFormatStyle = ({
+    type: "humanReadable";
+} & HumanReadableFormat) | ({
+    type: "timecode";
+} & TimeCodeFormat);
+/**
+ * Specifies the maximum precision to apply when formatting a duration.
+ *
+ * Log Safety: SAFE
+ */
+export type DurationPrecision = "DAYS" | "HOURS" | "MINUTES" | "SECONDS" | "AUTO";
 /**
  * Log Safety: UNSAFE
  */
@@ -1274,6 +1487,26 @@ properties.{propertyApiName}.isNull=false.
    * Log Safety: UNSAFE
    */
 export type FilterValue = LooselyBrandedString<"FilterValue">;
+/**
+ * Integer key for fixed value mapping.
+ *
+ * Log Safety: SAFE
+ */
+export type FixedValuesMapKey = number;
+/**
+ * Log Safety: UNSAFE
+ */
+export interface FunctionLogicRule {
+    functionRid: FunctionRid;
+    functionVersion: FunctionVersion;
+    functionInputValues: Record<FunctionParameterName, LogicRuleArgument>;
+}
+/**
+ * The name of an input to a function.
+ *
+ * Log Safety: UNSAFE
+ */
+export type FunctionParameterName = LooselyBrandedString<"FunctionParameterName">;
 /**
  * The unique resource identifier of a Function, useful for interacting with other Foundry APIs.
  *
@@ -1394,6 +1627,14 @@ export interface GtQueryV2 {
     propertyIdentifier?: PropertyIdentifier;
     value: PropertyValue;
 }
+/**
+ * Formats the duration as a human-readable written string.
+ *
+ * Log Safety: SAFE
+ */
+export interface HumanReadableFormat {
+    showFullUnits?: boolean;
+}
 /**
  * A union currently only consisting of the BlueprintIcon (more icon types may be added in the future).
  *
@@ -1459,6 +1700,15 @@ export type InterfaceLinkTypeLinkedEntityApiName = ({
  * Log Safety: SAFE
  */
 export type InterfaceLinkTypeRid = LooselyBrandedString<"InterfaceLinkTypeRid">;
+/**
+ * Represents an interface parameter property argument in a logic rule.
+ *
+ * Log Safety: UNSAFE
+ */
+export interface InterfaceParameterPropertyArgument {
+    parameterId: ParameterId;
+    sharedPropertyTypeRid: string;
+}
 /**
    * A shared property type with an additional field to indicate whether the property must be included on every
 object type that implements the interface, or whether it is optional.
@@ -1559,6 +1809,16 @@ export interface IsNullQueryV2 {
     propertyIdentifier?: PropertyIdentifier;
     value: boolean;
 }
+/**
+   * Known Foundry types for specialized formatting:
+
+userOrGroupRid: Format as user or group RID (both are structurally RIDs)
+resourceRid: Format as resource RID
+artifactGid: Format as artifact GID
+   *
+   * Log Safety: SAFE
+   */
+export type KnownType = "userOrGroupRid" | "resourceRid" | "artifactGid";
 /**
  * Finds least of two or more numeric, date or timestamp values.
  *
@@ -1918,6 +2178,28 @@ export type LogicRule = ({
 } & CreateObjectRule) | ({
     type: "createLink";
 } & CreateLinkRule);
+/**
+ * Represents an argument for a logic rule operation. An argument can be passed in via the action parameters, as a static value, or as some other value.
+ *
+ * Log Safety: UNSAFE
+ */
+export type LogicRuleArgument = ({
+    type: "currentTime";
+} & CurrentTimeArgument) | ({
+    type: "staticValue";
+} & StaticArgument) | ({
+    type: "currentUser";
+} & CurrentUserArgument) | ({
+    type: "parameterId";
+} & ParameterIdArgument) | ({
+    type: "interfaceParameterPropertyValue";
+} & InterfaceParameterPropertyArgument) | ({
+    type: "synchronousWebhookOutput";
+} & SynchronousWebhookOutputArgument) | ({
+    type: "objectParameterPropertyValue";
+} & ObjectParameterPropertyArgument) | ({
+    type: "uniqueIdentifier";
+} & UniqueIdentifierArgument);
 /**
  * Returns objects where the specified field is less than or equal to a value.
  *
@@ -2012,6 +2294,14 @@ export interface MinAggregationV2 {
     name?: AggregationMetricName;
     direction?: OrderByDirection;
 }
+/**
+ * Log Safety: UNSAFE
+ */
+export interface ModifyInterfaceLogicRule {
+    interfaceObjectToModify: ParameterId;
+    sharedPropertyArguments: Record<SharedPropertyTypeApiName, LogicRuleArgument>;
+    structPropertyArguments: Record<SharedPropertyTypeApiName, Record<StructFieldApiName, StructFieldArgument>>;
+}
 /**
  * Log Safety: UNSAFE
  */
@@ -2033,6 +2323,14 @@ export interface ModifyObjectEdit {
     primaryKey: PropertyValue;
     properties: Record<PropertyApiName, DataValue>;
 }
+/**
+ * Log Safety: UNSAFE
+ */
+export interface ModifyObjectLogicRule {
+    objectToModify: ParameterId;
+    propertyArguments: Record<PropertyApiName, LogicRuleArgument>;
+    structPropertyArguments: Record<PropertyApiName, Record<StructFieldApiName, StructFieldArgument>>;
+}
 /**
  * Log Safety: UNSAFE
  */
@@ -2097,6 +2395,188 @@ export interface NotQuery {
 export interface NotQueryV2 {
     value: SearchJsonQueryV2;
 }
+/**
+   * Attach arbitrary text before and/or after the formatted number.
+Example: prefix "USD " and postfix " total" displays as "USD 1,234.56 total"
+   *
+   * Log Safety: UNSAFE
+   */
+export interface NumberFormatAffix {
+    baseFormatOptions: NumberFormatOptions;
+    affix: Affix;
+}
+/**
+   * Display the value as basis points. Multiplies by 10,000 and appends "bps" suffix.
+Used in finance where 1 basis point = 0.01%.
+Example: 0.0025 displays as "25 bps", 0.01 displays as "100 bps"
+   *
+   * Log Safety: SAFE
+   */
+export interface NumberFormatBasisPoints {
+    baseFormatOptions: NumberFormatOptions;
+}
+/**
+   * Format numbers as currency values with proper symbols and styling.
+Example: 1234.56 with currency "USD" displays as "USD 1,234.56" (standard) or "USD 1.2K" (compact)
+   *
+   * Log Safety: UNSAFE
+   */
+export interface NumberFormatCurrency {
+    baseFormatOptions: NumberFormatOptions;
+    style: NumberFormatCurrencyStyle;
+    currencyCode: PropertyTypeReferenceOrStringConstant;
+}
+/**
+   * Currency rendering style options:
+
+STANDARD: Full currency formatting (e.g., "USD 1,234.56")
+COMPACT: Abbreviated currency formatting (e.g., "USD 1.2K")
+   *
+   * Log Safety: SAFE
+   */
+export type NumberFormatCurrencyStyle = "STANDARD" | "COMPACT";
+/**
+   * Format numbers with custom units not supported by standard formatting.
+Use this for domain-specific units like "requests/sec", "widgets", etc.
+Example: 1500 with unit "widgets" displays as "1,500 widgets"
+   *
+   * Log Safety: UNSAFE
+   */
+export interface NumberFormatCustomUnit {
+    baseFormatOptions: NumberFormatOptions;
+    unit: PropertyTypeReferenceOrStringConstant;
+}
+/**
+   * Format numeric values representing time durations.
+
+Human readable: 3661 seconds displays as "1h 1m 1s"
+Timecode: 3661 seconds displays as "01:01:01"
+   *
+   * Log Safety: UNSAFE
+   */
+export interface NumberFormatDuration {
+    formatStyle: DurationFormatStyle;
+    precision?: DurationPrecision;
+    baseValue: DurationBaseValue;
+}
+/**
+   * Map integer values to custom human-readable strings.
+Example: {1: "First", 2: "Second", 3: "Third"} would display 2 as "Second".
+   *
+   * Log Safety: UNSAFE
+   */
+export interface NumberFormatFixedValues {
+    values: Record<FixedValuesMapKey, string>;
+}
+/**
+   * Number notation style options:
+
+STANDARD: Regular number display ("1,234")
+SCIENTIFIC: Scientific notation ("1.234E3")
+ENGINEERING: Engineering notation ("1.234E3")
+COMPACT: Compact notation ("1.2K")
+   *
+   * Log Safety: SAFE
+   */
+export type NumberFormatNotation = "STANDARD" | "SCIENTIFIC" | "ENGINEERING" | "COMPACT";
+/**
+   * Base number formatting options that can be applied to all number formatters.
+Controls precision, grouping, rounding, and notation. Consistent with JavaScript's Intl.NumberFormat.
+Examples:
+
+useGrouping: true makes 1234567 display as "1,234,567"
+maximumFractionDigits: 2 makes 3.14159 display as "3.14"
+notation: SCIENTIFIC makes 1234 display as "1.234E3"
+   *
+   * Log Safety: SAFE
+   */
+export interface NumberFormatOptions {
+    useGrouping?: boolean;
+    convertNegativeToParenthesis?: boolean;
+    minimumIntegerDigits?: number;
+    minimumFractionDigits?: number;
+    maximumFractionDigits?: number;
+    minimumSignificantDigits?: number;
+    maximumSignificantDigits?: number;
+    notation?: NumberFormatNotation;
+    roundingMode?: NumberRoundingMode;
+}
+/**
+   * Display the value as a ratio with different scaling factors and suffixes:
+
+PERCENTAGE: Multiply by 100 and add "%" suffix (0.15 → "15%")
+PER_MILLE: Multiply by 1000 and add "‰" suffix (0.015 → "15‰")
+BASIS_POINTS: Multiply by 10000 and add "bps" suffix (0.0015 → "15bps")
+   *
+   * Log Safety: SAFE
+   */
+export interface NumberFormatRatio {
+    ratioType: NumberRatioType;
+    baseFormatOptions: NumberFormatOptions;
+}
+/**
+   * Scale the numeric value by dividing by the specified factor and append an appropriate suffix.
+
+THOUSANDS: 1500 displays as "1.5K"
+MILLIONS: 2500000 displays as "2.5M"
+BILLIONS: 3200000000 displays as "3.2B"
+   *
+   * Log Safety: SAFE
+   */
+export interface NumberFormatScale {
+    scaleType: NumberScaleType;
+    baseFormatOptions: NumberFormatOptions;
+}
+/**
+   * Standard number formatting with configurable options.
+This provides basic number formatting without any special units, scaling, or transformations.
+   *
+   * Log Safety: SAFE
+   */
+export interface NumberFormatStandard {
+    baseFormatOptions: NumberFormatOptions;
+}
+/**
+   * Format numbers with standard units supported by Intl.NumberFormat.
+Examples: "meter", "kilogram", "celsius", "percent"
+Input: 25 with unit "celsius" displays as "25 degrees C"
+   *
+   * Log Safety: UNSAFE
+   */
+export interface NumberFormatStandardUnit {
+    baseFormatOptions: NumberFormatOptions;
+    unit: PropertyTypeReferenceOrStringConstant;
+}
+/**
+   * Ratio format options for displaying proportional values:
+
+PERCENTAGE: Multiply by 100 and add "%" suffix
+PER_MILLE: Multiply by 1000 and add "‰" suffix
+BASIS_POINTS: Multiply by 10000 and add "bps" suffix
+   *
+   * Log Safety: SAFE
+   */
+export type NumberRatioType = "PERCENTAGE" | "PER_MILLE" | "BASIS_POINTS";
+/**
+   * Number rounding behavior:
+
+CEIL: Always round up (3.1 becomes 4)
+FLOOR: Always round down (3.9 becomes 3)
+ROUND_CLOSEST: Round to nearest (3.4 becomes 3, 3.6 becomes 4)
+   *
+   * Log Safety: SAFE
+   */
+export type NumberRoundingMode = "CEIL" | "FLOOR" | "ROUND_CLOSEST";
+/**
+   * Scale factor options for large numbers:
+
+THOUSANDS: Divide by 1,000 and add "K" suffix
+MILLIONS: Divide by 1,000,000 and add "M" suffix
+BILLIONS: Divide by 1,000,000,000 and add "B" suffix
+   *
+   * Log Safety: SAFE
+   */
+export type NumberScaleType = "THOUSANDS" | "MILLIONS" | "BILLIONS";
 /**
  * Log Safety: UNSAFE
  */
@@ -2131,6 +2611,15 @@ export interface ObjectLocator {
     objectTypeApiName: ObjectTypeApiName;
     primaryKeyValue: PrimaryKeyValue;
 }
+/**
+ * Represents an object parameter property argument in a logic rule.
+ *
+ * Log Safety: UNSAFE
+ */
+export interface ObjectParameterPropertyArgument {
+    parameterId: ParameterId;
+    propertyTypeApiName: PropertyTypeApiName;
+}
 /**
  * Log Safety: UNSAFE
  */
@@ -2319,6 +2808,7 @@ export interface ObjectSetNearestNeighborsType {
     objectSet: ObjectSet;
     propertyIdentifier: PropertyIdentifier;
     numNeighbors: number;
+    similarityThreshold?: number;
     query: NearestNeighborsQuery;
 }
 /**
@@ -2848,6 +3338,14 @@ Parameters can be viewed and managed in the Ontology Manager.
    * Log Safety: UNSAFE
    */
 export type ParameterId = LooselyBrandedString<"ParameterId">;
+/**
+ * Represents a parameter ID argument in a logic rule.
+ *
+ * Log Safety: UNSAFE
+ */
+export interface ParameterIdArgument {
+    parameterId: ParameterId;
+}
 /**
  * A possible value for the parameter. This is defined in the Ontology Manager by Actions admins.
  *
@@ -2945,6 +3443,23 @@ export type PropertyApiName = LooselyBrandedString<"PropertyApiName">;
 export interface PropertyApiNameSelector {
     apiName: PropertyApiName;
 }
+/**
+ * Formatting configuration for boolean property values.
+ *
+ * Log Safety: UNSAFE
+ */
+export interface PropertyBooleanFormattingRule {
+    valueIfTrue: string;
+    valueIfFalse: string;
+}
+/**
+ * Formatting configuration for date property values.
+ *
+ * Log Safety: UNSAFE
+ */
+export interface PropertyDateFormattingRule {
+    format: DatetimeFormat;
+}
 /**
    * Represents a filter used on properties.
 Endpoints that accept this supports optional parameters that have the form:
@@ -2990,10 +3505,71 @@ export type PropertyIdentifier = ({
 } & PropertyApiNameSelector) | ({
     type: "structField";
 } & StructFieldSelector);
+/**
+ * Formatting configuration for known Foundry types.
+ *
+ * Log Safety: SAFE
+ */
+export interface PropertyKnownTypeFormattingRule {
+    knownType: KnownType;
+}
+/**
+ * Wrapper for numeric formatting options.
+ *
+ * Log Safety: UNSAFE
+ */
+export interface PropertyNumberFormattingRule {
+    numberType: PropertyNumberFormattingRuleType;
+}
+/**
+ * Log Safety: UNSAFE
+ */
+export type PropertyNumberFormattingRuleType = ({
+    type: "standard";
+} & NumberFormatStandard) | ({
+    type: "duration";
+} & NumberFormatDuration) | ({
+    type: "fixedValues";
+} & NumberFormatFixedValues) | ({
+    type: "affix";
+} & NumberFormatAffix) | ({
+    type: "scale";
+} & NumberFormatScale) | ({
+    type: "currency";
+} & NumberFormatCurrency) | ({
+    type: "standardUnit";
+} & NumberFormatStandardUnit) | ({
+    type: "customUnit";
+} & NumberFormatCustomUnit) | ({
+    type: "ratio";
+} & NumberFormatRatio);
+/**
+ * Formatting configuration for timestamp property values.
+ *
+ * Log Safety: UNSAFE
+ */
+export interface PropertyTimestampFormattingRule {
+    format: DatetimeFormat;
+    displayTimezone: DatetimeTimezone;
+}
 /**
  * Log Safety: UNSAFE
  */
 export type PropertyTypeApiName = LooselyBrandedString<"PropertyTypeApiName">;
+/**
+ * Log Safety: UNSAFE
+ */
+export interface PropertyTypeReference {
+    propertyApiName: string;
+}
+/**
+ * Log Safety: UNSAFE
+ */
+export type PropertyTypeReferenceOrStringConstant = ({
+    type: "constant";
+} & StringConstant) | ({
+    type: "propertyType";
+} & PropertyTypeReference);
 /**
  * Log Safety: SAFE
  */
@@ -3029,6 +3605,7 @@ export interface PropertyV2 {
     status?: PropertyTypeStatus;
     visibility?: PropertyTypeVisibility;
     valueTypeApiName?: ValueTypeApiName;
+    valueFormatting?: PropertyValueFormattingRule;
 }
 /**
    * Represents the value of a property in the following format.
@@ -3066,6 +3643,30 @@ export type PropertyValue = any;
  * Log Safety: UNSAFE
  */
 export type PropertyValueEscapedString = LooselyBrandedString<"PropertyValueEscapedString">;
+/**
+   * This feature is experimental and may change in a future release.
+Comprehensive formatting configuration for displaying property values in user interfaces.
+Supports different value types including numbers, dates, timestamps, booleans, and known Foundry types.
+Each formatter type provides specific options tailored to that data type:
+
+Numbers: Support for percentages, currencies, units, scaling, and custom formatting
+Dates/Timestamps: Localized and custom formatting patterns
+Booleans: Custom true/false display text
+Known types: Special formatting for Foundry-specific identifiers
+   *
+   * Log Safety: UNSAFE
+   */
+export type PropertyValueFormattingRule = ({
+    type: "date";
+} & PropertyDateFormattingRule) | ({
+    type: "number";
+} & PropertyNumberFormattingRule) | ({
+    type: "boolean";
+} & PropertyBooleanFormattingRule) | ({
+    type: "knownType";
+} & PropertyKnownTypeFormattingRule) | ({
+    type: "timestamp";
+} & PropertyTimestampFormattingRule);
 /**
  * An error indicating that the subscribe request should be attempted on a different node.
  *
@@ -3370,6 +3971,18 @@ export interface RegexConstraint {
     pattern: string;
     partialMatch: boolean;
 }
+/**
+   * 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(?).
+Either field or propertyIdentifier can be supplied, but not both.
+   *
+   * Log Safety: UNSAFE
+   */
+export interface RegexQuery {
+    field?: PropertyApiName;
+    propertyIdentifier?: PropertyIdentifier;
+    value: string;
+}
 /**
  * A relative time, such as "3 days before" or "2 hours after" the current moment.
  *
@@ -3470,42 +4083,24 @@ export type SearchJsonQuery = ({
  * Log Safety: UNSAFE
  */
 export type SearchJsonQueryV2 = ({
-    type: "or";
-} & OrQueryV2) | ({
-    type: "in";
-} & InQuery) | ({
-    type: "doesNotIntersectPolygon";
-} & DoesNotIntersectPolygonQuery) | ({
     type: "lt";
 } & LtQueryV2) | ({
     type: "doesNotIntersectBoundingBox";
 } & DoesNotIntersectBoundingBoxQuery) | ({
-    type: "eq";
-} & EqualsQueryV2) | ({
-    type: "containsAllTerms";
-} & ContainsAllTermsQuery) | ({
-    type: "gt";
-} & GtQueryV2) | ({
     type: "wildcard";
 } & WildcardQuery) | ({
     type: "withinDistanceOf";
 } & WithinDistanceOfQuery) | ({
     type: "withinBoundingBox";
 } & WithinBoundingBoxQuery) | ({
-    type: "contains";
-} & ContainsQueryV2) | ({
     type: "not";
 } & NotQueryV2) | ({
     type: "intersectsBoundingBox";
 } & IntersectsBoundingBoxQuery) | ({
     type: "and";
 } & AndQueryV2) | ({
-    type: "isNull";
-} & IsNullQueryV2) | ({
     type: "containsAllTermsInOrderPrefixLastTerm";
 } & ContainsAllTermsInOrderPrefixLastTerm) | ({
-    type: "containsAnyTerm";
-} & ContainsAnyTermQuery) | ({
     type: "gte";
 } & GteQueryV2) | ({
     type: "containsAllTermsInOrder";
@@ -3516,6 +4111,26 @@ export type SearchJsonQueryV2 = ({
 } & IntersectsPolygonQuery) | ({
     type: "lte";
 } & LteQueryV2) | ({
+    type: "or";
+} & OrQueryV2) | ({
+    type: "in";
+} & InQuery) | ({
+    type: "doesNotIntersectPolygon";
+} & DoesNotIntersectPolygonQuery) | ({
+    type: "eq";
+} & EqualsQueryV2) | ({
+    type: "containsAllTerms";
+} & ContainsAllTermsQuery) | ({
+    type: "gt";
+} & GtQueryV2) | ({
+    type: "contains";
+} & ContainsQueryV2) | ({
+    type: "regex";
+} & RegexQuery) | ({
+    type: "isNull";
+} & IsNullQueryV2) | ({
+    type: "containsAnyTerm";
+} & ContainsAnyTermQuery) | ({
     type: "startsWith";
 } & StartsWithQuery);
 /**
@@ -3772,6 +4387,7 @@ export interface SharedPropertyType {
     description?: string;
     dataType: ObjectPropertyType;
     valueTypeApiName?: ValueTypeApiName;
+    valueFormatting?: PropertyValueFormattingRule;
 }
 /**
    * The name of the shared property type in the API in lowerCamelCase format. To find the API name for your
@@ -3798,6 +4414,14 @@ export interface StartsWithQuery {
     propertyIdentifier?: PropertyIdentifier;
     value: string;
 }
+/**
+ * Represents a static argument in a logic rule.
+ *
+ * Log Safety: UNSAFE
+ */
+export interface StaticArgument {
+    value: DataValue;
+}
 /**
    * Which format to serialize the binary stream in.
 ARROW is more efficient for streaming a large sized response.
@@ -3842,6 +4466,12 @@ export interface StreamTimeSeriesValuesRequest {
 export interface StreamTimeSeriesValuesResponse {
     data: Array<TimeseriesEntry>;
 }
+/**
+ * Log Safety: UNSAFE
+ */
+export interface StringConstant {
+    value: string;
+}
 /**
    * The parameter value must have a length within the defined range.
 This range is always inclusive.
@@ -3883,6 +4513,16 @@ export interface StructEvaluatedConstraint {
  * Log Safety: UNSAFE
  */
 export type StructFieldApiName = LooselyBrandedString<"StructFieldApiName">;
+/**
+ * Represents an argument used for an individual struct field.
+ *
+ * Log Safety: UNSAFE
+ */
+export type StructFieldArgument = ({
+    type: "structListParameterFieldValue";
+} & StructListParameterFieldArgument) | ({
+    type: "structParameterFieldValue";
+} & StructParameterFieldArgument);
 /**
    * A constraint that an action struct parameter field value must satisfy in order to be considered valid.
 Constraints can be configured on fields of struct parameters in the Ontology Manager.
@@ -3943,12 +4583,30 @@ export interface StructFieldType {
  * Log Safety: SAFE
  */
 export type StructFieldTypeRid = LooselyBrandedString<"StructFieldTypeRid">;
+/**
+ * Represents a struct list parameter field argument in a logic rule.
+ *
+ * Log Safety: UNSAFE
+ */
+export interface StructListParameterFieldArgument {
+    parameterId: ParameterId;
+    structParameterFieldApiName: StructParameterFieldApiName;
+}
 /**
  * The unique identifier of the struct parameter field.
  *
  * Log Safety: UNSAFE
  */
 export type StructParameterFieldApiName = LooselyBrandedString<"StructParameterFieldApiName">;
+/**
+ * Represents a struct parameter field argument in a logic rule.
+ *
+ * Log Safety: UNSAFE
+ */
+export interface StructParameterFieldArgument {
+    parameterId: ParameterId;
+    structParameterFieldApiName: StructParameterFieldApiName;
+}
 /**
  * Log Safety: UNSAFE
  */
@@ -4036,6 +4694,14 @@ export interface SyncApplyActionResponseV2 {
     validation?: ValidateActionResponseV2;
     edits?: ActionResults;
 }
+/**
+ * Represents a synchronous webhook output argument in a logic rule.
+ *
+ * Log Safety: UNSAFE
+ */
+export interface SynchronousWebhookOutputArgument {
+    webhookOutputParamName: string;
+}
 /**
  * Log Safety: UNSAFE
  */
@@ -4043,6 +4709,13 @@ export interface ThreeDimensionalAggregation {
     keyType: QueryAggregationKeyType;
     valueType: TwoDimensionalAggregation;
 }
+/**
+ * Formats the duration in a timecode format.
+ *
+ * Log Safety: SAFE
+ */
+export interface TimeCodeFormat {
+}
 /**
  * An absolute or relative range for a time series query.
  *
@@ -4199,6 +4872,14 @@ This can happen when a parameter's allowed values are defined by another paramet
    */
 export interface UnevaluableConstraint {
 }
+/**
+ * Represents a unique identifier argument in a logic rule.
+ *
+ * Log Safety: SAFE
+ */
+export interface UniqueIdentifierArgument {
+    linkId?: string;
+}
 /**
  * The string must be a valid UUID (Universally Unique Identifier).
  *