Skip to content

Plan, apply and roll back changes to a production ontology, with a blast radius report and a proof an auditor can re-check.

Add Foundry Ontology to OWL crosswalk case study

FABIOTESSb9c67233fa70
diff --git a/.gitignore b/.gitignore
index 6fafb6b3..5356ca29 100644
--- a/.gitignore
+++ b/.gitignore
@@ -9,6 +9,8 @@ data/
!case-studies/modip-plastics-kg/data/**
!case-studies/robot-safety-security-crosswalk/data/
!case-studies/robot-safety-security-crosswalk/data/**
+!case-studies/foundry-owl-crosswalk/data/
+!case-studies/foundry-owl-crosswalk/data/**
# OntoAxiom ground truth + scored results — the benchmark claims are unverifiable without them
!benchmark/ontoaxiom/data/
!benchmark/ontoaxiom/data/**
diff --git a/case-studies/foundry-owl-crosswalk/.gitignore b/case-studies/foundry-owl-crosswalk/.gitignore
new file mode 100644
index 00000000..52c3ff7d
--- /dev/null
+++ b/case-studies/foundry-owl-crosswalk/.gitignore
@@ -0,0 +1,2 @@
+# Outreach drafts name real recipients. Never publish them.
+OUTREACH.md
diff --git a/case-studies/foundry-owl-crosswalk/README.md b/case-studies/foundry-owl-crosswalk/README.md
new file mode 100644
index 00000000..7d30a466
--- /dev/null
+++ b/case-studies/foundry-owl-crosswalk/README.md
@@ -0,0 +1,97 @@
+# Foundry Ontology to OWL 2, and the loss in both directions
+
+A working crosswalk between the Palantir Foundry Ontology and the W3C standards
+stack, built to measure what the crossing costs rather than to claim it is free.
+
+## Why this exists
+
+Palantir's white paper *Enabling Interoperability and Preventing Lock-In with
+Foundry* states that Foundry offers "the ability to import/export in multiple
+open formats (RDF XML/TTL, OWL, etc.) natively".
+
+The product documentation describes something else. The Ontology Manager export
+produces JSON, and Palantir's own note on it reads: "You should not depend on
+the exported JSON schema as it may change over time." The type reference says
+only that Foundry data types are "inspired by similar concepts in RDF, OWL and
+XSD". No RDF or OWL export path appears anywhere in the documentation.
+
+So the bridge is missing. This case study builds it, and then measures the gap
+it cannot close.
+
+## What is measured
+
+Two directions, both counted rather than asserted.
+
+**Foundry to OWL.** Of the 22 property types in Palantir's `ObjectPropertyType`
+union, 11 have a direct XSD counterpart, 2 need OGC GeoSPARQL, 2 are structural
+rather than scalar, and 7 have no counterpart in any published standard. Among
+those 7 is `marking`, the Foundry security classification. Exported to OWL, a
+marking becomes an ordinary literal, indistinguishable from data and no longer
+enforceable.
+
+**OWL to Foundry.** Five real ontologies were parsed, their asserted constructs
+counted, and each construct checked against the fields that exist in Palantir's
+ontology model. IES4, the UK government Information Exchange Standard, loses its
+entire property hierarchy: 200 `rdfs:subPropertyOf` assertions have no
+destination. The pizza reference ontology, which uses OWL as a logic rather than
+as a vocabulary, strands 1,241 assertions.
+
+The pattern is consistent. Foundry holds a taxonomy well. It has no field for a
+theory. The constructs with no destination are precisely the ones a reasoner
+uses to detect that something is wrong.
+
+Full figures, with the chart, are in
+[`ontology/coverage-report.md`](ontology/coverage-report.md).
+
+## Ground truth
+
+Nothing here rests on a screenshot or a blog post. The Foundry side is taken
+from Palantir's own Apache-2.0 licensed source:
+
+- `palantir/foundry-platform-python`, the wire models for the v2 Ontologies API,
+ which define what a Foundry Ontology is.
+- `palantir/osdk-ts`, the fixtures Palantir uses to mock its own API, including
+ an object type named `objectTypeWithAllPropertyTypes` that exercises the whole
+ union.
+
+Both are vendored under `vendor/` with URL, licence and SHA-256 recorded in
+[`data/palantir-sources.json`](data/palantir-sources.json). The property type
+list is parsed out of Palantir's source at build time, so a type added upstream
+breaks the build instead of passing silently into the unmappable bucket.
+
+## Running it
+
+```bash
+python3 vendor_sources.py # fetch Palantir's sources, record checksums
+python3 extract_type_system.py # parse the property type union
+python3 build_fixture.py # assemble an ontology export from the fixtures
+python3 foundry_owl.py # cross to OWL 2 and SHACL, write the loss report
+python3 owl_to_foundry.py # audit the other direction on real ontologies
+python3 generate_report.py # render the report and its charts
+python3 -m pytest test_crosswalk.py -q
+```
+
+Verification uses this repository's own engine:
+
+```bash
+open-ontologies validate ontology/foundry-crosswalk.ttl
+open-ontologies defects ontology/foundry-crosswalk.ttl
+open-ontologies lint ontology/foundry-crosswalk.ttl
+```
+
+The defects check earned its place. It caught a real fault in the first version
+of the crosswalk, which declared each recovered inverse in one direction only.
+
+## Scope and method
+
+The fixture is Palantir's published test data, not a production ontology, so the
+counts describe the type system faithfully and the size of a real deployment not
+at all. The mapping choices are ours and are stated in `TYPE_MAP`, where each
+entry carries the reason it was made. Six lint warnings remain on the output;
+all six are missing descriptions inherited from Palantir's fixture, where 5 of 9
+object types and 55 of 68 properties carry none. The crosswalk does not invent
+documentation to make its output look better.
+
+## Licence
+
+Apache-2.0, matching the vendored Palantir sources.
diff --git a/case-studies/foundry-owl-crosswalk/build_fixture.py b/case-studies/foundry-owl-crosswalk/build_fixture.py
new file mode 100644
index 00000000..bb1fbd3b
--- /dev/null
+++ b/case-studies/foundry-owl-crosswalk/build_fixture.py
@@ -0,0 +1,147 @@
+"""Assemble a Foundry ontology export from Palantir's own published fixtures.
+
+Palantir ships the fixtures it uses to mock its own API, including an object
+type named `objectTypeWithAllPropertyTypes` that exercises every property type
+in the union. Those fixtures are TypeScript. This module strips the type
+annotations, evaluates the object literals with node, and assembles them into
+the `OntologyFullMetadata` shape that the v2 API returns, so the crosswalk is
+exercised against Palantir's data rather than data invented here.
+"""
+import json
+import pathlib
+import re
+import subprocess
+import tempfile
+
+HERE = pathlib.Path(__file__).parent
+VENDOR = HERE / "vendor"
+OUT = HERE / "data" / "foundry-ontology.json"
+
+ORDER = ["spts.ts", "objectTypeV2.ts", "linkTypes.ts", "interfaceTypes.ts"]
+
+IMPORT_RE = re.compile(
+ r'^import\s+(?:type\s+)?(?:\{[^}]*\}|\w+)\s+from\s+"[^"]+";', re.M | re.S
+)
+ANNOTATION_RE = re.compile(r"^(\s*(?:export\s+)?const\s+\w+)\s*:\s*[A-Za-z0-9_.]+(?:\[\])?\s*=", re.M)
+SATISFIES_RE = re.compile(r"\s+satisfies\s+[A-Za-z0-9_.]+")
+AS_CAST_RE = re.compile(r"\s+as\s+(?:const|[A-Za-z0-9_.]+(?:\[\])?)\b")
+
+
+def strip_typescript(source: str) -> tuple[str, list[str]]:
+ exported = re.findall(r"^export\s+const\s+(\w+)", source, re.M)
+ source = IMPORT_RE.sub("", source)
+ source = ANNOTATION_RE.sub(r"\1 =", source)
+ source = SATISFIES_RE.sub("", source)
+ source = AS_CAST_RE.sub("", source)
+ source = re.sub(r"^export\s+const\s+", "const ", source, flags=re.M)
+ return source, exported
+
+
+def evaluate() -> dict:
+ chunks, names = [], []
+ for filename in ORDER:
+ stripped, exported = strip_typescript((VENDOR / filename).read_text())
+ chunks.append(f"// ---- {filename}\n{stripped}")
+ names.extend(exported)
+ unique = sorted(set(names))
+ collector = ",\n".join(f' "{name}": {name}' for name in unique)
+ script = "\n".join(chunks) + f"\nconst __out = {{\n{collector}\n}};\nconsole.log(JSON.stringify(__out));\n"
+ with tempfile.NamedTemporaryFile("w", suffix=".mjs", delete=False) as handle:
+ handle.write(script)
+ path = handle.name
+ result = subprocess.run(["node", path], capture_output=True, text=True)
+ if result.returncode != 0:
+ raise SystemExit(f"node failed evaluating fixtures:\n{result.stderr[:2000]}")
+ return json.loads(result.stdout)
+
+
+def assemble(values: dict) -> dict:
+ """Build the OntologyFullMetadata shape the v2 API returns."""
+ object_types = {
+ value["apiName"]: value
+ for value in values.values()
+ if isinstance(value, dict) and "primaryKey" in value and "properties" in value
+ }
+ link_sides = [
+ value
+ for value in values.values()
+ if isinstance(value, dict) and "cardinality" in value and "linkTypeRid" in value
+ ]
+ interfaces = {
+ value["apiName"]: value
+ for value in values.values()
+ if isinstance(value, dict) and "extendsInterfaces" in value
+ }
+ shared_properties = {
+ value["apiName"]: value
+ for value in values.values()
+ if isinstance(value, dict)
+ and "dataType" in value
+ and "apiName" in value
+ and "rid" in value
+ and str(value.get("rid", "")).startswith("ri.sharedPropertyType")
+ }
+
+ # A link side names the object type it points AT. Group by rid so the two
+ # sides of one link are matched, then attach each side to its source type.
+ by_rid: dict[str, list[dict]] = {}
+ for side in link_sides:
+ by_rid.setdefault(side["linkTypeRid"], []).append(side)
+
+ attached: dict[str, list[dict]] = {name: [] for name in object_types}
+ for sides in by_rid.values():
+ if len(sides) == 2:
+ first, second = sides
+ attached.setdefault(second["objectTypeApiName"], []).append(first)
+ attached.setdefault(first["objectTypeApiName"], []).append(second)
+ else:
+ for side in sides:
+ attached.setdefault(side["objectTypeApiName"], []).append(side)
+
+ full = {}
+ for api_name, object_type in object_types.items():
+ full[api_name] = {
+ "objectType": object_type,
+ "linkTypes": attached.get(api_name, []),
+ "implementsInterfaces": [],
+ "implementsInterfaces2": {},
+ "sharedPropertyTypeMapping": {},
+ }
+
+ return {
+ "ontology": {
+ "apiName": "palantir-osdk-test-fixtures",
+ "displayName": "Palantir OSDK shared test fixtures",
+ "description": (
+ "Assembled from the fixtures Palantir publishes in "
+ "palantir/osdk-ts to mock the Foundry Ontology API."
+ ),
+ "rid": "ri.ontology.main.ontology.fixture",
+ },
+ "objectTypes": full,
+ "actionTypes": {},
+ "actionTypesFullMetadata": {},
+ "queryTypes": {},
+ "interfaceTypes": interfaces,
+ "sharedPropertyTypes": shared_properties,
+ "valueTypes": {},
+ }
+
+
+def main() -> None:
+ metadata = assemble(evaluate())
+ OUT.write_text(json.dumps(metadata, indent=2) + "\n")
+ properties = sum(
+ len(entry["objectType"]["properties"]) for entry in metadata["objectTypes"].values()
+ )
+ links = sum(len(entry["linkTypes"]) for entry in metadata["objectTypes"].values())
+ print(
+ f"object types: {len(metadata['objectTypes'])} "
+ f"properties: {properties} link sides: {links} "
+ f"interfaces: {len(metadata['interfaceTypes'])} "
+ f"shared property types: {len(metadata['sharedPropertyTypes'])}"
+ )
+
+
+if __name__ == "__main__":
+ main()
diff --git a/case-studies/foundry-owl-crosswalk/data/crosswalk-report.json b/case-studies/foundry-owl-crosswalk/data/crosswalk-report.json
new file mode 100644
index 00000000..217c4881
--- /dev/null
+++ b/case-studies/foundry-owl-crosswalk/data/crosswalk-report.json
@@ -0,0 +1,106 @@
+{
+ "objectTypes": 9,
+ "properties": 68,
+ "linkSides": 6,
+ "interfaces": 2,
+ "sharedPropertyTypes": 1,
+ "inversePairs": 2,
+ "keyAxioms": 9,
+ "objectTypesWithoutDescription": 5,
+ "propertiesWithoutDescription": 55,
+ "propertiesByFidelity": {
+ "direct": 49,
+ "structural": 3,
+ "none": 10,
+ "standard": 6
+ },
+ "lossyProperties": [
+ {
+ "objectType": "Employee",
+ "property": "employeeStatus",
+ "foundryType": "timeseries",
+ "elementType": null,
+ "reason": "A handle onto a Foundry time series, not a value. The series itself is not in the export."
+ },
+ {
+ "objectType": "Employee",
+ "property": "employeeSensor",
+ "foundryType": "timeseries",
+ "elementType": null,
+ "reason": "A handle onto a Foundry time series, not a value. The series itself is not in the export."
+ },
+ {
+ "objectType": "Employee",
+ "property": "employeeLocation",
+ "foundryType": "geotimeSeriesReference",
+ "elementType": null,
+ "reason": "A handle onto a Geotime integration. The track is not in the export."
+ },
+ {
+ "objectType": "Employee",
+ "property": "skillSetEmbedding",
+ "foundryType": "vector",
+ "elementType": null,
+ "reason": "An embedding. The export declares its dimension and sometimes the producing model, but no W3C datatype carries a vector, so both become annotations rather than a range."
+ },
+ {
+ "objectType": "objectTypeWithAllPropertyTypes",
+ "property": "attachment",
+ "foundryType": "attachment",
+ "elementType": null,
+ "reason": "A resource identifier pointing into Foundry blob storage. The value does not resolve outside the platform."
+ },
+ {
+ "objectType": "objectTypeWithAllPropertyTypes",
+ "property": "attachment2",
+ "foundryType": "attachment",
+ "elementType": null,
+ "reason": "A resource identifier pointing into Foundry blob storage. The value does not resolve outside the platform."
+ },
+ {
+ "objectType": "objectTypeWithAllPropertyTypes",
+ "property": "attachmentArray",
+ "foundryType": "array",
+ "elementType": "attachment",
+ "reason": "A resource identifier pointing into Foundry blob storage. The value does not resolve outside the platform."
+ },
+ {
+ "objectType": "objectTypeWithAllPropertyTypes",
+ "property": "mediaReference",
+ "foundryType": "mediaReference",
+ "elementType": null,
+ "reason": "A reference into a Foundry media set. Does not resolve outside the platform."
+ },
+ {
+ "objectType": "objectTypeWithAllPropertyTypes",
+ "property": "vector",
+ "foundryType": "vector",
+ "elementType": null,
+ "reason": "An embedding. The export declares its dimension and sometimes the producing model, but no W3C datatype carries a vector, so both become annotations rather than a range."
+ },
+ {
+ "objectType": "objectTypeWithAllPropertyTypes",
+ "property": "cipherText",
+ "foundryType": "cipherText",
+ "elementType": null,
+ "reason": "Ciphertext bound to a Foundry cipher channel. The channel reference is meaningless outside the platform."
+ }
+ ],
+ "droppedConstructs": [
+ {
+ "construct": "actionType",
+ "countInExport": 0,
+ "reason": "A Foundry action is a permissioned state change with parameters, validation and side effects. OWL describes what holds, not what may be done, so no axiom carries it."
+ },
+ {
+ "construct": "queryType",
+ "countInExport": 0,
+ "reason": "A Foundry query is a named function. SPARQL can express a query but the ontology has no place to declare one."
+ },
+ {
+ "construct": "valueType",
+ "countInExport": 0,
+ "reason": "A Foundry value type is a reusable semantic constraint. The nearest OWL construct is a datatype restriction, which cannot carry the Foundry formatting and validation metadata."
+ }
+ ]
+}
diff --git a/case-studies/foundry-owl-crosswalk/data/foundry-ontology.json b/case-studies/foundry-owl-crosswalk/data/foundry-ontology.json
new file mode 100644
index 00000000..d6f41ff4
--- /dev/null
+++ b/case-studies/foundry-owl-crosswalk/data/foundry-ontology.json
@@ -0,0 +1,1176 @@
+{
+ "ontology": {
+ "apiName": "palantir-osdk-test-fixtures",
+ "displayName": "Palantir OSDK shared test fixtures",
+ "description": "Assembled from the fixtures Palantir publishes in palantir/osdk-ts to mock the Foundry Ontology API.",
+ "rid": "ri.ontology.main.ontology.fixture"
+ },
+ "objectTypes": {
+ "BgaoNflPlayer": {
+ "objectType": {
+ "apiName": "BgaoNflPlayer",
+ "displayName": "id",
+ "pluralDisplayName": "BgaoNflPlayers",
+ "aliases": [],
+ "datasources": [],
+ "icon": {
+ "type": "blueprint",
+ "color": "blue",
+ "name": "box"
+ },
+ "primaryKey": "id",
+ "properties": {
+ "id": {
+ "dataType": {
+ "type": "string"
+ },
+ "rid": "rid",
+ "typeClasses": []
+ },
+ "gamesPlayed": {
+ "dataType": {
+ "type": "integer"
+ },
+ "rid": "rid",
+ "typeClasses": []
+ },
+ "name": {
+ "dataType": {
+ "type": "string"
+ },
+ "rid": "rid",
+ "typeClasses": []
+ },
+ "number": {
+ "dataType": {
+ "type": "integer"
+ },
+ "rid": "rid",
+ "typeClasses": []
+ },
+ "wikiUrl": {
+ "dataType": {
+ "type": "string"
+ },
+ "rid": "rid",
+ "typeClasses": []
+ },
+ "address": {
+ "dataType": {
+ "type": "struct",
+ "structFieldTypes": [
+ {
+ "apiName": "addressLine1",
+ "dataType": {
+ "type": "string"
+ },
+ "rid": "ri.a.b.c.d",
+ "typeClasses": []
+ },
+ {
+ "apiName": "addressLine2",
+ "dataType": {
+ "type": "string"
+ },
+ "rid": "ri.a.b.c.d",
+ "typeClasses": []
+ },
+ {
+ "apiName": "city",
+ "dataType": {
+ "type": "string"
+ },
+ "rid": "ri.a.b.c.d",
+ "typeClasses": []
+ },
+ {
+ "apiName": "state",
+ "dataType": {
+ "type": "string"
+ },
+ "rid": "ri.a.b.c.d",
+ "typeClasses": []
+ },
+ {
+ "apiName": "zipCode",
+ "dataType": {
+ "type": "integer"
+ },
+ "rid": "ri.a.b.c.d",
+ "typeClasses": []
+ }
+ ]
+ },
+ "rid": "rid",
+ "typeClasses": []
+ },
+ "addressArray": {
+ "dataType": {
+ "type": "array",
+ "subType": {
+ "type": "struct",
+ "structFieldTypes": [
+ {
+ "apiName": "addressLine1",
+ "dataType": {
+ "type": "string"
+ },
+ "rid": "ri.a.b.c.d",
+ "typeClasses": []
+ },
+ {
+ "apiName": "addressLine2",
+ "dataType": {
+ "type": "string"
+ },
+ "rid": "ri.a.b.c.d",
+ "typeClasses": []
+ },
+ {
+ "apiName": "city",
+ "dataType": {
+ "type": "geoshape"
+ },
+ "rid": "ri.a.b.c.d",
+ "typeClasses": []
+ },
+ {
+ "apiName": "location",
+ "dataType": {
+ "type": "geopoint"
+ },
+ "rid": "ri.a.b.c.d",
+ "typeClasses": []
+ },
+ {
+ "apiName": "zipCode",
+ "dataType": {
+ "type": "integer"
+ },
+ "rid": "ri.a.b.c.d",
+ "typeClasses": []
+ }
+ ]
+ },
+ "reducers": []
+ },
+ "rid": "ri.a.b.c.structArray",
+ "typeClasses": []
+ }
+ },
+ "rid": "ri.nflplayer",
+ "status": "ACTIVE",
+ "titleProperty": "name"
+ },
+ "linkTypes": [],
+ "implementsInterfaces": [],
+ "implementsInterfaces2": {},
+ "sharedPropertyTypeMapping": {}
+ },
+ "Employee": {
+ "objectType": {
+ "apiName": "Employee",
+ "displayName": "Employee",
+ "pluralDisplayName": "Employees",
+ "aliases": [],
+ "datasources": [],
+ "icon": {
+ "type": "blueprint",
+ "color": "blue",
+ "name": "person"
+ },
+ "description": "A full-time or part-time \n\n employee of our firm",
+ "primaryKey": "employeeId",
+ "titleProperty": "fullName",
+ "visibility": "NORMAL",
+ "properties": {
+ "employeeId": {
+ "dataType": {
+ "type": "integer"
+ },
+ "rid": "rid",
+ "typeClasses": []
+ },
+ "fullName": {
+ "dataType": {
+ "type": "string"
+ },
+ "rid": "rid",
+ "typeClasses": []
+ },
+ "office": {
+ "description": "The unique \"ID\" of the employee's \\\"primary\\\" assigned office.\n This is some more text.",
+ "dataType": {
+ "type": "string"
+ },
+ "rid": "rid",
+ "typeClasses": []
+ },
+ "class": {
+ "description": "",
+ "dataType": {
+ "type": "string"
+ },
+ "rid": "rid",
+ "typeClasses": []
+ },
+ "startDate": {
+ "description": "The date the employee was hired (most recently, if they were re-hired)",
+ "dataType": {
+ "type": "date"
+ },
+ "rid": "rid",
+ "typeClasses": []
+ },
+ "employeeStatus": {
+ "description": "TimeSeries of the status of the employee",
+ "dataType": {
+ "type": "timeseries",
+ "itemType": {
+ "type": "string"
+ }
+ },
+ "rid": "rid",
+ "typeClasses": []
+ },
+ "employeeSensor": {
+ "description": "TimeSeries sensor of the status of the employee",
+ "dataType": {
+ "type": "timeseries",
+ "itemType": {
+ "type": "string"
+ }
+ },
+ "rid": "rid",
+ "typeClasses": []
+ },
+ "employeeLocation": {
+ "description": "Geotime series reference of the location of the employee",
+ "dataType": {
+ "type": "geotimeSeriesReference"
+ },
+ "rid": "rid",
+ "typeClasses": []
+ },
+ "skillSet": {
+ "description": "The skills of the employee",
+ "dataType": {
+ "type": "string"
+ },
+ "rid": "rid",
+ "typeClasses": []
+ },
+ "skillSetEmbedding": {
+ "description": "Vectorized skill set",
+ "dataType": {
+ "type": "vector",
+ "dimension": 1536,
+ "supportsSearchWith": [
+ {
+ "value": "COSINE_SIMILARITY"
+ }
+ ],
+ "embeddingModel": {
+ "type": "lms",
+ "value": "OPENAI_TEXT_EMBEDDING_ADA_002"
+ }
+ },
+ "rid": "rid",
+ "typeClasses": []
+ },
+ "favoriteRestaurants": {
+ "dataType": {
+ "type": "array",
+ "subType": {
+ "type": "string"
+ },
+ "reducers": []
+ },
+ "rid": "rid",
+ "typeClasses": []
+ },
+ "employeeProfile": {
+ "description": "Employee profile with main value being the bio",
+ "dataType": {
+ "type": "struct",
+ "structFieldTypes": [
+ {
+ "apiName": "bio",
+ "dataType": {
+ "type": "string"
+ },
+ "rid": "ri.struct.bio",
+ "typeClasses": []
+ },
+ {
+ "apiName": "yearsExperience",
+ "dataType": {
+ "type": "integer"
+ },
+ "rid": "ri.struct.yearsExperience",
+ "typeClasses": []
+ }
+ ],
+ "mainValue": {
+ "mainValueType": {
+ "type": "string"
+ },
+ "fields": [
+ "bio"
+ ]
+ }
+ },
+ "rid": "rid",
+ "typeClasses": []
+ },
+ "performanceScores": {
+ "description": "Array of performance scores with reducers",
+ "dataType": {
+ "type": "array",
+ "subType": {
+ "type": "double"
+ },
+ "reducers": [
+ {
+ "direction": "DESCENDING_NULLS_LAST"
+ }
+ ]
+ },
+ "rid": "rid",
+ "typeClasses": []
+ }
+ },
+ "rid": "ri.ontology.main.object-type.401ac022-89eb-4591-8b7e-0a912b9efb44",
+ "status": "ACTIVE"
+ },
+ "linkTypes": [
+ {
+ "apiName": "lead",
+ "status": "EXPERIMENTAL",
+ "objectTypeApiName": "Employee",
+ "cardinality": "ONE",
+ "displayName": "Lead",
+ "linkTypeRid": "rid.link-type.327",
+ "foreignKeyPropertyApiName": "leadId"
+ },
+ {
+ "apiName": "peeps",
+ "status": "EXPERIMENTAL",
+ "objectTypeApiName": "Employee",
+ "cardinality": "MANY",
+ "displayName": "Peeps",
+ "linkTypeRid": "rid.link-type.327"
+ },
+ {
+ "apiName": "officeLink",
+ "status": "EXPERIMENTAL",
+ "objectTypeApiName": "Office",
+ "cardinality": "ONE",
+ "displayName": "Office",
+ "linkTypeRid": "rid.link-type.324",
+ "foreignKeyPropertyApiName": "office"
+ }
+ ],
+ "implementsInterfaces": [],
+ "implementsInterfaces2": {},
+ "sharedPropertyTypeMapping": {}
+ },
+ "equipment": {
+ "objectType": {
+ "apiName": "equipment",
+ "displayName": "Equipment",
+ "pluralDisplayName": "Equipment",
+ "aliases": [],
+ "datasources": [],
+ "icon": {
+ "type": "blueprint",
+ "color": "blue",
+ "name": "gear"
+ },
+ "primaryKey": "equipmentId",
+ "titleProperty": "type",
+ "properties": {
+ "equipmentId": {
+ "description": "The id of an equipment",
+ "dataType": {
+ "type": "string"
+ },
+ "rid": "rid",
+ "typeClasses": []
+ },
+ "type": {
+ "dataType": {
+ "type": "string"
+ },
+ "rid": "rid",
+ "typeClasses": []
+ }
+ },
+ "rid": "ri.ontology.main.object-type.808ac022-89eb-4591-8b7e-1a912b9efb45",
+ "status": "ACTIVE"
+ },
+ "linkTypes": [],
+ "implementsInterfaces": [],
+ "implementsInterfaces2": {},
+ "sharedPropertyTypeMapping": {}
+ },
+ "objectTypeWithAllPropertyTypes": {
+ "objectType": {
+ "apiName": "objectTypeWithAllPropertyTypes",
+ "displayName": "objectTypeWithAllPropertyType",
+ "pluralDisplayName": "objectTypeWithAllPropertyTypes",
+ "aliases": [],
+ "datasources": [],
+ "icon": {
+ "type": "blueprint",
+ "color": "blue",
+ "name": "person"
+ },
+ "description": "An object type with all property types",
+ "primaryKey": "id",
+ "titleProperty": "string",
+ "properties": {
+ "id": {
+ "dataType": {
+ "type": "integer"
+ },
+ "rid": "rid",
+ "typeClasses": []
+ },
+ "string": {
+ "dataType": {
+ "type": "string"
+ },
+ "rid": "rid",
+ "typeClasses": []
+ },
+ "boolean": {
+ "dataType": {
+ "type": "boolean"
+ },
+ "rid": "rid",
+ "typeClasses": []
+ },
+ "date": {
+ "dataType": {
+ "type": "date"
+ },
+ "rid": "rid",
+ "typeClasses": []
+ },
+ "dateTime": {
+ "dataType": {
+ "type": "timestamp"
+ },
+ "rid": "rid",
+ "typeClasses": []
+ },
+ "decimal": {
+ "dataType": {
+ "type": "decimal"
+ },
+ "rid": "rid",
+ "typeClasses": []
+ },
+ "integer": {
+ "dataType": {
+ "type": "integer"
+ },
+ "rid": "rid",
+ "typeClasses": []
+ },
+ "long": {
+ "dataType": {
+ "type": "long"
+ },
+ "rid": "rid",
+ "typeClasses": []
+ },
+ "short": {
+ "dataType": {
+ "type": "short"
+ },
+ "rid": "rid",
+ "typeClasses": []
+ },
+ "float": {
+ "dataType": {
+ "type": "float"
+ },
+ "rid": "rid",
+ "typeClasses": []
+ },
+ "double": {
+ "dataType": {
+ "type": "double"
+ },
+ "rid": "rid",
+ "typeClasses": []
+ },
+ "byte": {
+ "dataType": {
+ "type": "byte"
+ },
+ "rid": "rid",
+ "typeClasses": []
+ },
+ "attachment": {
+ "dataType": {
+ "type": "attachment"
+ },
+ "rid": "rid",
+ "typeClasses": []
+ },
+ "attachment2": {
+ "dataType": {
+ "type": "attachment"
+ },
+ "rid": "rid",
+ "typeClasses": []
+ },
+ "geoPoint": {
+ "dataType": {
+ "type": "geopoint"
+ },
+ "rid": "rid",
+ "typeClasses": []
+ },
+ "geoShape": {
+ "dataType": {
+ "type": "geoshape"
+ },
+ "rid": "rid",
+ "typeClasses": []
+ },
+ "stringArray": {
+ "dataType": {
+ "type": "array",
+ "subType": {
+ "type": "string"
+ },
+ "reducers": []
+ },
+ "rid": "rid",
+ "typeClasses": []
+ },
+ "booleanArray": {
+ "dataType": {
+ "type": "array",
+ "subType": {
+ "type": "boolean"
+ },
+ "reducers": []
+ },
+ "rid": "rid",
+ "typeClasses": []
+ },
+ "dateArray": {
+ "dataType": {
+ "type": "array",
+ "subType": {
+ "type": "date"
+ },
+ "reducers": []
+ },
+ "rid": "rid",
+ "typeClasses": []
+ },
+ "dateTimeArray": {
+ "dataType": {
+ "type": "array",
+ "subType": {
+ "type": "timestamp"
+ },
+ "reducers": []
+ },
+ "rid": "rid",
+ "typeClasses": []
+ },
+ "decimalArray": {
+ "dataType": {
+ "type": "array",
+ "subType": {
+ "type": "decimal"
+ },
+ "reducers": []
+ },
+ "rid": "rid",
+ "typeClasses": []
+ },
+ "integerArray": {
+ "dataType": {
+ "type": "array",
+ "subType": {
+ "type": "integer"
+ },
+ "reducers": []
+ },
+ "rid": "rid",
+ "typeClasses": []
+ },
+ "longArray": {
+ "dataType": {
+ "type": "array",
+ "subType": {
+ "type": "long"
+ },
+ "reducers": []
+ },
+ "rid": "rid",
+ "typeClasses": []
+ },
+ "shortArray": {
+ "dataType": {
+ "type": "array",
+ "subType": {
+ "type": "short"
+ },
+ "reducers": []
+ },
+ "rid": "rid",
+ "typeClasses": []
+ },
+ "floatArray": {
+ "dataType": {
+ "type": "array",
+ "subType": {
+ "type": "float"
+ },
+ "reducers": []
+ },
+ "rid": "rid",
+ "typeClasses": []
+ },
+ "doubleArray": {
+ "dataType": {
+ "type": "array",
+ "subType": {
+ "type": "double"
+ },
+ "reducers": []
+ },
+ "rid": "rid",
+ "typeClasses": []
+ },
+ "byteArray": {
+ "dataType": {
+ "type": "array",
+ "subType": {
+ "type": "byte"
+ },
+ "reducers": []
+ },
+ "rid": "rid",
+ "typeClasses": []
+ },
+ "attachmentArray": {
+ "dataType": {
+ "type": "array",
+ "subType": {
+ "type": "attachment"
+ },
+ "reducers": []
+ },
+ "rid": "rid",
+ "typeClasses": []
+ },
+ "geoPointArray": {
+ "dataType": {
+ "type": "array",
+ "subType": {
+ "type": "geopoint"
+ },
+ "reducers": []
+ },
+ "rid": "rid",
+ "typeClasses": []
+ },
+ "geoShapeArray": {
+ "dataType": {
+ "type": "array",
+ "subType": {
+ "type": "geoshape"
+ },
+ "reducers": []
+ },
+ "rid": "rid",
+ "typeClasses": []
+ },
+ "mediaReference": {
+ "dataType": {
+ "type": "mediaReference"
+ },
+ "rid": "rid",
+ "typeClasses": []
+ },
+ "vector": {
+ "dataType": {
+ "type": "vector",
+ "dimension": 100,
+ "supportsSearchWith": []
+ },
+ "rid": "rid",
+ "typeClasses": []
+ },
+ "cipherText": {
+ "dataType": {
+ "type": "cipherText"
+ },
+ "rid": "rid",
+ "typeClasses": []
+ }
+ },
+ "rid": "ri.ontology.main.object-type.401ac022-89eb-4591-8b7e-0a912b9efb44",
+ "status": "ACTIVE"
+ },
+ "linkTypes": [
+ {
+ "apiName": "linkedObjectType",
+ "status": "EXPERIMENTAL",
+ "objectTypeApiName": "objectTypeWithAllPropertyTypes",
+ "cardinality": "ONE",
+ "displayName": "Linked Object Type",
+ "linkTypeRid": "rid.link-type.832"
+ }
+ ],
+ "implementsInterfaces": [],
+ "implementsInterfaces2": {},
+ "sharedPropertyTypeMapping": {}
+ },
+ "ObjectWithTimestampPrimaryKey": {
+ "objectType": {
+ "apiName": "ObjectWithTimestampPrimaryKey",
+ "displayName": "ObjectWithTimestampPrimaryKey",
+ "pluralDisplayName": "ObjectWithTimestampPrimaryKeys",
+ "aliases": [],
+ "datasources": [],
+ "icon": {
+ "type": "blueprint",
+ "color": "blue",
+ "name": "person"
+ },
+ "description": "Object Type With Timestamp Primary Key",
+ "primaryKey": "timestamp",
+ "titleProperty": "value",
+ "properties": {
+ "timestamp": {
+ "dataType": {
+ "type": "timestamp"
+ },
+ "rid": "rid",
+ "typeClasses": []
+ },
+ "value": {
+ "dataType": {
+ "type": "string"
+ },
+ "rid": "rid",
+ "typeClasses": []
+ }
+ },
+ "rid": "ri.ontology.main.object-type.32bb9402-9cab-4705-81bb-edb65a4a6806",
+ "status": "ACTIVE"
+ },
+ "linkTypes": [],
+ "implementsInterfaces": [],
+ "implementsInterfaces2": {},
+ "sharedPropertyTypeMapping": {}
+ },
+ "Office": {
+ "objectType": {
+ "apiName": "Office",
+ "displayName": "Office",
+ "pluralDisplayName": "Office",
+ "aliases": [],
+ "datasources": [],
+ "icon": {
+ "type": "blueprint",
+ "color": "blue",
+ "name": "office"
+ },
+ "description": "A office in our Company",
+ "primaryKey": "officeId",
+ "titleProperty": "officeId",
+ "properties": {
+ "officeId": {
+ "dataType": {
+ "type": "string"
+ },
+ "rid": "rid",
+ "typeClasses": []
+ },
+ "entrance": {
+ "dataType": {
+ "type": "geopoint"
+ },
+ "rid": "rid",
+ "typeClasses": []
+ },
+ "occupiedArea": {
+ "description": "The occupied area of the Office",
+ "dataType": {
+ "type": "geoshape"
+ },
+ "rid": "rid",
+ "typeClasses": []
+ },
+ "name": {
+ "description": "The Name of the Office",
+ "dataType": {
+ "type": "string"
+ },
+ "rid": "rid",
+ "typeClasses": []
+ },
+ "capacity": {
+ "description": "The capacity of the Office",
+ "dataType": {
+ "type": "integer"
+ },
+ "rid": "rid",
+ "typeClasses": []
+ }
+ },
+ "rid": "ri.ontology.main.object-type.404ac022-89eb-4591-8b7e-1a912b9efb45",
+ "status": "ACTIVE"
+ },
+ "linkTypes": [
+ {
+ "apiName": "occupants",
+ "status": "EXPERIMENTAL",
+ "objectTypeApiName": "Employee",
+ "cardinality": "MANY",
+ "displayName": "Office Occupants",
+ "linkTypeRid": "rid.link-type.324"
+ },
+ {
+ "apiName": "visitedOffices",
+ "status": "EXPERIMENTAL",
+ "objectTypeApiName": "Office",
+ "cardinality": "MANY",
+ "displayName": "Visited Offices",
+ "linkTypeRid": "ri.a.b.c.visitedOffices"
+ }
+ ],
+ "implementsInterfaces": [],
+ "implementsInterfaces2": {},
+ "sharedPropertyTypeMapping": {}
+ },
+ "Person": {
+ "objectType": {
+ "apiName": "Person",
+ "displayName": "Person",
+ "pluralDisplayName": "Persons",
+ "aliases": [],
+ "datasources": [],
+ "icon": {
+ "type": "blueprint",
+ "color": "blue",
+ "name": "person"
+ },
+ "primaryKey": "id",
+ "properties": {
+ "id": {
+ "dataType": {
+ "type": "integer"
+ },
+ "rid": "rid",
+ "typeClasses": []
+ },
+ "name": {
+ "dataType": {
+ "type": "string"
+ },
+ "rid": "rid",
+ "typeClasses": []
+ }
+ },
+ "rid": "ri.person",
+ "status": "ACTIVE",
+ "titleProperty": "name"
+ },
+ "linkTypes": [],
+ "implementsInterfaces": [],
+ "implementsInterfaces2": {},
+ "sharedPropertyTypeMapping": {}
+ },
+ "Task": {
+ "objectType": {
+ "apiName": "Task",
+ "displayName": "Task",
+ "pluralDisplayName": "Tasks",
+ "aliases": [],
+ "datasources": [],
+ "icon": {
+ "type": "blueprint",
+ "color": "blue",
+ "name": "box"
+ },
+ "primaryKey": "id",
+ "properties": {
+ "id": {
+ "dataType": {
+ "type": "integer"
+ },
+ "rid": "rid",
+ "typeClasses": []
+ },
+ "name": {
+ "dataType": {
+ "type": "string"
+ },
+ "rid": "rid",
+ "typeClasses": []
+ }
+ },
+ "status": "ACTIVE",
+ "rid": "ri.task",
+ "titleProperty": "name"
+ },
+ "linkTypes": [],
+ "implementsInterfaces": [],
+ "implementsInterfaces2": {},
+ "sharedPropertyTypeMapping": {}
+ },
+ "Todo": {
+ "objectType": {
+ "apiName": "Todo",
+ "displayName": "Todo",
+ "pluralDisplayName": "ManyTodo",
+ "aliases": [],
+ "datasources": [],
+ "icon": {
+ "type": "blueprint",
+ "color": "blue",
+ "name": "box"
+ },
+ "primaryKey": "id",
+ "properties": {
+ "id": {
+ "dataType": {
+ "type": "integer"
+ },
+ "rid": "rid",
+ "typeClasses": []
+ },
+ "text": {
+ "dataType": {
+ "type": "string"
+ },
+ "rid": "rid",
+ "typeClasses": []
+ }
+ },
+ "rid": "ri.todo",
+ "status": "ACTIVE",
+ "titleProperty": "text"
+ },
+ "linkTypes": [],
+ "implementsInterfaces": [],
+ "implementsInterfaces2": {},
+ "sharedPropertyTypeMapping": {}
+ }
+ },
+ "actionTypes": {},
+ "actionTypesFullMetadata": {},
+ "queryTypes": {},
+ "interfaceTypes": {
+ "BarInterface": {
+ "apiName": "BarInterface",
+ "description": "Interface for Bar",
+ "displayName": "Bar Interface",
+ "rid": "ri.interface.main.interface.2",
+ "extendsInterfaces": [],
+ "properties": {},
+ "allProperties": {},
+ "propertiesV2": {},
+ "allPropertiesV2": {},
+ "links": {
+ "toFoo": {
+ "rid": "ri.interface.link.main.1",
+ "apiName": "toFoo",
+ "linkedEntityApiName": {
+ "type": "interfaceTypeApiName",
+ "apiName": "FooInterface"
+ },
+ "displayName": "foos",
+ "cardinality": "MANY",
+ "required": true
+ }
+ },
+ "implementedByObjectTypes": [],
+ "allExtendsInterfaces": [],
+ "allLinks": {
+ "toFoo": {
+ "rid": "ri.interface.link.main.1",
+ "apiName": "toFoo",
+ "linkedEntityApiName": {
+ "type": "interfaceTypeApiName",
+ "apiName": "FooInterface"
+ },
+ "displayName": "foos",
+ "cardinality": "MANY",
+ "required": true
+ }
+ }
+ },
+ "FooInterface": {
+ "apiName": "FooInterface",
+ "description": "Interface for Foo",
+ "displayName": "Foo Interface",
+ "rid": "ri.interface.main.interface.1",
+ "extendsInterfaces": [],
+ "properties": {
+ "fooSpt": {
+ "rid": "ri.sharedPropertyType.main.sharedPropertyType.1",
+ "apiName": "fooSpt",
+ "dataType": {
+ "type": "string"
+ },
+ "displayName": "Foo",
+ "description": "A foo",
+ "typeClasses": [],
+ "required": true
+ }
+ },
+ "propertiesV2": {
+ "fooSpt": {
+ "rid": "ri.sharedPropertyType.main.sharedPropertyType.1",
+ "apiName": "fooSpt",
+ "dataType": {
+ "type": "string"
+ },
+ "displayName": "Foo",
+ "description": "A foo",
+ "typeClasses": [],
+ "type": "interfaceSharedPropertyType",
+ "required": true
+ },
+ "fooIdp": {
+ "rid": "ri.interfacePropertyType.main.interfacePropertyType.1",
+ "apiName": "fooIdp",
+ "displayName": "Foo IDP",
+ "description": "A Foo IDP",
+ "dataType": {
+ "type": "string"
+ },
+ "requireImplementation": true,
+ "typeClasses": [],
+ "type": "interfaceDefinedPropertyType"
+ },
+ "fooArray": {
+ "rid": "ri.interfacePropertyType.main.interfacePropertyType.2",
+ "apiName": "fooArray",
+ "displayName": "Foo Array",
+ "description": "An array-valued Foo property",
+ "dataType": {
+ "type": "array",
+ "subType": {
+ "type": "string"
+ },
+ "reducers": []
+ },
+ "requireImplementation": false,
+ "typeClasses": [],
+ "type": "interfaceDefinedPropertyType"
+ }
+ },
+ "links": {
+ "toBar": {
+ "rid": "ri.interface.link.main.2",
+ "apiName": "toBar",
+ "linkedEntityApiName": {
+ "type": "interfaceTypeApiName",
+ "apiName": "BarInterface"
+ },
+ "displayName": "bars",
+ "cardinality": "MANY",
+ "required": true
+ }
+ },
+ "implementedByObjectTypes": [
+ "Employee",
+ "Person"
+ ],
+ "allProperties": {
+ "fooSpt": {
+ "rid": "ri.sharedPropertyType.main.sharedPropertyType.1",
+ "apiName": "fooSpt",
+ "dataType": {
+ "type": "string"
+ },
+ "displayName": "Foo",
+ "description": "A foo",
+ "typeClasses": [],
+ "required": true
+ }
+ },
+ "allPropertiesV2": {
+ "fooSpt": {
+ "rid": "ri.sharedPropertyType.main.sharedPropertyType.1",
+ "apiName": "fooSpt",
+ "dataType": {
+ "type": "string"
+ },
+ "displayName": "Foo",
+ "description": "A foo",
+ "typeClasses": [],
+ "requireImplementation": true
+ },
+ "fooIdp": {
+ "rid": "ri.interfacePropertyType.main.interfacePropertyType.1",
+ "apiName": "fooIdp",
+ "displayName": "Foo IDP",
+ "description": "A Foo IDP",
+ "dataType": {
+ "type": "string"
+ },
+ "requireImplementation": true,
+ "typeClasses": []
+ },
+ "fooArray": {
+ "rid": "ri.interfacePropertyType.main.interfacePropertyType.2",
+ "apiName": "fooArray",
+ "displayName": "Foo Array",
+ "description": "An array-valued Foo property",
+ "dataType": {
+ "type": "array",
+ "subType": {
+ "type": "string"
+ },
+ "reducers": []
+ },
+ "requireImplementation": false,
+ "typeClasses": []
+ }
+ },
+ "allExtendsInterfaces": [],
+ "allLinks": {
+ "toBar": {
+ "rid": "ri.interface.link.main.2",
+ "apiName": "toBar",
+ "linkedEntityApiName": {
+ "type": "interfaceTypeApiName",
+ "apiName": "BarInterface"
+ },
+ "displayName": "bars",
+ "cardinality": "MANY",
+ "required": true
+ }
+ }
+ }
+ },
+ "sharedPropertyTypes": {
+ "fooSpt": {
+ "rid": "ri.sharedPropertyType.main.sharedPropertyType.1",
+ "apiName": "fooSpt",
+ "dataType": {
+ "type": "string"
+ },
+ "displayName": "Foo",
+ "description": "A foo",
+ "typeClasses": []
+ }
+ },
+ "valueTypes": {}
+}
diff --git a/case-studies/foundry-owl-crosswalk/data/foundry-type-system.json b/case-studies/foundry-owl-crosswalk/data/foundry-type-system.json
new file mode 100644
index 00000000..14d18fe4
--- /dev/null
+++ b/case-studies/foundry-owl-crosswalk/data/foundry-type-system.json
@@ -0,0 +1,93 @@
+{
+ "count": 22,
+ "types": [
+ {
+ "model": "DateType",
+ "discriminator": "date"
+ },
+ {
+ "model": "StructType",
+ "discriminator": "struct"
+ },
+ {
+ "model": "StringType",
+ "discriminator": "string"
+ },
+ {
+ "model": "ByteType",
+ "discriminator": "byte"
+ },
+ {
+ "model": "DoubleType",
+ "discriminator": "double"
+ },
+ {
+ "model": "GeoPointType",
+ "discriminator": "geopoint"
+ },
+ {
+ "model": "GeotimeSeriesReferenceType",
+ "discriminator": "geotimeSeriesReference"
+ },
+ {
+ "model": "IntegerType",
+ "discriminator": "integer"
+ },
+ {
+ "model": "FloatType",
+ "discriminator": "float"
+ },
+ {
+ "model": "GeoShapeType",
+ "discriminator": "geoshape"
+ },
+ {
+ "model": "LongType",
+ "discriminator": "long"
+ },
+ {
+ "model": "BooleanType",
+ "discriminator": "boolean"
+ },
+ {
+ "model": "CipherTextType",
+ "discriminator": "cipherText"
+ },
+ {
+ "model": "MarkingType",
+ "discriminator": "marking"
+ },
+ {
+ "model": "AttachmentType",
+ "discriminator": "attachment"
+ },
+ {
+ "model": "MediaReferenceType",
+ "discriminator": "mediaReference"
+ },
+ {
+ "model": "TimeseriesType",
+ "discriminator": "timeseries"
+ },
+ {
+ "model": "OntologyObjectArrayType",
+ "discriminator": "array"
+ },
+ {
+ "model": "ShortType",
+ "discriminator": "short"
+ },
+ {
+ "model": "VectorType",
+ "discriminator": "vector"
+ },
+ {
+ "model": "DecimalType",
+ "discriminator": "decimal"
+ },
+ {
+ "model": "TimestampType",
+ "discriminator": "timestamp"
+ }
+ ]
+}
diff --git a/case-studies/foundry-owl-crosswalk/data/owl-to-foundry-audit.json b/case-studies/foundry-owl-crosswalk/data/owl-to-foundry-audit.json
new file mode 100644
index 00000000..6e33371f
--- /dev/null
+++ b/case-studies/foundry-owl-crosswalk/data/owl-to-foundry-audit.json
@@ -0,0 +1,460 @@
+{
+ "audits": [
+ {
+ "ontology": "ies4.ttl",
+ "triples": 3976,
+ "constructsUsed": 8,
+ "constructsByVerdict": {
+ "carried": 4,
+ "partial": 3,
+ "none": 1
+ },
+ "assertionsByVerdict": {
+ "carried": 1789,
+ "partial": 760,
+ "none": 200
+ },
+ "rows": [
+ {
+ "construct": "rdfs:label",
+ "assertions": 715,
+ "verdict": "carried",
+ "foundryDestination": "displayName",
+ "note": ""
+ },
+ {
+ "construct": "rdfs:comment",
+ "assertions": 715,
+ "verdict": "carried",
+ "foundryDestination": "description",
+ "note": ""
+ },
+ {
+ "construct": "rdfs:subClassOf",
+ "assertions": 574,
+ "verdict": "partial",
+ "foundryDestination": "InterfaceType.extendsInterfaces / implementsInterfaces",
+ "note": "Interfaces may extend interfaces. One object type may not subclass another."
+ },
+ {
+ "construct": "rdfs:subPropertyOf",
+ "assertions": 200,
+ "verdict": "none",
+ "foundryDestination": "",
+ "note": "No field arranges properties in a hierarchy."
+ },
+ {
+ "construct": "rdfs:domain",
+ "assertions": 198,
+ "verdict": "carried",
+ "foundryDestination": "ObjectTypeV2.properties",
+ "note": "A property belongs to the object type that declares it."
+ },
+ {
+ "construct": "owl:ObjectProperty",
+ "assertions": 161,
+ "verdict": "carried",
+ "foundryDestination": "LinkTypeSideV2",
+ "note": "A link between two object types."
+ },
+ {
+ "construct": "rdfs:range",
+ "assertions": 143,
+ "verdict": "partial",
+ "foundryDestination": "PropertyV2.dataType / LinkTypeSideV2.objectTypeApiName",
+ "note": "Carried for the types in the Foundry union only."
+ },
+ {
+ "construct": "owl:DatatypeProperty",
+ "assertions": 43,
+ "verdict": "partial",
+ "foundryDestination": "PropertyV2.dataType",
+ "note": "Carried only when the range maps to a Foundry property type."
+ }
+ ]
+ },
+ {
+ "ontology": "ies-core.ttl",
+ "triples": 1083,
+ "constructsUsed": 7,
+ "constructsByVerdict": {
+ "carried": 4,
+ "partial": 2,
+ "none": 1
+ },
+ "assertionsByVerdict": {
+ "carried": 379,
+ "partial": 178,
+ "none": 36
+ },
+ "rows": [
+ {
+ "construct": "rdfs:label",
+ "assertions": 212,
+ "verdict": "carried",
+ "foundryDestination": "displayName",
+ "note": ""
+ },
+ {
+ "construct": "rdfs:subClassOf",
+ "assertions": 144,
+ "verdict": "partial",
+ "foundryDestination": "InterfaceType.extendsInterfaces / implementsInterfaces",
+ "note": "Interfaces may extend interfaces. One object type may not subclass another."
+ },
+ {
+ "construct": "rdfs:comment",
+ "assertions": 137,
+ "verdict": "carried",
+ "foundryDestination": "description",
+ "note": ""
+ },
+ {
+ "construct": "rdfs:subPropertyOf",
+ "assertions": 36,
+ "verdict": "none",
+ "foundryDestination": "",
+ "note": "No field arranges properties in a hierarchy."
+ },
+ {
+ "construct": "rdfs:range",
+ "assertions": 34,
+ "verdict": "partial",
+ "foundryDestination": "PropertyV2.dataType / LinkTypeSideV2.objectTypeApiName",
+ "note": "Carried for the types in the Foundry union only."
+ },
+ {
+ "construct": "rdfs:domain",
+ "assertions": 29,
+ "verdict": "carried",
+ "foundryDestination": "ObjectTypeV2.properties",
+ "note": "A property belongs to the object type that declares it."
+ },
+ {
+ "construct": "owl:ObjectProperty",
+ "assertions": 1,
+ "verdict": "carried",
+ "foundryDestination": "LinkTypeSideV2",
+ "note": "A link between two object types."
+ }
+ ]
+ },
+ {
+ "ontology": "ies-top.ttl",
+ "triples": 239,
+ "constructsUsed": 6,
+ "constructsByVerdict": {
+ "carried": 3,
+ "partial": 2,
+ "none": 1
+ },
+ "assertionsByVerdict": {
+ "carried": 88,
+ "partial": 30,
+ "none": 21
+ },
+ "rows": [
+ {
+ "construct": "rdfs:label",
+ "assertions": 41,
+ "verdict": "carried",
+ "foundryDestination": "displayName",
+ "note": ""
+ },
+ {
+ "construct": "rdfs:comment",
+ "assertions": 39,
+ "verdict": "carried",
+ "foundryDestination": "description",
+ "note": ""
+ },
+ {
+ "construct": "rdfs:subClassOf",
+ "assertions": 23,
+ "verdict": "partial",
+ "foundryDestination": "InterfaceType.extendsInterfaces / implementsInterfaces",
+ "note": "Interfaces may extend interfaces. One object type may not subclass another."
+ },
+ {
+ "construct": "rdfs:subPropertyOf",
+ "assertions": 21,
+ "verdict": "none",
+ "foundryDestination": "",
+ "note": "No field arranges properties in a hierarchy."
+ },
+ {
+ "construct": "rdfs:domain",
+ "assertions": 8,
+ "verdict": "carried",
+ "foundryDestination": "ObjectTypeV2.properties",
+ "note": "A property belongs to the object type that declares it."
+ },
+ {
+ "construct": "rdfs:range",
+ "assertions": 7,
+ "verdict": "partial",
+ "foundryDestination": "PropertyV2.dataType / LinkTypeSideV2.objectTypeApiName",
+ "note": "Carried for the types in the Foundry union only."
+ }
+ ]
+ },
+ {
+ "ontology": "boro-building-handcrafted.ttl",
+ "triples": 355,
+ "constructsUsed": 8,
+ "constructsByVerdict": {
+ "carried": 4,
+ "partial": 3,
+ "none": 1
+ },
+ "assertionsByVerdict": {
+ "carried": 198,
+ "partial": 66,
+ "none": 18
+ },
+ "rows": [
+ {
+ "construct": "rdfs:label",
+ "assertions": 83,
+ "verdict": "carried",
+ "foundryDestination": "displayName",
+ "note": ""
+ },
+ {
+ "construct": "rdfs:comment",
+ "assertions": 83,
+ "verdict": "carried",
+ "foundryDestination": "description",
+ "note": ""
+ },
+ {
+ "construct": "rdfs:subClassOf",
+ "assertions": 44,
+ "verdict": "partial",
+ "foundryDestination": "InterfaceType.extendsInterfaces / implementsInterfaces",
+ "note": "Interfaces may extend interfaces. One object type may not subclass another."
+ },
+ {
+ "construct": "rdfs:domain",
+ "assertions": 18,
+ "verdict": "carried",
+ "foundryDestination": "ObjectTypeV2.properties",
+ "note": "A property belongs to the object type that declares it."
+ },
+ {
+ "construct": "rdfs:range",
+ "assertions": 18,
+ "verdict": "partial",
+ "foundryDestination": "PropertyV2.dataType / LinkTypeSideV2.objectTypeApiName",
+ "note": "Carried for the types in the Foundry union only."
+ },
+ {
+ "construct": "rdfs:subPropertyOf",
+ "assertions": 18,
+ "verdict": "none",
+ "foundryDestination": "",
+ "note": "No field arranges properties in a hierarchy."
+ },
+ {
+ "construct": "owl:ObjectProperty",
+ "assertions": 14,
+ "verdict": "carried",
+ "foundryDestination": "LinkTypeSideV2",
+ "note": "A link between two object types."
+ },
+ {
+ "construct": "owl:DatatypeProperty",
+ "assertions": 4,
+ "verdict": "partial",
+ "foundryDestination": "PropertyV2.dataType",
+ "note": "Carried only when the range maps to a Foundry property type."
+ }
+ ]
+ },
+ {
+ "ontology": "pizza-reference.owl",
+ "triples": 2332,
+ "constructsUsed": 24,
+ "constructsByVerdict": {
+ "none": 15,
+ "partial": 3,
+ "carried": 6
+ },
+ "assertionsByVerdict": {
+ "none": 1241,
+ "partial": 270,
+ "carried": 284
+ },
+ "rows": [
+ {
+ "construct": "owl:disjointWith",
+ "assertions": 796,
+ "verdict": "none",
+ "foundryDestination": "",
+ "note": "No field asserts that two types cannot share a member."
+ },
+ {
+ "construct": "rdfs:subClassOf",
+ "assertions": 259,
+ "verdict": "partial",
+ "foundryDestination": "InterfaceType.extendsInterfaces / implementsInterfaces",
+ "note": "Interfaces may extend interfaces. One object type may not subclass another."
+ },
+ {
+ "construct": "owl:Restriction",
+ "assertions": 188,
+ "verdict": "none",
+ "foundryDestination": "",
+ "note": "No field carries a class defined by a condition on a property."
+ },
+ {
+ "construct": "owl:someValuesFrom",
+ "assertions": 155,
+ "verdict": "none",
+ "foundryDestination": "",
+ "note": "Existential restriction has no Foundry field."
+ },
+ {
+ "construct": "owl:Class",
+ "assertions": 143,
+ "verdict": "carried",
+ "foundryDestination": "ObjectTypeV2 / InterfaceType",
+ "note": "A class becomes an object type or an interface."
+ },
+ {
+ "construct": "rdfs:label",
+ "assertions": 96,
+ "verdict": "carried",
+ "foundryDestination": "displayName",
+ "note": ""
+ },
+ {
+ "construct": "owl:allValuesFrom",
+ "assertions": 26,
+ "verdict": "none",
+ "foundryDestination": "",
+ "note": "Universal restriction has no Foundry field."
+ },
+ {
+ "construct": "rdfs:comment",
+ "assertions": 25,
+ "verdict": "carried",
+ "foundryDestination": "description",
+ "note": ""
+ },
+ {
+ "construct": "owl:unionOf",
+ "assertions": 25,
+ "verdict": "none",
+ "foundryDestination": "",
+ "note": "No field defines a class as a union."
+ },
+ {
+ "construct": "owl:equivalentClass",
+ "assertions": 15,
+ "verdict": "none",
+ "foundryDestination": "",
+ "note": "No field asserts that two types have the same members."
+ },
+ {
+ "construct": "owl:intersectionOf",
+ "assertions": 15,
+ "verdict": "none",
+ "foundryDestination": "",
+ "note": "No field defines a class as an intersection."
+ },
+ {
+ "construct": "owl:ObjectProperty",
+ "assertions": 8,
+ "verdict": "carried",
+ "foundryDestination": "LinkTypeSideV2",
+ "note": "A link between two object types."
+ },
+ {
+ "construct": "rdfs:range",
+ "assertions": 7,
+ "verdict": "partial",
+ "foundryDestination": "PropertyV2.dataType / LinkTypeSideV2.objectTypeApiName",
+ "note": "Carried for the types in the Foundry union only."
+ },
+ {
+ "construct": "rdfs:domain",
+ "assertions": 6,
+ "verdict": "carried",
+ "foundryDestination": "ObjectTypeV2.properties",
+ "note": "A property belongs to the object type that declares it."
+ },
+ {
+ "construct": "owl:inverseOf",
+ "assertions": 6,
+ "verdict": "carried",
+ "foundryDestination": "LinkTypeSideV2.linkTypeRid",
+ "note": "Two link sides sharing a rid are inverse."
+ },
+ {
+ "construct": "owl:hasValue",
+ "assertions": 6,
+ "verdict": "none",
+ "foundryDestination": "",
+ "note": "Value restriction has no Foundry field."
+ },
+ {
+ "construct": "owl:FunctionalProperty",
+ "assertions": 4,
+ "verdict": "partial",
+ "foundryDestination": "LinkTypeSideV2.cardinality = ONE",
+ "note": "Carried for links; a functional datatype property has no field."
+ },
+ {
+ "construct": "rdfs:subPropertyOf",
+ "assertions": 4,
+ "verdict": "none",
+ "foundryDestination": "",
+ "note": "No field arranges properties in a hierarchy."
+ },
+ {
+ "construct": "owl:InverseFunctionalProperty",
+ "assertions": 3,
+ "verdict": "none",
+ "foundryDestination": "",
+ "note": "No field declares a property inverse functional."
+ },
+ {
+ "construct": "owl:complementOf",
+ "assertions": 3,
+ "verdict": "none",
+ "foundryDestination": "",
+ "note": "No field defines a class as a complement."
+ },
+ {
+ "construct": "owl:TransitiveProperty",
+ "assertions": 2,
+ "verdict": "none",
+ "foundryDestination": "",
+ "note": "No field declares a property transitive."
+ },
+ {
+ "construct": "owl:minCardinality",
+ "assertions": 1,
+ "verdict": "none",
+ "foundryDestination": "",
+ "note": "Minimum cardinality has no Foundry field."
+ },
+ {
+ "construct": "owl:oneOf",
+ "assertions": 1,
+ "verdict": "none",
+ "foundryDestination": "",
+ "note": "No field defines a class by enumeration."
+ },
+ {
+ "construct": "owl:AllDifferent",
+ "assertions": 1,
+ "verdict": "none",
+ "foundryDestination": "",
+ "note": "No field asserts mutual difference."
+ }
+ ]
+ }
+ ]
+}
diff --git a/case-studies/foundry-owl-crosswalk/data/palantir-sources.json b/case-studies/foundry-owl-crosswalk/data/palantir-sources.json
new file mode 100644
index 00000000..f54c8bb1
--- /dev/null
+++ b/case-studies/foundry-owl-crosswalk/data/palantir-sources.json
@@ -0,0 +1,58 @@
+{
+ "sources": [
+ {
+ "file": "models.py",
+ "url": "https://raw.githubusercontent.com/palantir/foundry-platform-python/develop/foundry_sdk/v2/ontologies/models.py",
+ "repository": "palantir/foundry-platform-python",
+ "licence": "Apache-2.0",
+ "note": "Wire model definitions for the v2 Ontologies API.",
+ "bytes": 318020,
+ "sha256": "2a54626dd6db96f32028b432ba4cb60b5f83ff116895a5bf98639cfc349feb39"
+ },
+ {
+ "file": "core_models.py",
+ "url": "https://raw.githubusercontent.com/palantir/foundry-platform-python/develop/foundry_sdk/v2/core/models.py",
+ "repository": "palantir/foundry-platform-python",
+ "licence": "Apache-2.0",
+ "note": "Core wire models: the scalar property data types.",
+ "bytes": 31972,
+ "sha256": "381fdb658b5cbae6dcc47938474676095ffc3be1ed352db80c117ff3d7e7fb2d"
+ },
+ {
+ "file": "objectTypeV2.ts",
+ "url": "https://raw.githubusercontent.com/palantir/osdk-ts/main/packages/shared.test/src/stubs/objectTypeV2.ts",
+ "repository": "palantir/osdk-ts",
+ "licence": "Apache-2.0",
+ "note": "Object type fixtures used by Palantir to mock the Foundry API.",
+ "bytes": 17690,
+ "sha256": "5e7c841bf840c046aee333aa9bd199e6fc0844f3a7b1b6c3778b146ff794e70c"
+ },
+ {
+ "file": "linkTypes.ts",
+ "url": "https://raw.githubusercontent.com/palantir/osdk-ts/main/packages/shared.test/src/stubs/linkTypes.ts",
+ "repository": "palantir/osdk-ts",
+ "licence": "Apache-2.0",
+ "note": "Link type fixtures used by Palantir to mock the Foundry API.",
+ "bytes": 2356,
+ "sha256": "e506ae26346101dd1f914f99b95356b3110b42da8fccf71c5c9ab15dd6f3ba94"
+ },
+ {
+ "file": "spts.ts",
+ "url": "https://raw.githubusercontent.com/palantir/osdk-ts/main/packages/shared.test/src/stubs/spts.ts",
+ "repository": "palantir/osdk-ts",
+ "licence": "Apache-2.0",
+ "note": "Shared property type fixture.",
+ "bytes": 961,
+ "sha256": "4ac97ec8c19968d562998cafda20024c6691d8ac90fe0900994f46c227f6067d"
+ },
+ {
+ "file": "interfaceTypes.ts",
+ "url": "https://raw.githubusercontent.com/palantir/osdk-ts/main/packages/shared.test/src/stubs/interfaceTypes.ts",
+ "repository": "palantir/osdk-ts",
+ "licence": "Apache-2.0",
+ "note": "Interface type fixtures.",
+ "bytes": 3990,
+ "sha256": "fd02f220d81349533e08a503ca910d8d1488dd5f3cb58e71304a72c7fb224920"
+ }
+ ]
+}
diff --git a/case-studies/foundry-owl-crosswalk/extract_type_system.py b/case-studies/foundry-owl-crosswalk/extract_type_system.py
new file mode 100644
index 00000000..499bdeb6
--- /dev/null
+++ b/case-studies/foundry-owl-crosswalk/extract_type_system.py
@@ -0,0 +1,67 @@
+"""Derive the Foundry object property type system from Palantir's own SDK source.
+
+The list of property types a Foundry Ontology can hold is not typed by hand
+anywhere in this case study. It is parsed out of the `ObjectPropertyType` union
+in Palantir's published models, so it stays correct when Palantir changes it and
+fails loudly when the parse stops matching.
+"""
+import json
+import pathlib
+import re
+
+HERE = pathlib.Path(__file__).parent
+MODELS = HERE / "vendor" / "models.py"
+OUT = HERE / "data" / "foundry-type-system.json"
+
+UNION_RE = re.compile(
+ r"ObjectPropertyType: typing_extensions\.TypeAlias = .*?typing\.Union\[(.*?)\]",
+ re.DOTALL,
+)
+
+
+def discriminator_for(class_name: str, source: str) -> str:
+ """Find the JSON `type` discriminator Palantir assigns to a model class."""
+ pattern = re.compile(
+ r"class " + re.escape(class_name) + r"\(core\.ModelBase\):(.*?)(?=\nclass |\Z)",
+ re.DOTALL,
+ )
+ match = pattern.search(source)
+ if not match:
+ return ""
+ literal = re.search(r'type: typing\.Literal\["([^"]+)"\]', match.group(1))
+ return literal.group(1) if literal else ""
+
+
+def main() -> None:
+ source = MODELS.read_text()
+ union = UNION_RE.search(source)
+ if union is None:
+ raise SystemExit("ObjectPropertyType union not found; Palantir changed the SDK layout")
+
+ members = [
+ member.strip().strip('"').split(".")[-1]
+ for member in union.group(1).split(",")
+ if member.strip()
+ ]
+
+ core_models = HERE / "vendor" / "core_models.py"
+ core_source = core_models.read_text() if core_models.exists() else ""
+
+ types = []
+ for member in members:
+ discriminator = discriminator_for(member, source) or discriminator_for(
+ member, core_source
+ )
+ types.append({"model": member, "discriminator": discriminator})
+
+ OUT.write_text(
+ json.dumps({"count": len(types), "types": types}, indent=2) + "\n"
+ )
+ print(f"{len(types)} property types parsed from ObjectPropertyType union")
+ missing = [t["model"] for t in types if not t["discriminator"]]
+ if missing:
+ print(f"discriminator not resolved locally for {len(missing)}: {', '.join(missing)}")
+
+
+if __name__ == "__main__":
+ main()
diff --git a/case-studies/foundry-owl-crosswalk/foundry_owl.py b/case-studies/foundry-owl-crosswalk/foundry_owl.py
new file mode 100644
index 00000000..590de4dd
--- /dev/null
+++ b/case-studies/foundry-owl-crosswalk/foundry_owl.py
@@ -0,0 +1,498 @@
+"""Crosswalk a Foundry Ontology export into OWL 2 and SHACL, and report the loss.
+
+Palantir's marketing states that Foundry supports "the ability to import/export
+in multiple open formats (RDF XML/TTL, OWL, etc.) natively". The product
+documentation describes a proprietary JSON export and warns that its schema may
+change. This module builds the bridge that is missing and, more usefully,
+measures precisely what does not survive the crossing.
+
+Fidelity levels assigned to each Foundry property type:
+
+ direct an XSD datatype exists with the same value space
+ standard a published non-XSD standard carries it (OGC GeoSPARQL)
+ structural not a datatype at all; expressed as a shape, not a range
+ none no counterpart in any W3C or OGC standard
+"""
+from __future__ import annotations
+
+import json
+import pathlib
+from dataclasses import dataclass, field
+
+from rdflib import RDF, RDFS, XSD, BNode, Graph, Literal, Namespace, OWL, URIRef
+from rdflib.collection import Collection
+
+HERE = pathlib.Path(__file__).parent
+
+EX = Namespace("https://ontology.tesseract.academy/foundry-crosswalk/")
+FCX = Namespace("https://ontology.tesseract.academy/foundry-crosswalk/meta#")
+SH = Namespace("http://www.w3.org/ns/shacl#")
+SKOS = Namespace("http://www.w3.org/2004/02/skos/core#")
+GEO = Namespace("http://www.opengis.net/ont/geosparql#")
+
+DIRECT = "direct"
+STANDARD = "standard"
+STRUCTURAL = "structural"
+NONE = "none"
+
+
+@dataclass(frozen=True)
+class TypeMapping:
+ """How one Foundry property type crosses into the standards world."""
+
+ fidelity: str
+ target: URIRef | None
+ note: str
+
+
+# Keyed by the JSON discriminator Palantir assigns in its own SDK. The key set
+# is checked against the derived type system in the tests, so a Foundry type
+# added upstream fails the build rather than passing silently.
+TYPE_MAP: dict[str, TypeMapping] = {
+ "string": TypeMapping(DIRECT, XSD.string, "Unicode string."),
+ "boolean": TypeMapping(DIRECT, XSD.boolean, "Two-valued boolean."),
+ "byte": TypeMapping(DIRECT, XSD.byte, "8-bit signed integer."),
+ "short": TypeMapping(DIRECT, XSD.short, "16-bit signed integer."),
+ "integer": TypeMapping(DIRECT, XSD.int, "32-bit signed integer."),
+ "long": TypeMapping(DIRECT, XSD.long, "64-bit signed integer."),
+ "float": TypeMapping(DIRECT, XSD.float, "IEEE 754 single precision."),
+ "double": TypeMapping(DIRECT, XSD.double, "IEEE 754 double precision."),
+ "decimal": TypeMapping(DIRECT, XSD.decimal, "Arbitrary precision decimal."),
+ "date": TypeMapping(DIRECT, XSD.date, "ISO 8601 local date."),
+ "timestamp": TypeMapping(DIRECT, XSD.dateTime, "ISO 8601 instant."),
+ "geopoint": TypeMapping(
+ STANDARD,
+ GEO.wktLiteral,
+ "Carried by OGC GeoSPARQL, not by XSD. A consumer that reads only XSD "
+ "sees an opaque literal.",
+ ),
+ "geoshape": TypeMapping(
+ STANDARD,
+ GEO.wktLiteral,
+ "Carried by OGC GeoSPARQL, not by XSD.",
+ ),
+ "array": TypeMapping(
+ STRUCTURAL,
+ None,
+ "Cardinality, not a datatype. Expressed by omitting sh:maxCount and "
+ "ranging on the element type.",
+ ),
+ "struct": TypeMapping(
+ STRUCTURAL,
+ None,
+ "Expressed as a generated class with its own node shape, so a Foundry "
+ "struct becomes an object property in OWL.",
+ ),
+ "marking": TypeMapping(
+ NONE,
+ None,
+ "A Foundry security marking. No W3C standard carries access control. "
+ "Exported as an opaque literal, the classification is no longer "
+ "enforceable and no longer distinguishable from ordinary data.",
+ ),
+ "cipherText": TypeMapping(
+ NONE,
+ None,
+ "Ciphertext bound to a Foundry cipher channel. The channel reference is "
+ "meaningless outside the platform.",
+ ),
+ "attachment": TypeMapping(
+ NONE,
+ None,
+ "A resource identifier pointing into Foundry blob storage. The value "
+ "does not resolve outside the platform.",
+ ),
+ "mediaReference": TypeMapping(
+ NONE,
+ None,
+ "A reference into a Foundry media set. Does not resolve outside the "
+ "platform.",
+ ),
+ "timeseries": TypeMapping(
+ NONE,
+ None,
+ "A handle onto a Foundry time series, not a value. The series itself is "
+ "not in the export.",
+ ),
+ "geotimeSeriesReference": TypeMapping(
+ NONE,
+ None,
+ "A handle onto a Geotime integration. The track is not in the export.",
+ ),
+ "vector": TypeMapping(
+ NONE,
+ None,
+ "An embedding. The export declares its dimension and sometimes the "
+ "producing model, but no W3C datatype carries a vector, so both "
+ "become annotations rather than a range.",
+ ),
+}
+
+
+@dataclass
+class CrosswalkReport:
+ """Everything the crossing could not carry, counted rather than asserted."""
+
+ object_types: int = 0
+ properties: int = 0
+ link_sides: int = 0
+ interfaces: int = 0
+ shared_property_types: int = 0
+ inverse_pairs: int = 0
+ keys: int = 0
+ object_types_without_description: int = 0
+ properties_without_description: int = 0
+ by_fidelity: dict[str, int] = field(default_factory=dict)
+ lossy_properties: list[dict] = field(default_factory=list)
+ dropped_constructs: list[dict] = field(default_factory=list)
+
+ def as_dict(self) -> dict:
+ return {
+ "objectTypes": self.object_types,
+ "properties": self.properties,
+ "linkSides": self.link_sides,
+ "interfaces": self.interfaces,
+ "sharedPropertyTypes": self.shared_property_types,
+ "inversePairs": self.inverse_pairs,
+ "keyAxioms": self.keys,
+ "objectTypesWithoutDescription": self.object_types_without_description,
+ "propertiesWithoutDescription": self.properties_without_description,
+ "propertiesByFidelity": self.by_fidelity,
+ "lossyProperties": self.lossy_properties,
+ "droppedConstructs": self.dropped_constructs,
+ }
+
+
+def _safe(name: str) -> str:
+ return "".join(character if character.isalnum() else "_" for character in name)
+
+
+class Crosswalk:
+ def __init__(self, metadata: dict):
+ self.metadata = metadata
+ self.graph = Graph()
+ self.report = CrosswalkReport()
+ for prefix, namespace in (
+ ("ex", EX), ("fcx", FCX), ("sh", SH), ("skos", SKOS),
+ ("geo", GEO), ("owl", OWL), ("xsd", XSD),
+ ):
+ self.graph.bind(prefix, namespace)
+
+ # -- naming -------------------------------------------------------------
+ def class_iri(self, api_name: str) -> URIRef:
+ return EX[_safe(api_name)]
+
+ def property_iri(self, object_type: str, property_name: str) -> URIRef:
+ return EX[f"{_safe(object_type)}.{_safe(property_name)}"]
+
+ def link_iri(self, object_type: str, link_name: str) -> URIRef:
+ return EX[f"link.{_safe(object_type)}.{_safe(link_name)}"]
+
+ def shape_iri(self, api_name: str) -> URIRef:
+ return EX[f"{_safe(api_name)}Shape"]
+
+ # -- emit ---------------------------------------------------------------
+ def run(self) -> tuple[Graph, CrosswalkReport]:
+ self._emit_meta()
+ self._emit_interfaces()
+ self._emit_shared_property_types()
+ self._emit_object_types()
+ self._emit_links()
+ self._note_absent_constructs()
+ return self.graph, self.report
+
+ def _emit_meta(self) -> None:
+ ontology = self.metadata.get("ontology", {})
+ node = EX[""]
+ self.graph.add((node, RDF.type, OWL.Ontology))
+ if ontology.get("displayName"):
+ self.graph.add((node, RDFS.label, Literal(ontology["displayName"])))
+ if ontology.get("description"):
+ self.graph.add((node, RDFS.comment, Literal(ontology["description"])))
+ for term, comment in (
+ (FCX.foundryRid, "The Foundry resource identifier the term came from."),
+ (FCX.foundryType, "The Foundry property type discriminator."),
+ (FCX.foundryElementType, "The element type of a Foundry array property."),
+ (FCX.foundryDetail, "Foundry type detail with no standards counterpart."),
+ (FCX.fidelity, "How faithfully the Foundry type crossed into standards."),
+ (FCX.unmappable, "Marks a term whose Foundry meaning has no standards counterpart."),
+ (FCX.titleProperty, "The Foundry display title property."),
+ ):
+ self.graph.add((term, RDF.type, OWL.AnnotationProperty))
+ self.graph.add((term, RDFS.comment, Literal(comment)))
+
+ def _emit_interfaces(self) -> None:
+ for api_name, interface in self.metadata.get("interfaceTypes", {}).items():
+ iri = self.class_iri(api_name)
+ self.graph.add((iri, RDF.type, OWL.Class))
+ self.graph.add((iri, RDFS.label, Literal(interface.get("displayName", api_name))))
+ if interface.get("description"):
+ self.graph.add((iri, RDFS.comment, Literal(interface["description"])))
+ if interface.get("rid"):
+ self.graph.add((iri, FCX.foundryRid, Literal(interface["rid"])))
+ for parent in interface.get("extendsInterfaces", []):
+ self.graph.add((iri, RDFS.subClassOf, self.class_iri(parent)))
+ self.report.interfaces += 1
+
+ def _emit_shared_property_types(self) -> None:
+ for api_name, spt in self.metadata.get("sharedPropertyTypes", {}).items():
+ iri = EX[f"spt.{_safe(api_name)}"]
+ mapping = TYPE_MAP.get(spt.get("dataType", {}).get("type", ""))
+ kind = OWL.DatatypeProperty
+ if mapping and mapping.fidelity == STRUCTURAL:
+ kind = OWL.ObjectProperty
+ self.graph.add((iri, RDF.type, kind))
+ self.graph.add((iri, RDFS.label, Literal(spt.get("displayName", api_name))))
+ if spt.get("description"):
+ self.graph.add((iri, RDFS.comment, Literal(spt["description"])))
+ if mapping and mapping.target is not None:
+ self.graph.add((iri, RDFS.range, mapping.target))
+ self.report.shared_property_types += 1
+
+ def _emit_object_types(self) -> None:
+ for api_name, entry in self.metadata.get("objectTypes", {}).items():
+ object_type = entry["objectType"]
+ iri = self.class_iri(api_name)
+ shape = self.shape_iri(api_name)
+ self.graph.add((iri, RDF.type, OWL.Class))
+ self.graph.add((iri, RDFS.label, Literal(object_type.get("displayName", api_name))))
+ if object_type.get("description"):
+ self.graph.add((iri, RDFS.comment, Literal(object_type["description"])))
+ if object_type.get("pluralDisplayName"):
+ self.graph.add((iri, SKOS.altLabel, Literal(object_type["pluralDisplayName"])))
+ for alias in object_type.get("aliases") or []:
+ self.graph.add((iri, SKOS.altLabel, Literal(alias)))
+ if object_type.get("rid"):
+ self.graph.add((iri, FCX.foundryRid, Literal(object_type["rid"])))
+ if object_type.get("titleProperty"):
+ self.graph.add((iri, FCX.titleProperty, Literal(object_type["titleProperty"])))
+ for interface in entry.get("implementsInterfaces", []):
+ self.graph.add((iri, RDFS.subClassOf, self.class_iri(interface)))
+
+ self.graph.add((shape, RDF.type, SH.NodeShape))
+ self.graph.add((shape, SH.targetClass, iri))
+
+ primary_key = object_type.get("primaryKey")
+ for property_name, prop in object_type.get("properties", {}).items():
+ self._emit_property(api_name, iri, shape, property_name, prop, primary_key)
+ self.report.properties += 1
+
+ if primary_key and primary_key in object_type.get("properties", {}):
+ key_list = BNode()
+ Collection(self.graph, key_list, [self.property_iri(api_name, primary_key)])
+ self.graph.add((iri, OWL.hasKey, key_list))
+ self.report.keys += 1
+
+ if not object_type.get("description"):
+ self.report.object_types_without_description += 1
+ self.report.object_types += 1
+
+ def _emit_property(
+ self,
+ object_type_name: str,
+ class_iri: URIRef,
+ shape: URIRef,
+ property_name: str,
+ prop: dict,
+ primary_key: str | None,
+ ) -> None:
+ data_type = prop.get("dataType", {})
+ discriminator = data_type.get("type", "")
+ is_array = discriminator == "array"
+
+ # An array is cardinality, not a type. The element carries the meaning.
+ element = (data_type.get("subType") or {}) if is_array else data_type
+ element_type = element.get("type", "")
+ mapping = TYPE_MAP.get(element_type)
+ declared = TYPE_MAP.get(discriminator)
+
+ iri = self.property_iri(object_type_name, property_name)
+ is_object_valued = element_type == "struct"
+
+ self.graph.add(
+ (iri, RDF.type, OWL.ObjectProperty if is_object_valued else OWL.DatatypeProperty)
+ )
+ self.graph.add((iri, RDFS.label, Literal(prop.get("displayName") or property_name)))
+ if prop.get("description"):
+ self.graph.add((iri, RDFS.comment, Literal(prop["description"])))
+ self.graph.add((iri, RDFS.domain, class_iri))
+ self.graph.add((iri, FCX.foundryType, Literal(discriminator)))
+ if not prop.get("description"):
+ self.report.properties_without_description += 1
+ if is_array and element_type:
+ self.graph.add((iri, FCX.foundryElementType, Literal(element_type)))
+
+ fidelity = mapping.fidelity if mapping else NONE
+ self.graph.add((iri, FCX.fidelity, Literal(fidelity)))
+ self.report.by_fidelity[fidelity] = self.report.by_fidelity.get(fidelity, 0) + 1
+
+ property_shape = BNode()
+ self.graph.add((shape, SH.property, property_shape))
+ self.graph.add((property_shape, SH.path, iri))
+ self.graph.add((property_shape, SH.name, Literal(property_name)))
+
+ if is_object_valued:
+ struct_class = self._emit_struct_class(object_type_name, property_name, element)
+ self.graph.add((iri, RDFS.range, struct_class))
+ self.graph.add((property_shape, SH["class"], struct_class))
+ elif mapping is not None and mapping.target is not None:
+ self.graph.add((iri, RDFS.range, mapping.target))
+ self.graph.add((property_shape, SH.datatype, mapping.target))
+ else:
+ self.graph.add((iri, FCX.unmappable, Literal(True)))
+ note = (mapping or declared).note if (mapping or declared) else (
+ f"Unknown Foundry property type '{element_type or discriminator}'."
+ )
+ self.graph.add((iri, RDFS.comment, Literal(f"Not carried by the crosswalk. {note}")))
+ self.report.lossy_properties.append(
+ {
+ "objectType": object_type_name,
+ "property": property_name,
+ "foundryType": discriminator,
+ "elementType": element_type if is_array else None,
+ "reason": note,
+ }
+ )
+ # Keep whatever the export declared, as annotation rather than range.
+ for key in ("dimension", "itemType", "embeddingModel"):
+ if key in element:
+ value = element[key]
+ self.graph.add(
+ (
+ iri,
+ FCX.foundryDetail,
+ Literal(f"{key}={json.dumps(value, sort_keys=True)}"),
+ )
+ )
+
+ if not is_array:
+ self.graph.add((property_shape, SH.maxCount, Literal(1)))
+ if property_name == primary_key:
+ self.graph.add((property_shape, SH.minCount, Literal(1)))
+
+ def _emit_struct_class(
+ self, object_type_name: str, property_name: str, element: dict
+ ) -> URIRef:
+ struct_class = EX[f"{_safe(object_type_name)}.{_safe(property_name)}.Struct"]
+ self.graph.add((struct_class, RDF.type, OWL.Class))
+ self.graph.add((struct_class, RDFS.label, Literal(f"{property_name} struct")))
+ self.graph.add(
+ (
+ struct_class,
+ RDFS.comment,
+ Literal(
+ "Generated by the crosswalk. A Foundry struct is an inline "
+ f"record on {object_type_name}.{property_name}; OWL has no "
+ "inline record, so it becomes a class with its own shape."
+ ),
+ )
+ )
+ struct_shape = EX[f"{_safe(object_type_name)}.{_safe(property_name)}.StructShape"]
+ self.graph.add((struct_shape, RDF.type, SH.NodeShape))
+ self.graph.add((struct_shape, SH.targetClass, struct_class))
+ for field_definition in element.get("structFieldTypes") or []:
+ field_name = field_definition.get("apiName")
+ if not field_name:
+ continue
+ field_type = (field_definition.get("dataType") or {}).get("type", "")
+ field_mapping = TYPE_MAP.get(field_type)
+ field_iri = EX[
+ f"{_safe(object_type_name)}.{_safe(property_name)}.{_safe(field_name)}"
+ ]
+ self.graph.add((field_iri, RDF.type, OWL.DatatypeProperty))
+ self.graph.add((field_iri, RDFS.label, Literal(field_name)))
+ self.graph.add((field_iri, RDFS.domain, struct_class))
+ self.graph.add((field_iri, FCX.foundryType, Literal(field_type)))
+ field_shape = BNode()
+ self.graph.add((struct_shape, SH.property, field_shape))
+ self.graph.add((field_shape, SH.path, field_iri))
+ self.graph.add((field_shape, SH.maxCount, Literal(1)))
+ if field_mapping is not None and field_mapping.target is not None:
+ self.graph.add((field_iri, RDFS.range, field_mapping.target))
+ self.graph.add((field_shape, SH.datatype, field_mapping.target))
+ return struct_class
+
+ def _emit_links(self) -> None:
+ seen_rids: dict[str, URIRef] = {}
+ for api_name, entry in self.metadata.get("objectTypes", {}).items():
+ source = self.class_iri(api_name)
+ shape = self.shape_iri(api_name)
+ for side in entry.get("linkTypes", []):
+ link = self.link_iri(api_name, side["apiName"])
+ target = self.class_iri(side["objectTypeApiName"])
+ self.graph.add((link, RDF.type, OWL.ObjectProperty))
+ self.graph.add((link, RDFS.label, Literal(side.get("displayName", side["apiName"]))))
+ self.graph.add((link, RDFS.domain, source))
+ self.graph.add((link, RDFS.range, target))
+ self.graph.add((link, FCX.foundryRid, Literal(side["linkTypeRid"])))
+
+ property_shape = BNode()
+ self.graph.add((shape, SH.property, property_shape))
+ self.graph.add((property_shape, SH.path, link))
+ self.graph.add((property_shape, SH.name, Literal(side["apiName"])))
+ self.graph.add((property_shape, SH["class"], target))
+ if side["cardinality"] == "ONE":
+ self.graph.add((property_shape, SH.maxCount, Literal(1)))
+ self.graph.add((link, RDF.type, OWL.FunctionalProperty))
+
+ rid = side["linkTypeRid"]
+ if rid in seen_rids and seen_rids[rid] != link:
+ # Declare both directions. A reader who consults only the
+ # second property should still learn about the first.
+ self.graph.add((link, OWL.inverseOf, seen_rids[rid]))
+ self.graph.add((seen_rids[rid], OWL.inverseOf, link))
+ self.report.inverse_pairs += 1
+ else:
+ seen_rids[rid] = link
+ self.report.link_sides += 1
+
+ def _note_absent_constructs(self) -> None:
+ """Record Foundry constructs the export carries that OWL cannot express."""
+ action_types = self.metadata.get("actionTypes", {})
+ query_types = self.metadata.get("queryTypes", {})
+ value_types = self.metadata.get("valueTypes", {})
+ for label, count, note in (
+ (
+ "actionType",
+ len(action_types),
+ "A Foundry action is a permissioned state change with parameters, "
+ "validation and side effects. OWL describes what holds, not what "
+ "may be done, so no axiom carries it.",
+ ),
+ (
+ "queryType",
+ len(query_types),
+ "A Foundry query is a named function. SPARQL can express a query "
+ "but the ontology has no place to declare one.",
+ ),
+ (
+ "valueType",
+ len(value_types),
+ "A Foundry value type is a reusable semantic constraint. The "
+ "nearest OWL construct is a datatype restriction, which cannot "
+ "carry the Foundry formatting and validation metadata.",
+ ),
+ ):
+ self.report.dropped_constructs.append(
+ {"construct": label, "countInExport": count, "reason": note}
+ )
+
+
+def crosswalk_file(path: pathlib.Path) -> tuple[Graph, CrosswalkReport]:
+ metadata = json.loads(path.read_text())
+ return Crosswalk(metadata).run()
+
+
+def main() -> None:
+ graph, report = crosswalk_file(HERE / "data" / "foundry-ontology.json")
+ (HERE / "ontology").mkdir(exist_ok=True)
+ graph.serialize(destination=HERE / "ontology" / "foundry-crosswalk.ttl", format="turtle")
+ (HERE / "data" / "crosswalk-report.json").write_text(
+ json.dumps(report.as_dict(), indent=2) + "\n"
+ )
+ print(json.dumps(report.as_dict(), indent=2)[:1200])
+ print(f"\ntriples: {len(graph)}")
+
+
+if __name__ == "__main__":
+ main()
diff --git a/case-studies/foundry-owl-crosswalk/generate_report.py b/case-studies/foundry-owl-crosswalk/generate_report.py
new file mode 100644
index 00000000..8fb17d1f
--- /dev/null
+++ b/case-studies/foundry-owl-crosswalk/generate_report.py
@@ -0,0 +1,226 @@
+"""Render the coverage report and its chart from the measured data.
+
+No number in the report or the chart is typed here. Everything is read from
+the JSON the crosswalk and the audit produce, so a changed measurement changes
+the prose and the picture together.
+"""
+from __future__ import annotations
+
+import json
+import pathlib
+
+HERE = pathlib.Path(__file__).parent
+TYPES = json.loads((HERE / "data" / "foundry-type-system.json").read_text())
+REPORT = json.loads((HERE / "data" / "crosswalk-report.json").read_text())
+AUDIT = json.loads((HERE / "data" / "owl-to-foundry-audit.json").read_text())
+SOURCES = json.loads((HERE / "data" / "palantir-sources.json").read_text())
+
+import foundry_owl # noqa: E402
+
+INK = "#1a2b32"
+MUTED = "#5c6670"
+TEAL = "#00897b"
+AMBER = "#b45309"
+GRAY = "#8c959a"
+RULE = "#d7dee0"
+
+FIDELITY_COLOUR = {
+ "direct": TEAL,
+ "standard": "#4db6ac",
+ "structural": GRAY,
+ "none": AMBER,
+}
+FIDELITY_LABEL = {
+ "direct": "Direct XSD counterpart",
+ "standard": "Carried by OGC GeoSPARQL",
+ "structural": "Structural, expressed as a shape",
+ "none": "No counterpart in any standard",
+}
+VERDICT_COLOUR = {"carried": TEAL, "partial": GRAY, "none": AMBER}
+VERDICT_LABEL = {
+ "carried": "A Foundry field holds it",
+ "partial": "A Foundry field holds a weaker version",
+ "none": "No Foundry field can hold it",
+}
+
+
+def type_system_counts() -> dict[str, int]:
+ counts: dict[str, int] = {}
+ for mapping in foundry_owl.TYPE_MAP.values():
+ counts[mapping.fidelity] = counts.get(mapping.fidelity, 0) + 1
+ return counts
+
+
+def bars(rows, width=470, label_width=250, row_height=30) -> str:
+ """A horizontal bar chart as inline SVG. Rows are (label, value, colour)."""
+ largest = max((value for _, value, _ in rows), default=1) or 1
+ bar_width = width - label_width - 60
+ height = row_height * len(rows) + 10
+ parts = [
+ f'<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 {width} {height}" '
+ f'width="{width}" height="{height}" role="img">'
+ ]
+ for index, (label, value, colour) in enumerate(rows):
+ y = index * row_height + 8
+ length = max(2, int(bar_width * value / largest))
+ parts.append(
+ f'<text x="0" y="{y + 13}" font-family="system-ui,sans-serif" '
+ f'font-size="12" fill="{INK}">{label}</text>'
+ )
+ parts.append(
+ f'<rect x="{label_width}" y="{y + 2}" width="{length}" height="15" '
+ f'rx="2" fill="{colour}"/>'
+ )
+ parts.append(
+ f'<text x="{label_width + length + 7}" y="{y + 14}" '
+ f'font-family="system-ui,sans-serif" font-size="12" font-weight="600" '
+ f'fill="{MUTED}">{value}</text>'
+ )
+ parts.append("</svg>")
+ return "".join(parts)
+
+
+def main() -> None:
+ counts = type_system_counts()
+ order = ["direct", "standard", "structural", "none"]
+
+ type_chart = bars(
+ [(FIDELITY_LABEL[key], counts.get(key, 0), FIDELITY_COLOUR[key]) for key in order]
+ )
+ (HERE / "ontology" / "type-system-fidelity.svg").write_text(type_chart + "\n")
+
+ instance_chart = bars(
+ [
+ (FIDELITY_LABEL[key], REPORT["propertiesByFidelity"].get(key, 0), FIDELITY_COLOUR[key])
+ for key in order
+ ]
+ )
+ (HERE / "ontology" / "property-fidelity.svg").write_text(instance_chart + "\n")
+
+ audit_rows = []
+ for entry in AUDIT["audits"]:
+ by_verdict = entry["assertionsByVerdict"]
+ for verdict in ("carried", "partial", "none"):
+ audit_rows.append(
+ (
+ f"{entry['ontology']} — {VERDICT_LABEL[verdict]}",
+ by_verdict.get(verdict, 0),
+ VERDICT_COLOUR[verdict],
+ )
+ )
+ (HERE / "ontology" / "axiom-survival.svg").write_text(
+ bars(audit_rows, width=560, label_width=330, row_height=26) + "\n"
+ )
+
+ total_types = TYPES["count"]
+ lines = [
+ "# Coverage report",
+ "",
+ "Every figure on this page is written by `generate_report.py` from the",
+ "JSON that `foundry_owl.py` and `owl_to_foundry.py` produce. None is typed.",
+ "",
+ "## Sources",
+ "",
+ "| File | Repository | Licence | Bytes | SHA-256 (first 16) |",
+ "| --- | --- | --- | ---: | --- |",
+ ]
+ for source in SOURCES["sources"]:
+ lines.append(
+ f"| `{source['file']}` | {source['repository']} | {source['licence']} | "
+ f"{source['bytes']} | `{source['sha256'][:16]}` |"
+ )
+
+ lines += [
+ "",
+ "## The Foundry property type system",
+ "",
+ f"Palantir's `ObjectPropertyType` union declares {total_types} property types.",
+ "Parsed from their own SDK, not transcribed.",
+ "",
+ "| Fidelity | Types | Meaning |",
+ "| --- | ---: | --- |",
+ ]
+ for key in order:
+ lines.append(f"| {key} | {counts.get(key, 0)} | {FIDELITY_LABEL[key]} |")
+
+ lines += [
+ "",
+ "![Foundry property types by crossing fidelity](type-system-fidelity.svg)",
+ "",
+ "### Types with no counterpart in any standard",
+ "",
+ "| Foundry type | Why it does not cross |",
+ "| --- | --- |",
+ ]
+ for name, mapping in foundry_owl.TYPE_MAP.items():
+ if mapping.fidelity == "none":
+ lines.append(f"| `{name}` | {mapping.note} |")
+
+ lines += [
+ "",
+ "## The crossing, measured on Palantir's own fixture",
+ "",
+ "| Measure | Value |",
+ "| --- | ---: |",
+ f"| Object types | {REPORT['objectTypes']} |",
+ f"| Properties | {REPORT['properties']} |",
+ f"| Link sides | {REPORT['linkSides']} |",
+ f"| Interfaces | {REPORT['interfaces']} |",
+ f"| Shared property types | {REPORT['sharedPropertyTypes']} |",
+ f"| Inverse pairs recovered | {REPORT['inversePairs']} |",
+ f"| owl:hasKey axioms written | {REPORT['keyAxioms']} |",
+ f"| Properties the crosswalk cannot carry | {len(REPORT['lossyProperties'])} |",
+ "",
+ "![Properties by crossing fidelity](property-fidelity.svg)",
+ "",
+ "### Documentation present in the source",
+ "",
+ "The crosswalk never invents a definition. What the source omits stays omitted,",
+ "and the linter then reports it.",
+ "",
+ "| Measure | Value |",
+ "| --- | ---: |",
+ f"| Object types with no description | {REPORT['objectTypesWithoutDescription']} of {REPORT['objectTypes']} |",
+ f"| Properties with no description | {REPORT['propertiesWithoutDescription']} of {REPORT['properties']} |",
+ "",
+ "## The other direction",
+ "",
+ "Each ontology below was parsed, its asserted constructs counted, and each",
+ "construct checked against the fields that exist in Palantir's ontology model.",
+ "",
+ "| Ontology | Triples | Constructs used | Carried | Partial | No destination |",
+ "| --- | ---: | ---: | ---: | ---: | ---: |",
+ ]
+ for entry in AUDIT["audits"]:
+ by_verdict = entry["assertionsByVerdict"]
+ lines.append(
+ f"| `{entry['ontology']}` | {entry['triples']} | {entry['constructsUsed']} | "
+ f"{by_verdict.get('carried', 0)} | {by_verdict.get('partial', 0)} | "
+ f"{by_verdict.get('none', 0)} |"
+ )
+
+ lines += [
+ "",
+ "![Axiom survival by ontology](axiom-survival.svg)",
+ "",
+ "### Where each ontology loses its axioms",
+ "",
+ ]
+ for entry in AUDIT["audits"]:
+ stranded = [row for row in entry["rows"] if row["verdict"] == "none"]
+ if not stranded:
+ continue
+ lines.append(f"**{entry['ontology']}**")
+ lines.append("")
+ lines.append("| Construct | Assertions | Why it has no destination |")
+ lines.append("| --- | ---: | --- |")
+ for row in stranded:
+ lines.append(f"| `{row['construct']}` | {row['assertions']} | {row['note']} |")
+ lines.append("")
+
+ (HERE / "ontology" / "coverage-report.md").write_text("\n".join(lines) + "\n")
+ print(f"coverage report written, {len(lines)} lines")
+
+
+if __name__ == "__main__":
+ main()
diff --git a/case-studies/foundry-owl-crosswalk/ontology/axiom-survival.svg b/case-studies/foundry-owl-crosswalk/ontology/axiom-survival.svg
new file mode 100644
index 00000000..1d0a7eb5
--- /dev/null
+++ b/case-studies/foundry-owl-crosswalk/ontology/axiom-survival.svg
@@ -0,0 +1 @@
+<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 560 400" width="560" height="400" role="img"><text x="0" y="21" font-family="system-ui,sans-serif" font-size="12" fill="#1a2b32">ies4.ttl — A Foundry field holds it</text><rect x="330" y="10" width="170" height="15" rx="2" fill="#00897b"/><text x="507" y="22" font-family="system-ui,sans-serif" font-size="12" font-weight="600" fill="#5c6670">1789</text><text x="0" y="47" font-family="system-ui,sans-serif" font-size="12" fill="#1a2b32">ies4.ttl — A Foundry field holds a weaker version</text><rect x="330" y="36" width="72" height="15" rx="2" fill="#8c959a"/><text x="409" y="48" font-family="system-ui,sans-serif" font-size="12" font-weight="600" fill="#5c6670">760</text><text x="0" y="73" font-family="system-ui,sans-serif" font-size="12" fill="#1a2b32">ies4.ttl — No Foundry field can hold it</text><rect x="330" y="62" width="19" height="15" rx="2" fill="#b45309"/><text x="356" y="74" font-family="system-ui,sans-serif" font-size="12" font-weight="600" fill="#5c6670">200</text><text x="0" y="99" font-family="system-ui,sans-serif" font-size="12" fill="#1a2b32">ies-core.ttl — A Foundry field holds it</text><rect x="330" y="88" width="36" height="15" rx="2" fill="#00897b"/><text x="373" y="100" font-family="system-ui,sans-serif" font-size="12" font-weight="600" fill="#5c6670">379</text><text x="0" y="125" font-family="system-ui,sans-serif" font-size="12" fill="#1a2b32">ies-core.ttl — A Foundry field holds a weaker version</text><rect x="330" y="114" width="16" height="15" rx="2" fill="#8c959a"/><text x="353" y="126" font-family="system-ui,sans-serif" font-size="12" font-weight="600" fill="#5c6670">178</text><text x="0" y="151" font-family="system-ui,sans-serif" font-size="12" fill="#1a2b32">ies-core.ttl — No Foundry field can hold it</text><rect x="330" y="140" width="3" height="15" rx="2" fill="#b45309"/><text x="340" y="152" font-family="system-ui,sans-serif" font-size="12" font-weight="600" fill="#5c6670">36</text><text x="0" y="177" font-family="system-ui,sans-serif" font-size="12" fill="#1a2b32">ies-top.ttl — A Foundry field holds it</text><rect x="330" y="166" width="8" height="15" rx="2" fill="#00897b"/><text x="345" y="178" font-family="system-ui,sans-serif" font-size="12" font-weight="600" fill="#5c6670">88</text><text x="0" y="203" font-family="system-ui,sans-serif" font-size="12" fill="#1a2b32">ies-top.ttl — A Foundry field holds a weaker version</text><rect x="330" y="192" width="2" height="15" rx="2" fill="#8c959a"/><text x="339" y="204" font-family="system-ui,sans-serif" font-size="12" font-weight="600" fill="#5c6670">30</text><text x="0" y="229" font-family="system-ui,sans-serif" font-size="12" fill="#1a2b32">ies-top.ttl — No Foundry field can hold it</text><rect x="330" y="218" width="2" height="15" rx="2" fill="#b45309"/><text x="339" y="230" font-family="system-ui,sans-serif" font-size="12" font-weight="600" fill="#5c6670">21</text><text x="0" y="255" font-family="system-ui,sans-serif" font-size="12" fill="#1a2b32">boro-building-handcrafted.ttl — A Foundry field holds it</text><rect x="330" y="244" width="18" height="15" rx="2" fill="#00897b"/><text x="355" y="256" font-family="system-ui,sans-serif" font-size="12" font-weight="600" fill="#5c6670">198</text><text x="0" y="281" font-family="system-ui,sans-serif" font-size="12" fill="#1a2b32">boro-building-handcrafted.ttl — A Foundry field holds a weaker version</text><rect x="330" y="270" width="6" height="15" rx="2" fill="#8c959a"/><text x="343" y="282" font-family="system-ui,sans-serif" font-size="12" font-weight="600" fill="#5c6670">66</text><text x="0" y="307" font-family="system-ui,sans-serif" font-size="12" fill="#1a2b32">boro-building-handcrafted.ttl — No Foundry field can hold it</text><rect x="330" y="296" width="2" height="15" rx="2" fill="#b45309"/><text x="339" y="308" font-family="system-ui,sans-serif" font-size="12" font-weight="600" fill="#5c6670">18</text><text x="0" y="333" font-family="system-ui,sans-serif" font-size="12" fill="#1a2b32">pizza-reference.owl — A Foundry field holds it</text><rect x="330" y="322" width="26" height="15" rx="2" fill="#00897b"/><text x="363" y="334" font-family="system-ui,sans-serif" font-size="12" font-weight="600" fill="#5c6670">284</text><text x="0" y="359" font-family="system-ui,sans-serif" font-size="12" fill="#1a2b32">pizza-reference.owl — A Foundry field holds a weaker version</text><rect x="330" y="348" width="25" height="15" rx="2" fill="#8c959a"/><text x="362" y="360" font-family="system-ui,sans-serif" font-size="12" font-weight="600" fill="#5c6670">270</text><text x="0" y="385" font-family="system-ui,sans-serif" font-size="12" fill="#1a2b32">pizza-reference.owl — No Foundry field can hold it</text><rect x="330" y="374" width="117" height="15" rx="2" fill="#b45309"/><text x="454" y="386" font-family="system-ui,sans-serif" font-size="12" font-weight="600" fill="#5c6670">1241</text></svg>
diff --git a/case-studies/foundry-owl-crosswalk/ontology/coverage-report.md b/case-studies/foundry-owl-crosswalk/ontology/coverage-report.md
new file mode 100644
index 00000000..33816909
--- /dev/null
+++ b/case-studies/foundry-owl-crosswalk/ontology/coverage-report.md
@@ -0,0 +1,128 @@
+# Coverage report
+
+Every figure on this page is written by `generate_report.py` from the
+JSON that `foundry_owl.py` and `owl_to_foundry.py` produce. None is typed.
+
+## Sources
+
+| File | Repository | Licence | Bytes | SHA-256 (first 16) |
+| --- | --- | --- | ---: | --- |
+| `models.py` | palantir/foundry-platform-python | Apache-2.0 | 318020 | `2a54626dd6db96f3` |
+| `core_models.py` | palantir/foundry-platform-python | Apache-2.0 | 31972 | `381fdb658b5cbae6` |
+| `objectTypeV2.ts` | palantir/osdk-ts | Apache-2.0 | 17690 | `5e7c841bf840c046` |
+| `linkTypes.ts` | palantir/osdk-ts | Apache-2.0 | 2356 | `e506ae26346101dd` |
+| `spts.ts` | palantir/osdk-ts | Apache-2.0 | 961 | `4ac97ec8c19968d5` |
+| `interfaceTypes.ts` | palantir/osdk-ts | Apache-2.0 | 3990 | `fd02f220d8134953` |
+
+## The Foundry property type system
+
+Palantir's `ObjectPropertyType` union declares 22 property types.
+Parsed from their own SDK, not transcribed.
+
+| Fidelity | Types | Meaning |
+| --- | ---: | --- |
+| direct | 11 | Direct XSD counterpart |
+| standard | 2 | Carried by OGC GeoSPARQL |
+| structural | 2 | Structural, expressed as a shape |
+| none | 7 | No counterpart in any standard |
+
+![Foundry property types by crossing fidelity](type-system-fidelity.svg)
+
+### Types with no counterpart in any standard
+
+| Foundry type | Why it does not cross |
+| --- | --- |
+| `marking` | A Foundry security marking. No W3C standard carries access control. Exported as an opaque literal, the classification is no longer enforceable and no longer distinguishable from ordinary data. |
+| `cipherText` | Ciphertext bound to a Foundry cipher channel. The channel reference is meaningless outside the platform. |
+| `attachment` | A resource identifier pointing into Foundry blob storage. The value does not resolve outside the platform. |
+| `mediaReference` | A reference into a Foundry media set. Does not resolve outside the platform. |
+| `timeseries` | A handle onto a Foundry time series, not a value. The series itself is not in the export. |
+| `geotimeSeriesReference` | A handle onto a Geotime integration. The track is not in the export. |
+| `vector` | An embedding. The export declares its dimension and sometimes the producing model, but no W3C datatype carries a vector, so both become annotations rather than a range. |
+
+## The crossing, measured on Palantir's own fixture
+
+| Measure | Value |
+| --- | ---: |
+| Object types | 9 |
+| Properties | 68 |
+| Link sides | 6 |
+| Interfaces | 2 |
+| Shared property types | 1 |
+| Inverse pairs recovered | 2 |
+| owl:hasKey axioms written | 9 |
+| Properties the crosswalk cannot carry | 10 |
+
+![Properties by crossing fidelity](property-fidelity.svg)
+
+### Documentation present in the source
+
+The crosswalk never invents a definition. What the source omits stays omitted,
+and the linter then reports it.
+
+| Measure | Value |
+| --- | ---: |
+| Object types with no description | 5 of 9 |
+| Properties with no description | 55 of 68 |
+
+## The other direction
+
+Each ontology below was parsed, its asserted constructs counted, and each
+construct checked against the fields that exist in Palantir's ontology model.
+
+| Ontology | Triples | Constructs used | Carried | Partial | No destination |
+| --- | ---: | ---: | ---: | ---: | ---: |
+| `ies4.ttl` | 3976 | 8 | 1789 | 760 | 200 |
+| `ies-core.ttl` | 1083 | 7 | 379 | 178 | 36 |
+| `ies-top.ttl` | 239 | 6 | 88 | 30 | 21 |
+| `boro-building-handcrafted.ttl` | 355 | 8 | 198 | 66 | 18 |
+| `pizza-reference.owl` | 2332 | 24 | 284 | 270 | 1241 |
+
+![Axiom survival by ontology](axiom-survival.svg)
+
+### Where each ontology loses its axioms
+
+**ies4.ttl**
+
+| Construct | Assertions | Why it has no destination |
+| --- | ---: | --- |
+| `rdfs:subPropertyOf` | 200 | No field arranges properties in a hierarchy. |
+
+**ies-core.ttl**
+
+| Construct | Assertions | Why it has no destination |
+| --- | ---: | --- |
+| `rdfs:subPropertyOf` | 36 | No field arranges properties in a hierarchy. |
+
+**ies-top.ttl**
+
+| Construct | Assertions | Why it has no destination |
+| --- | ---: | --- |
+| `rdfs:subPropertyOf` | 21 | No field arranges properties in a hierarchy. |
+
+**boro-building-handcrafted.ttl**
+
+| Construct | Assertions | Why it has no destination |
+| --- | ---: | --- |
+| `rdfs:subPropertyOf` | 18 | No field arranges properties in a hierarchy. |
+
+**pizza-reference.owl**
+
+| Construct | Assertions | Why it has no destination |
+| --- | ---: | --- |
+| `owl:disjointWith` | 796 | No field asserts that two types cannot share a member. |
+| `owl:Restriction` | 188 | No field carries a class defined by a condition on a property. |
+| `owl:someValuesFrom` | 155 | Existential restriction has no Foundry field. |
+| `owl:allValuesFrom` | 26 | Universal restriction has no Foundry field. |
+| `owl:unionOf` | 25 | No field defines a class as a union. |
+| `owl:equivalentClass` | 15 | No field asserts that two types have the same members. |
+| `owl:intersectionOf` | 15 | No field defines a class as an intersection. |
+| `owl:hasValue` | 6 | Value restriction has no Foundry field. |
+| `rdfs:subPropertyOf` | 4 | No field arranges properties in a hierarchy. |
+| `owl:InverseFunctionalProperty` | 3 | No field declares a property inverse functional. |
+| `owl:complementOf` | 3 | No field defines a class as a complement. |
+| `owl:TransitiveProperty` | 2 | No field declares a property transitive. |
+| `owl:minCardinality` | 1 | Minimum cardinality has no Foundry field. |
+| `owl:oneOf` | 1 | No field defines a class by enumeration. |
+| `owl:AllDifferent` | 1 | No field asserts mutual difference. |
+
diff --git a/case-studies/foundry-owl-crosswalk/ontology/foundry-crosswalk.ttl b/case-studies/foundry-owl-crosswalk/ontology/foundry-crosswalk.ttl
new file mode 100644
index 00000000..84f96950
--- /dev/null
+++ b/case-studies/foundry-owl-crosswalk/ontology/foundry-crosswalk.ttl
@@ -0,0 +1,1115 @@
+@prefix ex: <https://ontology.tesseract.academy/foundry-crosswalk/> .
+@prefix fcx: <https://ontology.tesseract.academy/foundry-crosswalk/meta#> .
+@prefix geo: <http://www.opengis.net/ont/geosparql#> .
+@prefix owl: <http://www.w3.org/2002/07/owl#> .
+@prefix rdf: <http://www.w3.org/1999/02/22-rdf-syntax-ns#> .
+@prefix rdfs: <http://www.w3.org/2000/01/rdf-schema#> .
+@prefix sh: <http://www.w3.org/ns/shacl#> .
+@prefix skos: <http://www.w3.org/2004/02/skos/core#> .
+@prefix xsd: <http://www.w3.org/2001/XMLSchema#> .
+
+ex: a owl:Ontology ;
+ rdfs:label "Palantir OSDK shared test fixtures" ;
+ rdfs:comment "Assembled from the fixtures Palantir publishes in palantir/osdk-ts to mock the Foundry Ontology API." .
+
+ex:BarInterface a owl:Class ;
+ rdfs:label "Bar Interface" ;
+ rdfs:comment "Interface for Bar" ;
+ fcx:foundryRid "ri.interface.main.interface.2" .
+
+ex:BgaoNflPlayer.address.StructShape a sh:NodeShape ;
+ sh:property [ sh:datatype xsd:int ;
+ sh:maxCount 1 ;
+ sh:path ex:BgaoNflPlayer.address.zipCode ],
+ [ sh:datatype xsd:string ;
+ sh:maxCount 1 ;
+ sh:path ex:BgaoNflPlayer.address.city ],
+ [ sh:datatype xsd:string ;
+ sh:maxCount 1 ;
+ sh:path ex:BgaoNflPlayer.address.state ],
+ [ sh:datatype xsd:string ;
+ sh:maxCount 1 ;
+ sh:path ex:BgaoNflPlayer.address.addressLine1 ],
+ [ sh:datatype xsd:string ;
+ sh:maxCount 1 ;
+ sh:path ex:BgaoNflPlayer.address.addressLine2 ] ;
+ sh:targetClass ex:BgaoNflPlayer.address.Struct .
+
+ex:BgaoNflPlayer.addressArray.StructShape a sh:NodeShape ;
+ sh:property [ sh:datatype geo:wktLiteral ;
+ sh:maxCount 1 ;
+ sh:path ex:BgaoNflPlayer.addressArray.location ],
+ [ sh:datatype xsd:string ;
+ sh:maxCount 1 ;
+ sh:path ex:BgaoNflPlayer.addressArray.addressLine1 ],
+ [ sh:datatype xsd:string ;
+ sh:maxCount 1 ;
+ sh:path ex:BgaoNflPlayer.addressArray.addressLine2 ],
+ [ sh:datatype xsd:int ;
+ sh:maxCount 1 ;
+ sh:path ex:BgaoNflPlayer.addressArray.zipCode ],
+ [ sh:datatype geo:wktLiteral ;
+ sh:maxCount 1 ;
+ sh:path ex:BgaoNflPlayer.addressArray.city ] ;
+ sh:targetClass ex:BgaoNflPlayer.addressArray.Struct .
+
+ex:BgaoNflPlayerShape a sh:NodeShape ;
+ sh:property [ sh:datatype xsd:int ;
+ sh:maxCount 1 ;
+ sh:name "gamesPlayed" ;
+ sh:path ex:BgaoNflPlayer.gamesPlayed ],
+ [ sh:datatype xsd:int ;
+ sh:maxCount 1 ;
+ sh:name "number" ;
+ sh:path ex:BgaoNflPlayer.number ],
+ [ sh:datatype xsd:string ;
+ sh:maxCount 1 ;
+ sh:minCount 1 ;
+ sh:name "id" ;
+ sh:path ex:BgaoNflPlayer.id ],
+ [ sh:class ex:BgaoNflPlayer.addressArray.Struct ;
+ sh:name "addressArray" ;
+ sh:path ex:BgaoNflPlayer.addressArray ],
+ [ sh:datatype xsd:string ;
+ sh:maxCount 1 ;
+ sh:name "name" ;
+ sh:path ex:BgaoNflPlayer.name ],
+ [ sh:class ex:BgaoNflPlayer.address.Struct ;
+ sh:maxCount 1 ;
+ sh:name "address" ;
+ sh:path ex:BgaoNflPlayer.address ],
+ [ sh:datatype xsd:string ;
+ sh:maxCount 1 ;
+ sh:name "wikiUrl" ;
+ sh:path ex:BgaoNflPlayer.wikiUrl ] ;
+ sh:targetClass ex:BgaoNflPlayer .
+
+ex:Employee.employeeProfile.StructShape a sh:NodeShape ;
+ sh:property [ sh:datatype xsd:int ;
+ sh:maxCount 1 ;
+ sh:path ex:Employee.employeeProfile.yearsExperience ],
+ [ sh:datatype xsd:string ;
+ sh:maxCount 1 ;
+ sh:path ex:Employee.employeeProfile.bio ] ;
+ sh:targetClass ex:Employee.employeeProfile.Struct .
+
+ex:EmployeeShape a sh:NodeShape ;
+ sh:property [ sh:datatype xsd:date ;
+ sh:maxCount 1 ;
+ sh:name "startDate" ;
+ sh:path ex:Employee.startDate ],
+ [ sh:maxCount 1 ;
+ sh:name "employeeSensor" ;
+ sh:path ex:Employee.employeeSensor ],
+ [ sh:datatype xsd:string ;
+ sh:maxCount 1 ;
+ sh:name "office" ;
+ sh:path ex:Employee.office ],
+ [ sh:maxCount 1 ;
+ sh:name "employeeLocation" ;
+ sh:path ex:Employee.employeeLocation ],
+ [ sh:datatype xsd:string ;
+ sh:maxCount 1 ;
+ sh:name "class" ;
+ sh:path ex:Employee.class ],
+ [ sh:class ex:Employee ;
+ sh:name "peeps" ;
+ sh:path ex:link.Employee.peeps ],
+ [ sh:datatype xsd:string ;
+ sh:maxCount 1 ;
+ sh:name "skillSet" ;
+ sh:path ex:Employee.skillSet ],
+ [ sh:datatype xsd:double ;
+ sh:name "performanceScores" ;
+ sh:path ex:Employee.performanceScores ],
+ [ sh:class ex:Office ;
+ sh:maxCount 1 ;
+ sh:name "officeLink" ;
+ sh:path ex:link.Employee.officeLink ],
+ [ sh:class ex:Employee.employeeProfile.Struct ;
+ sh:maxCount 1 ;
+ sh:name "employeeProfile" ;
+ sh:path ex:Employee.employeeProfile ],
+ [ sh:class ex:Employee ;
+ sh:maxCount 1 ;
+ sh:name "lead" ;
+ sh:path ex:link.Employee.lead ],
+ [ sh:datatype xsd:string ;
+ sh:maxCount 1 ;
+ sh:name "fullName" ;
+ sh:path ex:Employee.fullName ],
+ [ sh:maxCount 1 ;
+ sh:name "skillSetEmbedding" ;
+ sh:path ex:Employee.skillSetEmbedding ],
+ [ sh:maxCount 1 ;
+ sh:name "employeeStatus" ;
+ sh:path ex:Employee.employeeStatus ],
+ [ sh:datatype xsd:int ;
+ sh:maxCount 1 ;
+ sh:minCount 1 ;
+ sh:name "employeeId" ;
+ sh:path ex:Employee.employeeId ],
+ [ sh:datatype xsd:string ;
+ sh:name "favoriteRestaurants" ;
+ sh:path ex:Employee.favoriteRestaurants ] ;
+ sh:targetClass ex:Employee .
+
+ex:FooInterface a owl:Class ;
+ rdfs:label "Foo Interface" ;
+ rdfs:comment "Interface for Foo" ;
+ fcx:foundryRid "ri.interface.main.interface.1" .
+
+ex:ObjectWithTimestampPrimaryKeyShape a sh:NodeShape ;
+ sh:property [ sh:datatype xsd:dateTime ;
+ sh:maxCount 1 ;
+ sh:minCount 1 ;
+ sh:name "timestamp" ;
+ sh:path ex:ObjectWithTimestampPrimaryKey.timestamp ],
+ [ sh:datatype xsd:string ;
+ sh:maxCount 1 ;
+ sh:name "value" ;
+ sh:path ex:ObjectWithTimestampPrimaryKey.value ] ;
+ sh:targetClass ex:ObjectWithTimestampPrimaryKey .
+
+ex:OfficeShape a sh:NodeShape ;
+ sh:property [ sh:datatype xsd:string ;
+ sh:maxCount 1 ;
+ sh:minCount 1 ;
+ sh:name "officeId" ;
+ sh:path ex:Office.officeId ],
+ [ sh:datatype xsd:int ;
+ sh:maxCount 1 ;
+ sh:name "capacity" ;
+ sh:path ex:Office.capacity ],
+ [ sh:datatype geo:wktLiteral ;
+ sh:maxCount 1 ;
+ sh:name "occupiedArea" ;
+ sh:path ex:Office.occupiedArea ],
+ [ sh:class ex:Office ;
+ sh:name "visitedOffices" ;
+ sh:path ex:link.Office.visitedOffices ],
+ [ sh:class ex:Employee ;
+ sh:name "occupants" ;
+ sh:path ex:link.Office.occupants ],
+ [ sh:datatype xsd:string ;
+ sh:maxCount 1 ;
+ sh:name "name" ;
+ sh:path ex:Office.name ],
+ [ sh:datatype geo:wktLiteral ;
+ sh:maxCount 1 ;
+ sh:name "entrance" ;
+ sh:path ex:Office.entrance ] ;
+ sh:targetClass ex:Office .
+
+ex:PersonShape a sh:NodeShape ;
+ sh:property [ sh:datatype xsd:int ;
+ sh:maxCount 1 ;
+ sh:minCount 1 ;
+ sh:name "id" ;
+ sh:path ex:Person.id ],
+ [ sh:datatype xsd:string ;
+ sh:maxCount 1 ;
+ sh:name "name" ;
+ sh:path ex:Person.name ] ;
+ sh:targetClass ex:Person .
+
+ex:TaskShape a sh:NodeShape ;
+ sh:property [ sh:datatype xsd:string ;
+ sh:maxCount 1 ;
+ sh:name "name" ;
+ sh:path ex:Task.name ],
+ [ sh:datatype xsd:int ;
+ sh:maxCount 1 ;
+ sh:minCount 1 ;
+ sh:name "id" ;
+ sh:path ex:Task.id ] ;
+ sh:targetClass ex:Task .
+
+ex:TodoShape a sh:NodeShape ;
+ sh:property [ sh:datatype xsd:int ;
+ sh:maxCount 1 ;
+ sh:minCount 1 ;
+ sh:name "id" ;
+ sh:path ex:Todo.id ],
+ [ sh:datatype xsd:string ;
+ sh:maxCount 1 ;
+ sh:name "text" ;
+ sh:path ex:Todo.text ] ;
+ sh:targetClass ex:Todo .
+
+ex:equipmentShape a sh:NodeShape ;
+ sh:property [ sh:datatype xsd:string ;
+ sh:maxCount 1 ;
+ sh:minCount 1 ;
+ sh:name "equipmentId" ;
+ sh:path ex:equipment.equipmentId ],
+ [ sh:datatype xsd:string ;
+ sh:maxCount 1 ;
+ sh:name "type" ;
+ sh:path ex:equipment.type ] ;
+ sh:targetClass ex:equipment .
+
+fcx:fidelity a owl:AnnotationProperty ;
+ rdfs:comment "How faithfully the Foundry type crossed into standards." .
+
+fcx:foundryDetail a owl:AnnotationProperty ;
+ rdfs:comment "Foundry type detail with no standards counterpart." .
+
+fcx:foundryElementType a owl:AnnotationProperty ;
+ rdfs:comment "The element type of a Foundry array property." .
+
+fcx:foundryRid a owl:AnnotationProperty ;
+ rdfs:comment "The Foundry resource identifier the term came from." .
+
+fcx:foundryType a owl:AnnotationProperty ;
+ rdfs:comment "The Foundry property type discriminator." .
+
+fcx:titleProperty a owl:AnnotationProperty ;
+ rdfs:comment "The Foundry display title property." .
+
+fcx:unmappable a owl:AnnotationProperty ;
+ rdfs:comment "Marks a term whose Foundry meaning has no standards counterpart." .
+
+ex:objectTypeWithAllPropertyTypesShape a sh:NodeShape ;
+ sh:property [ sh:name "attachmentArray" ;
+ sh:path ex:objectTypeWithAllPropertyTypes.attachmentArray ],
+ [ sh:datatype xsd:string ;
+ sh:name "stringArray" ;
+ sh:path ex:objectTypeWithAllPropertyTypes.stringArray ],
+ [ sh:datatype xsd:dateTime ;
+ sh:name "dateTimeArray" ;
+ sh:path ex:objectTypeWithAllPropertyTypes.dateTimeArray ],
+ [ sh:datatype xsd:dateTime ;
+ sh:maxCount 1 ;
+ sh:name "dateTime" ;
+ sh:path ex:objectTypeWithAllPropertyTypes.dateTime ],
+ [ sh:maxCount 1 ;
+ sh:name "vector" ;
+ sh:path ex:objectTypeWithAllPropertyTypes.vector ],
+ [ sh:datatype xsd:decimal ;
+ sh:maxCount 1 ;
+ sh:name "decimal" ;
+ sh:path ex:objectTypeWithAllPropertyTypes.decimal ],
+ [ sh:datatype xsd:long ;
+ sh:name "longArray" ;
+ sh:path ex:objectTypeWithAllPropertyTypes.longArray ],
+ [ sh:datatype xsd:double ;
+ sh:maxCount 1 ;
+ sh:name "double" ;
+ sh:path ex:objectTypeWithAllPropertyTypes.double ],
+ [ sh:datatype xsd:decimal ;
+ sh:name "decimalArray" ;
+ sh:path ex:objectTypeWithAllPropertyTypes.decimalArray ],
+ [ sh:maxCount 1 ;
+ sh:name "attachment" ;
+ sh:path ex:objectTypeWithAllPropertyTypes.attachment ],
+ [ sh:datatype xsd:date ;
+ sh:maxCount 1 ;
+ sh:name "date" ;
+ sh:path ex:objectTypeWithAllPropertyTypes.date ],
+ [ sh:datatype geo:wktLiteral ;
+ sh:maxCount 1 ;
+ sh:name "geoPoint" ;
+ sh:path ex:objectTypeWithAllPropertyTypes.geoPoint ],
+ [ sh:maxCount 1 ;
+ sh:name "attachment2" ;
+ sh:path ex:objectTypeWithAllPropertyTypes.attachment2 ],
+ [ sh:datatype xsd:int ;
+ sh:maxCount 1 ;
+ sh:name "integer" ;
+ sh:path ex:objectTypeWithAllPropertyTypes.integer ],
+ [ sh:datatype xsd:boolean ;
+ sh:maxCount 1 ;
+ sh:name "boolean" ;
+ sh:path ex:objectTypeWithAllPropertyTypes.boolean ],
+ [ sh:datatype xsd:byte ;
+ sh:maxCount 1 ;
+ sh:name "byte" ;
+ sh:path ex:objectTypeWithAllPropertyTypes.byte ],
+ [ sh:datatype xsd:date ;
+ sh:name "dateArray" ;
+ sh:path ex:objectTypeWithAllPropertyTypes.dateArray ],
+ [ sh:class ex:objectTypeWithAllPropertyTypes ;
+ sh:maxCount 1 ;
+ sh:name "linkedObjectType" ;
+ sh:path ex:link.objectTypeWithAllPropertyTypes.linkedObjectType ],
+ [ sh:datatype xsd:boolean ;
+ sh:name "booleanArray" ;
+ sh:path ex:objectTypeWithAllPropertyTypes.booleanArray ],
+ [ sh:maxCount 1 ;
+ sh:name "cipherText" ;
+ sh:path ex:objectTypeWithAllPropertyTypes.cipherText ],
+ [ sh:datatype geo:wktLiteral ;
+ sh:name "geoShapeArray" ;
+ sh:path ex:objectTypeWithAllPropertyTypes.geoShapeArray ],
+ [ sh:datatype xsd:long ;
+ sh:maxCount 1 ;
+ sh:name "long" ;
+ sh:path ex:objectTypeWithAllPropertyTypes.long ],
+ [ sh:datatype xsd:byte ;
+ sh:name "byteArray" ;
+ sh:path ex:objectTypeWithAllPropertyTypes.byteArray ],
+ [ sh:datatype xsd:short ;
+ sh:maxCount 1 ;
+ sh:name "short" ;
+ sh:path ex:objectTypeWithAllPropertyTypes.short ],
+ [ sh:datatype xsd:short ;
+ sh:name "shortArray" ;
+ sh:path ex:objectTypeWithAllPropertyTypes.shortArray ],
+ [ sh:maxCount 1 ;
+ sh:name "mediaReference" ;
+ sh:path ex:objectTypeWithAllPropertyTypes.mediaReference ],
+ [ sh:datatype xsd:int ;
+ sh:name "integerArray" ;
+ sh:path ex:objectTypeWithAllPropertyTypes.integerArray ],
+ [ sh:datatype geo:wktLiteral ;
+ sh:name "geoPointArray" ;
+ sh:path ex:objectTypeWithAllPropertyTypes.geoPointArray ],
+ [ sh:datatype xsd:double ;
+ sh:name "doubleArray" ;
+ sh:path ex:objectTypeWithAllPropertyTypes.doubleArray ],
+ [ sh:datatype xsd:float ;
+ sh:name "floatArray" ;
+ sh:path ex:objectTypeWithAllPropertyTypes.floatArray ],
+ [ sh:datatype xsd:int ;
+ sh:maxCount 1 ;
+ sh:minCount 1 ;
+ sh:name "id" ;
+ sh:path ex:objectTypeWithAllPropertyTypes.id ],
+ [ sh:datatype geo:wktLiteral ;
+ sh:maxCount 1 ;
+ sh:name "geoShape" ;
+ sh:path ex:objectTypeWithAllPropertyTypes.geoShape ],
+ [ sh:datatype xsd:float ;
+ sh:maxCount 1 ;
+ sh:name "float" ;
+ sh:path ex:objectTypeWithAllPropertyTypes.float ],
+ [ sh:datatype xsd:string ;
+ sh:maxCount 1 ;
+ sh:name "string" ;
+ sh:path ex:objectTypeWithAllPropertyTypes.string ] ;
+ sh:targetClass ex:objectTypeWithAllPropertyTypes .
+
+ex:spt.fooSpt a owl:DatatypeProperty ;
+ rdfs:label "Foo" ;
+ rdfs:comment "A foo" ;
+ rdfs:range xsd:string .
+
+ex:BgaoNflPlayer.address a owl:ObjectProperty ;
+ rdfs:label "address" ;
+ rdfs:domain ex:BgaoNflPlayer ;
+ rdfs:range ex:BgaoNflPlayer.address.Struct ;
+ fcx:fidelity "structural" ;
+ fcx:foundryType "struct" .
+
+ex:BgaoNflPlayer.address.addressLine1 a owl:DatatypeProperty ;
+ rdfs:label "addressLine1" ;
+ rdfs:domain ex:BgaoNflPlayer.address.Struct ;
+ rdfs:range xsd:string ;
+ fcx:foundryType "string" .
+
+ex:BgaoNflPlayer.address.addressLine2 a owl:DatatypeProperty ;
+ rdfs:label "addressLine2" ;
+ rdfs:domain ex:BgaoNflPlayer.address.Struct ;
+ rdfs:range xsd:string ;
+ fcx:foundryType "string" .
+
+ex:BgaoNflPlayer.address.city a owl:DatatypeProperty ;
+ rdfs:label "city" ;
+ rdfs:domain ex:BgaoNflPlayer.address.Struct ;
+ rdfs:range xsd:string ;
+ fcx:foundryType "string" .
+
+ex:BgaoNflPlayer.address.state a owl:DatatypeProperty ;
+ rdfs:label "state" ;
+ rdfs:domain ex:BgaoNflPlayer.address.Struct ;
+ rdfs:range xsd:string ;
+ fcx:foundryType "string" .
+
+ex:BgaoNflPlayer.address.zipCode a owl:DatatypeProperty ;
+ rdfs:label "zipCode" ;
+ rdfs:domain ex:BgaoNflPlayer.address.Struct ;
+ rdfs:range xsd:int ;
+ fcx:foundryType "integer" .
+
+ex:BgaoNflPlayer.addressArray a owl:ObjectProperty ;
+ rdfs:label "addressArray" ;
+ rdfs:domain ex:BgaoNflPlayer ;
+ rdfs:range ex:BgaoNflPlayer.addressArray.Struct ;
+ fcx:fidelity "structural" ;
+ fcx:foundryElementType "struct" ;
+ fcx:foundryType "array" .
+
+ex:BgaoNflPlayer.addressArray.addressLine1 a owl:DatatypeProperty ;
+ rdfs:label "addressLine1" ;
+ rdfs:domain ex:BgaoNflPlayer.addressArray.Struct ;
+ rdfs:range xsd:string ;
+ fcx:foundryType "string" .
+
+ex:BgaoNflPlayer.addressArray.addressLine2 a owl:DatatypeProperty ;
+ rdfs:label "addressLine2" ;
+ rdfs:domain ex:BgaoNflPlayer.addressArray.Struct ;
+ rdfs:range xsd:string ;
+ fcx:foundryType "string" .
+
+ex:BgaoNflPlayer.addressArray.city a owl:DatatypeProperty ;
+ rdfs:label "city" ;
+ rdfs:domain ex:BgaoNflPlayer.addressArray.Struct ;
+ rdfs:range geo:wktLiteral ;
+ fcx:foundryType "geoshape" .
+
+ex:BgaoNflPlayer.addressArray.location a owl:DatatypeProperty ;
+ rdfs:label "location" ;
+ rdfs:domain ex:BgaoNflPlayer.addressArray.Struct ;
+ rdfs:range geo:wktLiteral ;
+ fcx:foundryType "geopoint" .
+
+ex:BgaoNflPlayer.addressArray.zipCode a owl:DatatypeProperty ;
+ rdfs:label "zipCode" ;
+ rdfs:domain ex:BgaoNflPlayer.addressArray.Struct ;
+ rdfs:range xsd:int ;
+ fcx:foundryType "integer" .
+
+ex:BgaoNflPlayer.gamesPlayed a owl:DatatypeProperty ;
+ rdfs:label "gamesPlayed" ;
+ rdfs:domain ex:BgaoNflPlayer ;
+ rdfs:range xsd:int ;
+ fcx:fidelity "direct" ;
+ fcx:foundryType "integer" .
+
+ex:BgaoNflPlayer.name a owl:DatatypeProperty ;
+ rdfs:label "name" ;
+ rdfs:domain ex:BgaoNflPlayer ;
+ rdfs:range xsd:string ;
+ fcx:fidelity "direct" ;
+ fcx:foundryType "string" .
+
+ex:BgaoNflPlayer.number a owl:DatatypeProperty ;
+ rdfs:label "number" ;
+ rdfs:domain ex:BgaoNflPlayer ;
+ rdfs:range xsd:int ;
+ fcx:fidelity "direct" ;
+ fcx:foundryType "integer" .
+
+ex:BgaoNflPlayer.wikiUrl a owl:DatatypeProperty ;
+ rdfs:label "wikiUrl" ;
+ rdfs:domain ex:BgaoNflPlayer ;
+ rdfs:range xsd:string ;
+ fcx:fidelity "direct" ;
+ fcx:foundryType "string" .
+
+ex:Employee.class a owl:DatatypeProperty ;
+ rdfs:label "class" ;
+ rdfs:domain ex:Employee ;
+ rdfs:range xsd:string ;
+ fcx:fidelity "direct" ;
+ fcx:foundryType "string" .
+
+ex:Employee.employeeLocation a owl:DatatypeProperty ;
+ rdfs:label "employeeLocation" ;
+ rdfs:comment "Geotime series reference of the location of the employee",
+ "Not carried by the crosswalk. A handle onto a Geotime integration. The track is not in the export." ;
+ rdfs:domain ex:Employee ;
+ fcx:fidelity "none" ;
+ fcx:foundryType "geotimeSeriesReference" ;
+ fcx:unmappable true .
+
+ex:Employee.employeeProfile a owl:ObjectProperty ;
+ rdfs:label "employeeProfile" ;
+ rdfs:comment "Employee profile with main value being the bio" ;
+ rdfs:domain ex:Employee ;
+ rdfs:range ex:Employee.employeeProfile.Struct ;
+ fcx:fidelity "structural" ;
+ fcx:foundryType "struct" .
+
+ex:Employee.employeeProfile.bio a owl:DatatypeProperty ;
+ rdfs:label "bio" ;
+ rdfs:domain ex:Employee.employeeProfile.Struct ;
+ rdfs:range xsd:string ;
+ fcx:foundryType "string" .
+
+ex:Employee.employeeProfile.yearsExperience a owl:DatatypeProperty ;
+ rdfs:label "yearsExperience" ;
+ rdfs:domain ex:Employee.employeeProfile.Struct ;
+ rdfs:range xsd:int ;
+ fcx:foundryType "integer" .
+
+ex:Employee.employeeSensor a owl:DatatypeProperty ;
+ rdfs:label "employeeSensor" ;
+ rdfs:comment "Not carried by the crosswalk. A handle onto a Foundry time series, not a value. The series itself is not in the export.",
+ "TimeSeries sensor of the status of the employee" ;
+ rdfs:domain ex:Employee ;
+ fcx:fidelity "none" ;
+ fcx:foundryDetail "itemType={\"type\": \"string\"}" ;
+ fcx:foundryType "timeseries" ;
+ fcx:unmappable true .
+
+ex:Employee.employeeStatus a owl:DatatypeProperty ;
+ rdfs:label "employeeStatus" ;
+ rdfs:comment "Not carried by the crosswalk. A handle onto a Foundry time series, not a value. The series itself is not in the export.",
+ "TimeSeries of the status of the employee" ;
+ rdfs:domain ex:Employee ;
+ fcx:fidelity "none" ;
+ fcx:foundryDetail "itemType={\"type\": \"string\"}" ;
+ fcx:foundryType "timeseries" ;
+ fcx:unmappable true .
+
+ex:Employee.favoriteRestaurants a owl:DatatypeProperty ;
+ rdfs:label "favoriteRestaurants" ;
+ rdfs:domain ex:Employee ;
+ rdfs:range xsd:string ;
+ fcx:fidelity "direct" ;
+ fcx:foundryElementType "string" ;
+ fcx:foundryType "array" .
+
+ex:Employee.fullName a owl:DatatypeProperty ;
+ rdfs:label "fullName" ;
+ rdfs:domain ex:Employee ;
+ rdfs:range xsd:string ;
+ fcx:fidelity "direct" ;
+ fcx:foundryType "string" .
+
+ex:Employee.office a owl:DatatypeProperty ;
+ rdfs:label "office" ;
+ rdfs:comment """The unique "ID" of the employee's \\"primary\\" assigned office.
+ This is some more text.""" ;
+ rdfs:domain ex:Employee ;
+ rdfs:range xsd:string ;
+ fcx:fidelity "direct" ;
+ fcx:foundryType "string" .
+
+ex:Employee.performanceScores a owl:DatatypeProperty ;
+ rdfs:label "performanceScores" ;
+ rdfs:comment "Array of performance scores with reducers" ;
+ rdfs:domain ex:Employee ;
+ rdfs:range xsd:double ;
+ fcx:fidelity "direct" ;
+ fcx:foundryElementType "double" ;
+ fcx:foundryType "array" .
+
+ex:Employee.skillSet a owl:DatatypeProperty ;
+ rdfs:label "skillSet" ;
+ rdfs:comment "The skills of the employee" ;
+ rdfs:domain ex:Employee ;
+ rdfs:range xsd:string ;
+ fcx:fidelity "direct" ;
+ fcx:foundryType "string" .
+
+ex:Employee.skillSetEmbedding a owl:DatatypeProperty ;
+ rdfs:label "skillSetEmbedding" ;
+ rdfs:comment "Not carried by the crosswalk. An embedding. The export declares its dimension and sometimes the producing model, but no W3C datatype carries a vector, so both become annotations rather than a range.",
+ "Vectorized skill set" ;
+ rdfs:domain ex:Employee ;
+ fcx:fidelity "none" ;
+ fcx:foundryDetail "dimension=1536",
+ "embeddingModel={\"type\": \"lms\", \"value\": \"OPENAI_TEXT_EMBEDDING_ADA_002\"}" ;
+ fcx:foundryType "vector" ;
+ fcx:unmappable true .
+
+ex:Employee.startDate a owl:DatatypeProperty ;
+ rdfs:label "startDate" ;
+ rdfs:comment "The date the employee was hired (most recently, if they were re-hired)" ;
+ rdfs:domain ex:Employee ;
+ rdfs:range xsd:date ;
+ fcx:fidelity "direct" ;
+ fcx:foundryType "date" .
+
+ex:ObjectWithTimestampPrimaryKey.value a owl:DatatypeProperty ;
+ rdfs:label "value" ;
+ rdfs:domain ex:ObjectWithTimestampPrimaryKey ;
+ rdfs:range xsd:string ;
+ fcx:fidelity "direct" ;
+ fcx:foundryType "string" .
+
+ex:Office.capacity a owl:DatatypeProperty ;
+ rdfs:label "capacity" ;
+ rdfs:comment "The capacity of the Office" ;
+ rdfs:domain ex:Office ;
+ rdfs:range xsd:int ;
+ fcx:fidelity "direct" ;
+ fcx:foundryType "integer" .
+
+ex:Office.entrance a owl:DatatypeProperty ;
+ rdfs:label "entrance" ;
+ rdfs:domain ex:Office ;
+ rdfs:range geo:wktLiteral ;
+ fcx:fidelity "standard" ;
+ fcx:foundryType "geopoint" .
+
+ex:Office.name a owl:DatatypeProperty ;
+ rdfs:label "name" ;
+ rdfs:comment "The Name of the Office" ;
+ rdfs:domain ex:Office ;
+ rdfs:range xsd:string ;
+ fcx:fidelity "direct" ;
+ fcx:foundryType "string" .
+
+ex:Office.occupiedArea a owl:DatatypeProperty ;
+ rdfs:label "occupiedArea" ;
+ rdfs:comment "The occupied area of the Office" ;
+ rdfs:domain ex:Office ;
+ rdfs:range geo:wktLiteral ;
+ fcx:fidelity "standard" ;
+ fcx:foundryType "geoshape" .
+
+ex:Person.name a owl:DatatypeProperty ;
+ rdfs:label "name" ;
+ rdfs:domain ex:Person ;
+ rdfs:range xsd:string ;
+ fcx:fidelity "direct" ;
+ fcx:foundryType "string" .
+
+ex:Task.name a owl:DatatypeProperty ;
+ rdfs:label "name" ;
+ rdfs:domain ex:Task ;
+ rdfs:range xsd:string ;
+ fcx:fidelity "direct" ;
+ fcx:foundryType "string" .
+
+ex:Todo.text a owl:DatatypeProperty ;
+ rdfs:label "text" ;
+ rdfs:domain ex:Todo ;
+ rdfs:range xsd:string ;
+ fcx:fidelity "direct" ;
+ fcx:foundryType "string" .
+
+ex:equipment.type a owl:DatatypeProperty ;
+ rdfs:label "type" ;
+ rdfs:domain ex:equipment ;
+ rdfs:range xsd:string ;
+ fcx:fidelity "direct" ;
+ fcx:foundryType "string" .
+
+ex:link.Office.visitedOffices a owl:ObjectProperty ;
+ rdfs:label "Visited Offices" ;
+ rdfs:domain ex:Office ;
+ rdfs:range ex:Office ;
+ fcx:foundryRid "ri.a.b.c.visitedOffices" .
+
+ex:link.objectTypeWithAllPropertyTypes.linkedObjectType a owl:FunctionalProperty,
+ owl:ObjectProperty ;
+ rdfs:label "Linked Object Type" ;
+ rdfs:domain ex:objectTypeWithAllPropertyTypes ;
+ rdfs:range ex:objectTypeWithAllPropertyTypes ;
+ fcx:foundryRid "rid.link-type.832" .
+
+ex:objectTypeWithAllPropertyTypes.attachment a owl:DatatypeProperty ;
+ rdfs:label "attachment" ;
+ rdfs:comment "Not carried by the crosswalk. A resource identifier pointing into Foundry blob storage. The value does not resolve outside the platform." ;
+ rdfs:domain ex:objectTypeWithAllPropertyTypes ;
+ fcx:fidelity "none" ;
+ fcx:foundryType "attachment" ;
+ fcx:unmappable true .
+
+ex:objectTypeWithAllPropertyTypes.attachment2 a owl:DatatypeProperty ;
+ rdfs:label "attachment2" ;
+ rdfs:comment "Not carried by the crosswalk. A resource identifier pointing into Foundry blob storage. The value does not resolve outside the platform." ;
+ rdfs:domain ex:objectTypeWithAllPropertyTypes ;
+ fcx:fidelity "none" ;
+ fcx:foundryType "attachment" ;
+ fcx:unmappable true .
+
+ex:objectTypeWithAllPropertyTypes.attachmentArray a owl:DatatypeProperty ;
+ rdfs:label "attachmentArray" ;
+ rdfs:comment "Not carried by the crosswalk. A resource identifier pointing into Foundry blob storage. The value does not resolve outside the platform." ;
+ rdfs:domain ex:objectTypeWithAllPropertyTypes ;
+ fcx:fidelity "none" ;
+ fcx:foundryElementType "attachment" ;
+ fcx:foundryType "array" ;
+ fcx:unmappable true .
+
+ex:objectTypeWithAllPropertyTypes.boolean a owl:DatatypeProperty ;
+ rdfs:label "boolean" ;
+ rdfs:domain ex:objectTypeWithAllPropertyTypes ;
+ rdfs:range xsd:boolean ;
+ fcx:fidelity "direct" ;
+ fcx:foundryType "boolean" .
+
+ex:objectTypeWithAllPropertyTypes.booleanArray a owl:DatatypeProperty ;
+ rdfs:label "booleanArray" ;
+ rdfs:domain ex:objectTypeWithAllPropertyTypes ;
+ rdfs:range xsd:boolean ;
+ fcx:fidelity "direct" ;
+ fcx:foundryElementType "boolean" ;
+ fcx:foundryType "array" .
+
+ex:objectTypeWithAllPropertyTypes.byte a owl:DatatypeProperty ;
+ rdfs:label "byte" ;
+ rdfs:domain ex:objectTypeWithAllPropertyTypes ;
+ rdfs:range xsd:byte ;
+ fcx:fidelity "direct" ;
+ fcx:foundryType "byte" .
+
+ex:objectTypeWithAllPropertyTypes.byteArray a owl:DatatypeProperty ;
+ rdfs:label "byteArray" ;
+ rdfs:domain ex:objectTypeWithAllPropertyTypes ;
+ rdfs:range xsd:byte ;
+ fcx:fidelity "direct" ;
+ fcx:foundryElementType "byte" ;
+ fcx:foundryType "array" .
+
+ex:objectTypeWithAllPropertyTypes.cipherText a owl:DatatypeProperty ;
+ rdfs:label "cipherText" ;
+ rdfs:comment "Not carried by the crosswalk. Ciphertext bound to a Foundry cipher channel. The channel reference is meaningless outside the platform." ;
+ rdfs:domain ex:objectTypeWithAllPropertyTypes ;
+ fcx:fidelity "none" ;
+ fcx:foundryType "cipherText" ;
+ fcx:unmappable true .
+
+ex:objectTypeWithAllPropertyTypes.date a owl:DatatypeProperty ;
+ rdfs:label "date" ;
+ rdfs:domain ex:objectTypeWithAllPropertyTypes ;
+ rdfs:range xsd:date ;
+ fcx:fidelity "direct" ;
+ fcx:foundryType "date" .
+
+ex:objectTypeWithAllPropertyTypes.dateArray a owl:DatatypeProperty ;
+ rdfs:label "dateArray" ;
+ rdfs:domain ex:objectTypeWithAllPropertyTypes ;
+ rdfs:range xsd:date ;
+ fcx:fidelity "direct" ;
+ fcx:foundryElementType "date" ;
+ fcx:foundryType "array" .
+
+ex:objectTypeWithAllPropertyTypes.dateTime a owl:DatatypeProperty ;
+ rdfs:label "dateTime" ;
+ rdfs:domain ex:objectTypeWithAllPropertyTypes ;
+ rdfs:range xsd:dateTime ;
+ fcx:fidelity "direct" ;
+ fcx:foundryType "timestamp" .
+
+ex:objectTypeWithAllPropertyTypes.dateTimeArray a owl:DatatypeProperty ;
+ rdfs:label "dateTimeArray" ;
+ rdfs:domain ex:objectTypeWithAllPropertyTypes ;
+ rdfs:range xsd:dateTime ;
+ fcx:fidelity "direct" ;
+ fcx:foundryElementType "timestamp" ;
+ fcx:foundryType "array" .
+
+ex:objectTypeWithAllPropertyTypes.decimal a owl:DatatypeProperty ;
+ rdfs:label "decimal" ;
+ rdfs:domain ex:objectTypeWithAllPropertyTypes ;
+ rdfs:range xsd:decimal ;
+ fcx:fidelity "direct" ;
+ fcx:foundryType "decimal" .
+
+ex:objectTypeWithAllPropertyTypes.decimalArray a owl:DatatypeProperty ;
+ rdfs:label "decimalArray" ;
+ rdfs:domain ex:objectTypeWithAllPropertyTypes ;
+ rdfs:range xsd:decimal ;
+ fcx:fidelity "direct" ;
+ fcx:foundryElementType "decimal" ;
+ fcx:foundryType "array" .
+
+ex:objectTypeWithAllPropertyTypes.double a owl:DatatypeProperty ;
+ rdfs:label "double" ;
+ rdfs:domain ex:objectTypeWithAllPropertyTypes ;
+ rdfs:range xsd:double ;
+ fcx:fidelity "direct" ;
+ fcx:foundryType "double" .
+
+ex:objectTypeWithAllPropertyTypes.doubleArray a owl:DatatypeProperty ;
+ rdfs:label "doubleArray" ;
+ rdfs:domain ex:objectTypeWithAllPropertyTypes ;
+ rdfs:range xsd:double ;
+ fcx:fidelity "direct" ;
+ fcx:foundryElementType "double" ;
+ fcx:foundryType "array" .
+
+ex:objectTypeWithAllPropertyTypes.float a owl:DatatypeProperty ;
+ rdfs:label "float" ;
+ rdfs:domain ex:objectTypeWithAllPropertyTypes ;
+ rdfs:range xsd:float ;
+ fcx:fidelity "direct" ;
+ fcx:foundryType "float" .
+
+ex:objectTypeWithAllPropertyTypes.floatArray a owl:DatatypeProperty ;
+ rdfs:label "floatArray" ;
+ rdfs:domain ex:objectTypeWithAllPropertyTypes ;
+ rdfs:range xsd:float ;
+ fcx:fidelity "direct" ;
+ fcx:foundryElementType "float" ;
+ fcx:foundryType "array" .
+
+ex:objectTypeWithAllPropertyTypes.geoPoint a owl:DatatypeProperty ;
+ rdfs:label "geoPoint" ;
+ rdfs:domain ex:objectTypeWithAllPropertyTypes ;
+ rdfs:range geo:wktLiteral ;
+ fcx:fidelity "standard" ;
+ fcx:foundryType "geopoint" .
+
+ex:objectTypeWithAllPropertyTypes.geoPointArray a owl:DatatypeProperty ;
+ rdfs:label "geoPointArray" ;
+ rdfs:domain ex:objectTypeWithAllPropertyTypes ;
+ rdfs:range geo:wktLiteral ;
+ fcx:fidelity "standard" ;
+ fcx:foundryElementType "geopoint" ;
+ fcx:foundryType "array" .
+
+ex:objectTypeWithAllPropertyTypes.geoShape a owl:DatatypeProperty ;
+ rdfs:label "geoShape" ;
+ rdfs:domain ex:objectTypeWithAllPropertyTypes ;
+ rdfs:range geo:wktLiteral ;
+ fcx:fidelity "standard" ;
+ fcx:foundryType "geoshape" .
+
+ex:objectTypeWithAllPropertyTypes.geoShapeArray a owl:DatatypeProperty ;
+ rdfs:label "geoShapeArray" ;
+ rdfs:domain ex:objectTypeWithAllPropertyTypes ;
+ rdfs:range geo:wktLiteral ;
+ fcx:fidelity "standard" ;
+ fcx:foundryElementType "geoshape" ;
+ fcx:foundryType "array" .
+
+ex:objectTypeWithAllPropertyTypes.integer a owl:DatatypeProperty ;
+ rdfs:label "integer" ;
+ rdfs:domain ex:objectTypeWithAllPropertyTypes ;
+ rdfs:range xsd:int ;
+ fcx:fidelity "direct" ;
+ fcx:foundryType "integer" .
+
+ex:objectTypeWithAllPropertyTypes.integerArray a owl:DatatypeProperty ;
+ rdfs:label "integerArray" ;
+ rdfs:domain ex:objectTypeWithAllPropertyTypes ;
+ rdfs:range xsd:int ;
+ fcx:fidelity "direct" ;
+ fcx:foundryElementType "integer" ;
+ fcx:foundryType "array" .
+
+ex:objectTypeWithAllPropertyTypes.long a owl:DatatypeProperty ;
+ rdfs:label "long" ;
+ rdfs:domain ex:objectTypeWithAllPropertyTypes ;
+ rdfs:range xsd:long ;
+ fcx:fidelity "direct" ;
+ fcx:foundryType "long" .
+
+ex:objectTypeWithAllPropertyTypes.longArray a owl:DatatypeProperty ;
+ rdfs:label "longArray" ;
+ rdfs:domain ex:objectTypeWithAllPropertyTypes ;
+ rdfs:range xsd:long ;
+ fcx:fidelity "direct" ;
+ fcx:foundryElementType "long" ;
+ fcx:foundryType "array" .
+
+ex:objectTypeWithAllPropertyTypes.mediaReference a owl:DatatypeProperty ;
+ rdfs:label "mediaReference" ;
+ rdfs:comment "Not carried by the crosswalk. A reference into a Foundry media set. Does not resolve outside the platform." ;
+ rdfs:domain ex:objectTypeWithAllPropertyTypes ;
+ fcx:fidelity "none" ;
+ fcx:foundryType "mediaReference" ;
+ fcx:unmappable true .
+
+ex:objectTypeWithAllPropertyTypes.short a owl:DatatypeProperty ;
+ rdfs:label "short" ;
+ rdfs:domain ex:objectTypeWithAllPropertyTypes ;
+ rdfs:range xsd:short ;
+ fcx:fidelity "direct" ;
+ fcx:foundryType "short" .
+
+ex:objectTypeWithAllPropertyTypes.shortArray a owl:DatatypeProperty ;
+ rdfs:label "shortArray" ;
+ rdfs:domain ex:objectTypeWithAllPropertyTypes ;
+ rdfs:range xsd:short ;
+ fcx:fidelity "direct" ;
+ fcx:foundryElementType "short" ;
+ fcx:foundryType "array" .
+
+ex:objectTypeWithAllPropertyTypes.string a owl:DatatypeProperty ;
+ rdfs:label "string" ;
+ rdfs:domain ex:objectTypeWithAllPropertyTypes ;
+ rdfs:range xsd:string ;
+ fcx:fidelity "direct" ;
+ fcx:foundryType "string" .
+
+ex:objectTypeWithAllPropertyTypes.stringArray a owl:DatatypeProperty ;
+ rdfs:label "stringArray" ;
+ rdfs:domain ex:objectTypeWithAllPropertyTypes ;
+ rdfs:range xsd:string ;
+ fcx:fidelity "direct" ;
+ fcx:foundryElementType "string" ;
+ fcx:foundryType "array" .
+
+ex:objectTypeWithAllPropertyTypes.vector a owl:DatatypeProperty ;
+ rdfs:label "vector" ;
+ rdfs:comment "Not carried by the crosswalk. An embedding. The export declares its dimension and sometimes the producing model, but no W3C datatype carries a vector, so both become annotations rather than a range." ;
+ rdfs:domain ex:objectTypeWithAllPropertyTypes ;
+ fcx:fidelity "none" ;
+ fcx:foundryDetail "dimension=100" ;
+ fcx:foundryType "vector" ;
+ fcx:unmappable true .
+
+ex:BgaoNflPlayer.id a owl:DatatypeProperty ;
+ rdfs:label "id" ;
+ rdfs:domain ex:BgaoNflPlayer ;
+ rdfs:range xsd:string ;
+ fcx:fidelity "direct" ;
+ fcx:foundryType "string" .
+
+ex:Employee.employeeId a owl:DatatypeProperty ;
+ rdfs:label "employeeId" ;
+ rdfs:domain ex:Employee ;
+ rdfs:range xsd:int ;
+ fcx:fidelity "direct" ;
+ fcx:foundryType "integer" .
+
+ex:ObjectWithTimestampPrimaryKey.timestamp a owl:DatatypeProperty ;
+ rdfs:label "timestamp" ;
+ rdfs:domain ex:ObjectWithTimestampPrimaryKey ;
+ rdfs:range xsd:dateTime ;
+ fcx:fidelity "direct" ;
+ fcx:foundryType "timestamp" .
+
+ex:Office.officeId a owl:DatatypeProperty ;
+ rdfs:label "officeId" ;
+ rdfs:domain ex:Office ;
+ rdfs:range xsd:string ;
+ fcx:fidelity "direct" ;
+ fcx:foundryType "string" .
+
+ex:Person.id a owl:DatatypeProperty ;
+ rdfs:label "id" ;
+ rdfs:domain ex:Person ;
+ rdfs:range xsd:int ;
+ fcx:fidelity "direct" ;
+ fcx:foundryType "integer" .
+
+ex:Task.id a owl:DatatypeProperty ;
+ rdfs:label "id" ;
+ rdfs:domain ex:Task ;
+ rdfs:range xsd:int ;
+ fcx:fidelity "direct" ;
+ fcx:foundryType "integer" .
+
+ex:Todo.id a owl:DatatypeProperty ;
+ rdfs:label "id" ;
+ rdfs:domain ex:Todo ;
+ rdfs:range xsd:int ;
+ fcx:fidelity "direct" ;
+ fcx:foundryType "integer" .
+
+ex:equipment.equipmentId a owl:DatatypeProperty ;
+ rdfs:label "equipmentId" ;
+ rdfs:comment "The id of an equipment" ;
+ rdfs:domain ex:equipment ;
+ rdfs:range xsd:string ;
+ fcx:fidelity "direct" ;
+ fcx:foundryType "string" .
+
+ex:link.Employee.lead a owl:FunctionalProperty,
+ owl:ObjectProperty ;
+ rdfs:label "Lead" ;
+ rdfs:domain ex:Employee ;
+ rdfs:range ex:Employee ;
+ owl:inverseOf ex:link.Employee.peeps ;
+ fcx:foundryRid "rid.link-type.327" .
+
+ex:link.Employee.officeLink a owl:FunctionalProperty,
+ owl:ObjectProperty ;
+ rdfs:label "Office" ;
+ rdfs:domain ex:Employee ;
+ rdfs:range ex:Office ;
+ owl:inverseOf ex:link.Office.occupants ;
+ fcx:foundryRid "rid.link-type.324" .
+
+ex:link.Employee.peeps a owl:ObjectProperty ;
+ rdfs:label "Peeps" ;
+ rdfs:domain ex:Employee ;
+ rdfs:range ex:Employee ;
+ owl:inverseOf ex:link.Employee.lead ;
+ fcx:foundryRid "rid.link-type.327" .
+
+ex:link.Office.occupants a owl:ObjectProperty ;
+ rdfs:label "Office Occupants" ;
+ rdfs:domain ex:Office ;
+ rdfs:range ex:Employee ;
+ owl:inverseOf ex:link.Employee.officeLink ;
+ fcx:foundryRid "rid.link-type.324" .
+
+ex:objectTypeWithAllPropertyTypes.id a owl:DatatypeProperty ;
+ rdfs:label "id" ;
+ rdfs:domain ex:objectTypeWithAllPropertyTypes ;
+ rdfs:range xsd:int ;
+ fcx:fidelity "direct" ;
+ fcx:foundryType "integer" .
+
+ex:ObjectWithTimestampPrimaryKey a owl:Class ;
+ rdfs:label "ObjectWithTimestampPrimaryKey" ;
+ rdfs:comment "Object Type With Timestamp Primary Key" ;
+ owl:hasKey ( ex:ObjectWithTimestampPrimaryKey.timestamp ) ;
+ skos:altLabel "ObjectWithTimestampPrimaryKeys" ;
+ fcx:foundryRid "ri.ontology.main.object-type.32bb9402-9cab-4705-81bb-edb65a4a6806" ;
+ fcx:titleProperty "value" .
+
+ex:Person a owl:Class ;
+ rdfs:label "Person" ;
+ owl:hasKey ( ex:Person.id ) ;
+ skos:altLabel "Persons" ;
+ fcx:foundryRid "ri.person" ;
+ fcx:titleProperty "name" .
+
+ex:Task a owl:Class ;
+ rdfs:label "Task" ;
+ owl:hasKey ( ex:Task.id ) ;
+ skos:altLabel "Tasks" ;
+ fcx:foundryRid "ri.task" ;
+ fcx:titleProperty "name" .
+
+ex:Todo a owl:Class ;
+ rdfs:label "Todo" ;
+ owl:hasKey ( ex:Todo.id ) ;
+ skos:altLabel "ManyTodo" ;
+ fcx:foundryRid "ri.todo" ;
+ fcx:titleProperty "text" .
+
+ex:equipment a owl:Class ;
+ rdfs:label "Equipment" ;
+ owl:hasKey ( ex:equipment.equipmentId ) ;
+ skos:altLabel "Equipment" ;
+ fcx:foundryRid "ri.ontology.main.object-type.808ac022-89eb-4591-8b7e-1a912b9efb45" ;
+ fcx:titleProperty "type" .
+
+ex:Employee.employeeProfile.Struct a owl:Class ;
+ rdfs:label "employeeProfile struct" ;
+ rdfs:comment "Generated by the crosswalk. A Foundry struct is an inline record on Employee.employeeProfile; OWL has no inline record, so it becomes a class with its own shape." .
+
+ex:BgaoNflPlayer a owl:Class ;
+ rdfs:label "id" ;
+ owl:hasKey ( ex:BgaoNflPlayer.id ) ;
+ skos:altLabel "BgaoNflPlayers" ;
+ fcx:foundryRid "ri.nflplayer" ;
+ fcx:titleProperty "name" .
+
+ex:BgaoNflPlayer.address.Struct a owl:Class ;
+ rdfs:label "address struct" ;
+ rdfs:comment "Generated by the crosswalk. A Foundry struct is an inline record on BgaoNflPlayer.address; OWL has no inline record, so it becomes a class with its own shape." .
+
+ex:BgaoNflPlayer.addressArray.Struct a owl:Class ;
+ rdfs:label "addressArray struct" ;
+ rdfs:comment "Generated by the crosswalk. A Foundry struct is an inline record on BgaoNflPlayer.addressArray; OWL has no inline record, so it becomes a class with its own shape." .
+
+ex:Office a owl:Class ;
+ rdfs:label "Office" ;
+ rdfs:comment "A office in our Company" ;
+ owl:hasKey ( ex:Office.officeId ) ;
+ skos:altLabel "Office" ;
+ fcx:foundryRid "ri.ontology.main.object-type.404ac022-89eb-4591-8b7e-1a912b9efb45" ;
+ fcx:titleProperty "officeId" .
+
+ex:Employee a owl:Class ;
+ rdfs:label "Employee" ;
+ rdfs:comment """A full-time or part-time
+
+ employee of our firm""" ;
+ owl:hasKey ( ex:Employee.employeeId ) ;
+ skos:altLabel "Employees" ;
+ fcx:foundryRid "ri.ontology.main.object-type.401ac022-89eb-4591-8b7e-0a912b9efb44" ;
+ fcx:titleProperty "fullName" .
+
+ex:objectTypeWithAllPropertyTypes a owl:Class ;
+ rdfs:label "objectTypeWithAllPropertyType" ;
+ rdfs:comment "An object type with all property types" ;
+ owl:hasKey ( ex:objectTypeWithAllPropertyTypes.id ) ;
+ skos:altLabel "objectTypeWithAllPropertyTypes" ;
+ fcx:foundryRid "ri.ontology.main.object-type.401ac022-89eb-4591-8b7e-0a912b9efb44" ;
+ fcx:titleProperty "string" .
+
diff --git a/case-studies/foundry-owl-crosswalk/ontology/property-fidelity.svg b/case-studies/foundry-owl-crosswalk/ontology/property-fidelity.svg
new file mode 100644
index 00000000..826a5c7b
--- /dev/null
+++ b/case-studies/foundry-owl-crosswalk/ontology/property-fidelity.svg
@@ -0,0 +1 @@
+<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 470 130" width="470" height="130" role="img"><text x="0" y="21" font-family="system-ui,sans-serif" font-size="12" fill="#1a2b32">Direct XSD counterpart</text><rect x="250" y="10" width="160" height="15" rx="2" fill="#00897b"/><text x="417" y="22" font-family="system-ui,sans-serif" font-size="12" font-weight="600" fill="#5c6670">49</text><text x="0" y="51" font-family="system-ui,sans-serif" font-size="12" fill="#1a2b32">Carried by OGC GeoSPARQL</text><rect x="250" y="40" width="19" height="15" rx="2" fill="#4db6ac"/><text x="276" y="52" font-family="system-ui,sans-serif" font-size="12" font-weight="600" fill="#5c6670">6</text><text x="0" y="81" font-family="system-ui,sans-serif" font-size="12" fill="#1a2b32">Structural, expressed as a shape</text><rect x="250" y="70" width="9" height="15" rx="2" fill="#8c959a"/><text x="266" y="82" font-family="system-ui,sans-serif" font-size="12" font-weight="600" fill="#5c6670">3</text><text x="0" y="111" font-family="system-ui,sans-serif" font-size="12" fill="#1a2b32">No counterpart in any standard</text><rect x="250" y="100" width="32" height="15" rx="2" fill="#b45309"/><text x="289" y="112" font-family="system-ui,sans-serif" font-size="12" font-weight="600" fill="#5c6670">10</text></svg>
diff --git a/case-studies/foundry-owl-crosswalk/ontology/type-system-fidelity.svg b/case-studies/foundry-owl-crosswalk/ontology/type-system-fidelity.svg
new file mode 100644
index 00000000..d2dcb726
--- /dev/null
+++ b/case-studies/foundry-owl-crosswalk/ontology/type-system-fidelity.svg
@@ -0,0 +1 @@
+<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 470 130" width="470" height="130" role="img"><text x="0" y="21" font-family="system-ui,sans-serif" font-size="12" fill="#1a2b32">Direct XSD counterpart</text><rect x="250" y="10" width="160" height="15" rx="2" fill="#00897b"/><text x="417" y="22" font-family="system-ui,sans-serif" font-size="12" font-weight="600" fill="#5c6670">11</text><text x="0" y="51" font-family="system-ui,sans-serif" font-size="12" fill="#1a2b32">Carried by OGC GeoSPARQL</text><rect x="250" y="40" width="29" height="15" rx="2" fill="#4db6ac"/><text x="286" y="52" font-family="system-ui,sans-serif" font-size="12" font-weight="600" fill="#5c6670">2</text><text x="0" y="81" font-family="system-ui,sans-serif" font-size="12" fill="#1a2b32">Structural, expressed as a shape</text><rect x="250" y="70" width="29" height="15" rx="2" fill="#8c959a"/><text x="286" y="82" font-family="system-ui,sans-serif" font-size="12" font-weight="600" fill="#5c6670">2</text><text x="0" y="111" font-family="system-ui,sans-serif" font-size="12" fill="#1a2b32">No counterpart in any standard</text><rect x="250" y="100" width="101" height="15" rx="2" fill="#b45309"/><text x="358" y="112" font-family="system-ui,sans-serif" font-size="12" font-weight="600" fill="#5c6670">7</text></svg>
diff --git a/case-studies/foundry-owl-crosswalk/owl_to_foundry.py b/case-studies/foundry-owl-crosswalk/owl_to_foundry.py
new file mode 100644
index 00000000..ec88f9c2
--- /dev/null
+++ b/case-studies/foundry-owl-crosswalk/owl_to_foundry.py
@@ -0,0 +1,152 @@
+"""Audit the other direction: which OWL axioms have a destination in Foundry?
+
+The Foundry to OWL direction loses behaviour and security. The OWL to Foundry
+direction loses something else, and the loss is easy to miss because it is
+invisible in the resulting object graph: the axioms that let a reasoner detect
+a contradiction have nowhere to go.
+
+This module takes a real ontology, counts the axioms it actually asserts, and
+checks each construct against the destination fields that exist in Palantir's
+own published ontology model. The verdict per construct is one of:
+
+ carried a Foundry field holds the same meaning
+ partial a Foundry field holds a weaker version of it
+ none no field in the Foundry ontology model can hold it
+"""
+from __future__ import annotations
+
+import json
+import pathlib
+import sys
+
+from rdflib import OWL, RDF, RDFS, Graph, URIRef
+
+HERE = pathlib.Path(__file__).parent
+SHACL = URIRef("http://www.w3.org/ns/shacl#")
+
+CARRIED = "carried"
+PARTIAL = "partial"
+NONE = "none"
+
+# Destination is quoted from the field names in
+# palantir/foundry-platform-python foundry_sdk/v2/ontologies/models.py.
+DESTINATIONS: dict[URIRef, tuple[str, str, str]] = {
+ OWL.Class: (CARRIED, "ObjectTypeV2 / InterfaceType", "A class becomes an object type or an interface."),
+ OWL.DatatypeProperty: (PARTIAL, "PropertyV2.dataType", "Carried only when the range maps to a Foundry property type."),
+ OWL.ObjectProperty: (CARRIED, "LinkTypeSideV2", "A link between two object types."),
+ OWL.AnnotationProperty: (PARTIAL, "PropertyV2.description / typeClasses", "Free text survives; a typed annotation does not."),
+ RDFS.domain: (CARRIED, "ObjectTypeV2.properties", "A property belongs to the object type that declares it."),
+ RDFS.range: (PARTIAL, "PropertyV2.dataType / LinkTypeSideV2.objectTypeApiName", "Carried for the types in the Foundry union only."),
+ RDFS.label: (CARRIED, "displayName", ""),
+ RDFS.comment: (CARRIED, "description", ""),
+ OWL.inverseOf: (CARRIED, "LinkTypeSideV2.linkTypeRid", "Two link sides sharing a rid are inverse."),
+ OWL.FunctionalProperty: (PARTIAL, "LinkTypeSideV2.cardinality = ONE", "Carried for links; a functional datatype property has no field."),
+ OWL.hasKey: (PARTIAL, "ObjectTypeV2.primaryKey", "primaryKey is one property, so a composite key has no destination."),
+ RDFS.subClassOf: (PARTIAL, "InterfaceType.extendsInterfaces / implementsInterfaces", "Interfaces may extend interfaces. One object type may not subclass another."),
+ OWL.equivalentClass: (NONE, "", "No field asserts that two types have the same members."),
+ OWL.disjointWith: (NONE, "", "No field asserts that two types cannot share a member."),
+ OWL.AllDisjointClasses: (NONE, "", "No field asserts mutual disjointness."),
+ OWL.Restriction: (NONE, "", "No field carries a class defined by a condition on a property."),
+ OWL.someValuesFrom: (NONE, "", "Existential restriction has no Foundry field."),
+ OWL.allValuesFrom: (NONE, "", "Universal restriction has no Foundry field."),
+ OWL.hasValue: (NONE, "", "Value restriction has no Foundry field."),
+ OWL.cardinality: (NONE, "", "Exact cardinality on a property has no Foundry field."),
+ OWL.minCardinality: (NONE, "", "Minimum cardinality has no Foundry field."),
+ OWL.maxCardinality: (NONE, "", "Maximum cardinality on a property has no Foundry field."),
+ OWL.minQualifiedCardinality: (NONE, "", "Qualified cardinality has no Foundry field."),
+ OWL.maxQualifiedCardinality: (NONE, "", "Qualified cardinality has no Foundry field."),
+ OWL.qualifiedCardinality: (NONE, "", "Qualified cardinality has no Foundry field."),
+ OWL.TransitiveProperty: (NONE, "", "No field declares a property transitive."),
+ OWL.SymmetricProperty: (NONE, "", "No field declares a property symmetric."),
+ OWL.AsymmetricProperty: (NONE, "", "No field declares a property asymmetric."),
+ OWL.ReflexiveProperty: (NONE, "", "No field declares a property reflexive."),
+ OWL.IrreflexiveProperty: (NONE, "", "No field declares a property irreflexive."),
+ OWL.InverseFunctionalProperty: (NONE, "", "No field declares a property inverse functional."),
+ OWL.propertyChainAxiom: (NONE, "", "No field composes properties."),
+ RDFS.subPropertyOf: (NONE, "", "No field arranges properties in a hierarchy."),
+ OWL.unionOf: (NONE, "", "No field defines a class as a union."),
+ OWL.intersectionOf: (NONE, "", "No field defines a class as an intersection."),
+ OWL.complementOf: (NONE, "", "No field defines a class as a complement."),
+ OWL.oneOf: (NONE, "", "No field defines a class by enumeration."),
+ OWL.disjointUnionOf: (NONE, "", "No field defines a disjoint union."),
+ OWL.sameAs: (NONE, "", "No field asserts two individuals are the same."),
+ OWL.differentFrom: (NONE, "", "No field asserts two individuals differ."),
+ OWL.AllDifferent: (NONE, "", "No field asserts mutual difference."),
+ OWL.NegativePropertyAssertion: (NONE, "", "No field asserts that a statement is false."),
+ OWL.withRestrictions: (NONE, "", "No field carries a datatype restriction."),
+ OWL.onDatatype: (NONE, "", "No field carries a derived datatype."),
+}
+
+
+def count_constructs(graph: Graph) -> dict[URIRef, int]:
+ """Count how often each construct is actually asserted in the ontology."""
+ counts: dict[URIRef, int] = {}
+ for construct in DESTINATIONS:
+ # A construct is used either as a predicate or as the object of rdf:type.
+ as_predicate = sum(1 for _ in graph.triples((None, construct, None)))
+ as_type = sum(1 for _ in graph.triples((None, RDF.type, construct)))
+ total = as_predicate + as_type
+ if total:
+ counts[construct] = total
+ return counts
+
+
+def audit(graph: Graph, name: str) -> dict:
+ counts = count_constructs(graph)
+ rows = []
+ for construct, count in sorted(counts.items(), key=lambda item: -item[1]):
+ verdict, destination, note = DESTINATIONS[construct]
+ rows.append(
+ {
+ "construct": graph.namespace_manager.normalizeUri(construct),
+ "assertions": count,
+ "verdict": verdict,
+ "foundryDestination": destination,
+ "note": note,
+ }
+ )
+ totals: dict[str, int] = {}
+ axioms: dict[str, int] = {}
+ for row in rows:
+ totals[row["verdict"]] = totals.get(row["verdict"], 0) + 1
+ axioms[row["verdict"]] = axioms.get(row["verdict"], 0) + row["assertions"]
+ return {
+ "ontology": name,
+ "triples": len(graph),
+ "constructsUsed": len(rows),
+ "constructsByVerdict": totals,
+ "assertionsByVerdict": axioms,
+ "rows": rows,
+ }
+
+
+def main() -> None:
+ targets = sys.argv[1:] or [
+ str(HERE.parents[1] / "benchmark" / "reference" / "ies4.ttl"),
+ str(HERE.parents[1] / "benchmark" / "reference" / "pizza-reference.owl"),
+ ]
+ results = []
+ for target in targets:
+ path = pathlib.Path(target)
+ if not path.exists():
+ print(f"skipped, not found: {path}")
+ continue
+ graph = Graph()
+ graph.parse(path)
+ result = audit(graph, path.name)
+ results.append(result)
+ by_verdict = result["assertionsByVerdict"]
+ print(
+ f"{path.name}: {result['triples']} triples, "
+ f"{result['constructsUsed']} constructs used, "
+ f"axioms carried {by_verdict.get(CARRIED, 0)}, "
+ f"partial {by_verdict.get(PARTIAL, 0)}, "
+ f"no destination {by_verdict.get(NONE, 0)}"
+ )
+ (HERE / "data" / "owl-to-foundry-audit.json").write_text(
+ json.dumps({"audits": results}, indent=2) + "\n"
+ )
+
+
+if __name__ == "__main__":
+ main()
diff --git a/case-studies/foundry-owl-crosswalk/test_crosswalk.py b/case-studies/foundry-owl-crosswalk/test_crosswalk.py
new file mode 100644
index 00000000..7138922e
--- /dev/null
+++ b/case-studies/foundry-owl-crosswalk/test_crosswalk.py
@@ -0,0 +1,241 @@
+"""Tests for the Foundry to OWL crosswalk.
+
+Every number quoted in the case study is produced by this file or by the
+report the crosswalk writes. Nothing is typed twice.
+"""
+from __future__ import annotations
+
+import json
+import pathlib
+import subprocess
+import sys
+
+import pytest
+from rdflib import RDF, RDFS, XSD, Graph, Literal, OWL, URIRef
+
+sys.path.insert(0, str(pathlib.Path(__file__).parent))
+from foundry_owl import ( # noqa: E402
+ DIRECT,
+ EX,
+ FCX,
+ NONE,
+ SH,
+ STANDARD,
+ STRUCTURAL,
+ TYPE_MAP,
+ Crosswalk,
+ crosswalk_file,
+)
+
+HERE = pathlib.Path(__file__).parent
+FIXTURE = HERE / "data" / "foundry-ontology.json"
+TYPE_SYSTEM = HERE / "data" / "foundry-type-system.json"
+
+
[email protected](scope="module")
+def crosswalked():
+ return crosswalk_file(FIXTURE)
+
+
[email protected](scope="module")
+def graph(crosswalked):
+ return crosswalked[0]
+
+
[email protected](scope="module")
+def report(crosswalked):
+ return crosswalked[1]
+
+
+# -- the gate on Palantir's own type system --------------------------------
+
+def test_type_map_covers_palantir_type_system_exactly():
+ """If Palantir adds or removes a property type, this fails rather than
+ silently dropping the new type into the unmappable bucket."""
+ declared = {
+ entry["discriminator"]
+ for entry in json.loads(TYPE_SYSTEM.read_text())["types"]
+ }
+ assert declared == set(TYPE_MAP), (
+ f"in Palantir but not mapped: {sorted(declared - set(TYPE_MAP))}; "
+ f"mapped but not in Palantir: {sorted(set(TYPE_MAP) - declared)}"
+ )
+
+
+def test_type_system_size_is_twenty_two():
+ assert json.loads(TYPE_SYSTEM.read_text())["count"] == 22
+
+
+def test_fidelity_split_is_eleven_two_two_seven():
+ """The headline claim about the type system, asserted against the map."""
+ counts: dict[str, int] = {}
+ for mapping in TYPE_MAP.values():
+ counts[mapping.fidelity] = counts.get(mapping.fidelity, 0) + 1
+ assert counts == {DIRECT: 11, STANDARD: 2, STRUCTURAL: 2, NONE: 7}
+
+
+def test_every_direct_type_targets_xsd():
+ for name, mapping in TYPE_MAP.items():
+ if mapping.fidelity == DIRECT:
+ assert mapping.target is not None, name
+ assert str(mapping.target).startswith(str(XSD)), name
+
+
+def test_no_none_fidelity_type_has_a_target():
+ for name, mapping in TYPE_MAP.items():
+ if mapping.fidelity == NONE:
+ assert mapping.target is None, name
+
+
+# -- the output graph ------------------------------------------------------
+
+def test_graph_parses_and_is_non_trivial(graph):
+ assert len(graph) > 500
+
+
+def test_every_object_type_became_a_class(graph, report):
+ classes = set(graph.subjects(RDF.type, OWL.Class))
+ metadata = json.loads(FIXTURE.read_text())
+ for api_name in metadata["objectTypes"]:
+ assert EX[api_name] in classes, api_name
+ assert report.object_types == len(metadata["objectTypes"])
+
+
+def test_primary_key_became_an_owl_key(graph, report):
+ metadata = json.loads(FIXTURE.read_text())
+ assert report.keys == len(metadata["objectTypes"])
+ for api_name in metadata["objectTypes"]:
+ assert (EX[api_name], OWL.hasKey, None) in graph, api_name
+
+
+def test_cardinality_one_link_is_functional_and_capped(graph):
+ """Employee.lead has cardinality ONE in Palantir's fixture."""
+ lead = EX["link.Employee.lead"]
+ assert (lead, RDF.type, OWL.FunctionalProperty) in graph
+ shapes = [
+ shape
+ for shape in graph.subjects(SH.path, lead)
+ ]
+ assert shapes, "no property shape for the lead link"
+ assert any((shape, SH.maxCount, Literal(1)) in graph for shape in shapes)
+
+
+def test_cardinality_many_link_is_not_capped(graph):
+ peeps = EX["link.Employee.peeps"]
+ assert (peeps, RDF.type, OWL.FunctionalProperty) not in graph
+ for shape in graph.subjects(SH.path, peeps):
+ assert (shape, SH.maxCount, Literal(1)) not in graph
+
+
+def test_link_sides_sharing_a_rid_became_inverses(graph, report):
+ assert report.inverse_pairs == 2
+ assert (EX["link.Office.occupants"], OWL.inverseOf, EX["link.Employee.officeLink"]) in graph
+
+
+def test_interface_extension_became_subclass(graph):
+ metadata = json.loads(FIXTURE.read_text())
+ extending = [
+ (name, interface["extendsInterfaces"])
+ for name, interface in metadata["interfaceTypes"].items()
+ if interface.get("extendsInterfaces")
+ ]
+ for name, parents in extending:
+ for parent in parents:
+ assert (EX[name], RDFS.subClassOf, EX[parent]) in graph
+
+
+def test_array_property_has_no_max_count(graph):
+ array_property = EX["objectTypeWithAllPropertyTypes.stringArray"]
+ assert (array_property, RDFS.range, XSD.string) in graph
+ for shape in graph.subjects(SH.path, array_property):
+ assert (shape, SH.maxCount, Literal(1)) not in graph
+
+
+def test_struct_property_became_an_object_property_with_a_class(graph):
+ struct_property = EX["Employee.employeeProfile"]
+ assert (struct_property, RDF.type, OWL.ObjectProperty) in graph
+ struct_class = EX["Employee.employeeProfile.Struct"]
+ assert (struct_property, RDFS.range, struct_class) in graph
+ assert (struct_class, RDF.type, OWL.Class) in graph
+ assert (EX["Employee.employeeProfile.yearsExperience"], RDFS.range, XSD.int) in graph
+
+
+# -- the loss, which is the point ------------------------------------------
+
+def test_unmappable_properties_are_marked_not_silently_typed(graph, report):
+ """A property the crosswalk cannot carry must never acquire a range."""
+ unmappable = set(graph.subjects(FCX.unmappable, Literal(True)))
+ assert unmappable, "expected some properties to be unmappable"
+ for subject in unmappable:
+ assert (subject, RDFS.range, None) not in graph, subject
+ assert len(unmappable) == len(report.lossy_properties)
+
+
+def test_marking_property_is_reported_as_a_security_loss(report):
+ """Palantir's exhaustive fixture does not include a marking property, so
+ the mapping is asserted directly: a security marking must never be given a
+ datatype range, because that would present a classification as data."""
+ assert TYPE_MAP["marking"].fidelity == NONE
+ assert TYPE_MAP["marking"].target is None
+ assert "access control" in TYPE_MAP["marking"].note
+
+
+def test_a_marking_property_survives_as_a_flagged_loss():
+ """Inject a marking property and confirm it lands in the loss report."""
+ metadata = json.loads(FIXTURE.read_text())
+ employee = metadata["objectTypes"]["Employee"]["objectType"]
+ employee["properties"]["clearance"] = {
+ "dataType": {"type": "marking"},
+ "rid": "ri.property.marking",
+ "typeClasses": [],
+ }
+ _, injected = Crosswalk(metadata).run()
+ flagged = [
+ entry for entry in injected.lossyProperties_or_empty()
+ if entry["property"] == "clearance"
+ ] if hasattr(injected, "lossyProperties_or_empty") else [
+ entry for entry in injected.lossy_properties if entry["property"] == "clearance"
+ ]
+ assert len(flagged) == 1
+ assert flagged[0]["foundryType"] == "marking"
+
+
+def test_behavioural_constructs_are_recorded_as_absent(report):
+ constructs = {entry["construct"] for entry in report.dropped_constructs}
+ assert {"actionType", "queryType", "valueType"} <= constructs
+
+
+def test_report_totals_match_the_fixture(report):
+ metadata = json.loads(FIXTURE.read_text())
+ properties = sum(
+ len(entry["objectType"]["properties"]) for entry in metadata["objectTypes"].values()
+ )
+ assert report.properties == properties
+ assert sum(report.by_fidelity.values()) == properties
+
+
+# -- proof that the gate bites ---------------------------------------------
+
+def test_tampering_with_the_type_map_fails_the_gate(tmp_path):
+ """Remove one type from the map and the coverage gate must fail. This is
+ the evidence that the gate is load-bearing rather than decorative."""
+ source = (HERE / "foundry_owl.py").read_text()
+ tampered = source.replace(
+ ' "vector": TypeMapping(', ' "_removed_vector": TypeMapping(', 1
+ )
+ assert tampered != source
+ module_path = tmp_path / "foundry_owl.py"
+ module_path.write_text(tampered)
+ (tmp_path / "data").mkdir()
+ (tmp_path / "data" / "foundry-type-system.json").write_text(TYPE_SYSTEM.read_text())
+ probe = tmp_path / "probe.py"
+ probe.write_text(
+ "import json, sys, pathlib\n"
+ "sys.path.insert(0, str(pathlib.Path(__file__).parent))\n"
+ "from foundry_owl import TYPE_MAP\n"
+ "declared = {e['discriminator'] for e in json.loads("
+ "(pathlib.Path(__file__).parent / 'data' / 'foundry-type-system.json').read_text())['types']}\n"
+ "sys.exit(0 if declared == set(TYPE_MAP) else 1)\n"
+ )
+ result = subprocess.run([sys.executable, str(probe)], capture_output=True)
+ assert result.returncode == 1, "the coverage gate passed on a tampered type map"
diff --git a/case-studies/foundry-owl-crosswalk/vendor/core_models.py b/case-studies/foundry-owl-crosswalk/vendor/core_models.py
new file mode 100644
index 00000000..264e0e92
--- /dev/null
+++ b/case-studies/foundry-owl-crosswalk/vendor/core_models.py
@@ -0,0 +1,1098 @@
+# Copyright 2024 Palantir Technologies, Inc.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+
+from __future__ import annotations
+
+import typing
+
+import pydantic
+import typing_extensions
+
+from foundry_sdk import _core as core
+
+
+class AnyType(core.ModelBase):
+ """AnyType"""
+
+ type: typing.Literal["any"] = "any"
+
+
+class ArrayFieldType(core.ModelBase):
+ """ArrayFieldType"""
+
+ items_schema: FieldSchema = pydantic.Field(alias=str("itemsSchema")) # type: ignore[literal-required]
+ type: typing.Literal["array"] = "array"
+
+
+class AttachmentType(core.ModelBase):
+ """AttachmentType"""
+
+ type: typing.Literal["attachment"] = "attachment"
+
+
+Attribution: typing_extensions.TypeAlias = str
+"""Attribution for a request"""
+
+
+class BinaryType(core.ModelBase):
+ """BinaryType"""
+
+ type: typing.Literal["binary"] = "binary"
+
+
+class BooleanType(core.ModelBase):
+ """BooleanType"""
+
+ type: typing.Literal["boolean"] = "boolean"
+
+
+class BranchMetadata(core.ModelBase):
+ """Metadata about a Foundry branch."""
+
+ rid: FoundryBranch
+
+
+BranchName: typing_extensions.TypeAlias = str
+"""The name of a Branch."""
+
+
+BuildRid: typing_extensions.TypeAlias = core.RID
+"""The RID of a Build."""
+
+
+class ByteType(core.ModelBase):
+ """ByteType"""
+
+ type: typing.Literal["byte"] = "byte"
+
+
+CheckReportRid: typing_extensions.TypeAlias = core.RID
+"""The unique resource identifier (RID) of a Data Health Check Report."""
+
+
+CheckRid: typing_extensions.TypeAlias = core.RID
+"""The unique resource identifier (RID) of a Data Health Check."""
+
+
+class CipherTextType(core.ModelBase):
+ """CipherTextType"""
+
+ default_cipher_channel: typing.Optional[core.RID] = pydantic.Field(alias=str("defaultCipherChannel"), default=None) # type: ignore[literal-required]
+ """An optional Cipher Channel RID which can be used for encryption updates to empty values."""
+
+ type: typing.Literal["cipherText"] = "cipherText"
+
+
+Color: typing_extensions.TypeAlias = str
+"""The hex value of a color."""
+
+
+ColumnName: typing_extensions.TypeAlias = str
+"""The name of a column in a dataset."""
+
+
+ComputeSeconds: typing_extensions.TypeAlias = float
+"""A measurement of compute usage expressed in [compute-seconds](https://palantir.com/docs/foundry/resource-management/usage-types#compute-second). For more information, please refer to the [Usage types](https://palantir.com/docs/foundry/resource-management/usage-types) documentation."""
+
+
+ContentLength: typing_extensions.TypeAlias = core.Long
+"""ContentLength"""
+
+
+ContentType: typing_extensions.TypeAlias = str
+"""ContentType"""
+
+
+CreatedTime: typing_extensions.TypeAlias = core.AwareDatetime
+"""The time at which the resource was created."""
+
+
+CustomMetadata: typing_extensions.TypeAlias = typing.Dict[str, typing.Any]
+"""CustomMetadata"""
+
+
+class DatasetFieldSchema(core.ModelBase):
+ """A field in a Foundry dataset."""
+
+ type: SchemaFieldType
+ name: typing.Optional[FieldName] = None
+ """The name of a column. May be absent in nested schema objects."""
+
+ nullable: bool
+ """Indicates whether values of this field may be null."""
+
+ user_defined_type_class: typing.Optional[str] = pydantic.Field(alias=str("userDefinedTypeClass"), default=None) # type: ignore[literal-required]
+ """Canonical classname of the user-defined type for this field. This should be a subclass of Spark's `UserDefinedType`."""
+
+ custom_metadata: typing.Optional[CustomMetadata] = pydantic.Field(alias=str("customMetadata"), default=None) # type: ignore[literal-required]
+ """User-supplied custom metadata about the column, such as Foundry web archetypes, descriptions, etc."""
+
+ array_subtype: typing.Optional[DatasetFieldSchema] = pydantic.Field(alias=str("arraySubtype"), default=None) # type: ignore[literal-required]
+ """Only used when field type is array."""
+
+ precision: typing.Optional[int] = None
+ """Only used when field type is decimal."""
+
+ scale: typing.Optional[int] = None
+ """Only used when field type is decimal."""
+
+ map_key_type: typing.Optional[DatasetFieldSchema] = pydantic.Field(alias=str("mapKeyType"), default=None) # type: ignore[literal-required]
+ """Only used when field type is map."""
+
+ map_value_type: typing.Optional[DatasetFieldSchema] = pydantic.Field(alias=str("mapValueType"), default=None) # type: ignore[literal-required]
+ """Only used when field type is map."""
+
+ sub_schemas: typing.Optional[typing.List[DatasetFieldSchema]] = pydantic.Field(alias=str("subSchemas"), default=None) # type: ignore[literal-required]
+ """Only used when field type is struct."""
+
+
+DatasetRid: typing_extensions.TypeAlias = core.RID
+"""The Resource Identifier (RID) of a Dataset."""
+
+
+class DatasetSchema(core.ModelBase):
+ """The schema for a Foundry dataset. Files uploaded to this dataset must match this schema."""
+
+ field_schema_list: typing.List[DatasetFieldSchema] = pydantic.Field(alias=str("fieldSchemaList")) # type: ignore[literal-required]
+
+
+class DateType(core.ModelBase):
+ """DateType"""
+
+ type: typing.Literal["date"] = "date"
+
+
+class DecimalType(core.ModelBase):
+ """DecimalType"""
+
+ precision: typing.Optional[int] = None
+ """The total number of digits of the Decimal type. The maximum value is 38."""
+
+ scale: typing.Optional[int] = None
+ """The number of digits to the right of the decimal point. The maximum value is 38."""
+
+ type: typing.Literal["decimal"] = "decimal"
+
+
+DisplayName: typing_extensions.TypeAlias = str
+"""The display name of the entity."""
+
+
+class Distance(core.ModelBase):
+ """A measurement of distance."""
+
+ value: float
+ unit: DistanceUnit
+
+
+DistanceUnit: typing_extensions.TypeAlias = typing.Literal[
+ "MILLIMETERS",
+ "CENTIMETERS",
+ "METERS",
+ "KILOMETERS",
+ "INCHES",
+ "FEET",
+ "YARDS",
+ "MILES",
+ "NAUTICAL_MILES",
+]
+"""DistanceUnit"""
+
+
+class DoubleType(core.ModelBase):
+ """DoubleType"""
+
+ type: typing.Literal["double"] = "double"
+
+
+class Duration(core.ModelBase):
+ """A measurement of duration."""
+
+ value: int
+ """The duration value."""
+
+ unit: TimeUnit
+ """The unit of duration."""
+
+
+DurationSeconds: typing_extensions.TypeAlias = core.Long
+"""A duration of time measured in seconds."""
+
+
+EmbeddingModel: typing_extensions.TypeAlias = typing_extensions.Annotated[
+ typing.Union["LmsEmbeddingModel", "FoundryLiveDeployment"], pydantic.Field(discriminator="type")
+]
+"""EmbeddingModel"""
+
+
+EnrollmentRid: typing_extensions.TypeAlias = core.RID
+"""EnrollmentRid"""
+
+
+class Field(core.ModelBase):
+ """
+ A field in a Foundry schema. For more information on supported data types, see the
+ [supported field types](https://palantir.com/docs/foundry/data-integration/datasets/#supported-field-types) user documentation.
+ """
+
+ name: FieldName
+ schema_: FieldSchema = pydantic.Field(alias=str("schema")) # type: ignore[literal-required]
+
+
+FieldDataType: typing_extensions.TypeAlias = typing_extensions.Annotated[
+ typing.Union[
+ "StructFieldType",
+ "DateType",
+ "StringType",
+ "ByteType",
+ "DoubleType",
+ "IntegerType",
+ "FloatType",
+ "LongType",
+ "BooleanType",
+ "ArrayFieldType",
+ "BinaryType",
+ "ShortType",
+ "DecimalType",
+ "MapFieldType",
+ "TimestampType",
+ ],
+ pydantic.Field(discriminator="type"),
+]
+"""FieldDataType"""
+
+
+FieldName: typing_extensions.TypeAlias = str
+"""FieldName"""
+
+
+class FieldSchema(core.ModelBase):
+ """The specification of the type of a Foundry schema field."""
+
+ nullable: bool
+ custom_metadata: typing.Optional[CustomMetadata] = pydantic.Field(alias=str("customMetadata"), default=None) # type: ignore[literal-required]
+ data_type: FieldDataType = pydantic.Field(alias=str("dataType")) # type: ignore[literal-required]
+
+
+FilePath: typing_extensions.TypeAlias = str
+"""
+The path to a File within Foundry. Paths are relative and must not start with a leading slash.
+Examples: `my-file.txt`, `path/to/my-file.jpg`, `dataframe.snappy.parquet`.
+"""
+
+
+Filename: typing_extensions.TypeAlias = str
+"""The name of a File within Foundry. Examples: `my-file.txt`, `my-file.jpg`, `dataframe.snappy.parquet`."""
+
+
+class FilterBinaryType(core.ModelBase):
+ """FilterBinaryType"""
+
+ type: typing.Literal["binary"] = "binary"
+
+
+class FilterBooleanType(core.ModelBase):
+ """FilterBooleanType"""
+
+ type: typing.Literal["boolean"] = "boolean"
+
+
+class FilterDateTimeType(core.ModelBase):
+ """FilterDateTimeType"""
+
+ type: typing.Literal["dateTime"] = "dateTime"
+
+
+class FilterDateType(core.ModelBase):
+ """FilterDateType"""
+
+ type: typing.Literal["date"] = "date"
+
+
+class FilterDoubleType(core.ModelBase):
+ """FilterDoubleType"""
+
+ type: typing.Literal["double"] = "double"
+
+
+class FilterEnumType(core.ModelBase):
+ """FilterEnumType"""
+
+ values: typing.List[str]
+ """The values allowed by the enum type."""
+
+ type: typing.Literal["enum"] = "enum"
+
+
+class FilterFloatType(core.ModelBase):
+ """FilterFloatType"""
+
+ type: typing.Literal["float"] = "float"
+
+
+class FilterIntegerType(core.ModelBase):
+ """FilterIntegerType"""
+
+ type: typing.Literal["integer"] = "integer"
+
+
+class FilterLongType(core.ModelBase):
+ """FilterLongType"""
+
+ type: typing.Literal["long"] = "long"
+
+
+class FilterRidType(core.ModelBase):
+ """FilterRidType"""
+
+ type: typing.Literal["rid"] = "rid"
+
+
+class FilterStringType(core.ModelBase):
+ """FilterStringType"""
+
+ type: typing.Literal["string"] = "string"
+
+
+FilterType: typing_extensions.TypeAlias = typing_extensions.Annotated[
+ typing.Union[
+ "FilterDateTimeType",
+ "FilterDateType",
+ "FilterBooleanType",
+ "FilterStringType",
+ "FilterDoubleType",
+ "FilterBinaryType",
+ "FilterIntegerType",
+ "FilterFloatType",
+ "FilterRidType",
+ "FilterUuidType",
+ "FilterEnumType",
+ "FilterLongType",
+ ],
+ pydantic.Field(discriminator="type"),
+]
+"""FilterType"""
+
+
+class FilterUuidType(core.ModelBase):
+ """FilterUuidType"""
+
+ type: typing.Literal["uuid"] = "uuid"
+
+
+class FloatType(core.ModelBase):
+ """FloatType"""
+
+ type: typing.Literal["float"] = "float"
+
+
+FolderRid: typing_extensions.TypeAlias = core.RID
+"""FolderRid"""
+
+
+FoundryBranch: typing_extensions.TypeAlias = str
+"""The Foundry branch identifier, specifically its rid. Different identifier types may be used in the future as values."""
+
+
+class FoundryLiveDeployment(core.ModelBase):
+ """FoundryLiveDeployment"""
+
+ rid: typing.Optional[core.RID] = None
+ """The live deployment identifier. This rid is of the format 'ri.foundry-ml-live.main.live-deployment.<uuid>'."""
+
+ input_param_name: typing.Optional[str] = pydantic.Field(alias=str("inputParamName"), default=None) # type: ignore[literal-required]
+ """The name of the input parameter to the model which should contain the query string."""
+
+ output_param_name: typing.Optional[str] = pydantic.Field(alias=str("outputParamName"), default=None) # type: ignore[literal-required]
+ """The name of the output parameter to the model which should contain the computed embedding."""
+
+ type: typing.Literal["foundryLiveDeployment"] = "foundryLiveDeployment"
+
+
+class FullRowChangeDataCaptureConfiguration(core.ModelBase):
+ """
+ Configuration for change data capture which resolves the latest state of the dataset based on new full rows
+ being pushed to the stream. For example, if a value for a row is updated, it is only sufficient to publish
+ the entire new state of that row to the stream.
+ """
+
+ deletion_field_name: FieldName = pydantic.Field(alias=str("deletionFieldName")) # type: ignore[literal-required]
+ """The name of a boolean field in the schema that indicates whether or not a row has been deleted."""
+
+ ordering_field_name: FieldName = pydantic.Field(alias=str("orderingFieldName")) # type: ignore[literal-required]
+ """
+ The name of an ordering field that determines the newest state for a row in the dataset.
+
+ The ordering field can only be of the following types:
+ - Byte
+ - Date
+ - Decimal
+ - Integer
+ - Long
+ - Short
+ - String
+ - Timestamp
+ """
+
+ type: typing.Literal["fullRow"] = "fullRow"
+
+
+class GeoPointType(core.ModelBase):
+ """GeoPointType"""
+
+ type: typing.Literal["geopoint"] = "geopoint"
+
+
+class GeoShapeType(core.ModelBase):
+ """GeoShapeType"""
+
+ type: typing.Literal["geoshape"] = "geoshape"
+
+
+class GeohashType(core.ModelBase):
+ """GeohashType"""
+
+ type: typing.Literal["geohash"] = "geohash"
+
+
+class GeotimeSeriesReferenceType(core.ModelBase):
+ """GeotimeSeriesReferenceType"""
+
+ type: typing.Literal["geotimeSeriesReference"] = "geotimeSeriesReference"
+
+
+GroupId: typing_extensions.TypeAlias = core.UUID
+"""A Foundry Group ID."""
+
+
+GroupName: typing_extensions.TypeAlias = str
+"""The display name of a multipass group."""
+
+
+GroupRid: typing_extensions.TypeAlias = core.RID
+"""The unique resource identifier (RID) of a multipass group."""
+
+
+IncludeComputeUsage: typing_extensions.TypeAlias = bool
+"""
+Indicates whether the response should include compute usage details for the request. This feature is currently
+only available for OSDK applications.
+Note: Enabling this flag may slow down query performance and is not recommended for use in production.
+"""
+
+
+class IntegerType(core.ModelBase):
+ """IntegerType"""
+
+ type: typing.Literal["integer"] = "integer"
+
+
+JobRid: typing_extensions.TypeAlias = core.RID
+"""The RID of a Job."""
+
+
+class LmsEmbeddingModel(core.ModelBase):
+ """A model provided by Language Model Service."""
+
+ value: LmsEmbeddingModelValue
+ type: typing.Literal["lms"] = "lms"
+
+
+LmsEmbeddingModelValue: typing_extensions.TypeAlias = typing.Literal[
+ "OPENAI_TEXT_EMBEDDING_ADA_002",
+ "TEXT_EMBEDDING_3_LARGE",
+ "TEXT_EMBEDDING_3_SMALL",
+ "SNOWFLAKE_ARCTIC_EMBED_M",
+ "INSTRUCTOR_LARGE",
+ "BGE_BASE_EN_V1_5",
+]
+"""LmsEmbeddingModelValue"""
+
+
+class LongType(core.ModelBase):
+ """LongType"""
+
+ type: typing.Literal["long"] = "long"
+
+
+class MapFieldType(core.ModelBase):
+ """MapFieldType"""
+
+ key_schema: FieldSchema = pydantic.Field(alias=str("keySchema")) # type: ignore[literal-required]
+ value_schema: FieldSchema = pydantic.Field(alias=str("valueSchema")) # type: ignore[literal-required]
+ type: typing.Literal["map"] = "map"
+
+
+MarkingId: typing_extensions.TypeAlias = str
+"""The ID of a security marking."""
+
+
+class MarkingType(core.ModelBase):
+ """MarkingType"""
+
+ marking_type: typing.Optional[MarkingTypeValue] = pydantic.Field(alias=str("markingType"), default=None) # type: ignore[literal-required]
+ type: typing.Literal["marking"] = "marking"
+
+
+MarkingTypeValue: typing_extensions.TypeAlias = typing.Literal["CBAC", "MANDATORY"]
+"""
+The kind of marking applied by a marking property type.
+- `CBAC`: Classification-based access control markings.
+- `MANDATORY`: Standard non-classification markings. Example - Organizations.
+"""
+
+
+MediaItemPath: typing_extensions.TypeAlias = str
+"""
+A user-specified identifier for a media item within a media set.
+Paths must be less than 256 characters long.
+If multiple items are written to the same media set at the same path, then when retrieving by path the media
+item which was written last is returned.
+"""
+
+
+MediaItemReadToken: typing_extensions.TypeAlias = str
+"""A token that grants access to read specific media items."""
+
+
+MediaItemRid: typing_extensions.TypeAlias = core.RID
+"""The Resource Identifier (RID) of an individual Media Item within a Media Set in Foundry."""
+
+
+class MediaReference(core.ModelBase):
+ """The representation of a media reference."""
+
+ mime_type: MediaType = pydantic.Field(alias=str("mimeType")) # type: ignore[literal-required]
+ reference: Reference
+
+
+class MediaReferenceType(core.ModelBase):
+ """MediaReferenceType"""
+
+ type: typing.Literal["mediaReference"] = "mediaReference"
+
+
+MediaSetRid: typing_extensions.TypeAlias = core.RID
+"""The Resource Identifier (RID) of a Media Set in Foundry."""
+
+
+class MediaSetViewItem(core.ModelBase):
+ """MediaSetViewItem"""
+
+ media_set_rid: MediaSetRid = pydantic.Field(alias=str("mediaSetRid")) # type: ignore[literal-required]
+ media_set_view_rid: MediaSetViewRid = pydantic.Field(alias=str("mediaSetViewRid")) # type: ignore[literal-required]
+ media_item_rid: MediaItemRid = pydantic.Field(alias=str("mediaItemRid")) # type: ignore[literal-required]
+ token: typing.Optional[MediaItemReadToken] = None
+
+
+class MediaSetViewItemWrapper(core.ModelBase):
+ """MediaSetViewItemWrapper"""
+
+ media_set_view_item: MediaSetViewItem = pydantic.Field(alias=str("mediaSetViewItem")) # type: ignore[literal-required]
+ type: typing.Literal["mediaSetViewItem"] = "mediaSetViewItem"
+
+
+MediaSetViewRid: typing_extensions.TypeAlias = core.RID
+"""The Resource Identifier (RID) of a single View of a Media Set. A Media Set View is an independent collection of Media Items."""
+
+
+MediaType: typing_extensions.TypeAlias = str
+"""
+The [media type](https://www.iana.org/assignments/media-types/media-types.xhtml) of the file or attachment.
+Examples: `application/json`, `application/pdf`, `application/octet-stream`, `image/jpeg`
+"""
+
+
+NetworkEgressPolicyRid: typing_extensions.TypeAlias = core.RID
+"""The Resource Identifier (RID) of a Network Egress Policy."""
+
+
+class NullType(core.ModelBase):
+ """NullType"""
+
+ type: typing.Literal["null"] = "null"
+
+
+class NumericOrNonNumericType(core.ModelBase):
+ """
+ The time series property can either contain either numeric or non-numeric data. This enables mixed sensor types
+ where some sensor time series are numeric and others are categorical. A boolean property reference can be used
+ to determine if the series is numeric or non-numeric. Without this property, the series type can be either
+ numeric or non-numeric and must be inferred from the result of a time series query.
+ """
+
+ is_non_numeric_property_type_id: typing.Optional[str] = pydantic.Field(alias=str("isNonNumericPropertyTypeId"), default=None) # type: ignore[literal-required]
+ """
+ The boolean property type ID specifying whether the series is numeric or non-numeric. If the value is true,
+ the series is non-numeric.
+ """
+
+ type: typing.Literal["numericOrNonNumeric"] = "numericOrNonNumeric"
+
+
+Operation: typing_extensions.TypeAlias = str
+"""
+An operation that can be performed on a resource. Operations are used to define the permissions that a Role has.
+Operations are typically in the format `service:action`, where `service` is related to the type of resource and `action` is the action being performed.
+"""
+
+
+OperationScope: typing_extensions.TypeAlias = str
+"""OperationScope"""
+
+
+OrderByDirection: typing_extensions.TypeAlias = typing.Literal["ASC", "DESC"]
+"""Specifies the ordering direction (can be either `ASC` or `DESC`)"""
+
+
+OrganizationRid: typing_extensions.TypeAlias = core.RID
+"""OrganizationRid"""
+
+
+PageSize: typing_extensions.TypeAlias = int
+"""The page size to use for the endpoint."""
+
+
+PageToken: typing_extensions.TypeAlias = str
+"""
+The page token indicates where to start paging. This should be omitted from the first page's request.
+To fetch the next page, clients should take the value from the `nextPageToken` field of the previous response
+and use it to populate the `pageToken` field of the next request.
+"""
+
+
+PreviewMode: typing_extensions.TypeAlias = bool
+"""Enables the use of preview functionality."""
+
+
+PrincipalId: typing_extensions.TypeAlias = core.UUID
+"""The ID of a Foundry Group or User."""
+
+
+PrincipalType: typing_extensions.TypeAlias = typing.Literal["USER", "GROUP"]
+"""PrincipalType"""
+
+
+Realm: typing_extensions.TypeAlias = str
+"""
+Identifies which Realm a User or Group is a member of.
+The `palantir-internal-realm` is used for Users or Groups that are created in Foundry by administrators and not associated with any SSO provider.
+"""
+
+
+ReleaseStatus: typing_extensions.TypeAlias = typing.Literal[
+ "ACTIVE", "ENDORSED", "EXPERIMENTAL", "DEPRECATED"
+]
+"""The release status of the entity."""
+
+
+class Role(core.ModelBase):
+ """A set of permissions that can be assigned to a principal for a specific resource type."""
+
+ id: RoleId
+ role_set_id: RoleSetId = pydantic.Field(alias=str("roleSetId")) # type: ignore[literal-required]
+ name: str
+ description: str
+ is_default: bool = pydantic.Field(alias=str("isDefault")) # type: ignore[literal-required]
+ """Default roles are provided by Palantir and cannot be edited or modified by administrators."""
+
+ type: RoleContext
+ """The type of resource that is valid for this role."""
+
+ operations: typing.List[Operation]
+ """The operations that a principal can perform with this role on the assigned resource."""
+
+
+class RoleAssignmentUpdate(core.ModelBase):
+ """RoleAssignmentUpdate"""
+
+ role_id: RoleId = pydantic.Field(alias=str("roleId")) # type: ignore[literal-required]
+ principal_id: PrincipalId = pydantic.Field(alias=str("principalId")) # type: ignore[literal-required]
+
+
+RoleContext: typing_extensions.TypeAlias = typing.Literal["ORGANIZATION"]
+"""RoleContext"""
+
+
+RoleId: typing_extensions.TypeAlias = str
+"""
+The unique ID for a Role. Roles are sets of permissions that grant different levels of access to resources.
+The default roles in Foundry are: Owner, Editor, Viewer, and Discoverer. See more about
+[roles](https://palantir.com/docs/foundry/security/projects-and-roles#roles) in the user documentation.
+"""
+
+
+RoleSetId: typing_extensions.TypeAlias = str
+"""RoleSetId"""
+
+
+class ScenarioReferenceType(core.ModelBase):
+ """ScenarioReferenceType"""
+
+ type: typing.Literal["scenarioReference"] = "scenarioReference"
+
+
+ScheduleRid: typing_extensions.TypeAlias = core.RID
+"""The RID of a Schedule."""
+
+
+SchemaFieldType: typing_extensions.TypeAlias = typing.Literal[
+ "ARRAY",
+ "BINARY",
+ "BOOLEAN",
+ "BYTE",
+ "DATE",
+ "DECIMAL",
+ "DOUBLE",
+ "FLOAT",
+ "INTEGER",
+ "LONG",
+ "MAP",
+ "SHORT",
+ "STRING",
+ "STRUCT",
+ "TIMESTAMP",
+]
+"""The data type of a column in a dataset schema."""
+
+
+class ShortType(core.ModelBase):
+ """ShortType"""
+
+ type: typing.Literal["short"] = "short"
+
+
+SizeBytes: typing_extensions.TypeAlias = core.Long
+"""The size of the file or attachment in bytes."""
+
+
+class StreamSchema(core.ModelBase):
+ """The schema for a Foundry stream. Records pushed to this stream must match this schema."""
+
+ fields: typing.List[Field]
+ key_field_names: typing.Optional[typing.List[FieldName]] = pydantic.Field(alias=str("keyFieldNames"), default=None) # type: ignore[literal-required]
+ """
+ The names of the fields to be used as keys for partitioning records. These key fields are used to group
+ all records with the same key into the same partition, to guarantee processing order of grouped records. These
+ keys are not meant to uniquely identify records, and do not by themselves deduplicate records. To deduplicate
+ records, provide a change data capture configuration for the schema.
+
+ Key fields can only be of the following types:
+ - Boolean
+ - Byte
+ - Date
+ - Decimal
+ - Integer
+ - Long
+ - Short
+ - String
+ - Timestamp
+
+ For additional information on keys for Foundry streams, see the
+ [streaming keys](https://palantir.com/docs/foundry/building-pipelines/streaming-keys/) user documentation.
+ """
+
+ change_data_capture: typing.Optional[ChangeDataCaptureConfiguration] = pydantic.Field(alias=str("changeDataCapture"), default=None) # type: ignore[literal-required]
+
+
+class StringType(core.ModelBase):
+ """StringType"""
+
+ type: typing.Literal["string"] = "string"
+
+
+StructFieldName: typing_extensions.TypeAlias = str
+"""The name of a field in a `Struct`."""
+
+
+class StructFieldType(core.ModelBase):
+ """StructFieldType"""
+
+ sub_fields: typing.List[Field] = pydantic.Field(alias=str("subFields")) # type: ignore[literal-required]
+ type: typing.Literal["struct"] = "struct"
+
+
+TableRid: typing_extensions.TypeAlias = core.RID
+"""The Resource Identifier (RID) of a Table."""
+
+
+TimeSeriesItemType: typing_extensions.TypeAlias = typing_extensions.Annotated[
+ typing.Union["StringType", "DoubleType", "NumericOrNonNumericType"],
+ pydantic.Field(discriminator="type"),
+]
+"""A union of the types supported by time series properties."""
+
+
+TimeUnit: typing_extensions.TypeAlias = typing.Literal[
+ "MILLISECONDS", "SECONDS", "MINUTES", "HOURS", "DAYS", "WEEKS", "MONTHS", "YEARS"
+]
+"""TimeUnit"""
+
+
+class TimeseriesType(core.ModelBase):
+ """TimeseriesType"""
+
+ item_type: TimeSeriesItemType = pydantic.Field(alias=str("itemType")) # type: ignore[literal-required]
+ type: typing.Literal["timeseries"] = "timeseries"
+
+
+class TimestampType(core.ModelBase):
+ """TimestampType"""
+
+ type: typing.Literal["timestamp"] = "timestamp"
+
+
+TotalCount: typing_extensions.TypeAlias = core.Long
+"""The total number of items across all pages."""
+
+
+TraceParent: typing_extensions.TypeAlias = str
+"""The W3C Trace Context `traceparent` header value used to propagate distributed tracing information for Foundry telemetry. See https://www.w3.org/TR/trace-context/#traceparent-header for more details. Note the 16 byte trace ID encoded in the header must be derived from a time based uuid to be used within Foundry."""
+
+
+TraceState: typing_extensions.TypeAlias = str
+"""The W3C Trace Context `tracestate` header value, which is used to propagate vendor specific distributed tracing information for Foundry telemetry. See https://www.w3.org/TR/trace-context/#tracestate-header for more details."""
+
+
+class UnsupportedType(core.ModelBase):
+ """UnsupportedType"""
+
+ unsupported_type: str = pydantic.Field(alias=str("unsupportedType")) # type: ignore[literal-required]
+ params: typing.Dict[UnsupportedTypeParamKey, UnsupportedTypeParamValue]
+ type: typing.Literal["unsupported"] = "unsupported"
+
+
+UnsupportedTypeParamKey: typing_extensions.TypeAlias = str
+"""UnsupportedTypeParamKey"""
+
+
+UnsupportedTypeParamValue: typing_extensions.TypeAlias = str
+"""UnsupportedTypeParamValue"""
+
+
+UpdatedTime: typing_extensions.TypeAlias = core.AwareDatetime
+"""The time at which the resource was most recently updated."""
+
+
+UserId: typing_extensions.TypeAlias = core.UUID
+"""A Foundry User ID."""
+
+
+UserStatus: typing_extensions.TypeAlias = typing.Literal["ACTIVE", "DELETED"]
+"""Present status of user."""
+
+
+class VectorSimilarityFunction(core.ModelBase):
+ """
+ The vector similarity function to support approximate nearest neighbors search. Will result in an index
+ specific for the function.
+ """
+
+ value: typing.Optional[VectorSimilarityFunctionValue] = None
+
+
+VectorSimilarityFunctionValue: typing_extensions.TypeAlias = typing.Literal[
+ "COSINE_SIMILARITY", "DOT_PRODUCT", "EUCLIDEAN_DISTANCE"
+]
+"""VectorSimilarityFunctionValue"""
+
+
+class VectorType(core.ModelBase):
+ """Represents a fixed size vector of floats. These can be used for vector similarity searches."""
+
+ dimension: int
+ """The dimension of the vector."""
+
+ supports_search_with: typing.List[VectorSimilarityFunction] = pydantic.Field(alias=str("supportsSearchWith")) # type: ignore[literal-required]
+ embedding_model: typing.Optional[EmbeddingModel] = pydantic.Field(alias=str("embeddingModel"), default=None) # type: ignore[literal-required]
+ type: typing.Literal["vector"] = "vector"
+
+
+VersionId: typing_extensions.TypeAlias = core.UUID
+"""The version identifier of a dataset schema."""
+
+
+class VoidType(core.ModelBase):
+ """VoidType"""
+
+ type: typing.Literal["void"] = "void"
+
+
+ZoneId: typing_extensions.TypeAlias = str
+"""A string representation of a java.time.ZoneId"""
+
+
+ChangeDataCaptureConfiguration: typing_extensions.TypeAlias = FullRowChangeDataCaptureConfiguration
+"""
+Configuration for utilizing the stream as a change data capture (CDC) dataset. To configure CDC on a stream, at
+least one key needs to be provided.
+
+For more information on CDC in
+Foundry, see the [Change Data Capture](https://palantir.com/docs/foundry/data-integration/change-data-capture/) user documentation.
+"""
+
+
+CreatedBy: typing_extensions.TypeAlias = PrincipalId
+"""The Foundry user who created this resource"""
+
+
+Reference: typing_extensions.TypeAlias = MediaSetViewItemWrapper
+"""A union of the types supported by media reference properties."""
+
+
+UpdatedBy: typing_extensions.TypeAlias = UserId
+"""The Foundry user who last updated this resource"""
+
+
+core.resolve_forward_references_in_module(__name__)
+
+__all__ = [
+ "AnyType",
+ "ArrayFieldType",
+ "AttachmentType",
+ "Attribution",
+ "BinaryType",
+ "BooleanType",
+ "BranchMetadata",
+ "BranchName",
+ "BuildRid",
+ "ByteType",
+ "ChangeDataCaptureConfiguration",
+ "CheckReportRid",
+ "CheckRid",
+ "CipherTextType",
+ "Color",
+ "ColumnName",
+ "ComputeSeconds",
+ "ContentLength",
+ "ContentType",
+ "CreatedBy",
+ "CreatedTime",
+ "CustomMetadata",
+ "DatasetFieldSchema",
+ "DatasetRid",
+ "DatasetSchema",
+ "DateType",
+ "DecimalType",
+ "DisplayName",
+ "Distance",
+ "DistanceUnit",
+ "DoubleType",
+ "Duration",
+ "DurationSeconds",
+ "EmbeddingModel",
+ "EnrollmentRid",
+ "Field",
+ "FieldDataType",
+ "FieldName",
+ "FieldSchema",
+ "FilePath",
+ "Filename",
+ "FilterBinaryType",
+ "FilterBooleanType",
+ "FilterDateTimeType",
+ "FilterDateType",
+ "FilterDoubleType",
+ "FilterEnumType",
+ "FilterFloatType",
+ "FilterIntegerType",
+ "FilterLongType",
+ "FilterRidType",
+ "FilterStringType",
+ "FilterType",
+ "FilterUuidType",
+ "FloatType",
+ "FolderRid",
+ "FoundryBranch",
+ "FoundryLiveDeployment",
+ "FullRowChangeDataCaptureConfiguration",
+ "GeoPointType",
+ "GeoShapeType",
+ "GeohashType",
+ "GeotimeSeriesReferenceType",
+ "GroupId",
+ "GroupName",
+ "GroupRid",
+ "IncludeComputeUsage",
+ "IntegerType",
+ "JobRid",
+ "LmsEmbeddingModel",
+ "LmsEmbeddingModelValue",
+ "LongType",
+ "MapFieldType",
+ "MarkingId",
+ "MarkingType",
+ "MarkingTypeValue",
+ "MediaItemPath",
+ "MediaItemReadToken",
+ "MediaItemRid",
+ "MediaReference",
+ "MediaReferenceType",
+ "MediaSetRid",
+ "MediaSetViewItem",
+ "MediaSetViewItemWrapper",
+ "MediaSetViewRid",
+ "MediaType",
+ "NetworkEgressPolicyRid",
+ "NullType",
+ "NumericOrNonNumericType",
+ "Operation",
+ "OperationScope",
+ "OrderByDirection",
+ "OrganizationRid",
+ "PageSize",
+ "PageToken",
+ "PreviewMode",
+ "PrincipalId",
+ "PrincipalType",
+ "Realm",
+ "Reference",
+ "ReleaseStatus",
+ "Role",
+ "RoleAssignmentUpdate",
+ "RoleContext",
+ "RoleId",
+ "RoleSetId",
+ "ScenarioReferenceType",
+ "ScheduleRid",
+ "SchemaFieldType",
+ "ShortType",
+ "SizeBytes",
+ "StreamSchema",
+ "StringType",
+ "StructFieldName",
+ "StructFieldType",
+ "TableRid",
+ "TimeSeriesItemType",
+ "TimeUnit",
+ "TimeseriesType",
+ "TimestampType",
+ "TotalCount",
+ "TraceParent",
+ "TraceState",
+ "UnsupportedType",
+ "UnsupportedTypeParamKey",
+ "UnsupportedTypeParamValue",
+ "UpdatedBy",
+ "UpdatedTime",
+ "UserId",
+ "UserStatus",
+ "VectorSimilarityFunction",
+ "VectorSimilarityFunctionValue",
+ "VectorType",
+ "VersionId",
+ "VoidType",
+ "ZoneId",
+]
diff --git a/case-studies/foundry-owl-crosswalk/vendor/interfaceTypes.ts b/case-studies/foundry-owl-crosswalk/vendor/interfaceTypes.ts
new file mode 100644
index 00000000..f009fe10
--- /dev/null
+++ b/case-studies/foundry-owl-crosswalk/vendor/interfaceTypes.ts
@@ -0,0 +1,169 @@
+/*
+ * Copyright 2025 Palantir Technologies, Inc. All rights reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+import type {
+ InterfaceDefinedPropertyType,
+ InterfacePropertyApiName,
+ InterfacePropertyTypeRid,
+ InterfaceType,
+} from "@osdk/foundry.ontologies";
+
+import { fooSpt } from "./spts.js";
+
+const idp: InterfaceDefinedPropertyType = {
+ rid: "ri.interfacePropertyType.main.interfacePropertyType.1",
+ apiName: "fooIdp",
+ displayName: "Foo IDP",
+ description: "A Foo IDP",
+ dataType: {
+ type: "string",
+ },
+ requireImplementation: true,
+ typeClasses: [],
+};
+
+const arrayIdp: InterfaceDefinedPropertyType = {
+ rid: "ri.interfacePropertyType.main.interfacePropertyType.2",
+ apiName: "fooArray",
+ displayName: "Foo Array",
+ description: "An array-valued Foo property",
+ dataType: {
+ type: "array",
+ subType: {
+ type: "string",
+ },
+ reducers: [],
+ },
+ requireImplementation: false,
+ typeClasses: [],
+};
+
+export const BarInterface: InterfaceType = {
+ apiName: "BarInterface",
+ description: "Interface for Bar",
+ displayName: "Bar Interface",
+ rid: "ri.interface.main.interface.2",
+ extendsInterfaces: [],
+ properties: {},
+ allProperties: {},
+ propertiesV2: {},
+ allPropertiesV2: {},
+ links: {
+ toFoo: {
+ rid: "ri.interface.link.main.1",
+ apiName: "toFoo",
+ linkedEntityApiName: {
+ type: "interfaceTypeApiName",
+ apiName: "FooInterface",
+ },
+ displayName: "foos",
+ cardinality: "MANY",
+ required: true,
+ },
+ },
+ implementedByObjectTypes: [],
+ allExtendsInterfaces: [],
+ allLinks: {
+ toFoo: {
+ rid: "ri.interface.link.main.1",
+ apiName: "toFoo",
+ linkedEntityApiName: {
+ type: "interfaceTypeApiName",
+ apiName: "FooInterface",
+ },
+ displayName: "foos",
+ cardinality: "MANY",
+ required: true,
+ },
+ },
+};
+
+export const FooInterface: InterfaceType = {
+ apiName: "FooInterface",
+ description: "Interface for Foo",
+ displayName: "Foo Interface",
+ rid: "ri.interface.main.interface.1",
+ extendsInterfaces: [],
+ properties: {
+ fooSpt: {
+ ...fooSpt,
+ required: true,
+ },
+ },
+ propertiesV2: {
+ fooSpt: {
+ ...fooSpt,
+ type: "interfaceSharedPropertyType",
+ required: true,
+ },
+ fooIdp: {
+ ...idp,
+ type: "interfaceDefinedPropertyType",
+ },
+ fooArray: {
+ ...arrayIdp,
+ type: "interfaceDefinedPropertyType",
+ },
+ },
+ links: {
+ toBar: {
+ rid: "ri.interface.link.main.2",
+ apiName: "toBar",
+ linkedEntityApiName: {
+ type: "interfaceTypeApiName",
+ apiName: "BarInterface",
+ },
+ displayName: "bars",
+ cardinality: "MANY",
+ required: true,
+ },
+ },
+ implementedByObjectTypes: ["Employee", "Person"],
+ allProperties: {
+ fooSpt: {
+ ...fooSpt,
+ required: true,
+ },
+ },
+ allPropertiesV2: {
+ fooSpt: {
+ ...fooSpt,
+ rid: fooSpt.rid as InterfacePropertyTypeRid,
+ apiName: fooSpt.apiName as InterfacePropertyApiName,
+ requireImplementation: true,
+ },
+ fooIdp: {
+ ...idp,
+ },
+ fooArray: {
+ ...arrayIdp,
+ },
+ },
+ allExtendsInterfaces: [],
+ allLinks: {
+ toBar: {
+ rid: "ri.interface.link.main.2",
+ apiName: "toBar",
+ linkedEntityApiName: {
+ type: "interfaceTypeApiName",
+ apiName: "BarInterface",
+ },
+ displayName: "bars",
+ cardinality: "MANY",
+ required: true,
+ },
+ },
+};
diff --git a/case-studies/foundry-owl-crosswalk/vendor/linkTypes.ts b/case-studies/foundry-owl-crosswalk/vendor/linkTypes.ts
new file mode 100644
index 00000000..bfc8b6f6
--- /dev/null
+++ b/case-studies/foundry-owl-crosswalk/vendor/linkTypes.ts
@@ -0,0 +1,79 @@
+/*
+ * Copyright 2023 Palantir Technologies, Inc. All rights reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+import type { LinkTypeSideV2 } from "@osdk/foundry.ontologies";
+
+import {
+ employeeObjectType,
+ objectTypeWithAllPropertyTypes,
+ officeObjectType,
+} from "./objectTypes.js";
+
+export const peepsLinkType: LinkTypeSideV2 = {
+ apiName: "peeps",
+ status: "EXPERIMENTAL",
+ objectTypeApiName: employeeObjectType.apiName,
+ cardinality: "MANY",
+ displayName: "Peeps",
+ linkTypeRid: "rid.link-type.327",
+};
+
+export const leadLinkType: LinkTypeSideV2 = {
+ apiName: "lead",
+ status: "EXPERIMENTAL",
+ objectTypeApiName: employeeObjectType.apiName,
+ cardinality: "ONE",
+ displayName: "Lead",
+ linkTypeRid: peepsLinkType.linkTypeRid,
+ foreignKeyPropertyApiName: "leadId",
+};
+
+export const visitedOffices: LinkTypeSideV2 = {
+ apiName: "visitedOffices",
+ status: "EXPERIMENTAL",
+ objectTypeApiName: officeObjectType.apiName,
+ cardinality: "MANY",
+ displayName: "Visited Offices",
+ linkTypeRid: "ri.a.b.c.visitedOffices",
+};
+
+export const officeLinkType: LinkTypeSideV2 = {
+ apiName: "officeLink",
+ status: "EXPERIMENTAL",
+ objectTypeApiName: officeObjectType.apiName,
+ cardinality: "ONE",
+ displayName: "Office",
+ linkTypeRid: "rid.link-type.324",
+ foreignKeyPropertyApiName: "office",
+};
+
+export const occupants: LinkTypeSideV2 = {
+ apiName: "occupants",
+ status: "EXPERIMENTAL",
+ objectTypeApiName: employeeObjectType.apiName,
+ cardinality: "MANY",
+ displayName: "Office Occupants",
+ linkTypeRid: officeLinkType.linkTypeRid,
+};
+
+export const allPropertyTypesSelfLink: LinkTypeSideV2 = {
+ apiName: "linkedObjectType",
+ status: "EXPERIMENTAL",
+ objectTypeApiName: objectTypeWithAllPropertyTypes.apiName,
+ cardinality: "ONE",
+ displayName: "Linked Object Type",
+ linkTypeRid: "rid.link-type.832",
+};
diff --git a/case-studies/foundry-owl-crosswalk/vendor/models.py b/case-studies/foundry-owl-crosswalk/vendor/models.py
new file mode 100644
index 00000000..0b865d1b
--- /dev/null
+++ b/case-studies/foundry-owl-crosswalk/vendor/models.py
@@ -0,0 +1,7374 @@
+# Copyright 2024 Palantir Technologies, Inc.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+
+from __future__ import annotations
+
+import typing
+from datetime import date
+
+import annotated_types
+import pydantic
+import typing_extensions
+
+from foundry_sdk import _core as core
+from foundry_sdk.v2.core import models as core_models
+from foundry_sdk.v2.datasets import models as datasets_models
+from foundry_sdk.v2.geo import models as geo_models
+
+
+class AbsoluteTimeRange(core.ModelBase):
+ """ISO 8601 timestamps forming a range for a time series query. Start is inclusive and end is exclusive."""
+
+ start_time: typing.Optional[core.AwareDatetime] = pydantic.Field(alias=str("startTime"), default=None) # type: ignore[literal-required]
+ end_time: typing.Optional[core.AwareDatetime] = pydantic.Field(alias=str("endTime"), default=None) # type: ignore[literal-required]
+ type: typing.Literal["absolute"] = "absolute"
+
+
+class AbsoluteValuePropertyExpression(core.ModelBase):
+ """Calculates absolute value of a numeric value."""
+
+ property: DerivedPropertyDefinition
+ type: typing.Literal["absoluteValue"] = "absoluteValue"
+
+
+ActionExecutionTime: typing_extensions.TypeAlias = core.AwareDatetime
+"""An ISO 8601 timestamp."""
+
+
+ActionLogicRule: typing_extensions.TypeAlias = typing_extensions.Annotated[
+ typing.Union[
+ "ModifyInterfaceLogicRule",
+ "CreateOrModifyObjectLogicRule",
+ "ModifyObjectLogicRule",
+ "DeleteLinkLogicRule",
+ "CreateObjectLogicRule",
+ "CreateLinkLogicRule",
+ "BatchedFunctionLogicRule",
+ "CreateOrModifyObjectLogicRuleV2",
+ "DeleteInterfaceLinkLogicRule",
+ "DeleteObjectLogicRule",
+ "FunctionLogicRule",
+ "CreateInterfaceLinkLogicRule",
+ "CreateInterfaceLogicRule",
+ "ApplyScenarioLogicRule",
+ ],
+ pydantic.Field(discriminator="type"),
+]
+"""A detailed operation for an Action"""
+
+
+class ActionParameterArrayType(core.ModelBase):
+ """ActionParameterArrayType"""
+
+ sub_type: ActionParameterType = pydantic.Field(alias=str("subType")) # type: ignore[literal-required]
+ type: typing.Literal["array"] = "array"
+
+
+ActionParameterRid: typing_extensions.TypeAlias = core.RID
+"""The unique resource identifier of an action parameter, useful for interacting with other Foundry APIs."""
+
+
+ActionParameterType: typing_extensions.TypeAlias = typing_extensions.Annotated[
+ typing.Union[
+ core_models.DateType,
+ "OntologyInterfaceObjectType",
+ "OntologyStructType",
+ core_models.StringType,
+ core_models.DoubleType,
+ core_models.IntegerType,
+ core_models.GeoShapeType,
+ core_models.LongType,
+ "OntologyObjectTypeReferenceType",
+ core_models.BooleanType,
+ core_models.MarkingType,
+ core_models.ScenarioReferenceType,
+ core_models.AttachmentType,
+ core_models.MediaReferenceType,
+ "ActionParameterArrayType",
+ "OntologyObjectSetType",
+ core_models.GeohashType,
+ core_models.VectorType,
+ core_models.DecimalType,
+ "OntologyObjectType",
+ core_models.TimestampType,
+ ],
+ pydantic.Field(discriminator="type"),
+]
+"""A union of all the types supported by Ontology Action parameters."""
+
+
+class ActionParameterV2(core.ModelBase):
+ """Details about a parameter of an action."""
+
+ display_name: core_models.DisplayName = pydantic.Field(alias=str("displayName")) # type: ignore[literal-required]
+ description: typing.Optional[str] = None
+ data_type: ActionParameterType = pydantic.Field(alias=str("dataType")) # type: ignore[literal-required]
+ required: bool
+ type_classes: typing.Optional[typing.List[TypeClass]] = pydantic.Field(alias=str("typeClasses"), default=None) # type: ignore[literal-required]
+ validation: typing.Optional[ActionParameterValidation] = None
+
+
+class ActionParameterValidation(core.ModelBase):
+ """Validation metadata surfaced for a parameter."""
+
+ default_validation: ActionParameterValidationBlock = pydantic.Field(alias=str("defaultValidation")) # type: ignore[literal-required]
+
+
+class ActionParameterValidationBlock(core.ModelBase):
+ """Validation constraints for a parameter."""
+
+ allowed_values: typing.Optional[ParameterAllowedValues] = pydantic.Field(alias=str("allowedValues"), default=None) # type: ignore[literal-required]
+ array_size: typing.Optional[ParameterArraySize] = pydantic.Field(alias=str("arraySize"), default=None) # type: ignore[literal-required]
+
+
+ActionResults: typing_extensions.TypeAlias = typing_extensions.Annotated[
+ typing.Union["ObjectEdits", "ObjectTypeEdits"], pydantic.Field(discriminator="type")
+]
+"""ActionResults"""
+
+
+ActionRid: typing_extensions.TypeAlias = core.RID
+"""The unique resource identifier for an action."""
+
+
+ActionSectionRid: typing_extensions.TypeAlias = core.RID
+"""The unique resource identifier of an action section, useful for interacting with other Foundry APIs."""
+
+
+ActionTypeApiName: typing_extensions.TypeAlias = str
+"""
+The name of the action type in the API. To find the API name for your Action Type, use the `List action types`
+endpoint or check the **Ontology Manager**.
+"""
+
+
+class ActionTypeApiNameActionTypesQueryV2(core.ModelBase):
+ """Returns action types with an api name matching the given string predicate."""
+
+ value: FullTextStringPredicateV2
+ type: typing.Literal["actionTypeApiName"] = "actionTypeApiName"
+
+
+class ActionTypeDescriptionActionTypesQueryV2(core.ModelBase):
+ """Returns action types with a description matching the given string predicate."""
+
+ value: FullTextStringPredicateV2
+ type: typing.Literal["actionTypeDescription"] = "actionTypeDescription"
+
+
+class ActionTypeDisplayNameActionTypesQueryV2(core.ModelBase):
+ """Returns action types with a display name matching the given string predicate."""
+
+ value: FullTextStringPredicateV2
+ type: typing.Literal["actionTypeDisplayName"] = "actionTypeDisplayName"
+
+
+class ActionTypeFullMetadata(core.ModelBase):
+ """Returns the full metadata for an Action type in the Ontology."""
+
+ action_type: ActionTypeV2 = pydantic.Field(alias=str("actionType")) # type: ignore[literal-required]
+ full_logic_rules: typing.List[ActionLogicRule] = pydantic.Field(alias=str("fullLogicRules")) # type: ignore[literal-required]
+
+
+ActionTypeFuzziness: typing_extensions.TypeAlias = typing_extensions.Annotated[
+ typing.Union["FuzzinessAuto", "FuzzinessOff"], pydantic.Field(discriminator="type")
+]
+"""
+Fuzziness setting applied to `contains` full-text string predicates in the search query. If not provided,
+`auto` is used.
+"""
+
+
+ActionTypeLogicRuleTypeFilter: typing_extensions.TypeAlias = typing.Literal[
+ "ADD_OBJECT",
+ "MODIFY_OBJECT",
+ "DELETE_OBJECT",
+ "ADD_LINK",
+ "DELETE_LINK",
+ "FUNCTION",
+ "BATCHED_FUNCTION",
+ "ADD_OR_MODIFY_OBJECT",
+ "ADD_OR_MODIFY_OBJECT_V2",
+]
+"""Filter action types by the type of logic rule they contain."""
+
+
+ActionTypePermissionModelFilter: typing_extensions.TypeAlias = typing.Literal[
+ "DATASOURCE_DERIVED_PERMISSIONS", "ONTOLOGY_ROLES", "COMPASS_PROJECT"
+]
+"""Filter action types by permission model."""
+
+
+ActionTypeRid: typing_extensions.TypeAlias = core.RID
+"""The unique resource identifier of an action type, useful for interacting with other Foundry APIs."""
+
+
+class ActionTypeRidActionTypesQueryV2(core.ModelBase):
+ """Returns action types with the given rid."""
+
+ value: ActionTypeRid
+ type: typing.Literal["actionTypeRid"] = "actionTypeRid"
+
+
+ActionTypeSearchJsonQueryV2: typing_extensions.TypeAlias = typing_extensions.Annotated[
+ typing.Union[
+ "WebhookRidActionTypesQueryV2",
+ "HasActionLogActionTypesQueryV2",
+ "ActionTypeApiNameActionTypesQueryV2",
+ "OrActionTypesQueryV2",
+ "PermissionModelActionTypesQueryV2",
+ "HasWebhookActionTypesQueryV2",
+ "ActionTypeDisplayNameActionTypesQueryV2",
+ "AffectedLinkTypeRidActionTypesQueryV2",
+ "ActionTypeDescriptionActionTypesQueryV2",
+ "SectionRidActionTypesQueryV2",
+ "ParameterRidActionTypesQueryV2",
+ "ParameterNameActionTypesQueryV2",
+ "HasNotificationActionTypesQueryV2",
+ "FunctionRidActionTypesQueryV2",
+ "InputObjectTypeRidActionTypesQueryV2",
+ "RevertActionEnabledActionTypesQueryV2",
+ "LogicRuleActionTypesQueryV2",
+ "TypeClassesActionTypesQueryV2",
+ "AffectedInterfaceTypeRidActionTypesQueryV2",
+ "AndActionTypesQueryV2",
+ "ActionTypeRidActionTypesQueryV2",
+ "AffectedObjectTypeRidActionTypesQueryV2",
+ "StatusActionTypesQueryV2",
+ ],
+ pydantic.Field(discriminator="type"),
+]
+"""Represents the search query for an action type search. Supports filters for various action type features."""
+
+
+ActionTypeSortByV2: typing_extensions.TypeAlias = typing.Literal["actionTypeDisplayName"]
+"""Specifies the field to sort action types by."""
+
+
+ActionTypeStatusFilter: typing_extensions.TypeAlias = typing.Literal[
+ "EXPERIMENTAL", "ACTIVE", "DEPRECATED", "EXAMPLE"
+]
+"""Filter action types by status."""
+
+
+class ActionTypeV2(core.ModelBase):
+ """Represents an action type in the Ontology."""
+
+ api_name: ActionTypeApiName = pydantic.Field(alias=str("apiName")) # type: ignore[literal-required]
+ description: typing.Optional[str] = None
+ display_name: typing.Optional[core_models.DisplayName] = pydantic.Field(alias=str("displayName"), default=None) # type: ignore[literal-required]
+ status: core_models.ReleaseStatus
+ parameters: typing.Dict[ParameterId, ActionParameterV2]
+ rid: ActionTypeRid
+ operations: typing.List[LogicRule]
+ tool_description: typing.Optional[str] = pydantic.Field(alias=str("toolDescription"), default=None) # type: ignore[literal-required]
+ """Optional description intended for tool use contexts, such as AI agents."""
+
+
+class ActivePropertyTypeStatus(core.ModelBase):
+ """
+ This status indicates that the PropertyType will not change on short notice and should thus be safe to use in
+ user facing workflows.
+ """
+
+ type: typing.Literal["active"] = "active"
+
+
+class AddLink(core.ModelBase):
+ """AddLink"""
+
+ link_type_api_name_ato_b: LinkTypeApiName = pydantic.Field(alias=str("linkTypeApiNameAtoB")) # type: ignore[literal-required]
+ link_type_api_name_bto_a: LinkTypeApiName = pydantic.Field(alias=str("linkTypeApiNameBtoA")) # type: ignore[literal-required]
+ a_side_object: LinkSideObject = pydantic.Field(alias=str("aSideObject")) # type: ignore[literal-required]
+ b_side_object: LinkSideObject = pydantic.Field(alias=str("bSideObject")) # type: ignore[literal-required]
+ type: typing.Literal["addLink"] = "addLink"
+
+
+class AddLinkEdit(core.ModelBase):
+ """AddLinkEdit"""
+
+ object_type: ObjectTypeApiName = pydantic.Field(alias=str("objectType")) # type: ignore[literal-required]
+ primary_key: PrimaryKeyValue = pydantic.Field(alias=str("primaryKey")) # type: ignore[literal-required]
+ link_type: LinkTypeApiName = pydantic.Field(alias=str("linkType")) # type: ignore[literal-required]
+ linked_object_primary_key: PrimaryKeyValue = pydantic.Field(alias=str("linkedObjectPrimaryKey")) # type: ignore[literal-required]
+ type: typing.Literal["addLink"] = "addLink"
+
+
+class AddObject(core.ModelBase):
+ """AddObject"""
+
+ primary_key: PropertyValue = pydantic.Field(alias=str("primaryKey")) # type: ignore[literal-required]
+ object_type: ObjectTypeApiName = pydantic.Field(alias=str("objectType")) # type: ignore[literal-required]
+ type: typing.Literal["addObject"] = "addObject"
+
+
+class AddObjectEdit(core.ModelBase):
+ """AddObjectEdit"""
+
+ object_type: ObjectTypeApiName = pydantic.Field(alias=str("objectType")) # type: ignore[literal-required]
+ properties: typing.Dict[PropertyApiName, typing.Optional[DataValue]]
+ type: typing.Literal["addObject"] = "addObject"
+
+
+class AddPropertyExpression(core.ModelBase):
+ """Adds two or more numeric values."""
+
+ properties: typing.List[DerivedPropertyDefinition]
+ type: typing.Literal["add"] = "add"
+
+
+class AffectedInterfaceTypeRidActionTypesQueryV2(core.ModelBase):
+ """Returns action types which edit the interface type with the given rid."""
+
+ value: InterfaceTypeRid
+ type: typing.Literal["affectedInterfaceTypeRid"] = "affectedInterfaceTypeRid"
+
+
+class AffectedLinkTypeRidActionTypesQueryV2(core.ModelBase):
+ """Returns action types which edit the link type with the given rid."""
+
+ value: LinkTypeRid
+ type: typing.Literal["affectedLinkTypeRid"] = "affectedLinkTypeRid"
+
+
+class AffectedObjectTypeRidActionTypesQueryV2(core.ModelBase):
+ """Returns action types which edit the object type with the given rid."""
+
+ value: ObjectTypeRid
+ type: typing.Literal["affectedObjectTypeRid"] = "affectedObjectTypeRid"
+
+
+class Affix(core.ModelBase):
+ """Affix"""
+
+ prefix: typing.Optional[PropertyTypeReferenceOrStringConstant] = None
+ postfix: typing.Optional[PropertyTypeReferenceOrStringConstant] = None
+
+
+class AggregateObjectSetRequestV2(core.ModelBase):
+ """AggregateObjectSetRequestV2"""
+
+ aggregation: typing.List[AggregationV2]
+ object_set: ObjectSet = pydantic.Field(alias=str("objectSet")) # type: ignore[literal-required]
+ group_by: typing.List[AggregationGroupByV2] = pydantic.Field(alias=str("groupBy")) # type: ignore[literal-required]
+ accuracy: typing.Optional[AggregationAccuracyRequest] = None
+ include_compute_usage: typing.Optional[core_models.IncludeComputeUsage] = pydantic.Field(alias=str("includeComputeUsage"), default=None) # type: ignore[literal-required]
+
+
+class AggregateObjectsRequestV2(core.ModelBase):
+ """AggregateObjectsRequestV2"""
+
+ aggregation: typing.List[AggregationV2]
+ where: typing.Optional[SearchJsonQueryV2] = None
+ group_by: typing.List[AggregationGroupByV2] = pydantic.Field(alias=str("groupBy")) # type: ignore[literal-required]
+ accuracy: typing.Optional[AggregationAccuracyRequest] = None
+
+
+class AggregateObjectsResponseItemV2(core.ModelBase):
+ """AggregateObjectsResponseItemV2"""
+
+ group: typing.Dict[AggregationGroupKeyV2, typing.Optional[AggregationGroupValueV2]]
+ metrics: typing.List[AggregationMetricResultV2]
+
+
+class AggregateObjectsResponseV2(core.ModelBase):
+ """AggregateObjectsResponseV2"""
+
+ excluded_items: typing.Optional[int] = pydantic.Field(alias=str("excludedItems"), default=None) # type: ignore[literal-required]
+ accuracy: AggregationAccuracy
+ data: typing.List[AggregateObjectsResponseItemV2]
+ compute_usage: typing.Optional[core_models.ComputeSeconds] = pydantic.Field(alias=str("computeUsage"), default=None) # type: ignore[literal-required]
+
+
+class AggregateTimeSeries(core.ModelBase):
+ """AggregateTimeSeries"""
+
+ method: TimeSeriesAggregationMethod
+ strategy: TimeSeriesAggregationStrategy
+
+
+AggregationAccuracy: typing_extensions.TypeAlias = typing.Literal["ACCURATE", "APPROXIMATE"]
+"""AggregationAccuracy"""
+
+
+AggregationAccuracyRequest: typing_extensions.TypeAlias = typing.Literal[
+ "REQUIRE_ACCURATE", "ALLOW_APPROXIMATE"
+]
+"""
+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.
+"""
+
+
+class AggregationDurationGroupingV2(core.ModelBase):
+ """
+ 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.
+ """
+
+ field: typing.Optional[PropertyApiName] = None
+ property_identifier: typing.Optional[PropertyIdentifier] = pydantic.Field(alias=str("propertyIdentifier"), default=None) # type: ignore[literal-required]
+ value: int
+ unit: TimeUnit
+ type: typing.Literal["duration"] = "duration"
+
+
+class AggregationExactGroupingV2(core.ModelBase):
+ """
+ Divides objects into groups according to an exact value.
+ Either `field` or `propertyIdentifier` must be supplied, but not both.
+ """
+
+ field: typing.Optional[PropertyApiName] = None
+ property_identifier: typing.Optional[PropertyIdentifier] = pydantic.Field(alias=str("propertyIdentifier"), default=None) # type: ignore[literal-required]
+ max_group_count: typing.Optional[int] = pydantic.Field(alias=str("maxGroupCount"), default=None) # type: ignore[literal-required]
+ """
+ The maximum number of groups to return. If omitted, defaults to 10,000.
+
+ The server allocates resources based on the specified `maxGroupCount`. When the number of distinct
+ values in your data is within this limit, results are accurate and the top N values are returned
+ correctly. When distinct values exceed what the allocated resources can handle, results may become
+ approximate.
+
+ If you need accurate results with high-cardinality properties, set `maxGroupCount` high enough to
+ cover your distinct values. Items exceeding the limit are excluded from results and counted in
+ `excludedItems`. The response `accuracy` field indicates whether the results are `ACCURATE` or
+ `APPROXIMATE`.
+ """
+
+ default_value: typing.Optional[str] = pydantic.Field(alias=str("defaultValue"), default=None) # type: ignore[literal-required]
+ """
+ Includes a group with the specified default value that includes all objects where the specified field's value is null.
+ Cannot be used with includeNullValues.
+ """
+
+ include_null_values: typing.Optional[bool] = pydantic.Field(alias=str("includeNullValues"), default=None) # type: ignore[literal-required]
+ """
+ Includes a group with a null value that includes all objects where the specified field's value is null.
+ Cannot be used with defaultValue or orderBy clauses on the aggregation.
+ """
+
+ type: typing.Literal["exact"] = "exact"
+
+
+class AggregationFixedWidthGroupingV2(core.ModelBase):
+ """
+ Divides objects into groups with the specified width.
+ Either `field` or `propertyIdentifier` must be supplied, but not both.
+ """
+
+ field: typing.Optional[PropertyApiName] = None
+ property_identifier: typing.Optional[PropertyIdentifier] = pydantic.Field(alias=str("propertyIdentifier"), default=None) # type: ignore[literal-required]
+ fixed_width: int = pydantic.Field(alias=str("fixedWidth")) # type: ignore[literal-required]
+ type: typing.Literal["fixedWidth"] = "fixedWidth"
+
+
+AggregationGroupByV2: typing_extensions.TypeAlias = typing_extensions.Annotated[
+ typing.Union[
+ "AggregationDurationGroupingV2",
+ "AggregationFixedWidthGroupingV2",
+ "AggregationRangesGroupingV2",
+ "AggregationExactGroupingV2",
+ ],
+ pydantic.Field(discriminator="type"),
+]
+"""Specifies a grouping for aggregation results."""
+
+
+AggregationGroupKeyV2: typing_extensions.TypeAlias = str
+"""AggregationGroupKeyV2"""
+
+
+AggregationGroupValueV2: typing_extensions.TypeAlias = typing.Any
+"""AggregationGroupValueV2"""
+
+
+AggregationMetricName: typing_extensions.TypeAlias = str
+"""A user-specified alias for an aggregation metric name."""
+
+
+class AggregationMetricResultV2(core.ModelBase):
+ """AggregationMetricResultV2"""
+
+ name: str
+ value: typing.Optional[typing.Any] = None
+ """
+ The value of the metric. This will be a double in the case of
+ a numeric metric, or a date string in the case of a date metric.
+ """
+
+
+class AggregationRangeV2(core.ModelBase):
+ """Specifies a range from an inclusive start value to an exclusive end value."""
+
+ start_value: typing.Any = pydantic.Field(alias=str("startValue")) # type: ignore[literal-required]
+ """Inclusive start."""
+
+ end_value: typing.Any = pydantic.Field(alias=str("endValue")) # type: ignore[literal-required]
+ """Exclusive end."""
+
+
+class AggregationRangesGroupingV2(core.ModelBase):
+ """
+ Divides objects into groups according to specified ranges.
+ Either `field` or `propertyIdentifier` must be supplied, but not both.
+ """
+
+ field: typing.Optional[PropertyApiName] = None
+ property_identifier: typing.Optional[PropertyIdentifier] = pydantic.Field(alias=str("propertyIdentifier"), default=None) # type: ignore[literal-required]
+ ranges: typing.List[AggregationRangeV2]
+ type: typing.Literal["ranges"] = "ranges"
+
+
+AggregationV2: typing_extensions.TypeAlias = typing_extensions.Annotated[
+ typing.Union[
+ "ApproximateDistinctAggregationV2",
+ "MinAggregationV2",
+ "AvgAggregationV2",
+ "MaxAggregationV2",
+ "ApproximatePercentileAggregationV2",
+ "CountAggregationV2",
+ "SumAggregationV2",
+ "ExactDistinctAggregationV2",
+ ],
+ pydantic.Field(discriminator="type"),
+]
+"""Specifies an aggregation function."""
+
+
+class AllOfRule(core.ModelBase):
+ """Matches intervals satisfying all the rules in the query"""
+
+ rules: typing.List[IntervalQueryRule]
+ max_gaps: typing.Optional[int] = pydantic.Field(alias=str("maxGaps"), default=None) # type: ignore[literal-required]
+ """The maximum gaps between the intervals produced by the sub-rules. If not set, then gaps are not considered."""
+
+ ordered: bool
+ """If true, the matched intervals must occur in order."""
+
+ type: typing.Literal["allOf"] = "allOf"
+
+
+class AndActionTypesQueryV2(core.ModelBase):
+ """Returns action types where every query is satisfied. An empty list matches all action types."""
+
+ value: typing.List[ActionTypeSearchJsonQueryV2]
+ type: typing.Literal["and"] = "and"
+
+
+class AndQueryV2(core.ModelBase):
+ """Returns objects where every query is satisfied."""
+
+ value: typing.List[SearchJsonQueryV2]
+ type: typing.Literal["and"] = "and"
+
+
+class AnyOfRule(core.ModelBase):
+ """Matches intervals satisfying any of the rules in the query"""
+
+ rules: typing.List[IntervalQueryRule]
+ type: typing.Literal["anyOf"] = "anyOf"
+
+
+ApplyActionMode: typing_extensions.TypeAlias = typing.Literal[
+ "VALIDATE_ONLY", "VALIDATE_AND_EXECUTE"
+]
+"""If not specified, defaults to `VALIDATE_AND_EXECUTE`."""
+
+
+class ApplyActionOverrides(core.ModelBase):
+ """ApplyActionOverrides"""
+
+ unique_identifier_link_id_values: typing.Dict[UniqueIdentifierLinkId, UniqueIdentifierValue] = pydantic.Field(alias=str("uniqueIdentifierLinkIdValues")) # type: ignore[literal-required]
+ action_execution_time: typing.Optional[ActionExecutionTime] = pydantic.Field(alias=str("actionExecutionTime"), default=None) # type: ignore[literal-required]
+
+
+class ApplyActionRequestOptions(core.ModelBase):
+ """ApplyActionRequestOptions"""
+
+ mode: typing.Optional[ApplyActionMode] = None
+ return_edits: typing.Optional[ReturnEditsMode] = pydantic.Field(alias=str("returnEdits"), default=None) # type: ignore[literal-required]
+
+
+class ApplyActionRequestV2(core.ModelBase):
+ """ApplyActionRequestV2"""
+
+ options: typing.Optional[ApplyActionRequestOptions] = None
+ parameters: typing.Dict[ParameterId, typing.Optional[DataValue]]
+
+
+class ApplyActionWithOverridesRequest(core.ModelBase):
+ """ApplyActionWithOverridesRequest"""
+
+ request: ApplyActionRequestV2
+ overrides: ApplyActionOverrides
+
+
+class ApplyReducersAndExtractMainValueLoadLevel(core.ModelBase):
+ """Performs both apply reducers and extract main value to return the reduced main value."""
+
+ type: typing.Literal["applyReducersAndExtractMainValue"] = "applyReducersAndExtractMainValue"
+
+
+class ApplyReducersLoadLevel(core.ModelBase):
+ """Returns a single value of an array as configured in the ontology."""
+
+ type: typing.Literal["applyReducers"] = "applyReducers"
+
+
+class ApplyScenarioLogicRule(core.ModelBase):
+ """
+ An Action rule that merges the edits accumulated on a referenced Scenario into the ontology data context
+ where the Action is applied. If the Action is applied against another Scenario, the edits are merged into
+ that target Scenario.
+
+ The scenario is supplied through the parameter identified by `scenarioParameter`, whose value type is
+ `scenarioReference`. The affected object types and link types are explicitly enumerated in the scope.
+ """
+
+ scenario_parameter: ParameterId = pydantic.Field(alias=str("scenarioParameter")) # type: ignore[literal-required]
+ object_type_api_names: typing.List[ObjectTypeApiName] = pydantic.Field(alias=str("objectTypeApiNames")) # type: ignore[literal-required]
+ link_types: typing.List[ObjectTypeLinkTypeApiNameMapping] = pydantic.Field(alias=str("linkTypes")) # type: ignore[literal-required]
+ type: typing.Literal["applyScenario"] = "applyScenario"
+
+
+class ApplyScenarioRule(core.ModelBase):
+ """
+ An Action rule that applies the edits accumulated on a referenced Scenario onto the ontology data context
+ where the Action is applied. If the Action is applied in the context of main ontology data, the edits are
+ applied there. If the Action is applied in the context of another Scenario, the edits are applied in that
+ other Scenario.
+
+ The scenario is supplied through the parameter identified by `scenarioParameter` of type
+ `scenarioReference`. The affected object types and link types are explicitly enumerated in the scope.
+ """
+
+ scenario_parameter: ParameterId = pydantic.Field(alias=str("scenarioParameter")) # type: ignore[literal-required]
+ object_type_api_names: typing.List[ObjectTypeApiName] = pydantic.Field(alias=str("objectTypeApiNames")) # type: ignore[literal-required]
+ link_types: typing.List[ObjectTypeLinkTypeApiNameMapping] = pydantic.Field(alias=str("linkTypes")) # type: ignore[literal-required]
+ type: typing.Literal["applyScenario"] = "applyScenario"
+
+
+class ApproximateDistinctAggregationV2(core.ModelBase):
+ """
+ Computes an approximate number of distinct values for the provided field.
+ Either `field` or `propertyIdentifier` must be supplied, but not both.
+ """
+
+ field: typing.Optional[PropertyApiName] = None
+ property_identifier: typing.Optional[PropertyIdentifier] = pydantic.Field(alias=str("propertyIdentifier"), default=None) # type: ignore[literal-required]
+ name: typing.Optional[AggregationMetricName] = None
+ direction: typing.Optional[OrderByDirection] = None
+ type: typing.Literal["approximateDistinct"] = "approximateDistinct"
+
+
+class ApproximatePercentileAggregationV2(core.ModelBase):
+ """
+ Computes the approximate percentile value for the provided field. Requires Object Storage V2.
+ Either `field` or `propertyIdentifier` must be supplied, but not both.
+ """
+
+ field: typing.Optional[PropertyApiName] = None
+ property_identifier: typing.Optional[PropertyIdentifier] = pydantic.Field(alias=str("propertyIdentifier"), default=None) # type: ignore[literal-required]
+ name: typing.Optional[AggregationMetricName] = None
+ approximate_percentile: float = pydantic.Field(alias=str("approximatePercentile")) # type: ignore[literal-required]
+ direction: typing.Optional[OrderByDirection] = None
+ type: typing.Literal["approximatePercentile"] = "approximatePercentile"
+
+
+class Arg(core.ModelBase):
+ """Arg"""
+
+ name: str
+ value: str
+
+
+class ArrayConstraint(core.ModelBase):
+ """ArrayConstraint"""
+
+ minimum_size: typing.Optional[int] = pydantic.Field(alias=str("minimumSize"), default=None) # type: ignore[literal-required]
+ maximum_size: typing.Optional[int] = pydantic.Field(alias=str("maximumSize"), default=None) # type: ignore[literal-required]
+ unique_values: bool = pydantic.Field(alias=str("uniqueValues")) # type: ignore[literal-required]
+ value_constraint: typing.Optional[ValueTypeConstraint] = pydantic.Field(alias=str("valueConstraint"), default=None) # type: ignore[literal-required]
+ type: typing.Literal["array"] = "array"
+
+
+class ArrayEvaluatedConstraint(core.ModelBase):
+ """Evaluated constraints of array parameters that support per-entry constraint evaluations."""
+
+ entries: typing.List[ArrayEntryEvaluatedConstraint]
+ type: typing.Literal["array"] = "array"
+
+
+class ArraySizeConstraint(core.ModelBase):
+ """The parameter expects an array of values and the size of the array must fall within the defined range."""
+
+ lt: typing.Optional[typing.Any] = None
+ """Less than"""
+
+ lte: typing.Optional[typing.Any] = None
+ """Less than or equal"""
+
+ gt: typing.Optional[typing.Any] = None
+ """Greater than"""
+
+ gte: typing.Optional[typing.Any] = None
+ """Greater than or equal"""
+
+ type: typing.Literal["arraySize"] = "arraySize"
+
+
+ArtifactRepositoryRid: typing_extensions.TypeAlias = core.RID
+"""ArtifactRepositoryRid"""
+
+
+class AttachmentAllowedValues(core.ModelBase):
+ """The parameter value (an attachment rid) must reference an attachment within the configured size limit."""
+
+ max_size_bytes: typing.Optional[core_models.SizeBytes] = pydantic.Field(alias=str("maxSizeBytes"), default=None) # type: ignore[literal-required]
+ type: typing.Literal["attachment"] = "attachment"
+
+
+AttachmentMetadataResponse: typing_extensions.TypeAlias = typing_extensions.Annotated[
+ typing.Union["AttachmentV2", "ListAttachmentsResponseV2"], pydantic.Field(discriminator="type")
+]
+"""The attachment metadata response"""
+
+
+AttachmentRid: typing_extensions.TypeAlias = core.RID
+"""The unique resource identifier of an attachment."""
+
+
+class AttachmentV2(core.ModelBase):
+ """The representation of an attachment."""
+
+ rid: AttachmentRid
+ filename: core_models.Filename
+ size_bytes: core_models.SizeBytes = pydantic.Field(alias=str("sizeBytes")) # type: ignore[literal-required]
+ media_type: core_models.MediaType = pydantic.Field(alias=str("mediaType")) # type: ignore[literal-required]
+ type: typing.Literal["single"] = "single"
+
+
+class AvgAggregationV2(core.ModelBase):
+ """
+ Computes the average value for the provided field.
+ Either `field` or `propertyIdentifier` must be supplied, but not both.
+ """
+
+ field: typing.Optional[PropertyApiName] = None
+ property_identifier: typing.Optional[PropertyIdentifier] = pydantic.Field(alias=str("propertyIdentifier"), default=None) # type: ignore[literal-required]
+ name: typing.Optional[AggregationMetricName] = None
+ direction: typing.Optional[OrderByDirection] = None
+ type: typing.Literal["avg"] = "avg"
+
+
+BatchActionObjectEdit: typing_extensions.TypeAlias = typing_extensions.Annotated[
+ typing.Union["ModifyObject", "AddObject", "AddLink"], pydantic.Field(discriminator="type")
+]
+"""BatchActionObjectEdit"""
+
+
+class BatchActionObjectEdits(core.ModelBase):
+ """BatchActionObjectEdits"""
+
+ edits: typing.List[BatchActionObjectEdit]
+ added_object_count: int = pydantic.Field(alias=str("addedObjectCount")) # type: ignore[literal-required]
+ modified_objects_count: int = pydantic.Field(alias=str("modifiedObjectsCount")) # type: ignore[literal-required]
+ deleted_objects_count: int = pydantic.Field(alias=str("deletedObjectsCount")) # type: ignore[literal-required]
+ added_links_count: int = pydantic.Field(alias=str("addedLinksCount")) # type: ignore[literal-required]
+ deleted_links_count: int = pydantic.Field(alias=str("deletedLinksCount")) # type: ignore[literal-required]
+ type: typing.Literal["edits"] = "edits"
+
+
+BatchActionResults: typing_extensions.TypeAlias = typing_extensions.Annotated[
+ typing.Union["BatchActionObjectEdits", "ObjectTypeEdits"], pydantic.Field(discriminator="type")
+]
+"""BatchActionResults"""
+
+
+class BatchApplyActionRequestItem(core.ModelBase):
+ """BatchApplyActionRequestItem"""
+
+ parameters: typing.Dict[ParameterId, typing.Optional[DataValue]]
+
+
+class BatchApplyActionRequestItemWithOverrides(core.ModelBase):
+ """BatchApplyActionRequestItemWithOverrides"""
+
+ parameters: typing.Dict[ParameterId, typing.Optional[DataValue]]
+ overrides: typing.Optional[ApplyActionOverrides] = None
+
+
+class BatchApplyActionRequestOptions(core.ModelBase):
+ """BatchApplyActionRequestOptions"""
+
+ return_edits: typing.Optional[BatchReturnEditsMode] = pydantic.Field(alias=str("returnEdits"), default=None) # type: ignore[literal-required]
+
+
+class BatchApplyActionRequestV2(core.ModelBase):
+ """BatchApplyActionRequestV2"""
+
+ options: typing.Optional[BatchApplyActionRequestOptions] = None
+ requests: typing.List[BatchApplyActionRequestItem]
+
+
+class BatchApplyActionResponseV2(core.ModelBase):
+ """BatchApplyActionResponseV2"""
+
+ edits: typing.Optional[BatchActionResults] = None
+
+
+class BatchApplyActionWithOverridesRequest(core.ModelBase):
+ """BatchApplyActionWithOverridesRequest"""
+
+ options: typing.Optional[BatchApplyActionRequestOptions] = None
+ requests: typing.List[BatchApplyActionRequestItemWithOverrides]
+
+
+BatchReturnEditsMode: typing_extensions.TypeAlias = typing.Literal["ALL", "NONE"]
+"""If not specified, defaults to `NONE`."""
+
+
+class BatchedFunctionLogicRule(core.ModelBase):
+ """BatchedFunctionLogicRule"""
+
+ object_set_rid_input_name: FunctionParameterName = pydantic.Field(alias=str("objectSetRidInputName")) # type: ignore[literal-required]
+ function_rule: FunctionLogicRule = pydantic.Field(alias=str("functionRule")) # type: ignore[literal-required]
+ type: typing.Literal["batchedFunction"] = "batchedFunction"
+
+
+class BlueprintIcon(core.ModelBase):
+ """BlueprintIcon"""
+
+ color: str
+ """A hexadecimal color code."""
+
+ name: str
+ """
+ The [name](https://blueprintjs.com/docs/#icons/icons-list) of the Blueprint icon.
+ Used to specify the Blueprint icon to represent the object type in a React app.
+ """
+
+ type: typing.Literal["blueprint"] = "blueprint"
+
+
+class BooleanValue(core.ModelBase):
+ """BooleanValue"""
+
+ value: bool
+ type: typing.Literal["booleanValue"] = "booleanValue"
+
+
+class BoundingBoxValue(core.ModelBase):
+ """The top left and bottom right coordinate points that make up the bounding box."""
+
+ top_left: WithinBoundingBoxPoint = pydantic.Field(alias=str("topLeft")) # type: ignore[literal-required]
+ bottom_right: WithinBoundingBoxPoint = pydantic.Field(alias=str("bottomRight")) # type: ignore[literal-required]
+ type: typing.Literal["envelope"] = "envelope"
+
+
+class CenterPoint(core.ModelBase):
+ """The coordinate point to use as the center of the distance query."""
+
+ center: CenterPointTypes
+ distance: core_models.Distance
+
+
+CipherChannelStrategy: typing_extensions.TypeAlias = typing.Literal[
+ "PREFER_EXISTING", "PREFER_DEFAULT", "EXISTING_ONLY", "DEFAULT_ONLY"
+]
+"""
+Controls which Cipher Channel is used when encrypting a value. If not specified, defaults to `PREFER_EXISTING`.
+
+- `PREFER_EXISTING`: use the Cipher Channel parsed from the existing ciphertext value; fall back to the default channel configured in ontology metadata.
+- `PREFER_DEFAULT`: use the default channel configured in ontology metadata; fall back to the channel parsed from the existing ciphertext value.
+- `EXISTING_ONLY`: use the channel parsed from the existing ciphertext value only; error if the value is not already encrypted.
+- `DEFAULT_ONLY`: use the default channel configured in ontology metadata only; error if none is configured.
+"""
+
+
+CipherText: typing_extensions.TypeAlias = str
+"""
+A value encrypted with [Cipher](https://palantir.com/docs/foundry/cipher/overview/), stored in its envelope form which encodes
+the Cipher Channel used to encrypt it (for example `CIPHER::{cipherChannelRid}::<ciphertext>::CIPHER`).
+"""
+
+
+ColumnName: typing_extensions.TypeAlias = str
+"""The name of a column in a tabular datasource."""
+
+
+class ColumnPropertyMapping(core.ModelBase):
+ """A property bound to a single column in the backing datasource."""
+
+ column: ColumnName
+ type: typing.Literal["column"] = "column"
+
+
+ConjunctiveMarkingSummary: typing_extensions.TypeAlias = typing.List["MarkingId"]
+"""
+The conjunctive set of markings required to access the property value.
+All markings from a conjunctive set must be met for access.
+"""
+
+
+ContainerConjunctiveMarkingSummary: typing_extensions.TypeAlias = typing.List["MarkingId"]
+"""
+The conjunctive set of markings for the container of this property value,
+such as the project of a dataset. These markings may differ from the marking
+on the actual property value, but still must be satisfied for accessing the property
+
+All markings from a conjunctive set must be met for access.
+"""
+
+
+ContainerDisjunctiveMarkingSummary: typing_extensions.TypeAlias = typing.List[
+ typing.List["MarkingId"]
+]
+"""
+The disjunctive set of markings for the container of this property value,
+such as the project of a dataset. These markings may differ from the marking
+on the actual property value, but still must be satisfied for accessing the property
+All markings from a conjunctive set must be met for access.
+
+Disjunctive markings are represented as a conjunctive list of disjunctive sets.
+The top-level set is a conjunction of sets, where each inner set should be
+treated as a unit where any marking within the set can satisfy the set.
+All sets within the top level set should be satisfied.
+"""
+
+
+class ContainsAllTermsInOrderPrefixLastTerm(core.ModelBase):
+ """
+ Returns objects where the specified field contains all of the terms in the order provided,
+ but they do have to be adjacent to each other.
+ The last term can be a partial prefix match. Allows you to specify a property to query on
+ by a variety of means. Either `field` or `propertyIdentifier` can be supplied, but not both.
+ """
+
+ field: typing.Optional[PropertyApiName] = None
+ property_identifier: typing.Optional[PropertyIdentifier] = pydantic.Field(alias=str("propertyIdentifier"), default=None) # type: ignore[literal-required]
+ value: str
+ type: typing.Literal["containsAllTermsInOrderPrefixLastTerm"] = (
+ "containsAllTermsInOrderPrefixLastTerm"
+ )
+
+
+class ContainsAllTermsInOrderQuery(core.ModelBase):
+ """
+ Returns objects where the specified field contains all of the terms in the order provided,
+ but they do have to be adjacent to each other. Allows you to specify a property to query on
+ by a variety of means. Either `field` or `propertyIdentifier` must be supplied, but not both.
+ """
+
+ field: typing.Optional[PropertyApiName] = None
+ property_identifier: typing.Optional[PropertyIdentifier] = pydantic.Field(alias=str("propertyIdentifier"), default=None) # type: ignore[literal-required]
+ value: str
+ type: typing.Literal["containsAllTermsInOrder"] = "containsAllTermsInOrder"
+
+
+class ContainsAllTermsQuery(core.ModelBase):
+ """
+ Returns objects where the specified field contains all of the whitespace separated words in any
+ order in the provided value. This query supports fuzzy matching. Allows you to specify a property to query on
+ by a variety of means. Either `field` or `propertyIdentifier` must be supplied, but not both.
+ """
+
+ field: typing.Optional[PropertyApiName] = None
+ property_identifier: typing.Optional[PropertyIdentifier] = pydantic.Field(alias=str("propertyIdentifier"), default=None) # type: ignore[literal-required]
+ value: str
+ fuzzy: typing.Optional[FuzzyV2] = None
+ type: typing.Literal["containsAllTerms"] = "containsAllTerms"
+
+
+class ContainsAnyTermQuery(core.ModelBase):
+ """
+ Returns objects where the specified field contains any of the whitespace separated words in any
+ order in the provided value. This query supports fuzzy matching. Allows you to specify a property to query on
+ by a variety of means. Either `field` or `propertyIdentifier` must be supplied, but not both.
+ """
+
+ field: typing.Optional[PropertyApiName] = None
+ property_identifier: typing.Optional[PropertyIdentifier] = pydantic.Field(alias=str("propertyIdentifier"), default=None) # type: ignore[literal-required]
+ value: str
+ fuzzy: typing.Optional[FuzzyV2] = None
+ type: typing.Literal["containsAnyTerm"] = "containsAnyTerm"
+
+
+class ContainsQueryV2(core.ModelBase):
+ """
+ Returns objects where the specified array contains a value. Allows you to specify a property to query on by a
+ variety of means. Either `field` or `propertyIdentifier` must be supplied, but not both.
+ """
+
+ field: typing.Optional[PropertyApiName] = None
+ property_identifier: typing.Optional[PropertyIdentifier] = pydantic.Field(alias=str("propertyIdentifier"), default=None) # type: ignore[literal-required]
+ value: PropertyValue
+ type: typing.Literal["contains"] = "contains"
+
+
+class CountAggregationV2(core.ModelBase):
+ """Computes the total count of objects."""
+
+ name: typing.Optional[AggregationMetricName] = None
+ direction: typing.Optional[OrderByDirection] = None
+ type: typing.Literal["count"] = "count"
+
+
+class CountObjectsResponseV2(core.ModelBase):
+ """CountObjectsResponseV2"""
+
+ count: typing.Optional[int] = None
+
+
+class CreateEdit(core.ModelBase):
+ """CreateEdit"""
+
+ properties: typing.Dict[PropertyApiName, PropertyValue]
+ """
+ The property values of the object at the time of creation.
+ Maps property API names to their values.
+ """
+
+ type: typing.Literal["createEdit"] = "createEdit"
+
+
+class CreateInterfaceLinkLogicRule(core.ModelBase):
+ """CreateInterfaceLinkLogicRule"""
+
+ interface_type_api_name: InterfaceTypeApiName = pydantic.Field(alias=str("interfaceTypeApiName")) # type: ignore[literal-required]
+ interface_link_type_api_name: InterfaceLinkTypeApiName = pydantic.Field(alias=str("interfaceLinkTypeApiName")) # type: ignore[literal-required]
+ source_object: ParameterId = pydantic.Field(alias=str("sourceObject")) # type: ignore[literal-required]
+ target_object: ParameterId = pydantic.Field(alias=str("targetObject")) # type: ignore[literal-required]
+ type: typing.Literal["createInterfaceLink"] = "createInterfaceLink"
+
+
+class CreateInterfaceLogicRule(core.ModelBase):
+ """CreateInterfaceLogicRule"""
+
+ interface_type_api_name: InterfaceTypeApiName = pydantic.Field(alias=str("interfaceTypeApiName")) # type: ignore[literal-required]
+ object_type: ParameterId = pydantic.Field(alias=str("objectType")) # type: ignore[literal-required]
+ shared_property_arguments: typing.Dict[SharedPropertyTypeApiName, LogicRuleArgument] = pydantic.Field(alias=str("sharedPropertyArguments")) # type: ignore[literal-required]
+ struct_property_arguments: typing.Dict[SharedPropertyTypeApiName, typing.Dict[StructFieldApiName, StructFieldArgument]] = pydantic.Field(alias=str("structPropertyArguments")) # type: ignore[literal-required]
+ type: typing.Literal["createInterface"] = "createInterface"
+
+
+class CreateInterfaceObjectRule(core.ModelBase):
+ """CreateInterfaceObjectRule"""
+
+ interface_type_api_name: InterfaceTypeApiName = pydantic.Field(alias=str("interfaceTypeApiName")) # type: ignore[literal-required]
+ type: typing.Literal["createInterfaceObject"] = "createInterfaceObject"
+
+
+class CreateLinkLogicRule(core.ModelBase):
+ """CreateLinkLogicRule"""
+
+ link_type_api_name: LinkTypeApiName = pydantic.Field(alias=str("linkTypeApiName")) # type: ignore[literal-required]
+ source_object: ParameterId = pydantic.Field(alias=str("sourceObject")) # type: ignore[literal-required]
+ target_object: ParameterId = pydantic.Field(alias=str("targetObject")) # type: ignore[literal-required]
+ type: typing.Literal["createLink"] = "createLink"
+
+
+class CreateLinkRule(core.ModelBase):
+ """CreateLinkRule"""
+
+ link_type_api_name_ato_b: LinkTypeApiName = pydantic.Field(alias=str("linkTypeApiNameAtoB")) # type: ignore[literal-required]
+ link_type_api_name_bto_a: LinkTypeApiName = pydantic.Field(alias=str("linkTypeApiNameBtoA")) # type: ignore[literal-required]
+ a_side_object_type_api_name: ObjectTypeApiName = pydantic.Field(alias=str("aSideObjectTypeApiName")) # type: ignore[literal-required]
+ b_side_object_type_api_name: ObjectTypeApiName = pydantic.Field(alias=str("bSideObjectTypeApiName")) # type: ignore[literal-required]
+ type: typing.Literal["createLink"] = "createLink"
+
+
+class CreateObjectLogicRule(core.ModelBase):
+ """CreateObjectLogicRule"""
+
+ object_type_api_name: ObjectTypeApiName = pydantic.Field(alias=str("objectTypeApiName")) # type: ignore[literal-required]
+ property_arguments: typing.Dict[PropertyApiName, LogicRuleArgument] = pydantic.Field(alias=str("propertyArguments")) # type: ignore[literal-required]
+ struct_property_arguments: typing.Dict[PropertyApiName, typing.Dict[StructFieldApiName, StructFieldArgument]] = pydantic.Field(alias=str("structPropertyArguments")) # type: ignore[literal-required]
+ type: typing.Literal["createObject"] = "createObject"
+
+
+class CreateObjectRule(core.ModelBase):
+ """CreateObjectRule"""
+
+ object_type_api_name: ObjectTypeApiName = pydantic.Field(alias=str("objectTypeApiName")) # type: ignore[literal-required]
+ type: typing.Literal["createObject"] = "createObject"
+
+
+class CreateOntologyScenarioRequest(core.ModelBase):
+ """The request payload for creating an ontology scenario."""
+
+ base: typing.Optional[OntologyBase] = None
+ expire_after: typing.Optional[core.AwareDatetime] = pydantic.Field(alias=str("expireAfter"), default=None) # type: ignore[literal-required]
+ """
+ The date after which the scenario expires and is automatically cleaned up.
+ Defaults to 31 days after creation. Must be after creation and no later
+ than 31 days after creation.
+ """
+
+
+class CreateOntologyScenarioResponse(core.ModelBase):
+ """The response payload for creating an ontology scenario."""
+
+ scenario_rid: OntologyScenarioRid = pydantic.Field(alias=str("scenarioRid")) # type: ignore[literal-required]
+
+
+class CreateOrModifyObjectLogicRule(core.ModelBase):
+ """CreateOrModifyObjectLogicRule"""
+
+ object_type_api_name: ObjectTypeApiName = pydantic.Field(alias=str("objectTypeApiName")) # type: ignore[literal-required]
+ property_arguments: typing.Dict[PropertyApiName, LogicRuleArgument] = pydantic.Field(alias=str("propertyArguments")) # type: ignore[literal-required]
+ struct_property_arguments: typing.Dict[PropertyApiName, typing.Dict[StructFieldApiName, StructFieldArgument]] = pydantic.Field(alias=str("structPropertyArguments")) # type: ignore[literal-required]
+ type: typing.Literal["createOrModifyObject"] = "createOrModifyObject"
+
+
+class CreateOrModifyObjectLogicRuleV2(core.ModelBase):
+ """CreateOrModifyObjectLogicRuleV2"""
+
+ object_to_modify: ParameterId = pydantic.Field(alias=str("objectToModify")) # type: ignore[literal-required]
+ property_arguments: typing.Dict[PropertyApiName, LogicRuleArgument] = pydantic.Field(alias=str("propertyArguments")) # type: ignore[literal-required]
+ struct_property_arguments: typing.Dict[PropertyApiName, typing.Dict[StructFieldApiName, StructFieldArgument]] = pydantic.Field(alias=str("structPropertyArguments")) # type: ignore[literal-required]
+ type: typing.Literal["createOrModifyObjectV2"] = "createOrModifyObjectV2"
+
+
+class CreateTemporaryObjectSetRequestV2(core.ModelBase):
+ """CreateTemporaryObjectSetRequestV2"""
+
+ object_set: ObjectSet = pydantic.Field(alias=str("objectSet")) # type: ignore[literal-required]
+
+
+class CreateTemporaryObjectSetResponseV2(core.ModelBase):
+ """CreateTemporaryObjectSetResponseV2"""
+
+ object_set_rid: ObjectSetRid = pydantic.Field(alias=str("objectSetRid")) # type: ignore[literal-required]
+
+
+class CurrentTimeArgument(core.ModelBase):
+ """Represents the current time argument in a logic rule."""
+
+ type: typing.Literal["currentTime"] = "currentTime"
+
+
+class CurrentUserArgument(core.ModelBase):
+ """Represents the current user argument in a logic rule."""
+
+ type: typing.Literal["currentUser"] = "currentUser"
+
+
+DataValue: typing_extensions.TypeAlias = typing.Any
+"""
+Represents the value of data in the following format. Note that these values can be nested, for example an array of structs.
+| Type | JSON encoding | Example |
+|-------------------------------------|-------------------------------------------------------|---------------------------------------------------------------------------------------------------------------------------------------------------------------|
+| Array | array | `["alpha", "bravo", "charlie"]` |
+| Attachment | string | `"ri.attachments.main.attachment.2f944bae-5851-4204-8615-920c969a9f2e"` |
+| Boolean | boolean | `true` |
+| Byte | number | `31` |
+| CipherText | string | `"CIPHER::ri.bellaso.main.cipher-channel.e414ab9e-b606-499a-a0e1-844fa296ba7e::unzjs3VifsTxuIpf1fH1CJ7OaPBr2bzMMdozPaZJtCii8vVG60yXIEmzoOJaEl9mfFFe::CIPHER"` |
+| Date | ISO 8601 extended local date string | `"2021-05-01"` |
+| Decimal | string | `"2.718281828"` |
+| Double | number | `3.14159265` |
+| EntrySet | array of JSON objects | `[{"key": "EMP1234", "value": "true"}, {"key": "EMP4444", "value": "false"}]` |
+| Float | number | `3.14159265` |
+| Integer | number | `238940` |
+| Long | string | `"58319870951433"` |
+| Marking | string | `"MU"` |
+| Null | null | `null` |
+| Object Set | string OR the object set definition | `ri.object-set.main.versioned-object-set.h13274m8-23f5-431c-8aee-a4554157c57z` |
+| Ontology Object Reference | JSON encoding of the object's primary key | `10033123` or `"EMP1234"` |
+| Ontology Interface Object Reference | JSON encoding of the object's API name and primary key| `{"objectTypeApiName":"Employee", "primaryKeyValue":"EMP1234"}` |
+| Ontology Object Type Reference | string of the object type's api name | `"Employee"` |
+| Scenario Reference | string of the scenario RID | `"ri.actions..scenario.cf2a8a49-8b56-446d-ab04-a6bc7fadef48"` |
+| Set | array | `["alpha", "bravo", "charlie"]` |
+| Short | number | `8739` |
+| String | string | `"Call me Ishmael"` |
+| Struct | JSON object | `{"name": "John Doe", "age": 42}` |
+| TwoDimensionalAggregation | JSON object | `{"groups": [{"key": "alpha", "value": 100}, {"key": "beta", "value": 101}]}` |
+| ThreeDimensionalAggregation | JSON object | `{"groups": [{"key": "NYC", "groups": [{"key": "Engineer", "value" : 100}]}]}` |
+| Timestamp | ISO 8601 extended offset date-time string in UTC zone | `"2021-01-04T05:00:00Z"` |
+"""
+
+
+DatasourceBranchId: typing_extensions.TypeAlias = str
+"""The id of a datasource branch. Branch ids are user supplied strings, not RIDs."""
+
+
+DatasourceRid: typing_extensions.TypeAlias = core.RID
+"""Randomly generated identifier for an object type's datasource."""
+
+
+class DateValue(core.ModelBase):
+ """DateValue"""
+
+ value: date
+ type: typing.Literal["dateValue"] = "dateValue"
+
+
+class DatetimeAllowedValues(core.ModelBase):
+ """The parameter value must fall within the specified date or timestamp range."""
+
+ gt: typing.Optional[ParameterDatetimeValue] = None
+ gte: typing.Optional[ParameterDatetimeValue] = None
+ lt: typing.Optional[ParameterDatetimeValue] = None
+ lte: typing.Optional[ParameterDatetimeValue] = None
+ type: typing.Literal["datetime"] = "datetime"
+
+
+DatetimeFormat: typing_extensions.TypeAlias = typing_extensions.Annotated[
+ typing.Union["DatetimeStringFormat", "DatetimeLocalizedFormat"],
+ pydantic.Field(discriminator="type"),
+]
+"""DatetimeFormat"""
+
+
+class DatetimeLocalizedFormat(core.ModelBase):
+ """Predefined localized formatting options."""
+
+ format: DatetimeLocalizedFormatType
+ type: typing.Literal["localizedFormat"] = "localizedFormat"
+
+
+DatetimeLocalizedFormatType: typing_extensions.TypeAlias = typing.Literal[
+ "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",
+]
+"""Localized date/time format types."""
+
+
+class DatetimeStringFormat(core.ModelBase):
+ """A strictly specified date format pattern."""
+
+ pattern: str
+ """A valid format string composed of date/time patterns."""
+
+ type: typing.Literal["stringFormat"] = "stringFormat"
+
+
+DatetimeTimezone: typing_extensions.TypeAlias = typing_extensions.Annotated[
+ typing.Union["DatetimeTimezoneStatic", "DatetimeTimezoneUser"],
+ pydantic.Field(discriminator="type"),
+]
+"""DatetimeTimezone"""
+
+
+class DatetimeTimezoneStatic(core.ModelBase):
+ """DatetimeTimezoneStatic"""
+
+ zone_id: PropertyTypeReferenceOrStringConstant = pydantic.Field(alias=str("zoneId")) # type: ignore[literal-required]
+ type: typing.Literal["static"] = "static"
+
+
+class DatetimeTimezoneUser(core.ModelBase):
+ """The user's local timezone."""
+
+ type: typing.Literal["user"] = "user"
+
+
+class DecryptionResult(core.ModelBase):
+ """The result of a CipherText decryption. If successful, the plaintext decrypted value will be returned. Otherwise, an error will be thrown."""
+
+ plaintext: Plaintext
+
+
+class DeleteEdit(core.ModelBase):
+ """DeleteEdit"""
+
+ previous_properties: typing.Dict[PropertyApiName, PropertyValue] = pydantic.Field(alias=str("previousProperties")) # type: ignore[literal-required]
+ type: typing.Literal["deleteEdit"] = "deleteEdit"
+
+
+class DeleteInterfaceLinkLogicRule(core.ModelBase):
+ """DeleteInterfaceLinkLogicRule"""
+
+ interface_type_api_name: InterfaceTypeApiName = pydantic.Field(alias=str("interfaceTypeApiName")) # type: ignore[literal-required]
+ interface_link_type_api_name: InterfaceLinkTypeApiName = pydantic.Field(alias=str("interfaceLinkTypeApiName")) # type: ignore[literal-required]
+ source_object: ParameterId = pydantic.Field(alias=str("sourceObject")) # type: ignore[literal-required]
+ target_object: ParameterId = pydantic.Field(alias=str("targetObject")) # type: ignore[literal-required]
+ type: typing.Literal["deleteInterfaceLink"] = "deleteInterfaceLink"
+
+
+class DeleteInterfaceObjectRule(core.ModelBase):
+ """DeleteInterfaceObjectRule"""
+
+ interface_type_api_name: InterfaceTypeApiName = pydantic.Field(alias=str("interfaceTypeApiName")) # type: ignore[literal-required]
+ type: typing.Literal["deleteInterfaceObject"] = "deleteInterfaceObject"
+
+
+class DeleteLink(core.ModelBase):
+ """DeleteLink"""
+
+ link_type_api_name_ato_b: LinkTypeApiName = pydantic.Field(alias=str("linkTypeApiNameAtoB")) # type: ignore[literal-required]
+ link_type_api_name_bto_a: LinkTypeApiName = pydantic.Field(alias=str("linkTypeApiNameBtoA")) # type: ignore[literal-required]
+ a_side_object: LinkSideObject = pydantic.Field(alias=str("aSideObject")) # type: ignore[literal-required]
+ b_side_object: LinkSideObject = pydantic.Field(alias=str("bSideObject")) # type: ignore[literal-required]
+ type: typing.Literal["deleteLink"] = "deleteLink"
+
+
+class DeleteLinkEdit(core.ModelBase):
+ """DeleteLinkEdit"""
+
+ object_type: ObjectTypeApiName = pydantic.Field(alias=str("objectType")) # type: ignore[literal-required]
+ primary_key: PrimaryKeyValue = pydantic.Field(alias=str("primaryKey")) # type: ignore[literal-required]
+ link_type: LinkTypeApiName = pydantic.Field(alias=str("linkType")) # type: ignore[literal-required]
+ linked_object_primary_key: PrimaryKeyValue = pydantic.Field(alias=str("linkedObjectPrimaryKey")) # type: ignore[literal-required]
+ type: typing.Literal["removeLink"] = "removeLink"
+
+
+class DeleteLinkLogicRule(core.ModelBase):
+ """DeleteLinkLogicRule"""
+
+ link_type_api_name: LinkTypeApiName = pydantic.Field(alias=str("linkTypeApiName")) # type: ignore[literal-required]
+ source_object: ParameterId = pydantic.Field(alias=str("sourceObject")) # type: ignore[literal-required]
+ target_object: ParameterId = pydantic.Field(alias=str("targetObject")) # type: ignore[literal-required]
+ type: typing.Literal["deleteLink"] = "deleteLink"
+
+
+class DeleteLinkRule(core.ModelBase):
+ """DeleteLinkRule"""
+
+ link_type_api_name_ato_b: LinkTypeApiName = pydantic.Field(alias=str("linkTypeApiNameAtoB")) # type: ignore[literal-required]
+ link_type_api_name_bto_a: LinkTypeApiName = pydantic.Field(alias=str("linkTypeApiNameBtoA")) # type: ignore[literal-required]
+ a_side_object_type_api_name: ObjectTypeApiName = pydantic.Field(alias=str("aSideObjectTypeApiName")) # type: ignore[literal-required]
+ b_side_object_type_api_name: ObjectTypeApiName = pydantic.Field(alias=str("bSideObjectTypeApiName")) # type: ignore[literal-required]
+ type: typing.Literal["deleteLink"] = "deleteLink"
+
+
+class DeleteObject(core.ModelBase):
+ """DeleteObject"""
+
+ primary_key: PropertyValue = pydantic.Field(alias=str("primaryKey")) # type: ignore[literal-required]
+ object_type: ObjectTypeApiName = pydantic.Field(alias=str("objectType")) # type: ignore[literal-required]
+ type: typing.Literal["deleteObject"] = "deleteObject"
+
+
+class DeleteObjectEdit(core.ModelBase):
+ """DeleteObjectEdit"""
+
+ object_type: ObjectTypeApiName = pydantic.Field(alias=str("objectType")) # type: ignore[literal-required]
+ primary_key: PropertyValue = pydantic.Field(alias=str("primaryKey")) # type: ignore[literal-required]
+ type: typing.Literal["deleteObject"] = "deleteObject"
+
+
+class DeleteObjectLogicRule(core.ModelBase):
+ """DeleteObjectLogicRule"""
+
+ object_to_delete: ParameterId = pydantic.Field(alias=str("objectToDelete")) # type: ignore[literal-required]
+ type: typing.Literal["deleteObject"] = "deleteObject"
+
+
+class DeleteObjectRule(core.ModelBase):
+ """DeleteObjectRule"""
+
+ object_type_api_name: ObjectTypeApiName = pydantic.Field(alias=str("objectTypeApiName")) # type: ignore[literal-required]
+ type: typing.Literal["deleteObject"] = "deleteObject"
+
+
+class DeprecatedPropertyTypeStatus(core.ModelBase):
+ """
+ This status indicates that the PropertyType is reaching the end of its life and will be removed as per the
+ deadline specified.
+ """
+
+ message: str
+ deadline: core.AwareDatetime
+ replaced_by: typing.Optional[PropertyTypeRid] = pydantic.Field(alias=str("replacedBy"), default=None) # type: ignore[literal-required]
+ type: typing.Literal["deprecated"] = "deprecated"
+
+
+DerivedPropertyApiName: typing_extensions.TypeAlias = str
+"""The name of the derived property that will be returned."""
+
+
+DerivedPropertyDefinition: typing_extensions.TypeAlias = typing_extensions.Annotated[
+ typing.Union[
+ "AddPropertyExpression",
+ "AbsoluteValuePropertyExpression",
+ "ExtractPropertyExpression",
+ "SelectedPropertyExpression",
+ "NegatePropertyExpression",
+ "SubtractPropertyExpression",
+ "PropertyApiNameSelector",
+ "LeastPropertyExpression",
+ "DividePropertyExpression",
+ "MultiplyPropertyExpression",
+ "GreatestPropertyExpression",
+ ],
+ pydantic.Field(discriminator="type"),
+]
+"""Definition of a derived property."""
+
+
+DirectSourceRid: typing_extensions.TypeAlias = core.RID
+"""The RID of a direct-write source backing an object type."""
+
+
+DisjunctiveMarkingSummary: typing_extensions.TypeAlias = typing.List[typing.List["MarkingId"]]
+"""
+The disjunctive set of markings required to access the property value.
+Disjunctive markings are represented as a conjunctive list of disjunctive sets.
+The top-level set is a conjunction of sets, where each inner set should be
+treated as a unit where any marking within the set can satisfy the set.
+All sets within the top level set should be satisfied.
+"""
+
+
+class DividePropertyExpression(core.ModelBase):
+ """Divides the left numeric value by the right numeric value."""
+
+ left: DerivedPropertyDefinition
+ right: DerivedPropertyDefinition
+ type: typing.Literal["divide"] = "divide"
+
+
+class DoesNotIntersectBoundingBoxQuery(core.ModelBase):
+ """
+ Returns objects where the specified field does not intersect the bounding box provided. Allows you to specify a
+ property to query on by a variety of means. Either `field` or `propertyIdentifier` must be supplied, but not
+ both.
+ """
+
+ field: typing.Optional[PropertyApiName] = None
+ property_identifier: typing.Optional[PropertyIdentifier] = pydantic.Field(alias=str("propertyIdentifier"), default=None) # type: ignore[literal-required]
+ value: BoundingBoxValue
+ type: typing.Literal["doesNotIntersectBoundingBox"] = "doesNotIntersectBoundingBox"
+
+
+class DoesNotIntersectPolygonQuery(core.ModelBase):
+ """
+ Returns objects where the specified field does not intersect the polygon provided. Allows you to specify a
+ property to query on by a variety of means. Either `field` or `propertyIdentifier` must be supplied, but not
+ both.
+ """
+
+ field: typing.Optional[PropertyApiName] = None
+ property_identifier: typing.Optional[PropertyIdentifier] = pydantic.Field(alias=str("propertyIdentifier"), default=None) # type: ignore[literal-required]
+ value: PolygonValue
+ type: typing.Literal["doesNotIntersectPolygon"] = "doesNotIntersectPolygon"
+
+
+class DoubleValue(core.ModelBase):
+ """DoubleValue"""
+
+ value: float
+ type: typing.Literal["doubleValue"] = "doubleValue"
+
+
+class DoubleVector(core.ModelBase):
+ """
+ The vector to search with. The vector must be of the same dimension as the vectors stored in the provided
+ propertyIdentifier.
+ """
+
+ value: typing.List[float]
+ type: typing.Literal["vector"] = "vector"
+
+
+DurationBaseValue: typing_extensions.TypeAlias = typing.Literal["SECONDS", "MILLISECONDS"]
+"""Specifies the unit of the input duration value."""
+
+
+DurationFormatStyle: typing_extensions.TypeAlias = typing_extensions.Annotated[
+ typing.Union["HumanReadableFormat", "TimeCodeFormat"], pydantic.Field(discriminator="type")
+]
+"""DurationFormatStyle"""
+
+
+DurationPrecision: typing_extensions.TypeAlias = typing.Literal[
+ "DAYS", "HOURS", "MINUTES", "SECONDS", "AUTO"
+]
+"""Specifies the maximum precision to apply when formatting a duration."""
+
+
+EditHistoryEdit: typing_extensions.TypeAlias = typing_extensions.Annotated[
+ typing.Union["CreateEdit", "DeleteEdit", "ModifyEdit"], pydantic.Field(discriminator="type")
+]
+"""EditHistoryEdit"""
+
+
+class EditOnlyPropertyMapping(core.ModelBase):
+ """A property on an object type that is permissioned to a tabular datasource, but the contents are only populated through Actions."""
+
+ type: typing.Literal["editOnly"] = "editOnly"
+
+
+EditsHistoryFilter: typing_extensions.TypeAlias = typing_extensions.Annotated[
+ typing.Union["EditsHistoryTimestampFilter", "EditsHistoryOperationIdsFilter"],
+ pydantic.Field(discriminator="type"),
+]
+"""EditsHistoryFilter"""
+
+
+class EditsHistoryOperationIdsFilter(core.ModelBase):
+ """EditsHistoryOperationIdsFilter"""
+
+ operation_ids: typing.List[ActionRid] = pydantic.Field(alias=str("operationIds")) # type: ignore[literal-required]
+ type: typing.Literal["operationIdsFilter"] = "operationIdsFilter"
+
+
+EditsHistorySortOrder: typing_extensions.TypeAlias = typing.Literal["newest_first", "oldest_first"]
+"""EditsHistorySortOrder"""
+
+
+class EditsHistoryTimestampFilter(core.ModelBase):
+ """EditsHistoryTimestampFilter"""
+
+ start_time: typing.Optional[core.AwareDatetime] = pydantic.Field(alias=str("startTime"), default=None) # type: ignore[literal-required]
+ """
+ Filter edits to only those that occurred after this timestamp (inclusive).
+ ISO 8601 format. Example: "2024-01-01T00:00:00Z"
+ """
+
+ end_time: typing.Optional[core.AwareDatetime] = pydantic.Field(alias=str("endTime"), default=None) # type: ignore[literal-required]
+ """
+ Filter edits to only those that occurred before this timestamp (inclusive).
+ ISO 8601 format. Example: "2024-12-31T23:59:59Z"
+ """
+
+ type: typing.Literal["timestampFilter"] = "timestampFilter"
+
+
+class EncryptionRequest(core.ModelBase):
+ """The request to encrypt a plaintext value into a CipherText value."""
+
+ plaintext: Plaintext
+
+
+class EncryptionResult(core.ModelBase):
+ """The result of a CipherText encryption. If successful, the encrypted ciphertext value will be returned. Otherwise, an error will be thrown."""
+
+ ciphertext: CipherText
+
+
+class EntrySetType(core.ModelBase):
+ """EntrySetType"""
+
+ key_type: QueryDataType = pydantic.Field(alias=str("keyType")) # type: ignore[literal-required]
+ value_type: QueryDataType = pydantic.Field(alias=str("valueType")) # type: ignore[literal-required]
+ type: typing.Literal["entrySet"] = "entrySet"
+
+
+class EnumConstraint(core.ModelBase):
+ """EnumConstraint"""
+
+ options: typing.List[typing.Optional[PropertyValue]]
+ type: typing.Literal["enum"] = "enum"
+
+
+class EqualsQueryV2(core.ModelBase):
+ """
+ Returns objects where the specified field is equal to a value. Allows you to specify a property to query on
+ by a variety of means. Either `field` or `propertyIdentifier` must be supplied, but not both.
+
+ For string properties, full term matching only works when **Selectable** is enabled for the property in Ontology Manager.
+ """
+
+ field: typing.Optional[PropertyApiName] = None
+ property_identifier: typing.Optional[PropertyIdentifier] = pydantic.Field(alias=str("propertyIdentifier"), default=None) # type: ignore[literal-required]
+ value: PropertyValue
+ type: typing.Literal["eq"] = "eq"
+
+
+class Error(core.ModelBase):
+ """Error"""
+
+ error: ErrorName
+ args: typing.List[Arg]
+ type: typing.Literal["error"] = "error"
+
+
+class ErrorComputingSecurity(core.ModelBase):
+ """Indicates the server was not able to load the securities of the property."""
+
+ type: typing.Literal["errorComputingSecurity"] = "errorComputingSecurity"
+
+
+ErrorName: typing_extensions.TypeAlias = str
+"""ErrorName"""
+
+
+class ExactDistinctAggregationV2(core.ModelBase):
+ """
+ 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.
+ """
+
+ field: typing.Optional[PropertyApiName] = None
+ property_identifier: typing.Optional[PropertyIdentifier] = pydantic.Field(alias=str("propertyIdentifier"), default=None) # type: ignore[literal-required]
+ name: typing.Optional[AggregationMetricName] = None
+ direction: typing.Optional[OrderByDirection] = None
+ type: typing.Literal["exactDistinct"] = "exactDistinct"
+
+
+class ExamplePropertyTypeStatus(core.ModelBase):
+ """
+ This status indicates that the PropertyType is an example. It is backed by notional data that should not be
+ used for actual workflows, but can be used to test those workflows.
+ """
+
+ type: typing.Literal["example"] = "example"
+
+
+class ExecuteQueryRequest(core.ModelBase):
+ """ExecuteQueryRequest"""
+
+ parameters: typing.Dict[ParameterId, typing.Optional[DataValue]]
+
+
+class ExecuteQueryResponse(core.ModelBase):
+ """ExecuteQueryResponse"""
+
+ value: DataValue
+
+
+class ExperimentalPropertyTypeStatus(core.ModelBase):
+ """This status indicates that the PropertyType is in development."""
+
+ type: typing.Literal["experimental"] = "experimental"
+
+
+ExtractDatePart: typing_extensions.TypeAlias = typing.Literal["DAYS", "MONTHS", "QUARTERS", "YEARS"]
+"""ExtractDatePart"""
+
+
+class ExtractMainValueLoadLevel(core.ModelBase):
+ """Returns the main value of a struct as configured in the ontology."""
+
+ type: typing.Literal["extractMainValue"] = "extractMainValue"
+
+
+class ExtractPropertyExpression(core.ModelBase):
+ """Extracts the specified date part from a date or timestamp."""
+
+ property: DerivedPropertyDefinition
+ part: ExtractDatePart
+ type: typing.Literal["extract"] = "extract"
+
+
+FilterValue: typing_extensions.TypeAlias = str
+"""
+Represents the value of a property filter. For instance, false is the FilterValue in
+`properties.{propertyApiName}.isNull=false`.
+"""
+
+
+class FixedDatetimeValue(core.ModelBase):
+ """An absolute datetime bound (ISO 8601 timestamp or date string)."""
+
+ value: ParameterConstraintValue
+ type: typing.Literal["fixed"] = "fixed"
+
+
+FixedValuesMapKey: typing_extensions.TypeAlias = int
+"""Integer key for fixed value mapping."""
+
+
+class FullTextStringContainsPredicate(core.ModelBase):
+ """
+ Matches strings which contain the given string or parts of the given string. The exact behaviour can vary
+ depending on the attribute searched for due to optimized text analysis.
+ """
+
+ value: str
+ type: typing.Literal["contains"] = "contains"
+
+
+class FullTextStringExactPredicate(core.ModelBase):
+ """Matches strings representing the same sequence of characters as the given string."""
+
+ value: str
+ type: typing.Literal["exact"] = "exact"
+
+
+FullTextStringPredicateV2: typing_extensions.TypeAlias = typing_extensions.Annotated[
+ typing.Union["FullTextStringContainsPredicate", "FullTextStringExactPredicate"],
+ pydantic.Field(discriminator="type"),
+]
+"""A predicate for matching strings."""
+
+
+class FunctionLogicRule(core.ModelBase):
+ """FunctionLogicRule"""
+
+ function_rid: FunctionRid = pydantic.Field(alias=str("functionRid")) # type: ignore[literal-required]
+ function_version: FunctionVersion = pydantic.Field(alias=str("functionVersion")) # type: ignore[literal-required]
+ function_input_values: typing.Dict[FunctionParameterName, LogicRuleArgument] = pydantic.Field(alias=str("functionInputValues")) # type: ignore[literal-required]
+ type: typing.Literal["function"] = "function"
+
+
+FunctionParameterName: typing_extensions.TypeAlias = str
+"""The name of an input to a function."""
+
+
+FunctionRid: typing_extensions.TypeAlias = core.RID
+"""The unique resource identifier of a Function, useful for interacting with other Foundry APIs."""
+
+
+class FunctionRidActionTypesQueryV2(core.ModelBase):
+ """Returns action types which use the function with the given rid."""
+
+ value: FunctionRid
+ type: typing.Literal["functionRid"] = "functionRid"
+
+
+FunctionVersion: typing_extensions.TypeAlias = str
+"""
+The version of the given Function, written `<major>.<minor>.<patch>-<tag>`, where `-<tag>` is optional.
+Examples: `1.2.3`, `1.2.3-rc1`.
+"""
+
+
+class FuzzinessAuto(core.ModelBase):
+ """
+ Fuzzy search is activated, which can help discover additional results based on small differences in
+ spelling, although some additional results may be less relevant.
+ """
+
+ type: typing.Literal["auto"] = "auto"
+
+
+class FuzzinessOff(core.ModelBase):
+ """
+ Fuzzy search is turned off. Matches generated by modifying one or more characters of the search query are
+ not returned.
+ """
+
+ type: typing.Literal["off"] = "off"
+
+
+class FuzzyRule(core.ModelBase):
+ """
+ Matches intervals containing terms that are similar to the provided term, within an edit distance
+ defined by fuzziness. An edit is a single character change needed to make a term match, including
+ character insertion, deletion, substitution, or transposition of two adjacent characters.
+ """
+
+ term: str
+ """The term to match."""
+
+ fuzziness: typing.Optional[int] = None
+ """Maximum edit distance allowed for matching. Valid values are 0, 1, or 2. Defaults to 2."""
+
+ type: typing.Literal["fuzzy"] = "fuzzy"
+
+
+FuzzyV2: typing_extensions.TypeAlias = bool
+"""Setting fuzzy to `true` allows approximate matching in search queries that support it."""
+
+
+class GeoJsonString(core.ModelBase):
+ """A GeoJSON geometry specification."""
+
+ geo_json: str = pydantic.Field(alias=str("geoJson")) # type: ignore[literal-required]
+ """
+ A GeoJSON geometry string. Supported geometry types include Point, MultiPoint, LineString,
+ MultiLineString, Polygon, MultiPolygon, and GeometryCollection.
+ """
+
+ type: typing.Literal["geoJson"] = "geoJson"
+
+
+GeoShapeV2Geometry: typing_extensions.TypeAlias = typing_extensions.Annotated[
+ typing.Union["BoundingBoxValue", "GeoJsonString"], pydantic.Field(discriminator="type")
+]
+"""Geometry specification for a GeoShapeV2Query. Supports bounding box envelopes and arbitrary GeoJSON geometries."""
+
+
+class GeoShapeV2Query(core.ModelBase):
+ """
+ Returns objects where the specified field satisfies the provided geometry query with the given spatial operator.
+ Supports both envelope (bounding box) and GeoJSON geometries for filtering geopoint or geoshape properties.
+ Either `field` or `propertyIdentifier` can be supplied, but not both.
+ """
+
+ field: typing.Optional[PropertyApiName] = None
+ property_identifier: typing.Optional[PropertyIdentifier] = pydantic.Field(alias=str("propertyIdentifier"), default=None) # type: ignore[literal-required]
+ geometry: GeoShapeV2Geometry
+ spatial_filter_mode: SpatialFilterMode = pydantic.Field(alias=str("spatialFilterMode")) # type: ignore[literal-required]
+ type: typing.Literal["geoShapeV2"] = "geoShapeV2"
+
+
+GeotemporalSeriesEntry: typing_extensions.TypeAlias = typing.Dict[
+ "PropertyApiName", "PropertyValue"
+]
+"""
+A single geotemporal data point. Each entry is a map from property API names to property values. Standard
+entries include "time" (ISO 8601 timestamp) and "position" (GeoPoint), and may include additional geotemporal
+series metadata fields such as speed, heading, or altitude.
+"""
+
+
+GeotimeSeriesIntegrationRid: typing_extensions.TypeAlias = core.RID
+"""The unique resource identifier of a geotime integration."""
+
+
+class GeotimeSeriesValue(core.ModelBase):
+ """The underlying data values pointed to by a GeotimeSeriesReference."""
+
+ position: geo_models.Position
+ timestamp: core.AwareDatetime
+ type: typing.Literal["geotimeSeriesValue"] = "geotimeSeriesValue"
+
+
+class GetActionTypeByRidBatchRequest(core.ModelBase):
+ """GetActionTypeByRidBatchRequest"""
+
+ requests: typing_extensions.Annotated[
+ typing.List[GetActionTypeByRidBatchRequestElement],
+ annotated_types.Len(min_length=1, max_length=100),
+ ]
+
+
+class GetActionTypeByRidBatchRequestElement(core.ModelBase):
+ """GetActionTypeByRidBatchRequestElement"""
+
+ action_type_rid: ActionTypeRid = pydantic.Field(alias=str("actionTypeRid")) # type: ignore[literal-required]
+
+
+class GetActionTypeByRidBatchResponse(core.ModelBase):
+ """GetActionTypeByRidBatchResponse"""
+
+ data: typing.List[ActionTypeV2]
+
+
+class GetActionTypeFullMetadataBatchRequest(core.ModelBase):
+ """GetActionTypeFullMetadataBatchRequest"""
+
+ requests: typing_extensions.Annotated[
+ typing.List[GetActionTypeFullMetadataBatchRequestElement],
+ annotated_types.Len(min_length=1, max_length=100),
+ ]
+
+
+class GetActionTypeFullMetadataBatchRequestElement(core.ModelBase):
+ """GetActionTypeFullMetadataBatchRequestElement"""
+
+ action_type: ActionTypeApiName = pydantic.Field(alias=str("actionType")) # type: ignore[literal-required]
+
+
+class GetActionTypeFullMetadataBatchResponse(core.ModelBase):
+ """GetActionTypeFullMetadataBatchResponse"""
+
+ data: typing.List[ActionTypeFullMetadata]
+
+
+class GetObjectTypeByRidBatchRequest(core.ModelBase):
+ """GetObjectTypeByRidBatchRequest"""
+
+ requests: typing_extensions.Annotated[
+ typing.List[GetObjectTypeByRidBatchRequestElement],
+ annotated_types.Len(min_length=1, max_length=100),
+ ]
+
+
+class GetObjectTypeByRidBatchRequestElement(core.ModelBase):
+ """GetObjectTypeByRidBatchRequestElement"""
+
+ object_type_rid: ObjectTypeRid = pydantic.Field(alias=str("objectTypeRid")) # type: ignore[literal-required]
+
+
+class GetObjectTypeByRidBatchResponse(core.ModelBase):
+ """GetObjectTypeByRidBatchResponse"""
+
+ data: typing.List[ObjectTypeV2]
+
+
+class GetObjectTypeFullMetadataBatchRequest(core.ModelBase):
+ """GetObjectTypeFullMetadataBatchRequest"""
+
+ requests: typing_extensions.Annotated[
+ typing.List[GetObjectTypeFullMetadataBatchRequestElement],
+ annotated_types.Len(min_length=1, max_length=100),
+ ]
+ include_link_types: typing.Optional[bool] = pydantic.Field(alias=str("includeLinkTypes"), default=None) # type: ignore[literal-required]
+ """
+ A flag that will return all outgoing link types for each requested object type in that object type's
+ `linkTypes`. When false or omitted, `linkTypes` is empty.
+ """
+
+
+class GetObjectTypeFullMetadataBatchRequestElement(core.ModelBase):
+ """GetObjectTypeFullMetadataBatchRequestElement"""
+
+ object_type: ObjectTypeApiName = pydantic.Field(alias=str("objectType")) # type: ignore[literal-required]
+
+
+class GetObjectTypeFullMetadataBatchResponse(core.ModelBase):
+ """GetObjectTypeFullMetadataBatchResponse"""
+
+ data: typing.List[ObjectTypeFullMetadata]
+ """
+ The requested object types, in the order they were requested. Object types that were not found are
+ omitted, so this may contain fewer entries than were requested.
+
+ Each object type's `linkTypes` is only populated when the request specifies
+ `includeLinkTypes=true`, and is ordered by link type API name. It may also be empty if the object
+ type has no outgoing link types, or if the requesting token cannot see the object types on the
+ other side of them.
+ """
+
+
+class GetOutgoingLinkTypesByObjectTypeRidBatchRequest(core.ModelBase):
+ """GetOutgoingLinkTypesByObjectTypeRidBatchRequest"""
+
+ requests: typing_extensions.Annotated[
+ typing.List[GetOutgoingLinkTypesByObjectTypeRidBatchRequestElement],
+ annotated_types.Len(min_length=1, max_length=100),
+ ]
+ filter_link_type_rids: typing.List[LinkTypeRid] = pydantic.Field(alias=str("filterLinkTypeRids")) # type: ignore[literal-required]
+ """
+ If provided, only return outgoing link types with RIDs in this list.
+ If omitted, all outgoing link types for each requested object type are returned.
+ """
+
+
+class GetOutgoingLinkTypesByObjectTypeRidBatchRequestElement(core.ModelBase):
+ """GetOutgoingLinkTypesByObjectTypeRidBatchRequestElement"""
+
+ object_type_rid: ObjectTypeRid = pydantic.Field(alias=str("objectTypeRid")) # type: ignore[literal-required]
+
+
+class GetOutgoingLinkTypesByObjectTypeRidBatchResponse(core.ModelBase):
+ """GetOutgoingLinkTypesByObjectTypeRidBatchResponse"""
+
+ data: typing.Dict[ObjectTypeRid, typing.List[LinkTypeSideV2]]
+
+
+class GetQueryTypeByRidBatchRequest(core.ModelBase):
+ """GetQueryTypeByRidBatchRequest"""
+
+ requests: typing_extensions.Annotated[
+ typing.List[GetQueryTypeByRidBatchRequestElement],
+ annotated_types.Len(min_length=1, max_length=100),
+ ]
+
+
+class GetQueryTypeByRidBatchRequestElement(core.ModelBase):
+ """GetQueryTypeByRidBatchRequestElement"""
+
+ query_type_rid: FunctionRid = pydantic.Field(alias=str("queryTypeRid")) # type: ignore[literal-required]
+ function_version: typing.Optional[FunctionVersion] = pydantic.Field(alias=str("functionVersion"), default=None) # type: ignore[literal-required]
+
+
+class GetQueryTypeByRidBatchResponse(core.ModelBase):
+ """GetQueryTypeByRidBatchResponse"""
+
+ data: typing.List[QueryTypeV2]
+
+
+class GetSelectedPropertyOperation(core.ModelBase):
+ """
+ Gets a single value of a property. Throws if the target object set is on the MANY side of the link and could
+ explode the cardinality.
+
+ Use collectList or collectSet which will return a list of values in that case.
+ """
+
+ selected_property_api_name: PropertyApiName = pydantic.Field(alias=str("selectedPropertyApiName")) # type: ignore[literal-required]
+ type: typing.Literal["get"] = "get"
+
+
+class GreatestPropertyExpression(core.ModelBase):
+ """Finds greatest of two or more numeric, date or timestamp values."""
+
+ properties: typing.List[DerivedPropertyDefinition]
+ type: typing.Literal["greatest"] = "greatest"
+
+
+class GroupMemberConstraint(core.ModelBase):
+ """The parameter value must be the user id of a member belonging to at least one of the groups defined by the constraint."""
+
+ type: typing.Literal["groupMember"] = "groupMember"
+
+
+class GtQueryV2(core.ModelBase):
+ """
+ Returns objects where the specified field is greater than a value. Allows you to specify a property to query on
+ by a variety of means. Either `field` or `propertyIdentifier` must be supplied, but not both.
+ """
+
+ field: typing.Optional[PropertyApiName] = None
+ property_identifier: typing.Optional[PropertyIdentifier] = pydantic.Field(alias=str("propertyIdentifier"), default=None) # type: ignore[literal-required]
+ value: PropertyValue
+ type: typing.Literal["gt"] = "gt"
+
+
+class GteQueryV2(core.ModelBase):
+ """
+ Returns objects where the specified field is greater than or equal to a value. Allows you to specify a property
+ to query on by a variety of means. Either `field` or `propertyIdentifier` must be supplied, but not both.
+ """
+
+ field: typing.Optional[PropertyApiName] = None
+ property_identifier: typing.Optional[PropertyIdentifier] = pydantic.Field(alias=str("propertyIdentifier"), default=None) # type: ignore[literal-required]
+ value: PropertyValue
+ type: typing.Literal["gte"] = "gte"
+
+
+class HasActionLogActionTypesQueryV2(core.ModelBase):
+ """Returns action types based on whether they have an action log."""
+
+ value: bool
+ type: typing.Literal["hasActionLog"] = "hasActionLog"
+
+
+class HasNotificationActionTypesQueryV2(core.ModelBase):
+ """Returns action types based on whether they have a notification."""
+
+ value: bool
+ type: typing.Literal["hasNotification"] = "hasNotification"
+
+
+class HasWebhookActionTypesQueryV2(core.ModelBase):
+ """Returns action types based on whether they reference a webhook."""
+
+ value: bool
+ type: typing.Literal["hasWebhook"] = "hasWebhook"
+
+
+class HumanReadableFormat(core.ModelBase):
+ """Formats the duration as a human-readable written string."""
+
+ show_full_units: typing.Optional[bool] = pydantic.Field(alias=str("showFullUnits"), default=None) # type: ignore[literal-required]
+ """Whether to show full or abbreviated time units."""
+
+ type: typing.Literal["humanReadable"] = "humanReadable"
+
+
+class InQuery(core.ModelBase):
+ """
+ Returns objects where the specified field equals any of the provided values. Allows you to
+ specify a property to query on by a variety of means. If an empty array is provided as the value, then the filter will match all objects
+ in the object set. Either `field` or `propertyIdentifier` must be supplied, but not both.
+
+ For string properties, full term matching only works when **Selectable** is enabled for the property in Ontology Manager.
+ """
+
+ field: typing.Optional[PropertyApiName] = None
+ property_identifier: typing.Optional[PropertyIdentifier] = pydantic.Field(alias=str("propertyIdentifier"), default=None) # type: ignore[literal-required]
+ value: typing.List[PropertyValue]
+ type: typing.Literal["in"] = "in"
+
+
+class InputObjectTypeRidActionTypesQueryV2(core.ModelBase):
+ """Returns action types which reference the object type with the given rid as an input or product."""
+
+ value: ObjectTypeRid
+ type: typing.Literal["inputObjectTypeRid"] = "inputObjectTypeRid"
+
+
+class IntegerValue(core.ModelBase):
+ """IntegerValue"""
+
+ value: int
+ type: typing.Literal["integerValue"] = "integerValue"
+
+
+InterfaceActionTypeConstraintApiName: typing_extensions.TypeAlias = str
+"""
+The name in the API of an action defined on an interface that implementing object types provide a concrete
+action type for.
+"""
+
+
+class InterfaceDefinedPropertyType(core.ModelBase):
+ """
+ An interface property type with an additional field to indicate constraints that need to be satisfied by
+ implementing object property types.
+ """
+
+ rid: InterfacePropertyTypeRid
+ api_name: InterfacePropertyApiName = pydantic.Field(alias=str("apiName")) # type: ignore[literal-required]
+ display_name: core_models.DisplayName = pydantic.Field(alias=str("displayName")) # type: ignore[literal-required]
+ description: typing.Optional[str] = None
+ """The description of the interface property type."""
+
+ data_type: ObjectPropertyType = pydantic.Field(alias=str("dataType")) # type: ignore[literal-required]
+ value_type_api_name: typing.Optional[ValueTypeApiName] = pydantic.Field(alias=str("valueTypeApiName"), default=None) # type: ignore[literal-required]
+ require_implementation: bool = pydantic.Field(alias=str("requireImplementation")) # type: ignore[literal-required]
+ """Whether each implementing object type must declare an implementation for this property."""
+
+ type_classes: typing.Optional[typing.List[TypeClass]] = pydantic.Field(alias=str("typeClasses"), default=None) # type: ignore[literal-required]
+ type: typing.Literal["interfaceDefinedPropertyType"] = "interfaceDefinedPropertyType"
+
+
+class InterfaceLinkType(core.ModelBase):
+ """
+ A link type constraint defined at the interface level where the implementation of the links is provided
+ by the implementing object types.
+ """
+
+ rid: InterfaceLinkTypeRid
+ api_name: InterfaceLinkTypeApiName = pydantic.Field(alias=str("apiName")) # type: ignore[literal-required]
+ display_name: core_models.DisplayName = pydantic.Field(alias=str("displayName")) # type: ignore[literal-required]
+ description: typing.Optional[str] = None
+ """The description of the interface link type."""
+
+ linked_entity_api_name: InterfaceLinkTypeLinkedEntityApiName = pydantic.Field(alias=str("linkedEntityApiName")) # type: ignore[literal-required]
+ cardinality: InterfaceLinkTypeCardinality
+ required: bool
+ """Whether each implementing object type must declare at least one implementation of this link."""
+
+
+InterfaceLinkTypeApiName: typing_extensions.TypeAlias = str
+"""
+The name of the interface link type in the API. To find the API name for your Interface Link Type, check the
+[Ontology Manager](https://palantir.com/docs/foundry/ontology-manager/overview/).
+"""
+
+
+InterfaceLinkTypeCardinality: typing_extensions.TypeAlias = typing.Literal["ONE", "MANY"]
+"""
+The cardinality of the link in the given direction. Cardinality can be "ONE", meaning an object can
+link to zero or one other objects, or "MANY", meaning an object can link to any number of other objects.
+"""
+
+
+InterfaceLinkTypeLinkedEntityApiName: typing_extensions.TypeAlias = typing_extensions.Annotated[
+ typing.Union["LinkedObjectTypeApiName", "LinkedInterfaceTypeApiName"],
+ pydantic.Field(discriminator="type"),
+]
+"""A reference to the linked entity. This can either be an object or an interface type."""
+
+
+InterfaceLinkTypeRid: typing_extensions.TypeAlias = core.RID
+"""The unique resource identifier of an interface link type, useful for interacting with other Foundry APIs."""
+
+
+class InterfaceParameterPropertyArgument(core.ModelBase):
+ """Represents an interface parameter property argument in a logic rule."""
+
+ parameter_id: ParameterId = pydantic.Field(alias=str("parameterId")) # type: ignore[literal-required]
+ shared_property_type_rid: core.RID = pydantic.Field(alias=str("sharedPropertyTypeRid")) # type: ignore[literal-required]
+ type: typing.Literal["interfaceParameterPropertyValue"] = "interfaceParameterPropertyValue"
+
+
+InterfacePropertyApiName: typing_extensions.TypeAlias = str
+"""
+The name of the interface property type in the API in lowerCamelCase format. To find the API name for your
+interface property type, use the `List interface types` endpoint and check the `allPropertiesV2` field or check
+the **Ontology Manager**.
+"""
+
+
+class InterfacePropertyLocalPropertyImplementation(core.ModelBase):
+ """An implementation of an interface property via a local property."""
+
+ property_api_name: PropertyApiName = pydantic.Field(alias=str("propertyApiName")) # type: ignore[literal-required]
+ type: typing.Literal["localPropertyImplementation"] = "localPropertyImplementation"
+
+
+class InterfacePropertyReducedPropertyImplementation(core.ModelBase):
+ """An implementation of an interface property via applying reducers on the nested implementation."""
+
+ implementation: NestedInterfacePropertyTypeImplementation
+ type: typing.Literal["reducedPropertyImplementation"] = "reducedPropertyImplementation"
+
+
+class InterfacePropertyStructFieldImplementation(core.ModelBase):
+ """An implementation of an interface property via the field of a local struct property."""
+
+ struct_field_of_property: StructFieldOfPropertyImplementation = pydantic.Field(alias=str("structFieldOfProperty")) # type: ignore[literal-required]
+ type: typing.Literal["structFieldImplementation"] = "structFieldImplementation"
+
+
+class InterfacePropertyStructImplementation(core.ModelBase):
+ """
+ An implementation of a struct interface property via a local struct property. Specifies a mapping of interface
+ struct fields to local struct fields or properties.
+ """
+
+ mapping: InterfacePropertyStructImplementationMapping
+ type: typing.Literal["structImplementation"] = "structImplementation"
+
+
+InterfacePropertyStructImplementationMapping: typing_extensions.TypeAlias = typing.Dict[
+ "StructFieldApiName", "PropertyOrStructFieldOfPropertyImplementation"
+]
+"""
+An implementation of a struct interface property via a local struct property. Specifies a mapping of interface
+struct fields to local struct fields or properties.
+"""
+
+
+InterfacePropertyType: typing_extensions.TypeAlias = typing_extensions.Annotated[
+ typing.Union["InterfaceDefinedPropertyType", "InterfaceSharedPropertyType"],
+ pydantic.Field(discriminator="type"),
+]
+"""
+The definition of an interface property type on an interface. An interface property can either be backed by a
+shared property type or defined on the interface directly.
+"""
+
+
+InterfacePropertyTypeImplementation: typing_extensions.TypeAlias = typing_extensions.Annotated[
+ typing.Union[
+ "InterfacePropertyStructFieldImplementation",
+ "InterfacePropertyStructImplementation",
+ "InterfacePropertyLocalPropertyImplementation",
+ "InterfacePropertyReducedPropertyImplementation",
+ ],
+ pydantic.Field(discriminator="type"),
+]
+"""Describes how an object type implements an interface property."""
+
+
+InterfacePropertyTypeRid: typing_extensions.TypeAlias = core.RID
+"""The unique resource identifier of an interface property type, useful for interacting with other Foundry APIs."""
+
+
+class InterfaceSharedPropertyType(core.ModelBase):
+ """
+ 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.
+ """
+
+ rid: SharedPropertyTypeRid
+ api_name: SharedPropertyTypeApiName = pydantic.Field(alias=str("apiName")) # type: ignore[literal-required]
+ display_name: core_models.DisplayName = pydantic.Field(alias=str("displayName")) # type: ignore[literal-required]
+ description: typing.Optional[str] = None
+ """A short text that describes the SharedPropertyType."""
+
+ data_type: ObjectPropertyType = pydantic.Field(alias=str("dataType")) # type: ignore[literal-required]
+ value_type_api_name: typing.Optional[ValueTypeApiName] = pydantic.Field(alias=str("valueTypeApiName"), default=None) # type: ignore[literal-required]
+ value_formatting: typing.Optional[PropertyValueFormattingRule] = pydantic.Field(alias=str("valueFormatting"), default=None) # type: ignore[literal-required]
+ required: bool
+ """Whether each implementing object type must declare an implementation for this property."""
+
+ type_classes: typing.Optional[typing.List[TypeClass]] = pydantic.Field(alias=str("typeClasses"), default=None) # type: ignore[literal-required]
+ type: typing.Literal["interfaceSharedPropertyType"] = "interfaceSharedPropertyType"
+
+
+InterfaceToObjectTypeMapping: typing_extensions.TypeAlias = typing.Dict[
+ "SharedPropertyTypeApiName", "PropertyApiName"
+]
+"""Represents an implementation of an interface (the mapping of interface property to local property)."""
+
+
+InterfaceToObjectTypeMappingV2: typing_extensions.TypeAlias = typing.Dict[
+ "InterfacePropertyApiName", "InterfacePropertyTypeImplementation"
+]
+"""Represents an implementation of an interface (the mapping of interface property to how it is implemented."""
+
+
+InterfaceToObjectTypeMappings: typing_extensions.TypeAlias = typing.Dict[
+ "ObjectTypeApiName", "InterfaceToObjectTypeMapping"
+]
+"""Map from object type to the interface-to-object-type mapping for that object type."""
+
+
+InterfaceToObjectTypeMappingsV2: typing_extensions.TypeAlias = typing.Dict[
+ "ObjectTypeApiName", "InterfaceToObjectTypeMappingV2"
+]
+"""Map from object type to the interface property implementations of that object type."""
+
+
+class InterfaceType(core.ModelBase):
+ """Represents an interface type in the Ontology."""
+
+ rid: InterfaceTypeRid
+ api_name: InterfaceTypeApiName = pydantic.Field(alias=str("apiName")) # type: ignore[literal-required]
+ display_name: core_models.DisplayName = pydantic.Field(alias=str("displayName")) # type: ignore[literal-required]
+ description: typing.Optional[str] = None
+ """The description of the interface."""
+
+ properties: typing.Dict[SharedPropertyTypeApiName, InterfaceSharedPropertyType]
+ """
+ A map from a shared property type API name to the corresponding shared property type. The map describes the
+ set of properties the interface has. A shared property type must be unique across all of the properties.
+ This field only includes properties on the interface that are backed by shared property types.
+ """
+
+ all_properties: typing.Dict[SharedPropertyTypeApiName, InterfaceSharedPropertyType] = pydantic.Field(alias=str("allProperties")) # type: ignore[literal-required]
+ """
+ A map from a shared property type API name to the corresponding shared property type. The map describes the
+ set of properties the interface has, including properties from all directly and indirectly extended
+ interfaces.
+ This field only includes properties on the interface that are backed by shared property types.
+ """
+
+ properties_v2: typing.Dict[InterfacePropertyApiName, InterfacePropertyType] = pydantic.Field(alias=str("propertiesV2")) # type: ignore[literal-required]
+ """
+ A map from a interface property type API name to the corresponding interface property type. The map
+ describes the set of properties the interface has. An interface property can either be backed by a shared
+ property or it can be defined directly on the interface.
+ """
+
+ all_properties_v2: typing.Dict[InterfacePropertyApiName, ResolvedInterfacePropertyType] = pydantic.Field(alias=str("allPropertiesV2")) # type: ignore[literal-required]
+ """
+ A map from a interface property type API name to the corresponding interface property type. The map
+ describes the set of properties the interface has, including properties from all directly and indirectly
+ extended interfaces.
+ """
+
+ extends_interfaces: typing.List[InterfaceTypeApiName] = pydantic.Field(alias=str("extendsInterfaces")) # type: ignore[literal-required]
+ """
+ A list of interface API names that this interface extends. An interface can extend other interfaces to
+ inherit their properties.
+ """
+
+ all_extends_interfaces: typing.List[InterfaceTypeApiName] = pydantic.Field(alias=str("allExtendsInterfaces")) # type: ignore[literal-required]
+ """A list of interface API names that this interface extends, both directly and indirectly."""
+
+ implemented_by_object_types: typing.List[ObjectTypeApiName] = pydantic.Field(alias=str("implementedByObjectTypes")) # type: ignore[literal-required]
+ """A list of object API names that implement this interface."""
+
+ links: typing.Dict[InterfaceLinkTypeApiName, InterfaceLinkType]
+ """
+ A map from an interface link type API name to the corresponding interface link type. The map describes the
+ set of link types the interface has.
+ """
+
+ all_links: typing.Dict[InterfaceLinkTypeApiName, InterfaceLinkType] = pydantic.Field(alias=str("allLinks")) # type: ignore[literal-required]
+ """
+ A map from an interface link type API name to the corresponding interface link type. The map describes the
+ set of link types the interface has, including links from all directly and indirectly extended interfaces.
+ """
+
+
+InterfaceTypeApiName: typing_extensions.TypeAlias = str
+"""
+The name of the interface type in the API in UpperCamelCase format. To find the API name for your interface
+type, use the `List interface types` endpoint or check the **Ontology Manager**.
+"""
+
+
+InterfaceTypeRid: typing_extensions.TypeAlias = core.RID
+"""The unique resource identifier of an interface, useful for interacting with other Foundry APIs."""
+
+
+class IntersectsBoundingBoxQuery(core.ModelBase):
+ """
+ Returns objects where the specified field intersects the bounding box provided. Allows you to specify a property
+ to query on by a variety of means. Either `field` or `propertyIdentifier` must be supplied, but not both.
+ """
+
+ field: typing.Optional[PropertyApiName] = None
+ property_identifier: typing.Optional[PropertyIdentifier] = pydantic.Field(alias=str("propertyIdentifier"), default=None) # type: ignore[literal-required]
+ value: BoundingBoxValue
+ type: typing.Literal["intersectsBoundingBox"] = "intersectsBoundingBox"
+
+
+class IntersectsPolygonQuery(core.ModelBase):
+ """
+ Returns objects where the specified field intersects the polygon provided. Allows you to specify a property to
+ query on by a variety of means. Either `field` or `propertyIdentifier` must be supplied, but not both.
+ """
+
+ field: typing.Optional[PropertyApiName] = None
+ property_identifier: typing.Optional[PropertyIdentifier] = pydantic.Field(alias=str("propertyIdentifier"), default=None) # type: ignore[literal-required]
+ value: PolygonValue
+ type: typing.Literal["intersectsPolygon"] = "intersectsPolygon"
+
+
+class IntervalQuery(core.ModelBase):
+ """
+ Returns objects where the specified field matches the sub-rule provided. This applies to the analyzed form of
+ text fields. Either `field` or `propertyIdentifier` can be supplied, but not both.
+ """
+
+ field: typing.Optional[PropertyApiName] = None
+ property_identifier: typing.Optional[PropertyIdentifier] = pydantic.Field(alias=str("propertyIdentifier"), default=None) # type: ignore[literal-required]
+ rule: IntervalQueryRule
+ type: typing.Literal["interval"] = "interval"
+
+
+IntervalQueryRule: typing_extensions.TypeAlias = typing_extensions.Annotated[
+ typing.Union["AllOfRule", "MatchRule", "AnyOfRule", "PrefixOnLastTokenRule", "FuzzyRule"],
+ pydantic.Field(discriminator="type"),
+]
+"""Sub-rule used for evaluating an IntervalQuery"""
+
+
+class IsNullQueryV2(core.ModelBase):
+ """
+ Returns objects based on the existence of the specified field. Allows you to specify a property to query on
+ by a variety of means. Either `field` or `propertyIdentifier` must be supplied, but not both.
+ """
+
+ field: typing.Optional[PropertyApiName] = None
+ property_identifier: typing.Optional[PropertyIdentifier] = pydantic.Field(alias=str("propertyIdentifier"), default=None) # type: ignore[literal-required]
+ value: bool
+ type: typing.Literal["isNull"] = "isNull"
+
+
+KnownType: typing_extensions.TypeAlias = typing.Literal[
+ "USER_OR_GROUP_ID", "RESOURCE_RID", "ARTIFACT_GID"
+]
+"""
+Known Foundry types for specialized formatting:
+- userOrGroupRid: Format as user or group
+- resourceRid: Format as resource
+- artifactGid: Format as artifact
+"""
+
+
+class LeastPropertyExpression(core.ModelBase):
+ """Finds least of two or more numeric, date or timestamp values."""
+
+ properties: typing.List[DerivedPropertyDefinition]
+ type: typing.Literal["least"] = "least"
+
+
+class LengthConstraint(core.ModelBase):
+ """LengthConstraint"""
+
+ minimum_length: typing.Optional[float] = pydantic.Field(alias=str("minimumLength"), default=None) # type: ignore[literal-required]
+ maximum_length: typing.Optional[float] = pydantic.Field(alias=str("maximumLength"), default=None) # type: ignore[literal-required]
+ type: typing.Literal["length"] = "length"
+
+
+class LinkSideObject(core.ModelBase):
+ """LinkSideObject"""
+
+ primary_key: PropertyValue = pydantic.Field(alias=str("primaryKey")) # type: ignore[literal-required]
+ object_type: ObjectTypeApiName = pydantic.Field(alias=str("objectType")) # type: ignore[literal-required]
+
+
+LinkTypeApiName: typing_extensions.TypeAlias = str
+"""
+The name of the link type in the API. To find the API name for your Link Type, check the **Ontology Manager**
+application.
+"""
+
+
+LinkTypeId: typing_extensions.TypeAlias = str
+"""The unique ID of a link type. To find the ID for your link type, check the **Ontology Manager** application."""
+
+
+LinkTypeRid: typing_extensions.TypeAlias = core.RID
+"""LinkTypeRid"""
+
+
+LinkTypeSideCardinality: typing_extensions.TypeAlias = typing.Literal["ONE", "MANY"]
+"""LinkTypeSideCardinality"""
+
+
+class LinkTypeSideV2(core.ModelBase):
+ """
+ `foreignKeyPropertyApiName` is the API name of the foreign key on this object type. If absent, the link is
+ either a m2m link or the linked object has the foreign key and this object type has the primary key.
+ """
+
+ api_name: LinkTypeApiName = pydantic.Field(alias=str("apiName")) # type: ignore[literal-required]
+ display_name: core_models.DisplayName = pydantic.Field(alias=str("displayName")) # type: ignore[literal-required]
+ status: core_models.ReleaseStatus
+ object_type_api_name: ObjectTypeApiName = pydantic.Field(alias=str("objectTypeApiName")) # type: ignore[literal-required]
+ cardinality: LinkTypeSideCardinality
+ foreign_key_property_api_name: typing.Optional[PropertyApiName] = pydantic.Field(alias=str("foreignKeyPropertyApiName"), default=None) # type: ignore[literal-required]
+ link_type_rid: LinkTypeRid = pydantic.Field(alias=str("linkTypeRid")) # type: ignore[literal-required]
+
+
+class LinkedInterfaceTypeApiName(core.ModelBase):
+ """A reference to the linked interface type."""
+
+ api_name: InterfaceTypeApiName = pydantic.Field(alias=str("apiName")) # type: ignore[literal-required]
+ type: typing.Literal["interfaceTypeApiName"] = "interfaceTypeApiName"
+
+
+class LinkedObjectLocator(core.ModelBase):
+ """
+ Does not contain information about the source object. Should be used in a nested type that provides information about source objects.
+ The `targetObject` Ontology Object in this response will only ever have the `__primaryKey` and `__apiName`
+ fields present, thus functioning as object locators rather than full objects.
+ """
+
+ target_object: typing.Optional[OntologyObjectV2] = pydantic.Field(alias=str("targetObject"), default=None) # type: ignore[literal-required]
+ link_type: typing.Optional[LinkTypeApiName] = pydantic.Field(alias=str("linkType"), default=None) # type: ignore[literal-required]
+
+
+class LinkedObjectTypeApiName(core.ModelBase):
+ """A reference to the linked object type."""
+
+ api_name: ObjectTypeApiName = pydantic.Field(alias=str("apiName")) # type: ignore[literal-required]
+ type: typing.Literal["objectTypeApiName"] = "objectTypeApiName"
+
+
+class LinksFromObject(core.ModelBase):
+ """
+ The Ontology Objects in this response will only ever have the `__primaryKey` and `__apiName`
+ fields present, thus functioning as object locators rather than full objects.
+ """
+
+ source_object: typing.Optional[OntologyObjectV2] = pydantic.Field(alias=str("sourceObject"), default=None) # type: ignore[literal-required]
+ linked_objects: typing.List[LinkedObjectLocator] = pydantic.Field(alias=str("linkedObjects")) # type: ignore[literal-required]
+
+
+class ListActionTypesFullMetadataResponse(core.ModelBase):
+ """ListActionTypesFullMetadataResponse"""
+
+ next_page_token: typing.Optional[core_models.PageToken] = pydantic.Field(alias=str("nextPageToken"), default=None) # type: ignore[literal-required]
+ data: typing.List[ActionTypeFullMetadata]
+
+
+class ListActionTypesResponseV2(core.ModelBase):
+ """ListActionTypesResponseV2"""
+
+ next_page_token: typing.Optional[core_models.PageToken] = pydantic.Field(alias=str("nextPageToken"), default=None) # type: ignore[literal-required]
+ data: typing.List[ActionTypeV2]
+
+
+class ListAttachmentsResponseV2(core.ModelBase):
+ """ListAttachmentsResponseV2"""
+
+ data: typing.List[AttachmentV2]
+ next_page_token: typing.Optional[core_models.PageToken] = pydantic.Field(alias=str("nextPageToken"), default=None) # type: ignore[literal-required]
+ type: typing.Literal["multiple"] = "multiple"
+
+
+class ListInterfaceLinkedObjectsResponse(core.ModelBase):
+ """ListInterfaceLinkedObjectsResponse"""
+
+ data: typing.List[OntologyObjectV2]
+ next_page_token: typing.Optional[core_models.PageToken] = pydantic.Field(alias=str("nextPageToken"), default=None) # type: ignore[literal-required]
+
+
+class ListInterfaceTypesResponse(core.ModelBase):
+ """ListInterfaceTypesResponse"""
+
+ next_page_token: typing.Optional[core_models.PageToken] = pydantic.Field(alias=str("nextPageToken"), default=None) # type: ignore[literal-required]
+ data: typing.List[InterfaceType]
+
+
+class ListLinkedObjectsResponseV2(core.ModelBase):
+ """ListLinkedObjectsResponseV2"""
+
+ data: typing.List[OntologyObjectV2]
+ next_page_token: typing.Optional[core_models.PageToken] = pydantic.Field(alias=str("nextPageToken"), default=None) # type: ignore[literal-required]
+
+
+class ListObjectTypesV2Response(core.ModelBase):
+ """ListObjectTypesV2Response"""
+
+ next_page_token: typing.Optional[core_models.PageToken] = pydantic.Field(alias=str("nextPageToken"), default=None) # type: ignore[literal-required]
+ data: typing.List[ObjectTypeV2]
+ """The list of object types in the current page."""
+
+
+class ListObjectsForInterfaceResponse(core.ModelBase):
+ """ListObjectsForInterfaceResponse"""
+
+ next_page_token: typing.Optional[core_models.PageToken] = pydantic.Field(alias=str("nextPageToken"), default=None) # type: ignore[literal-required]
+ data: typing.List[OntologyObjectV2]
+ """The list of interface instances in the current page."""
+
+ total_count: core_models.TotalCount = pydantic.Field(alias=str("totalCount")) # type: ignore[literal-required]
+
+
+class ListObjectsResponseV2(core.ModelBase):
+ """ListObjectsResponseV2"""
+
+ next_page_token: typing.Optional[core_models.PageToken] = pydantic.Field(alias=str("nextPageToken"), default=None) # type: ignore[literal-required]
+ data: typing.List[OntologyObjectV2]
+ """The list of objects in the current page."""
+
+ total_count: core_models.TotalCount = pydantic.Field(alias=str("totalCount")) # type: ignore[literal-required]
+
+
+class ListOntologiesV2Response(core.ModelBase):
+ """ListOntologiesV2Response"""
+
+ data: typing.List[OntologyV2]
+ """The list of Ontologies the user has access to."""
+
+
+class ListOntologyValueTypesResponse(core.ModelBase):
+ """ListOntologyValueTypesResponse"""
+
+ data: typing.List[OntologyValueType]
+
+
+class ListOutgoingInterfaceLinkTypesResponse(core.ModelBase):
+ """ListOutgoingInterfaceLinkTypesResponse"""
+
+ next_page_token: typing.Optional[core_models.PageToken] = pydantic.Field(alias=str("nextPageToken"), default=None) # type: ignore[literal-required]
+ data: typing.List[InterfaceLinkType]
+ """The list of interface link types in the current page."""
+
+
+class ListOutgoingLinkTypesResponseV2(core.ModelBase):
+ """ListOutgoingLinkTypesResponseV2"""
+
+ next_page_token: typing.Optional[core_models.PageToken] = pydantic.Field(alias=str("nextPageToken"), default=None) # type: ignore[literal-required]
+ data: typing.List[LinkTypeSideV2]
+ """The list of link type sides in the current page."""
+
+
+class ListQueryTypesResponseV2(core.ModelBase):
+ """ListQueryTypesResponseV2"""
+
+ next_page_token: typing.Optional[core_models.PageToken] = pydantic.Field(alias=str("nextPageToken"), default=None) # type: ignore[literal-required]
+ data: typing.List[QueryTypeV2]
+
+
+class ListScenarioConflictingObjectsResponse(core.ModelBase):
+ """The objects that have a conflicting edit within a scenario for a given object type."""
+
+ data: typing.List[ObjectLocator]
+ """The list of objects that have a conflicting edit within the scenario."""
+
+ next_page_token: typing.Optional[core_models.PageToken] = pydantic.Field(alias=str("nextPageToken"), default=None) # type: ignore[literal-required]
+
+
+class ListScenarioEditedEntityTypesResponse(core.ModelBase):
+ """The object types and link types that have been modified within a scenario."""
+
+ object_types: typing.List[ObjectTypeApiName] = pydantic.Field(alias=str("objectTypes")) # type: ignore[literal-required]
+ """The list of object type API names that have been modified within the scenario."""
+
+ link_types: typing.List[ObjectTypeLinkTypeApiNameMapping] = pydantic.Field(alias=str("linkTypes")) # type: ignore[literal-required]
+ """
+ The list of edited link types grouped by source object type.
+
+ Note that only many-to-many link types are returned. One-to-many link type edits are surfaced as object
+ edits on the object type that owns the foreign key property.
+ """
+
+
+class ListScenarioEditedLinkTypesResponse(core.ModelBase):
+ """The link types that have been modified within a scenario."""
+
+ data: typing.List[LinkTypeApiName]
+ """The list of link type API names that have been modified within the scenario."""
+
+
+class ListScenarioEditedLinksResponse(core.ModelBase):
+ """The linked objects that have been edited within a scenario for a given link type, grouped by source object."""
+
+ data: typing.List[LinksFromObject]
+ """The list of linked objects that have been edited within the scenario, grouped by source object."""
+
+ next_page_token: typing.Optional[core_models.PageToken] = pydantic.Field(alias=str("nextPageToken"), default=None) # type: ignore[literal-required]
+
+
+class ListScenarioEditedObjectTypesResponse(core.ModelBase):
+ """The object types that have been modified within a scenario."""
+
+ data: typing.List[ObjectTypeApiName]
+ """The list of object type API names that have been modified within the scenario."""
+
+
+class ListScenarioEditedObjectsResponse(core.ModelBase):
+ """
+ The objects that have been edited within a scenario for a given object type.
+
+ The Ontology Objects in this response will only ever have the `__primaryKey` and `__apiName`
+ fields present, thus functioning as object locators rather than full objects.
+ """
+
+ data: typing.List[OntologyObjectV2]
+ """The list of objects that have been edited within the scenario."""
+
+ next_page_token: typing.Optional[core_models.PageToken] = pydantic.Field(alias=str("nextPageToken"), default=None) # type: ignore[literal-required]
+
+
+class LoadGeotemporalSeriesRequest(core.ModelBase):
+ """
+ The request body for loading entries from a geotemporal series reference property.
+
+ A geotemporal series represents time-indexed geographic observations for an object, such as the location history
+ of a vehicle or aircraft. Each entry in the response is a map of property names to values, following the same
+ structure as `OntologyObjectV2`.
+
+ The `range` field is required and restricts results to a specific time window. Both `startTime` and `endTime`
+ are required on `range`. The `additionalProperties` field controls which additional properties appear in each
+ returned entry. Results are paginated; use `pageToken` from a previous response to retrieve additional pages.
+ """
+
+ range: AbsoluteTimeRange
+ additional_properties: typing.List[SelectedPropertyApiName] = pydantic.Field(alias=str("additionalProperties")) # type: ignore[literal-required]
+ """
+ The additional property API names to include in each entry. The "time" and "position" properties are always
+ included and do not need to be specified here. Use this to request additional geotemporal series metadata
+ properties such as "speed" or "heading". Properties that are not available for the underlying geotemporal
+ integration will be omitted from the response entries.
+ """
+
+ page_token: typing.Optional[core_models.PageToken] = pydantic.Field(alias=str("pageToken"), default=None) # type: ignore[literal-required]
+ page_size: typing.Optional[core_models.PageSize] = pydantic.Field(alias=str("pageSize"), default=None) # type: ignore[literal-required]
+
+
+class LoadGeotemporalSeriesResponse(core.ModelBase):
+ """
+ The response when loading entries from a geotemporal series reference property.
+
+ Each entry in `data` is a map of property names to values containing the fields requested via
+ `additionalProperties` in the corresponding `LoadGeotemporalSeriesRequest`. If `nextPageToken` is present,
+ additional entries are available and can be retrieved by passing the token in a subsequent request.
+ """
+
+ data: typing.List[GeotemporalSeriesEntry]
+ next_page_token: typing.Optional[core_models.PageToken] = pydantic.Field(alias=str("nextPageToken"), default=None) # type: ignore[literal-required]
+
+
+class LoadObjectSetLinksRequestV2(core.ModelBase):
+ """LoadObjectSetLinksRequestV2"""
+
+ object_set: ObjectSet = pydantic.Field(alias=str("objectSet")) # type: ignore[literal-required]
+ links: typing.List[LinkTypeApiName]
+ page_token: typing.Optional[core_models.PageToken] = pydantic.Field(alias=str("pageToken"), default=None) # type: ignore[literal-required]
+ include_compute_usage: typing.Optional[core_models.IncludeComputeUsage] = pydantic.Field(alias=str("includeComputeUsage"), default=None) # type: ignore[literal-required]
+
+
+class LoadObjectSetLinksResponseV2(core.ModelBase):
+ """LoadObjectSetLinksResponseV2"""
+
+ data: typing.List[LinksFromObject]
+ next_page_token: typing.Optional[core_models.PageToken] = pydantic.Field(alias=str("nextPageToken"), default=None) # type: ignore[literal-required]
+ compute_usage: typing.Optional[core_models.ComputeSeconds] = pydantic.Field(alias=str("computeUsage"), default=None) # type: ignore[literal-required]
+
+
+class LoadObjectSetRequestV2(core.ModelBase):
+ """Represents the API POST body when loading an `ObjectSet`."""
+
+ object_set: ObjectSet = pydantic.Field(alias=str("objectSet")) # type: ignore[literal-required]
+ order_by: typing.Optional[SearchOrderByV2] = pydantic.Field(alias=str("orderBy"), default=None) # type: ignore[literal-required]
+ select: typing.List[SelectedPropertyApiName]
+ select_v2: typing.Optional[typing.List[PropertyIdentifier]] = pydantic.Field(alias=str("selectV2"), default=None) # type: ignore[literal-required]
+ """
+ The identifiers of the properties to include in the response. Only selectV2 or select should be populated,
+ but not both.
+ """
+
+ default_load_level: typing.Optional[PropertyLoadLevel] = pydantic.Field(alias=str("defaultLoadLevel"), default=None) # type: ignore[literal-required]
+ load_ontology_defined_derived_properties: typing.Optional[bool] = pydantic.Field(alias=str("loadOntologyDefinedDerivedProperties"), default=None) # type: ignore[literal-required]
+ """
+ A flag to load ontology-defined derived properties (OTDPs) in the response. Defaults to true.
+ Only applies when no explicit property selection (`select`/`selectV2`) is provided; when specific
+ properties are selected, this flag has no effect and the selected properties are always returned.
+
+ This feature is experimental and not yet generally available.
+ """
+
+ page_token: typing.Optional[core_models.PageToken] = pydantic.Field(alias=str("pageToken"), default=None) # type: ignore[literal-required]
+ page_size: typing.Optional[core_models.PageSize] = pydantic.Field(alias=str("pageSize"), default=None) # type: ignore[literal-required]
+ exclude_rid: typing.Optional[bool] = pydantic.Field(alias=str("excludeRid"), default=None) # type: ignore[literal-required]
+ """
+ A flag to exclude the retrieval of the `__rid` property.
+ Setting this to true may improve performance of this endpoint for object types in OSV2.
+ """
+
+ load_property_securities: typing.Optional[bool] = pydantic.Field(alias=str("loadPropertySecurities"), default=None) # type: ignore[literal-required]
+ """
+ A flag to load the securities for all properties.
+ Setting this flag to true will return a list of securities in the `propertySecurities` field of the response.
+ Returned objects will return all properties as Secured Property Values, which provide the property data
+ as well an index into the `propertySecurities` list.
+ This feature is experimental and not yet generally available.
+ """
+
+ snapshot: typing.Optional[bool] = None
+ """
+ A flag to use snapshot consistency when paging.
+ Setting this to true will give you a consistent view from before you start paging through the results, ensuring you do not get duplicate or missing items.
+ Setting this to false will let new results enter as you page, but you may encounter duplicate or missing items.
+ This defaults to false if not specified, which means you will always get the latest results.
+ """
+
+ include_compute_usage: typing.Optional[core_models.IncludeComputeUsage] = pydantic.Field(alias=str("includeComputeUsage"), default=None) # type: ignore[literal-required]
+ reference_signing_options: typing.Optional[ReferenceSigningOptions] = pydantic.Field(alias=str("referenceSigningOptions"), default=None) # type: ignore[literal-required]
+
+
+class LoadObjectSetResponseV2(core.ModelBase):
+ """Represents the API response when loading an `ObjectSet`."""
+
+ data: typing.List[OntologyObjectV2]
+ """The list of objects in the current Page."""
+
+ next_page_token: typing.Optional[core_models.PageToken] = pydantic.Field(alias=str("nextPageToken"), default=None) # type: ignore[literal-required]
+ total_count: core_models.TotalCount = pydantic.Field(alias=str("totalCount")) # type: ignore[literal-required]
+ compute_usage: typing.Optional[core_models.ComputeSeconds] = pydantic.Field(alias=str("computeUsage"), default=None) # type: ignore[literal-required]
+ property_securities: typing.Optional[typing.List[PropertySecurities]] = pydantic.Field(alias=str("propertySecurities"), default=None) # type: ignore[literal-required]
+
+
+class LoadObjectSetV2MultipleObjectTypesRequest(core.ModelBase):
+ """Represents the API POST body when loading an `ObjectSet`. Used on the `/loadObjectsMultipleObjectTypes` endpoint only."""
+
+ object_set: ObjectSet = pydantic.Field(alias=str("objectSet")) # type: ignore[literal-required]
+ order_by: typing.Optional[SearchOrderByV2] = pydantic.Field(alias=str("orderBy"), default=None) # type: ignore[literal-required]
+ select: typing.List[SelectedPropertyApiName]
+ select_v2: typing.Optional[typing.List[PropertyIdentifier]] = pydantic.Field(alias=str("selectV2"), default=None) # type: ignore[literal-required]
+ """
+ The identifiers of the properties to include in the response. Only selectV2 or select should be populated,
+ but not both.
+ """
+
+ default_load_level: typing.Optional[PropertyLoadLevel] = pydantic.Field(alias=str("defaultLoadLevel"), default=None) # type: ignore[literal-required]
+ load_ontology_defined_derived_properties: typing.Optional[bool] = pydantic.Field(alias=str("loadOntologyDefinedDerivedProperties"), default=None) # type: ignore[literal-required]
+ """
+ A flag to load ontology-defined derived properties (OTDPs) in the response. Defaults to true.
+ Only applies when no explicit property selection (`select`/`selectV2`) is provided; when specific
+ properties are selected, this flag has no effect and the selected properties are always returned.
+
+ This flag does not affect interface properties that are implemented by an OTDP on an
+ object type; those are always returned regardless of this flag.
+
+ This feature is experimental and not yet generally available.
+ """
+
+ page_token: typing.Optional[core_models.PageToken] = pydantic.Field(alias=str("pageToken"), default=None) # type: ignore[literal-required]
+ page_size: typing.Optional[core_models.PageSize] = pydantic.Field(alias=str("pageSize"), default=None) # type: ignore[literal-required]
+ exclude_rid: typing.Optional[bool] = pydantic.Field(alias=str("excludeRid"), default=None) # type: ignore[literal-required]
+ """
+ A flag to exclude the retrieval of the `$rid` property.
+ Setting this to true may improve performance of this endpoint for object types in OSV2.
+ """
+
+ load_property_securities: typing.Optional[bool] = pydantic.Field(alias=str("loadPropertySecurities"), default=None) # type: ignore[literal-required]
+ """
+ A flag to load the securities for all properties.
+ Setting this flag to true will return a list of securities in the `propertySecurities` field of the response.
+ Returned objects will return all properties as Secured Property Values, which provide the property data
+ as well an index into the `propertySecurities` list.
+ This feature is experimental and not yet generally available.
+ """
+
+ snapshot: typing.Optional[bool] = None
+ """
+ A flag to use snapshot consistency when paging.
+ Setting this to true will give you a consistent view from before you start paging through the results, ensuring you do not get duplicate or missing items.
+ Setting this to false will let new results enter as you page, but you may encounter duplicate or missing items.
+ This defaults to false if not specified, which means you will always get the latest results.
+ """
+
+ include_compute_usage: typing.Optional[core_models.IncludeComputeUsage] = pydantic.Field(alias=str("includeComputeUsage"), default=None) # type: ignore[literal-required]
+ reference_signing_options: typing.Optional[ReferenceSigningOptions] = pydantic.Field(alias=str("referenceSigningOptions"), default=None) # type: ignore[literal-required]
+
+
+class LoadObjectSetV2MultipleObjectTypesResponse(core.ModelBase):
+ """
+ Represents the API response when loading an `ObjectSet`. An `interfaceToObjectTypeMappings` field is
+ optionally returned if the type scope of the returned object set includes any interfaces. The "type scope"
+ of an object set refers to whether objects contain all their properties (object-type type scope) or just the
+ properties that implement interface properties (interface type scope). There can be multiple type scopes in a
+ single object set- some objects may have all their properties and some may only have interface properties.
+
+ The `interfaceToObjectTypeMappings` field contains mappings from `SharedPropertyTypeApiName`s on the interface(s) to
+ `PropertyApiName` for properties on the object(s).
+
+ The `interfaceToObjectTypeMappingsV2` field contains mappings from `InterfacePropertyApiName`s on the
+ interface(s) to `InterfacePropertyTypeImplementation` for properties on the object(s). This therefore includes
+ implementations of both properties backed by SharedPropertyTypes as well as properties defined on the interface.
+ """
+
+ data: typing.List[OntologyObjectV2]
+ """The list of objects in the current page."""
+
+ next_page_token: typing.Optional[core_models.PageToken] = pydantic.Field(alias=str("nextPageToken"), default=None) # type: ignore[literal-required]
+ total_count: core_models.TotalCount = pydantic.Field(alias=str("totalCount")) # type: ignore[literal-required]
+ interface_to_object_type_mappings: typing.Dict[InterfaceTypeApiName, InterfaceToObjectTypeMappings] = pydantic.Field(alias=str("interfaceToObjectTypeMappings")) # type: ignore[literal-required]
+ interface_to_object_type_mappings_v2: typing.Dict[InterfaceTypeApiName, InterfaceToObjectTypeMappingsV2] = pydantic.Field(alias=str("interfaceToObjectTypeMappingsV2")) # type: ignore[literal-required]
+ compute_usage: typing.Optional[core_models.ComputeSeconds] = pydantic.Field(alias=str("computeUsage"), default=None) # type: ignore[literal-required]
+ property_securities: typing.Optional[typing.List[PropertySecurities]] = pydantic.Field(alias=str("propertySecurities"), default=None) # type: ignore[literal-required]
+
+
+class LoadObjectSetV2ObjectsOrInterfacesRequest(core.ModelBase):
+ """Represents the API POST body when loading an `ObjectSet`. Used on the `/loadObjectsOrInterfaces` endpoint only."""
+
+ object_set: ObjectSet = pydantic.Field(alias=str("objectSet")) # type: ignore[literal-required]
+ order_by: typing.Optional[SearchOrderByV2] = pydantic.Field(alias=str("orderBy"), default=None) # type: ignore[literal-required]
+ select: typing.List[SelectedPropertyApiName]
+ select_v2: typing.Optional[typing.List[PropertyIdentifier]] = pydantic.Field(alias=str("selectV2"), default=None) # type: ignore[literal-required]
+ """
+ The identifiers of the properties to include in the response. Only selectV2 or select should be populated,
+ but not both.
+ """
+
+ default_load_level: typing.Optional[PropertyLoadLevel] = pydantic.Field(alias=str("defaultLoadLevel"), default=None) # type: ignore[literal-required]
+ load_ontology_defined_derived_properties: typing.Optional[bool] = pydantic.Field(alias=str("loadOntologyDefinedDerivedProperties"), default=None) # type: ignore[literal-required]
+ """
+ A flag to load ontology-defined derived properties (OTDPs) in the response. Defaults to true.
+ Only applies when no explicit property selection (`select`/`selectV2`) is provided; when specific
+ properties are selected, this flag has no effect and the selected properties are always returned.
+
+ This flag does not affect interface properties that are implemented by an OTDP on an
+ object type; those are always returned regardless of this flag.
+
+ This feature is experimental and not yet generally available.
+ """
+
+ page_token: typing.Optional[core_models.PageToken] = pydantic.Field(alias=str("pageToken"), default=None) # type: ignore[literal-required]
+ page_size: typing.Optional[core_models.PageSize] = pydantic.Field(alias=str("pageSize"), default=None) # type: ignore[literal-required]
+ exclude_rid: typing.Optional[bool] = pydantic.Field(alias=str("excludeRid"), default=None) # type: ignore[literal-required]
+ """
+ A flag to exclude the retrieval of the `$rid` property.
+ Setting this to true may improve performance of this endpoint for object types in OSV2.
+ """
+
+ snapshot: typing.Optional[bool] = None
+ """
+ A flag to use snapshot consistency when paging.
+ Setting this to true will give you a consistent view from before you start paging through the results, ensuring you do not get duplicate or missing items.
+ Setting this to false will let new results enter as you page, but you may encounter duplicate or missing items.
+ This defaults to false if not specified, which means you will always get the latest results.
+ """
+
+ reference_signing_options: typing.Optional[ReferenceSigningOptions] = pydantic.Field(alias=str("referenceSigningOptions"), default=None) # type: ignore[literal-required]
+
+
+class LoadObjectSetV2ObjectsOrInterfacesResponse(core.ModelBase):
+ """
+ Represents the API response when loading an `ObjectSet`. Objects in the returned set can either have properties
+ defined by an interface that the objects belong to or properties defined by the object type of the object.
+ """
+
+ data: typing.List[OntologyObjectV2]
+ """The list of objects in the current page."""
+
+ next_page_token: typing.Optional[core_models.PageToken] = pydantic.Field(alias=str("nextPageToken"), default=None) # type: ignore[literal-required]
+ total_count: core_models.TotalCount = pydantic.Field(alias=str("totalCount")) # type: ignore[literal-required]
+ transaction_id: typing.Optional[OntologyTransactionId] = pydantic.Field(alias=str("transactionId"), default=None) # type: ignore[literal-required]
+
+
+class LoadOntologyMetadataRequest(core.ModelBase):
+ """The Ontology metadata (i.e., object, link, action, query, and interface types) to load."""
+
+ object_types: typing.List[ObjectTypeApiName] = pydantic.Field(alias=str("objectTypes")) # type: ignore[literal-required]
+ link_types: typing.List[LinkTypeApiName] = pydantic.Field(alias=str("linkTypes")) # type: ignore[literal-required]
+ action_types: typing.List[ActionTypeApiName] = pydantic.Field(alias=str("actionTypes")) # type: ignore[literal-required]
+ query_types: typing.List[VersionedQueryTypeApiName] = pydantic.Field(alias=str("queryTypes")) # type: ignore[literal-required]
+ interface_types: typing.List[InterfaceTypeApiName] = pydantic.Field(alias=str("interfaceTypes")) # type: ignore[literal-required]
+ include_action_type_full_metadata: typing.Optional[bool] = pydantic.Field(alias=str("includeActionTypeFullMetadata"), default=None) # type: ignore[literal-required]
+ """
+ When set to `true`, the `actionTypesFullMetadata` field of the response will be populated in addition to
+ `actionTypes`.
+ """
+
+
+LogicRule: typing_extensions.TypeAlias = typing_extensions.Annotated[
+ typing.Union[
+ "DeleteInterfaceObjectRule",
+ "ModifyInterfaceObjectRule",
+ "ModifyObjectRule",
+ "DeleteObjectRule",
+ "CreateInterfaceObjectRule",
+ "DeleteLinkRule",
+ "CreateObjectRule",
+ "CreateLinkRule",
+ "ApplyScenarioRule",
+ ],
+ pydantic.Field(discriminator="type"),
+]
+"""LogicRule"""
+
+
+class LogicRuleActionTypesQueryV2(core.ModelBase):
+ """Returns action types which contain a logic rule of the given type."""
+
+ value: ActionTypeLogicRuleTypeFilter
+ type: typing.Literal["logicRule"] = "logicRule"
+
+
+LogicRuleArgument: typing_extensions.TypeAlias = typing_extensions.Annotated[
+ typing.Union[
+ "CurrentTimeArgument",
+ "StaticArgument",
+ "CurrentUserArgument",
+ "ParameterIdArgument",
+ "InterfaceParameterPropertyArgument",
+ "SynchronousWebhookOutputArgument",
+ "ObjectParameterPropertyArgument",
+ "UniqueIdentifierArgument",
+ ],
+ pydantic.Field(discriminator="type"),
+]
+"""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."""
+
+
+class LongValue(core.ModelBase):
+ """LongValue"""
+
+ value: core.Long
+ type: typing.Literal["longValue"] = "longValue"
+
+
+class LtQueryV2(core.ModelBase):
+ """
+ Returns objects where the specified field is less than a value. Allows you to specify a property to query on
+ by a variety of means. Either `field` or `propertyIdentifier` must be supplied, but not both.
+ """
+
+ field: typing.Optional[PropertyApiName] = None
+ property_identifier: typing.Optional[PropertyIdentifier] = pydantic.Field(alias=str("propertyIdentifier"), default=None) # type: ignore[literal-required]
+ value: PropertyValue
+ type: typing.Literal["lt"] = "lt"
+
+
+class LteQueryV2(core.ModelBase):
+ """
+ Returns objects where the specified field is less than or equal to a value. Allows you to specify a property to
+ query on by a variety of means. Either `field` or `propertyIdentifier` must be supplied, but not both.
+ """
+
+ field: typing.Optional[PropertyApiName] = None
+ property_identifier: typing.Optional[PropertyIdentifier] = pydantic.Field(alias=str("propertyIdentifier"), default=None) # type: ignore[literal-required]
+ value: PropertyValue
+ type: typing.Literal["lte"] = "lte"
+
+
+class MarkdownAllowedValues(core.ModelBase):
+ """The parameter value (a markdown-formatted string) must satisfy the configured length bounds."""
+
+ gte: typing.Optional[int] = None
+ """Character length greater than or equal."""
+
+ lte: typing.Optional[int] = None
+ """Character length less than or equal."""
+
+ type: typing.Literal["markdown"] = "markdown"
+
+
+MarkingId: typing_extensions.TypeAlias = str
+"""The id of a classification or mandatory marking."""
+
+
+class MatchRule(core.ModelBase):
+ """Matches intervals containing the terms in the query"""
+
+ query: str
+ max_gaps: typing.Optional[int] = pydantic.Field(alias=str("maxGaps"), default=None) # type: ignore[literal-required]
+ """
+ The maximum gaps between matched terms in the interval. For example, in the text "quick brown fox",
+ the terms "quick" and "fox" have a gap of one. If not set, then gaps are not considered.
+ """
+
+ ordered: bool
+ """If true, the matched terms must occur in order."""
+
+ type: typing.Literal["match"] = "match"
+
+
+class MaxAggregationV2(core.ModelBase):
+ """
+ Computes the maximum value for the provided field.
+ Either `field` or `propertyIdentifier` must be supplied, but not both.
+ """
+
+ field: typing.Optional[PropertyApiName] = None
+ property_identifier: typing.Optional[PropertyIdentifier] = pydantic.Field(alias=str("propertyIdentifier"), default=None) # type: ignore[literal-required]
+ name: typing.Optional[AggregationMetricName] = None
+ direction: typing.Optional[OrderByDirection] = None
+ type: typing.Literal["max"] = "max"
+
+
+class MediaMetadata(core.ModelBase):
+ """MediaMetadata"""
+
+ path: typing.Optional[core_models.MediaItemPath] = None
+ size_bytes: core_models.SizeBytes = pydantic.Field(alias=str("sizeBytes")) # type: ignore[literal-required]
+ media_type: core_models.MediaType = pydantic.Field(alias=str("mediaType")) # type: ignore[literal-required]
+
+
+class MinAggregationV2(core.ModelBase):
+ """
+ Computes the minimum value for the provided field.
+ Either `field` or `propertyIdentifier` must be supplied, but not both.
+ """
+
+ field: typing.Optional[PropertyApiName] = None
+ property_identifier: typing.Optional[PropertyIdentifier] = pydantic.Field(alias=str("propertyIdentifier"), default=None) # type: ignore[literal-required]
+ name: typing.Optional[AggregationMetricName] = None
+ direction: typing.Optional[OrderByDirection] = None
+ type: typing.Literal["min"] = "min"
+
+
+class ModifyEdit(core.ModelBase):
+ """ModifyEdit"""
+
+ includes_all_previous_values: typing.Optional[bool] = pydantic.Field(alias=str("includesAllPreviousValues"), default=None) # type: ignore[literal-required]
+ previous_properties: typing.Dict[PropertyApiName, PropertyValue] = pydantic.Field(alias=str("previousProperties")) # type: ignore[literal-required]
+ """
+ The property values before the modification.
+ Only includes properties that were changed.
+ Maps property API names to their previous values.
+ """
+
+ properties: typing.Dict[PropertyApiName, PropertyValue]
+ type: typing.Literal["modifyEdit"] = "modifyEdit"
+
+
+class ModifyInterfaceLogicRule(core.ModelBase):
+ """ModifyInterfaceLogicRule"""
+
+ interface_object_to_modify: ParameterId = pydantic.Field(alias=str("interfaceObjectToModify")) # type: ignore[literal-required]
+ shared_property_arguments: typing.Dict[SharedPropertyTypeApiName, LogicRuleArgument] = pydantic.Field(alias=str("sharedPropertyArguments")) # type: ignore[literal-required]
+ struct_property_arguments: typing.Dict[SharedPropertyTypeApiName, typing.Dict[StructFieldApiName, StructFieldArgument]] = pydantic.Field(alias=str("structPropertyArguments")) # type: ignore[literal-required]
+ type: typing.Literal["modifyInterface"] = "modifyInterface"
+
+
+class ModifyInterfaceObjectRule(core.ModelBase):
+ """ModifyInterfaceObjectRule"""
+
+ interface_type_api_name: InterfaceTypeApiName = pydantic.Field(alias=str("interfaceTypeApiName")) # type: ignore[literal-required]
+ type: typing.Literal["modifyInterfaceObject"] = "modifyInterfaceObject"
+
+
+class ModifyObject(core.ModelBase):
+ """ModifyObject"""
+
+ primary_key: PropertyValue = pydantic.Field(alias=str("primaryKey")) # type: ignore[literal-required]
+ object_type: ObjectTypeApiName = pydantic.Field(alias=str("objectType")) # type: ignore[literal-required]
+ type: typing.Literal["modifyObject"] = "modifyObject"
+
+
+class ModifyObjectEdit(core.ModelBase):
+ """ModifyObjectEdit"""
+
+ object_type: ObjectTypeApiName = pydantic.Field(alias=str("objectType")) # type: ignore[literal-required]
+ primary_key: PropertyValue = pydantic.Field(alias=str("primaryKey")) # type: ignore[literal-required]
+ properties: typing.Dict[PropertyApiName, typing.Optional[DataValue]]
+ type: typing.Literal["modifyObject"] = "modifyObject"
+
+
+class ModifyObjectLogicRule(core.ModelBase):
+ """ModifyObjectLogicRule"""
+
+ object_to_modify: ParameterId = pydantic.Field(alias=str("objectToModify")) # type: ignore[literal-required]
+ property_arguments: typing.Dict[PropertyApiName, LogicRuleArgument] = pydantic.Field(alias=str("propertyArguments")) # type: ignore[literal-required]
+ struct_property_arguments: typing.Dict[PropertyApiName, typing.Dict[StructFieldApiName, StructFieldArgument]] = pydantic.Field(alias=str("structPropertyArguments")) # type: ignore[literal-required]
+ type: typing.Literal["modifyObject"] = "modifyObject"
+
+
+class ModifyObjectRule(core.ModelBase):
+ """ModifyObjectRule"""
+
+ object_type_api_name: ObjectTypeApiName = pydantic.Field(alias=str("objectTypeApiName")) # type: ignore[literal-required]
+ type: typing.Literal["modifyObject"] = "modifyObject"
+
+
+class MultiplyPropertyExpression(core.ModelBase):
+ """Multiplies two or more numeric values."""
+
+ properties: typing.List[DerivedPropertyDefinition]
+ type: typing.Literal["multiply"] = "multiply"
+
+
+class MustBeEmptyAllowedValues(core.ModelBase):
+ """The parameter must be omitted or empty."""
+
+ type: typing.Literal["mustBeEmpty"] = "mustBeEmpty"
+
+
+NearestNeighborsQuery: typing_extensions.TypeAlias = typing_extensions.Annotated[
+ typing.Union["DoubleVector", "NearestNeighborsQueryText"], pydantic.Field(discriminator="type")
+]
+"""
+Queries support either a vector matching the embedding model defined on the property, or text that is
+automatically embedded.
+"""
+
+
+class NearestNeighborsQueryText(core.ModelBase):
+ """Automatically embed the text in a vector using the embedding model configured for the given propertyIdentifier."""
+
+ value: str
+ type: typing.Literal["text"] = "text"
+
+
+class NegatePropertyExpression(core.ModelBase):
+ """Negates a numeric value."""
+
+ property: DerivedPropertyDefinition
+ type: typing.Literal["negate"] = "negate"
+
+
+NestedInterfacePropertyTypeImplementation: typing_extensions.TypeAlias = (
+ typing_extensions.Annotated[
+ typing.Union[
+ "InterfacePropertyStructFieldImplementation",
+ "InterfacePropertyStructImplementation",
+ "InterfacePropertyLocalPropertyImplementation",
+ ],
+ pydantic.Field(discriminator="type"),
+ ]
+)
+"""
+Describes how an object type implements an interface property when a reducer is applied to it. Is missing a
+reduced property implementation to prevent arbitrarily nested implementations.
+"""
+
+
+class NestedQueryAggregation(core.ModelBase):
+ """NestedQueryAggregation"""
+
+ key: typing.Any
+ groups: typing.List[QueryAggregation]
+
+
+class NoLoadLevel(core.ModelBase):
+ """
+ Returns the property as-is, without applying reducers or extracting a struct main value. Useful as an
+ explicit per-property load level (via `PropertyWithLoadLevelSelector`) to opt a property out of a
+ `defaultLoadLevel`.
+ """
+
+ type: typing.Literal["noLoadLevel"] = "noLoadLevel"
+
+
+class NotQueryV2(core.ModelBase):
+ """Returns objects where the query is not satisfied."""
+
+ value: SearchJsonQueryV2
+ type: typing.Literal["not"] = "not"
+
+
+class NowDatetimeValue(core.ModelBase):
+ """The current evaluation time itself. Carries no fields."""
+
+ type: typing.Literal["now"] = "now"
+
+
+class NumberFormatAffix(core.ModelBase):
+ """
+ Attach arbitrary text before and/or after the formatted number.
+ Example: prefix "USD " and postfix " total" displays as "USD 1,234.56 total"
+ """
+
+ base_format_options: NumberFormatOptions = pydantic.Field(alias=str("baseFormatOptions")) # type: ignore[literal-required]
+ affix: Affix
+ type: typing.Literal["affix"] = "affix"
+
+
+class NumberFormatCurrency(core.ModelBase):
+ """
+ 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)
+ """
+
+ base_format_options: NumberFormatOptions = pydantic.Field(alias=str("baseFormatOptions")) # type: ignore[literal-required]
+ style: NumberFormatCurrencyStyle
+ currency_code: PropertyTypeReferenceOrStringConstant = pydantic.Field(alias=str("currencyCode")) # type: ignore[literal-required]
+ type: typing.Literal["currency"] = "currency"
+
+
+NumberFormatCurrencyStyle: typing_extensions.TypeAlias = typing.Literal["STANDARD", "COMPACT"]
+"""
+Currency rendering style options:
+- STANDARD: Full currency formatting (e.g., "USD 1,234.56")
+- COMPACT: Abbreviated currency formatting (e.g., "USD 1.2K")
+"""
+
+
+class NumberFormatCustomUnit(core.ModelBase):
+ """
+ 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"
+ """
+
+ base_format_options: NumberFormatOptions = pydantic.Field(alias=str("baseFormatOptions")) # type: ignore[literal-required]
+ unit: PropertyTypeReferenceOrStringConstant
+ type: typing.Literal["customUnit"] = "customUnit"
+
+
+class NumberFormatDuration(core.ModelBase):
+ """
+ Format numeric values representing time durations.
+ - Human readable: 3661 seconds displays as "1h 1m 1s"
+ - Timecode: 3661 seconds displays as "01:01:01"
+ """
+
+ format_style: DurationFormatStyle = pydantic.Field(alias=str("formatStyle")) # type: ignore[literal-required]
+ precision: typing.Optional[DurationPrecision] = None
+ base_value: DurationBaseValue = pydantic.Field(alias=str("baseValue")) # type: ignore[literal-required]
+ type: typing.Literal["duration"] = "duration"
+
+
+class NumberFormatFixedValues(core.ModelBase):
+ """
+ Map integer values to custom human-readable strings.
+ Example: {1: "First", 2: "Second", 3: "Third"} would display 2 as "Second".
+ """
+
+ values: typing.Dict[FixedValuesMapKey, str]
+ type: typing.Literal["fixedValues"] = "fixedValues"
+
+
+NumberFormatNotation: typing_extensions.TypeAlias = typing.Literal[
+ "STANDARD", "SCIENTIFIC", "ENGINEERING", "COMPACT"
+]
+"""
+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")
+"""
+
+
+class NumberFormatOptions(core.ModelBase):
+ """
+ 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"
+ """
+
+ use_grouping: typing.Optional[bool] = pydantic.Field(alias=str("useGrouping"), default=None) # type: ignore[literal-required]
+ """If true, show a locale-appropriate number grouping (e.g. thousands for en)."""
+
+ convert_negative_to_parenthesis: typing.Optional[bool] = pydantic.Field(alias=str("convertNegativeToParenthesis"), default=None) # type: ignore[literal-required]
+ """If true, wrap negative numbers in parentheses instead of a minus sign."""
+
+ minimum_integer_digits: typing.Optional[int] = pydantic.Field(alias=str("minimumIntegerDigits"), default=None) # type: ignore[literal-required]
+ minimum_fraction_digits: typing.Optional[int] = pydantic.Field(alias=str("minimumFractionDigits"), default=None) # type: ignore[literal-required]
+ maximum_fraction_digits: typing.Optional[int] = pydantic.Field(alias=str("maximumFractionDigits"), default=None) # type: ignore[literal-required]
+ minimum_significant_digits: typing.Optional[int] = pydantic.Field(alias=str("minimumSignificantDigits"), default=None) # type: ignore[literal-required]
+ maximum_significant_digits: typing.Optional[int] = pydantic.Field(alias=str("maximumSignificantDigits"), default=None) # type: ignore[literal-required]
+ notation: typing.Optional[NumberFormatNotation] = None
+ rounding_mode: typing.Optional[NumberRoundingMode] = pydantic.Field(alias=str("roundingMode"), default=None) # type: ignore[literal-required]
+
+
+class NumberFormatRatio(core.ModelBase):
+ """
+ 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")
+ """
+
+ ratio_type: NumberRatioType = pydantic.Field(alias=str("ratioType")) # type: ignore[literal-required]
+ base_format_options: NumberFormatOptions = pydantic.Field(alias=str("baseFormatOptions")) # type: ignore[literal-required]
+ type: typing.Literal["ratio"] = "ratio"
+
+
+class NumberFormatScale(core.ModelBase):
+ """
+ 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"
+ """
+
+ scale_type: NumberScaleType = pydantic.Field(alias=str("scaleType")) # type: ignore[literal-required]
+ base_format_options: NumberFormatOptions = pydantic.Field(alias=str("baseFormatOptions")) # type: ignore[literal-required]
+ type: typing.Literal["scale"] = "scale"
+
+
+class NumberFormatStandard(core.ModelBase):
+ """
+ Standard number formatting with configurable options.
+ This provides basic number formatting without any special units, scaling, or transformations.
+ """
+
+ base_format_options: NumberFormatOptions = pydantic.Field(alias=str("baseFormatOptions")) # type: ignore[literal-required]
+ type: typing.Literal["standard"] = "standard"
+
+
+class NumberFormatStandardUnit(core.ModelBase):
+ """
+ Format numbers with standard units supported by Intl.NumberFormat.
+ Examples: "meter", "kilogram", "celsius", "percent"
+ Input: 25 with unit "celsius" displays as "25 degrees C"
+ """
+
+ base_format_options: NumberFormatOptions = pydantic.Field(alias=str("baseFormatOptions")) # type: ignore[literal-required]
+ unit: PropertyTypeReferenceOrStringConstant
+ type: typing.Literal["standardUnit"] = "standardUnit"
+
+
+NumberRatioType: typing_extensions.TypeAlias = typing.Literal[
+ "PERCENTAGE", "PER_MILLE", "BASIS_POINTS"
+]
+"""
+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
+"""
+
+
+NumberRoundingMode: typing_extensions.TypeAlias = typing.Literal["CEIL", "FLOOR", "ROUND_CLOSEST"]
+"""
+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)
+"""
+
+
+NumberScaleType: typing_extensions.TypeAlias = typing.Literal["THOUSANDS", "MILLIONS", "BILLIONS"]
+"""
+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
+"""
+
+
+ObjectEdit: typing_extensions.TypeAlias = typing_extensions.Annotated[
+ typing.Union["ModifyObject", "DeleteObject", "AddObject", "DeleteLink", "AddLink"],
+ pydantic.Field(discriminator="type"),
+]
+"""ObjectEdit"""
+
+
+class ObjectEditHistoryEntry(core.ModelBase):
+ """
+ Represents a single object edit operation in the history. This captures when an object was
+ created, modified, or deleted as part of an action execution.
+ """
+
+ object_primary_key: ObjectPrimaryKeyV2 = pydantic.Field(alias=str("objectPrimaryKey")) # type: ignore[literal-required]
+ operation_id: ActionRid = pydantic.Field(alias=str("operationId")) # type: ignore[literal-required]
+ action_type_rid: ActionTypeRid = pydantic.Field(alias=str("actionTypeRid")) # type: ignore[literal-required]
+ user_id: str = pydantic.Field(alias=str("userId")) # type: ignore[literal-required]
+ """The user ID or principal that performed the action"""
+
+ timestamp: core.AwareDatetime
+ """When this edit occurred (ISO 8601 format)"""
+
+ edit: EditHistoryEdit
+
+
+class ObjectEdits(core.ModelBase):
+ """ObjectEdits"""
+
+ edits: typing.List[ObjectEdit]
+ added_object_count: int = pydantic.Field(alias=str("addedObjectCount")) # type: ignore[literal-required]
+ modified_objects_count: int = pydantic.Field(alias=str("modifiedObjectsCount")) # type: ignore[literal-required]
+ deleted_objects_count: int = pydantic.Field(alias=str("deletedObjectsCount")) # type: ignore[literal-required]
+ added_links_count: int = pydantic.Field(alias=str("addedLinksCount")) # type: ignore[literal-required]
+ deleted_links_count: int = pydantic.Field(alias=str("deletedLinksCount")) # type: ignore[literal-required]
+ type: typing.Literal["edits"] = "edits"
+
+
+class ObjectLoadingResponseOptions(core.ModelBase):
+ """Optional features to toggle when generating the object loading response."""
+
+ should_load_object_rids: typing.Optional[bool] = pydantic.Field(alias=str("shouldLoadObjectRids"), default=None) # type: ignore[literal-required]
+ """
+ Whether returned objects should include their RIDs. Note that resolving object RIDs can add 100s of
+ milliseconds to the execution time, and should be avoided where not needed.
+ """
+
+
+class ObjectLocator(core.ModelBase):
+ """An object identifier containing an object type API name and primary key."""
+
+ object_type_api_name: ObjectTypeApiName = pydantic.Field(alias=str("objectTypeApiName")) # type: ignore[literal-required]
+ primary_key_value: PrimaryKeyValue = pydantic.Field(alias=str("primaryKeyValue")) # type: ignore[literal-required]
+
+
+class ObjectParameterPropertyArgument(core.ModelBase):
+ """Represents an object parameter property argument in a logic rule."""
+
+ parameter_id: ParameterId = pydantic.Field(alias=str("parameterId")) # type: ignore[literal-required]
+ property_type_api_name: PropertyTypeApiName = pydantic.Field(alias=str("propertyTypeApiName")) # type: ignore[literal-required]
+ type: typing.Literal["objectParameterPropertyValue"] = "objectParameterPropertyValue"
+
+
+ObjectPrimaryKey: typing_extensions.TypeAlias = typing.Dict["PropertyApiName", "PropertyValue"]
+"""ObjectPrimaryKey"""
+
+
+ObjectPrimaryKeyV2: typing_extensions.TypeAlias = typing.Dict[
+ "PropertyApiName", "PrimaryKeyValueV2"
+]
+"""ObjectPrimaryKeyV2"""
+
+
+ObjectPropertyType: typing_extensions.TypeAlias = typing_extensions.Annotated[
+ typing.Union[
+ core_models.DateType,
+ "StructType",
+ core_models.StringType,
+ core_models.ByteType,
+ core_models.DoubleType,
+ core_models.GeoPointType,
+ core_models.GeotimeSeriesReferenceType,
+ core_models.IntegerType,
+ core_models.FloatType,
+ core_models.GeoShapeType,
+ core_models.LongType,
+ core_models.BooleanType,
+ core_models.CipherTextType,
+ core_models.MarkingType,
+ core_models.AttachmentType,
+ core_models.MediaReferenceType,
+ core_models.TimeseriesType,
+ "OntologyObjectArrayType",
+ core_models.ShortType,
+ core_models.VectorType,
+ core_models.DecimalType,
+ core_models.TimestampType,
+ ],
+ pydantic.Field(discriminator="type"),
+]
+"""A union of all the types supported by Ontology Object properties."""
+
+
+class ObjectPropertyValueConstraint(core.ModelBase):
+ """The parameter value must be a property value of an object found within an object set."""
+
+ type: typing.Literal["objectPropertyValue"] = "objectPropertyValue"
+
+
+class ObjectQueryResultConstraint(core.ModelBase):
+ """The parameter value must be the primary key of an object found within an object set."""
+
+ type: typing.Literal["objectQueryResult"] = "objectQueryResult"
+
+
+ObjectRid: typing_extensions.TypeAlias = core.RID
+"""The unique resource identifier of an object, useful for interacting with other Foundry APIs."""
+
+
+ObjectSet: typing_extensions.TypeAlias = typing_extensions.Annotated[
+ typing.Union[
+ "ObjectSetSearchAroundType",
+ "ObjectSetStaticType",
+ "ObjectSetIntersectionType",
+ "ObjectSetWithPropertiesType",
+ "ObjectSetInterfaceLinkSearchAroundType",
+ "ObjectSetSubtractType",
+ "ObjectSetNearestNeighborsType",
+ "ObjectSetUnionType",
+ "ObjectSetAsTypeType",
+ "ObjectSetMethodInputType",
+ "ObjectSetReferenceType",
+ "ObjectSetFilterType",
+ "ObjectSetInterfaceBaseType",
+ "ObjectSetAsBaseObjectTypesType",
+ "ObjectSetBaseType",
+ ],
+ pydantic.Field(discriminator="type"),
+]
+"""Represents the definition of an `ObjectSet` in the `Ontology`."""
+
+
+class ObjectSetAsBaseObjectTypesType(core.ModelBase):
+ """
+ Casts the objects in the object set to their base type and thus ensures objects are returned with all of their
+ properties in the resulting object set, not just the properties that implement interface properties.
+ """
+
+ object_set: ObjectSet = pydantic.Field(alias=str("objectSet")) # type: ignore[literal-required]
+ type: typing.Literal["asBaseObjectTypes"] = "asBaseObjectTypes"
+
+
+class ObjectSetAsTypeType(core.ModelBase):
+ """
+ Casts an object set to a specified object type or interface type API name. Any object whose object type does
+ not match the object type provided or implement the interface type provided will be dropped from the resulting
+ object set.
+ """
+
+ entity_type: str = pydantic.Field(alias=str("entityType")) # type: ignore[literal-required]
+ """An object type or interface type API name."""
+
+ object_set: ObjectSet = pydantic.Field(alias=str("objectSet")) # type: ignore[literal-required]
+ type: typing.Literal["asType"] = "asType"
+
+
+class ObjectSetBaseType(core.ModelBase):
+ """ObjectSetBaseType"""
+
+ object_type: str = pydantic.Field(alias=str("objectType")) # type: ignore[literal-required]
+ """The API name of the object type."""
+
+ type: typing.Literal["base"] = "base"
+
+
+class ObjectSetFilterType(core.ModelBase):
+ """ObjectSetFilterType"""
+
+ object_set: ObjectSet = pydantic.Field(alias=str("objectSet")) # type: ignore[literal-required]
+ where: SearchJsonQueryV2
+ type: typing.Literal["filter"] = "filter"
+
+
+class ObjectSetInterfaceBaseType(core.ModelBase):
+ """ObjectSetInterfaceBaseType"""
+
+ interface_type: str = pydantic.Field(alias=str("interfaceType")) # type: ignore[literal-required]
+ """
+ An object set with objects that implement the interface with the given interface API name. The objects in
+ the object set will only have properties that implement properties of the given interface, unless you set the includeAllBaseObjectProperties flag.
+ """
+
+ include_all_base_object_properties: typing.Optional[bool] = pydantic.Field(alias=str("includeAllBaseObjectProperties"), default=None) # type: ignore[literal-required]
+ """
+ A flag that will return all of the underlying object properties for the objects that implement the interface.
+ This includes properties that don't explicitly implement an SPT on the interface.
+ """
+
+ type: typing.Literal["interfaceBase"] = "interfaceBase"
+
+
+class ObjectSetInterfaceLinkSearchAroundType(core.ModelBase):
+ """ObjectSetInterfaceLinkSearchAroundType"""
+
+ object_set: ObjectSet = pydantic.Field(alias=str("objectSet")) # type: ignore[literal-required]
+ interface_link: InterfaceLinkTypeApiName = pydantic.Field(alias=str("interfaceLink")) # type: ignore[literal-required]
+ type: typing.Literal["interfaceLinkSearchAround"] = "interfaceLinkSearchAround"
+
+
+class ObjectSetIntersectionType(core.ModelBase):
+ """ObjectSetIntersectionType"""
+
+ object_sets: typing.List[ObjectSet] = pydantic.Field(alias=str("objectSets")) # type: ignore[literal-required]
+ type: typing.Literal["intersect"] = "intersect"
+
+
+class ObjectSetMethodInputType(core.ModelBase):
+ """
+ ObjectSet which is the root of a MethodObjectSet definition.
+
+ This feature is experimental and not yet generally available.
+ """
+
+ type: typing.Literal["methodInput"] = "methodInput"
+
+
+class ObjectSetNearestNeighborsType(core.ModelBase):
+ """
+ ObjectSet containing the top `numNeighbors` objects with `propertyIdentifier` nearest to the input vector or
+ text. This can only be performed on a property with type vector that has been configured to be searched with
+ approximate nearest neighbors using a similarity function configured in the Ontology.
+
+ A non-zero score for each resulting object is returned when the `orderType` in the `orderBy` field is set to
+ `relevance`. Note that:
+ - Scores will not be returned if a nearestNeighbors object set is composed through union, subtraction
+ or intersection with non-nearestNeighbors object sets.
+ - If results have scores, the order of the scores will be decreasing (duplicate scores are possible).
+ """
+
+ object_set: ObjectSet = pydantic.Field(alias=str("objectSet")) # type: ignore[literal-required]
+ property_identifier: PropertyIdentifier = pydantic.Field(alias=str("propertyIdentifier")) # type: ignore[literal-required]
+ num_neighbors: int = pydantic.Field(alias=str("numNeighbors")) # type: ignore[literal-required]
+ """
+ The number of objects to return. If the number of documents in the objectType is less than the provided
+ value, all objects will be returned. This value is limited to 1 &lt;= numNeighbors &lt;= 500.
+ """
+
+ similarity_threshold: typing.Optional[float] = pydantic.Field(alias=str("similarityThreshold"), default=None) # type: ignore[literal-required]
+ """
+ The similarity threshold results must be above to be included in the returned in the object set.
+ 0 &lt;= Threshold &lt;= 1. Where 1 is identical and 0 is least similar.
+ """
+
+ query: NearestNeighborsQuery
+ type: typing.Literal["nearestNeighbors"] = "nearestNeighbors"
+
+
+class ObjectSetReferenceType(core.ModelBase):
+ """ObjectSetReferenceType"""
+
+ reference: ObjectSetRid
+ type: typing.Literal["reference"] = "reference"
+
+
+ObjectSetRid: typing_extensions.TypeAlias = core.RID
+"""ObjectSetRid"""
+
+
+class ObjectSetSearchAroundType(core.ModelBase):
+ """ObjectSetSearchAroundType"""
+
+ object_set: ObjectSet = pydantic.Field(alias=str("objectSet")) # type: ignore[literal-required]
+ link: LinkTypeApiName
+ type: typing.Literal["searchAround"] = "searchAround"
+
+
+class ObjectSetStaticType(core.ModelBase):
+ """ObjectSetStaticType"""
+
+ objects: typing.List[ObjectRid]
+ type: typing.Literal["static"] = "static"
+
+
+class ObjectSetStreamSubscribeRequest(core.ModelBase):
+ """
+ `branch` identifies the Foundry branch. `scenarioRid` identifies the Ontology Scenario.
+ If a scenario is based on a non-default branch, `branch` must identify that non-default base branch.
+ """
+
+ object_set: ObjectSet = pydantic.Field(alias=str("objectSet")) # type: ignore[literal-required]
+ branch: typing.Optional[core_models.FoundryBranch] = None
+ scenario_rid: typing.Optional[OntologyScenarioRid] = pydantic.Field(alias=str("scenarioRid"), default=None) # type: ignore[literal-required]
+ property_set: typing.List[SelectedPropertyApiName] = pydantic.Field(alias=str("propertySet")) # type: ignore[literal-required]
+ reference_set: typing.List[SelectedPropertyApiName] = pydantic.Field(alias=str("referenceSet")) # type: ignore[literal-required]
+ object_loading_response_options: typing.Optional[ObjectLoadingResponseOptions] = pydantic.Field(alias=str("objectLoadingResponseOptions"), default=None) # type: ignore[literal-required]
+
+
+class ObjectSetStreamSubscribeRequests(core.ModelBase):
+ """
+ The list of object sets that should be subscribed to. A client can stop subscribing to an object set
+ by removing the request from subsequent ObjectSetStreamSubscribeRequests.
+ """
+
+ id: RequestId
+ requests: typing.List[ObjectSetStreamSubscribeRequest]
+
+
+ObjectSetSubscribeResponse: typing_extensions.TypeAlias = typing_extensions.Annotated[
+ typing.Union["QosError", "SubscriptionSuccess", "SubscriptionError"],
+ pydantic.Field(discriminator="type"),
+]
+"""ObjectSetSubscribeResponse"""
+
+
+class ObjectSetSubscribeResponses(core.ModelBase):
+ """Returns a response for every request in the same order. Duplicate requests will be assigned the same SubscriberId."""
+
+ responses: typing.List[ObjectSetSubscribeResponse]
+ id: RequestId
+ type: typing.Literal["subscribeResponses"] = "subscribeResponses"
+
+
+class ObjectSetSubtractType(core.ModelBase):
+ """ObjectSetSubtractType"""
+
+ object_sets: typing.List[ObjectSet] = pydantic.Field(alias=str("objectSets")) # type: ignore[literal-required]
+ type: typing.Literal["subtract"] = "subtract"
+
+
+class ObjectSetUnionType(core.ModelBase):
+ """ObjectSetUnionType"""
+
+ object_sets: typing.List[ObjectSet] = pydantic.Field(alias=str("objectSets")) # type: ignore[literal-required]
+ type: typing.Literal["union"] = "union"
+
+
+ObjectSetUpdate: typing_extensions.TypeAlias = typing_extensions.Annotated[
+ typing.Union["ReferenceUpdate", "ObjectUpdate"], pydantic.Field(discriminator="type")
+]
+"""ObjectSetUpdate"""
+
+
+class ObjectSetUpdates(core.ModelBase):
+ """ObjectSetUpdates"""
+
+ id: SubscriptionId
+ updates: typing.List[ObjectSetUpdate]
+ type: typing.Literal["objectSetChanged"] = "objectSetChanged"
+
+
+class ObjectSetWithPropertiesType(core.ModelBase):
+ """
+ ObjectSet which returns objects with additional derived properties.
+
+ This feature is experimental and not yet generally available.
+ """
+
+ object_set: ObjectSet = pydantic.Field(alias=str("objectSet")) # type: ignore[literal-required]
+ derived_properties: typing.Dict[DerivedPropertyApiName, DerivedPropertyDefinition] = pydantic.Field(alias=str("derivedProperties")) # type: ignore[literal-required]
+ """Map of the name of the derived property to return and its definition"""
+
+ type: typing.Literal["withProperties"] = "withProperties"
+
+
+ObjectState: typing_extensions.TypeAlias = typing.Literal["ADDED_OR_UPDATED", "REMOVED"]
+"""
+Represents the state of the object within the object set. ADDED_OR_UPDATED indicates that the object was
+added to the set or the object has updated and was previously in the set. REMOVED indicates that the object
+was removed from the set due to the object being deleted or the object no longer meets the object set
+definition.
+"""
+
+
+ObjectTypeApiName: typing_extensions.TypeAlias = str
+"""
+The name of the object type in the API in camelCase format. To find the API name for your Object Type, use the
+`List object types` endpoint or check the **Ontology Manager**.
+"""
+
+
+class ObjectTypeDatasetDatasource(core.ModelBase):
+ """An object type datasource backed by a Foundry dataset."""
+
+ dataset_rid: datasets_models.DatasetRid = pydantic.Field(alias=str("datasetRid")) # type: ignore[literal-required]
+ branch: typing.Optional[DatasourceBranchId] = None
+ property_mapping: typing.Dict[PropertyApiName, PropertyTypeMappingInfo] = pydantic.Field(alias=str("propertyMapping")) # type: ignore[literal-required]
+ """
+ A mapping from property API name to a description of how that property is bound to the dataset. Properties
+ whose mapping info cannot be modeled are omitted.
+ """
+
+ type: typing.Literal["dataset"] = "dataset"
+
+
+class ObjectTypeDatasource(core.ModelBase):
+ """
+ A datasource that supplies property values for an object type. Each object type can have one or more
+ datasources; together they back all of the object type's properties. The `definition` carries the RID of the
+ backing Foundry resource (for example, the dataset RID for a dataset-backed object type), enabling callers to
+ navigate from an object type to its backing data.
+ """
+
+ rid: DatasourceRid
+ definition: ObjectTypeDatasourceDefinition
+
+
+ObjectTypeDatasourceDefinition: typing_extensions.TypeAlias = typing_extensions.Annotated[
+ typing.Union[
+ "ObjectTypeTimeSeriesDatasource",
+ "ObjectTypeUnsupportedDatasource",
+ "ObjectTypeRestrictedViewDatasource",
+ "ObjectTypeStreamDatasource",
+ "ObjectTypeMediaSetViewDatasource",
+ "ObjectTypeDirectDatasource",
+ "ObjectTypeGeotimeSeriesDatasource",
+ "ObjectTypeEditsOnlyDatasource",
+ "ObjectTypeDatasetDatasource",
+ "ObjectTypeTableDatasource",
+ ],
+ pydantic.Field(discriminator="type"),
+]
+"""
+The definition of an object type datasource, identifying the kind of Foundry resource that backs the object
+type.
+"""
+
+
+class ObjectTypeDirectDatasource(core.ModelBase):
+ """
+ An object type datasource backed by a direct-write source. Property values are written directly to the
+ datasource rather than being read from a separate Foundry resource. Unlike an edits-only datasource, a direct
+ datasource has a backing source that values are written to by some writer. An edits-only datasource has no
+ backing source at all and its properties are populated solely via Actions.
+ """
+
+ direct_source_rid: DirectSourceRid = pydantic.Field(alias=str("directSourceRid")) # type: ignore[literal-required]
+ property_mapping: typing.Dict[PropertyApiName, PropertyTypeMappingInfo] = pydantic.Field(alias=str("propertyMapping")) # type: ignore[literal-required]
+ """
+ A mapping from property API name to a description of how that property is bound to the direct datasource.
+ Properties whose mapping info cannot be modeled are omitted.
+ """
+
+ type: typing.Literal["direct"] = "direct"
+
+
+class ObjectTypeEdits(core.ModelBase):
+ """ObjectTypeEdits"""
+
+ edited_object_types: typing.List[ObjectTypeApiName] = pydantic.Field(alias=str("editedObjectTypes")) # type: ignore[literal-required]
+ type: typing.Literal["largeScaleEdits"] = "largeScaleEdits"
+
+
+class ObjectTypeEditsHistoryRequest(core.ModelBase):
+ """
+ Request object for querying object type edits history, containing both filters and pagination parameters
+
+ If objectPrimaryKey property is set, the method will return edits history for the particular object.
+ Otherwise, the method will return edits history for all objects of this object type.
+ """
+
+ object_primary_key: typing.Optional[ObjectPrimaryKeyV2] = pydantic.Field(alias=str("objectPrimaryKey"), default=None) # type: ignore[literal-required]
+ filters: typing.Optional[EditsHistoryFilter] = None
+ sort_order: typing.Optional[EditsHistorySortOrder] = pydantic.Field(alias=str("sortOrder"), default=None) # type: ignore[literal-required]
+ include_all_previous_properties: typing.Optional[bool] = pydantic.Field(alias=str("includeAllPreviousProperties"), default=None) # type: ignore[literal-required]
+ page_size: typing.Optional[int] = pydantic.Field(alias=str("pageSize"), default=None) # type: ignore[literal-required]
+ """The maximum number of edits to return per page. Defaults to 100."""
+
+ page_token: typing.Optional[str] = pydantic.Field(alias=str("pageToken"), default=None) # type: ignore[literal-required]
+ """Token for retrieving the next page of results"""
+
+
+class ObjectTypeEditsHistoryResponse(core.ModelBase):
+ """
+ Response containing the history of edits for objects of a specific object type.
+ Only contains object edits (create, modify, delete) - link edits are not included.
+ """
+
+ data: typing.List[ObjectEditHistoryEntry]
+ """List of historical edits for this object type"""
+
+ total_count: typing.Optional[int] = pydantic.Field(alias=str("totalCount"), default=None) # type: ignore[literal-required]
+ """Count of items in the data array above"""
+
+ next_page_token: typing.Optional[str] = pydantic.Field(alias=str("nextPageToken"), default=None) # type: ignore[literal-required]
+ """Token for retrieving the next page of results"""
+
+
+class ObjectTypeEditsOnlyDatasource(core.ModelBase):
+ """
+ An object type datasource that is not backed by any external Foundry resource. All properties on the object type
+ can only be populated via Actions. Other datasources have edit only *properties*, which are permissioned to the
+ backing tabular datasource. This datasource has no backing tabular datasource and is a true edit only object
+ type. Note that this datasource type is incompatible with any other datasource and all the properties on the
+ object type are backed by it.
+ """
+
+ type: typing.Literal["editsOnly"] = "editsOnly"
+
+
+class ObjectTypeFullMetadata(core.ModelBase):
+ """ObjectTypeFullMetadata"""
+
+ object_type: ObjectTypeV2 = pydantic.Field(alias=str("objectType")) # type: ignore[literal-required]
+ link_types: typing.List[LinkTypeSideV2] = pydantic.Field(alias=str("linkTypes")) # type: ignore[literal-required]
+ implements_interfaces: typing.List[InterfaceTypeApiName] = pydantic.Field(alias=str("implementsInterfaces")) # type: ignore[literal-required]
+ """A list of interfaces that this object type implements."""
+
+ implements_interfaces2: typing.Dict[InterfaceTypeApiName, ObjectTypeInterfaceImplementation] = pydantic.Field(alias=str("implementsInterfaces2")) # type: ignore[literal-required]
+ """A list of interfaces that this object type implements and how it implements them."""
+
+ shared_property_type_mapping: typing.Dict[SharedPropertyTypeApiName, PropertyApiName] = pydantic.Field(alias=str("sharedPropertyTypeMapping")) # type: ignore[literal-required]
+ """
+ A map from shared property type API name to backing local property API name for the shared property types
+ present on this object type.
+ """
+
+
+class ObjectTypeGeotimeSeriesDatasource(core.ModelBase):
+ """
+ An object type datasource backed by a Geotime series integration, providing values for Geotime series reference
+ properties.
+ """
+
+ geotime_series_integration_rid: GeotimeSeriesIntegrationRid = pydantic.Field(alias=str("geotimeSeriesIntegrationRid")) # type: ignore[literal-required]
+ properties: typing.List[PropertyApiName]
+ """The set of properties that are bound to the Geotime series."""
+
+ type: typing.Literal["geotimeSeries"] = "geotimeSeries"
+
+
+ObjectTypeId: typing_extensions.TypeAlias = str
+"""The unique identifier (ID) for an object type. This can be viewed in [Ontology Manager](https://palantir.com/docs/foundry/ontology-manager/overview/)."""
+
+
+class ObjectTypeInterfaceImplementation(core.ModelBase):
+ """ObjectTypeInterfaceImplementation"""
+
+ api_name: typing.Optional[InterfaceTypeApiName] = pydantic.Field(alias=str("apiName"), default=None) # type: ignore[literal-required]
+ rid: typing.Optional[InterfaceTypeRid] = None
+ properties: typing.Dict[SharedPropertyTypeApiName, PropertyApiName]
+ properties_v2: typing.Dict[InterfacePropertyApiName, InterfacePropertyTypeImplementation] = pydantic.Field(alias=str("propertiesV2")) # type: ignore[literal-required]
+ links: typing.Dict[InterfaceLinkTypeApiName, typing.List[LinkTypeApiName]]
+ action_types: typing.Dict[InterfaceActionTypeConstraintApiName, ActionTypeApiName] = pydantic.Field(alias=str("actionTypes")) # type: ignore[literal-required]
+ """
+ A map from interface action type constraint API name to the API name of the concrete action type on this
+ object type that implements it. Action types the caller is not authorized to access are omitted, so this
+ map may not cover every action type constraint declared on the interface.
+ """
+
+
+class ObjectTypeLinkTypeApiNameMapping(core.ModelBase):
+ """
+ Groups link type API names by the object type they're scoped to. Link type API names are only unique within
+ an object type, so this pairing is required to identify a link type unambiguously.
+ """
+
+ object_type_api_name: ObjectTypeApiName = pydantic.Field(alias=str("objectTypeApiName")) # type: ignore[literal-required]
+ link_types: typing.List[LinkTypeApiName] = pydantic.Field(alias=str("linkTypes")) # type: ignore[literal-required]
+ """The list of link type API names scoped by the object type."""
+
+
+class ObjectTypeMediaSetViewDatasource(core.ModelBase):
+ """An object type datasource backed by a Foundry media set view, providing media for media reference properties."""
+
+ media_set_rid: core_models.MediaSetRid = pydantic.Field(alias=str("mediaSetRid")) # type: ignore[literal-required]
+ media_set_view_rid: core_models.MediaSetViewRid = pydantic.Field(alias=str("mediaSetViewRid")) # type: ignore[literal-required]
+ properties: typing.List[PropertyApiName]
+ """The set of properties that are bound to the media view."""
+
+ type: typing.Literal["mediaSetView"] = "mediaSetView"
+
+
+class ObjectTypeRestrictedViewDatasource(core.ModelBase):
+ """An object type datasource backed by a Foundry restricted view."""
+
+ restricted_view_rid: RestrictedViewRid = pydantic.Field(alias=str("restrictedViewRid")) # type: ignore[literal-required]
+ property_mapping: typing.Dict[PropertyApiName, PropertyTypeMappingInfo] = pydantic.Field(alias=str("propertyMapping")) # type: ignore[literal-required]
+ """
+ A mapping from property API name to a description of how that property is bound to the restricted view.
+ Properties whose mapping info cannot be modeled are omitted.
+ """
+
+ type: typing.Literal["restrictedView"] = "restrictedView"
+
+
+ObjectTypeRid: typing_extensions.TypeAlias = core.RID
+"""The unique resource identifier of an object type, useful for interacting with other Foundry APIs."""
+
+
+class ObjectTypeStreamDatasource(core.ModelBase):
+ """An object type datasource backed by a Foundry stream."""
+
+ stream_rid: StreamRid = pydantic.Field(alias=str("streamRid")) # type: ignore[literal-required]
+ branch: typing.Optional[DatasourceBranchId] = None
+ property_mapping: typing.Dict[PropertyApiName, PropertyTypeMappingInfo] = pydantic.Field(alias=str("propertyMapping")) # type: ignore[literal-required]
+ """
+ A mapping from property API name to a description of how that property is bound to the stream. Properties
+ whose mapping info cannot be modeled are omitted.
+ """
+
+ type: typing.Literal["stream"] = "stream"
+
+
+class ObjectTypeTableDatasource(core.ModelBase):
+ """An object type datasource backed by a Foundry table."""
+
+ table_rid: TableRid = pydantic.Field(alias=str("tableRid")) # type: ignore[literal-required]
+ branch: typing.Optional[DatasourceBranchId] = None
+ property_mapping: typing.Dict[PropertyApiName, PropertyTypeMappingInfo] = pydantic.Field(alias=str("propertyMapping")) # type: ignore[literal-required]
+ """
+ A mapping from property API name to a description of how that property is bound to the table. Properties
+ whose mapping info cannot be modeled are omitted.
+ """
+
+ type: typing.Literal["table"] = "table"
+
+
+class ObjectTypeTimeSeriesDatasource(core.ModelBase):
+ """An object type datasource backed by a time series sync, providing values for time-dependent properties."""
+
+ time_series_sync_rid: TimeseriesSyncRid = pydantic.Field(alias=str("timeSeriesSyncRid")) # type: ignore[literal-required]
+ properties: typing.List[PropertyApiName]
+ """The set of properties that are bound to the time series."""
+
+ type: typing.Literal["timeSeries"] = "timeSeries"
+
+
+class ObjectTypeUnsupportedDatasource(core.ModelBase):
+ """
+ A datasource of a kind not yet exposed in the public API. The `unsupportedType` discriminator supplies the
+ underlying OMS variant so callers can recognize known but unmodelled cases (e.g., derived properties). Variants
+ the adapter does not recognise at all are returned with an `"unknown"` discriminator. The `properties` list
+ enumerates the property API names this datasource backs. The `properties` will be empty for `"unknown"`
+ datasources.
+ """
+
+ unsupported_type: str = pydantic.Field(alias=str("unsupportedType")) # type: ignore[literal-required]
+ """
+ A short, stable discriminator naming the underlying OMS variant. E.g., `"derivedProperties"` for
+ derived-properties datasources or `"unknown"` for variants the adapter does not recognize.
+ """
+
+ properties: typing.List[PropertyApiName]
+ """The property API names that this datasource backs."""
+
+ type: typing.Literal["unsupported"] = "unsupported"
+
+
+class ObjectTypeV2(core.ModelBase):
+ """Represents an object type in the Ontology."""
+
+ api_name: ObjectTypeApiName = pydantic.Field(alias=str("apiName")) # type: ignore[literal-required]
+ display_name: core_models.DisplayName = pydantic.Field(alias=str("displayName")) # type: ignore[literal-required]
+ status: core_models.ReleaseStatus
+ description: typing.Optional[str] = None
+ """The description of the object type."""
+
+ plural_display_name: str = pydantic.Field(alias=str("pluralDisplayName")) # type: ignore[literal-required]
+ """The plural display name of the object type."""
+
+ icon: Icon
+ primary_key: PropertyApiName = pydantic.Field(alias=str("primaryKey")) # type: ignore[literal-required]
+ properties: typing.Dict[PropertyApiName, PropertyV2]
+ """A map of the properties of the object type."""
+
+ rid: ObjectTypeRid
+ title_property: PropertyApiName = pydantic.Field(alias=str("titleProperty")) # type: ignore[literal-required]
+ visibility: typing.Optional[ObjectTypeVisibility] = None
+ aliases: typing.Optional[typing.List[str]] = None
+ """
+ Alternative names (synonyms) for the object type, usable as search terms. This field is only populated on
+ the get-by-RID read paths (e.g. `getObjectTypeV2`); it is always empty on the `listObjectTypesV2` endpoint.
+ """
+
+ datasources: typing.Optional[typing.List[ObjectTypeDatasource]] = None
+ """
+ The datasources backing this object type which the user has access to see. Only populated when the request
+ specifies `includeDatasources=true`. This list may be empty if the user doesn't have access to any
+ datasources.
+ """
+
+
+ObjectTypeVisibility: typing_extensions.TypeAlias = typing.Literal["NORMAL", "PROMINENT", "HIDDEN"]
+"""The suggested visibility of the object type."""
+
+
+class ObjectUpdate(core.ModelBase):
+ """ObjectUpdate"""
+
+ object: OntologyObjectV2
+ state: ObjectState
+ type: typing.Literal["object"] = "object"
+
+
+class OneOfAllowedValues(core.ModelBase):
+ """The parameter value must be one of a fixed set of labelled options."""
+
+ options: typing.List[ParameterAllowedValueOption]
+ """The predefined set of options."""
+
+ other_values_allowed: bool = pydantic.Field(alias=str("otherValuesAllowed")) # type: ignore[literal-required]
+ """Whether values outside `options` are allowed."""
+
+ type: typing.Literal["oneOf"] = "oneOf"
+
+
+class OneOfConstraint(core.ModelBase):
+ """The parameter has a manually predefined set of options."""
+
+ options: typing.List[ParameterOption]
+ other_values_allowed: bool = pydantic.Field(alias=str("otherValuesAllowed")) # type: ignore[literal-required]
+ """A flag denoting whether custom, user provided values will be considered valid. This is configured via the **Allowed "Other" value** toggle in the **Ontology Manager**."""
+
+ type: typing.Literal["oneOf"] = "oneOf"
+
+
+OntologyApiName: typing_extensions.TypeAlias = str
+"""OntologyApiName"""
+
+
+class OntologyArrayType(core.ModelBase):
+ """OntologyArrayType"""
+
+ item_type: OntologyDataType = pydantic.Field(alias=str("itemType")) # type: ignore[literal-required]
+ type: typing.Literal["array"] = "array"
+
+
+class OntologyBaseBranch(core.ModelBase):
+ """A branch reference used to initialize a scenario."""
+
+ branch: core_models.FoundryBranch
+ type: typing.Literal["branch"] = "branch"
+
+
+OntologyDataType: typing_extensions.TypeAlias = typing_extensions.Annotated[
+ typing.Union[
+ core_models.DateType,
+ "OntologyStructType",
+ "OntologySetType",
+ core_models.StringType,
+ core_models.ByteType,
+ core_models.DoubleType,
+ core_models.IntegerType,
+ core_models.FloatType,
+ core_models.AnyType,
+ core_models.LongType,
+ core_models.BooleanType,
+ core_models.CipherTextType,
+ core_models.MarkingType,
+ core_models.UnsupportedType,
+ core_models.MediaReferenceType,
+ "OntologyArrayType",
+ "OntologyObjectSetType",
+ core_models.BinaryType,
+ core_models.ShortType,
+ core_models.DecimalType,
+ "OntologyMapType",
+ core_models.TimestampType,
+ "OntologyObjectType",
+ ],
+ pydantic.Field(discriminator="type"),
+]
+"""A union of all the primitive types used by Palantir's Ontology-based products."""
+
+
+class OntologyFullMetadata(core.ModelBase):
+ """OntologyFullMetadata"""
+
+ ontology: OntologyV2
+ object_types: typing.Dict[ObjectTypeApiName, ObjectTypeFullMetadata] = pydantic.Field(alias=str("objectTypes")) # type: ignore[literal-required]
+ action_types: typing.Dict[ActionTypeApiName, ActionTypeV2] = pydantic.Field(alias=str("actionTypes")) # type: ignore[literal-required]
+ action_types_full_metadata: typing.Dict[ActionTypeApiName, ActionTypeFullMetadata] = pydantic.Field(alias=str("actionTypesFullMetadata")) # type: ignore[literal-required]
+ """
+ The full metadata for the loaded action types. This is only populated if the request opted in to it by
+ setting `includeActionTypeFullMetadata` to `true`. The `actionTypes` field is always populated,
+ regardless of this flag.
+ """
+
+ query_types: typing.Dict[VersionedQueryTypeApiName, QueryTypeV2] = pydantic.Field(alias=str("queryTypes")) # type: ignore[literal-required]
+ interface_types: typing.Dict[InterfaceTypeApiName, InterfaceType] = pydantic.Field(alias=str("interfaceTypes")) # type: ignore[literal-required]
+ shared_property_types: typing.Dict[SharedPropertyTypeApiName, SharedPropertyType] = pydantic.Field(alias=str("sharedPropertyTypes")) # type: ignore[literal-required]
+ branch: typing.Optional[core_models.BranchMetadata] = None
+ value_types: typing.Dict[ValueTypeApiName, OntologyValueType] = pydantic.Field(alias=str("valueTypes")) # type: ignore[literal-required]
+
+
+OntologyIdentifier: typing_extensions.TypeAlias = str
+"""
+The API name or RID of the Ontology. To find the API name or RID, use the **List Ontologies** endpoint or
+check the **Ontology Manager**.
+"""
+
+
+class OntologyInterfaceObjectSetType(core.ModelBase):
+ """OntologyInterfaceObjectSetType"""
+
+ interface_type_api_name: InterfaceTypeApiName = pydantic.Field(alias=str("interfaceTypeApiName")) # type: ignore[literal-required]
+ type: typing.Literal["interfaceObjectSet"] = "interfaceObjectSet"
+
+
+class OntologyInterfaceObjectType(core.ModelBase):
+ """OntologyInterfaceObjectType"""
+
+ interface_type_api_name: typing.Optional[InterfaceTypeApiName] = pydantic.Field(alias=str("interfaceTypeApiName"), default=None) # type: ignore[literal-required]
+ type: typing.Literal["interfaceObject"] = "interfaceObject"
+
+
+class OntologyMapType(core.ModelBase):
+ """OntologyMapType"""
+
+ key_type: OntologyDataType = pydantic.Field(alias=str("keyType")) # type: ignore[literal-required]
+ value_type: OntologyDataType = pydantic.Field(alias=str("valueType")) # type: ignore[literal-required]
+ type: typing.Literal["map"] = "map"
+
+
+class OntologyObjectArrayType(core.ModelBase):
+ """OntologyObjectArrayType"""
+
+ sub_type: ObjectPropertyType = pydantic.Field(alias=str("subType")) # type: ignore[literal-required]
+ reducers: typing.List[OntologyObjectArrayTypeReducer]
+ """
+ If non-empty, this property can be reduced to a single value of the subtype. The reducers are applied in
+ order to determine a winning value. The array can be loaded as a reduced value or as the full array in an
+ object set.
+ """
+
+ type: typing.Literal["array"] = "array"
+
+
+class OntologyObjectArrayTypeReducer(core.ModelBase):
+ """OntologyObjectArrayTypeReducer"""
+
+ direction: OntologyObjectArrayTypeReducerSortDirection
+ field: typing.Optional[StructFieldApiName] = None
+
+
+OntologyObjectArrayTypeReducerSortDirection: typing_extensions.TypeAlias = typing.Literal[
+ "ASCENDING_NULLS_LAST", "DESCENDING_NULLS_LAST"
+]
+"""OntologyObjectArrayTypeReducerSortDirection"""
+
+
+class OntologyObjectSetType(core.ModelBase):
+ """OntologyObjectSetType"""
+
+ object_api_name: typing.Optional[ObjectTypeApiName] = pydantic.Field(alias=str("objectApiName"), default=None) # type: ignore[literal-required]
+ object_type_api_name: typing.Optional[ObjectTypeApiName] = pydantic.Field(alias=str("objectTypeApiName"), default=None) # type: ignore[literal-required]
+ type: typing.Literal["objectSet"] = "objectSet"
+
+
+class OntologyObjectType(core.ModelBase):
+ """OntologyObjectType"""
+
+ object_api_name: ObjectTypeApiName = pydantic.Field(alias=str("objectApiName")) # type: ignore[literal-required]
+ object_type_api_name: ObjectTypeApiName = pydantic.Field(alias=str("objectTypeApiName")) # type: ignore[literal-required]
+ type: typing.Literal["object"] = "object"
+
+
+class OntologyObjectTypeReferenceType(core.ModelBase):
+ """OntologyObjectTypeReferenceType"""
+
+ type: typing.Literal["objectType"] = "objectType"
+
+
+OntologyObjectV2: typing_extensions.TypeAlias = typing.Dict["PropertyApiName", "PropertyValue"]
+"""Represents an object in the Ontology."""
+
+
+OntologyRid: typing_extensions.TypeAlias = core.RID
+"""
+The unique Resource Identifier (RID) of the Ontology. To look up your Ontology RID, please use the
+`List ontologies` endpoint or check the **Ontology Manager**.
+"""
+
+
+OntologyScenarioRid: typing_extensions.TypeAlias = core.RID
+"""The unique resource identifier of an ontology scenario."""
+
+
+class OntologySetType(core.ModelBase):
+ """OntologySetType"""
+
+ item_type: OntologyDataType = pydantic.Field(alias=str("itemType")) # type: ignore[literal-required]
+ type: typing.Literal["set"] = "set"
+
+
+class OntologyStructField(core.ModelBase):
+ """OntologyStructField"""
+
+ name: core_models.StructFieldName
+ field_type: OntologyDataType = pydantic.Field(alias=str("fieldType")) # type: ignore[literal-required]
+ required: bool
+
+
+class OntologyStructType(core.ModelBase):
+ """OntologyStructType"""
+
+ fields: typing.List[OntologyStructField]
+ type: typing.Literal["struct"] = "struct"
+
+
+OntologyTransactionId: typing_extensions.TypeAlias = str
+"""The ID identifying a transaction."""
+
+
+class OntologyV2(core.ModelBase):
+ """Metadata about an Ontology."""
+
+ api_name: OntologyApiName = pydantic.Field(alias=str("apiName")) # type: ignore[literal-required]
+ display_name: core_models.DisplayName = pydantic.Field(alias=str("displayName")) # type: ignore[literal-required]
+ description: str
+ rid: OntologyRid
+
+
+class OntologyValueType(core.ModelBase):
+ """OntologyValueType"""
+
+ api_name: ValueTypeApiName = pydantic.Field(alias=str("apiName")) # type: ignore[literal-required]
+ display_name: core_models.DisplayName = pydantic.Field(alias=str("displayName")) # type: ignore[literal-required]
+ description: typing.Optional[str] = None
+ rid: ValueTypeRid
+ status: typing.Optional[ValueTypeStatus] = None
+ field_type: ValueTypeFieldType = pydantic.Field(alias=str("fieldType")) # type: ignore[literal-required]
+ version: str
+ constraints: typing.List[ValueTypeConstraint]
+
+
+class OrActionTypesQueryV2(core.ModelBase):
+ """Returns action types where at least one query is satisfied. An empty list matches no action types."""
+
+ value: typing.List[ActionTypeSearchJsonQueryV2]
+ type: typing.Literal["or"] = "or"
+
+
+class OrQueryV2(core.ModelBase):
+ """Returns objects where at least 1 query is satisfied."""
+
+ value: typing.List[SearchJsonQueryV2]
+ type: typing.Literal["or"] = "or"
+
+
+OrderBy: typing_extensions.TypeAlias = str
+"""
+A command representing the list of properties to order by. Properties should be delimited by commas and
+prefixed by `p` or `properties`. The format expected format is
+`orderBy=properties.{property}:{sortDirection},properties.{property}:{sortDirection}...`
+
+By default, the ordering for a property is ascending, and this can be explicitly specified by appending
+`:asc` (for ascending) or `:desc` (for descending).
+
+Example: use `orderBy=properties.lastName:asc` to order by a single property,
+`orderBy=properties.lastName,properties.firstName,properties.age:desc` to order by multiple properties.
+You may also use the shorthand `p` instead of `properties` such as `orderBy=p.lastName:asc`.
+"""
+
+
+OrderByDirection: typing_extensions.TypeAlias = typing.Literal["ASC", "DESC"]
+"""OrderByDirection"""
+
+
+class ParameterAllowedValueOption(core.ModelBase):
+ """A possible value for the parameter."""
+
+ display_name: core_models.DisplayName = pydantic.Field(alias=str("displayName")) # type: ignore[literal-required]
+ value: DataValue
+
+
+ParameterAllowedValues: typing_extensions.TypeAlias = typing_extensions.Annotated[
+ typing.Union[
+ "OneOfAllowedValues",
+ "DatetimeAllowedValues",
+ "AttachmentAllowedValues",
+ "ValueTypeAllowedValues",
+ "MarkdownAllowedValues",
+ "RangeAllowedValues",
+ "MustBeEmptyAllowedValues",
+ "TextAllowedValues",
+ ],
+ pydantic.Field(discriminator="type"),
+]
+"""The allowed-values constraint configured on an action parameter."""
+
+
+class ParameterArraySize(core.ModelBase):
+ """Bounds on the size of an array-typed parameter."""
+
+ gte: typing.Optional[int] = None
+ """Greater than or equal."""
+
+ lte: typing.Optional[int] = None
+ """Less than or equal."""
+
+
+ParameterConstraintValue: typing_extensions.TypeAlias = typing_extensions.Annotated[
+ typing.Union[
+ "StaticConstraintValue", "ParameterLengthConstraintValue", "ParameterValueConstraintValue"
+ ],
+ pydantic.Field(discriminator="type"),
+]
+"""
+The source of a constraint bound value: either a literal or a reference to another parameter that is
+resolved when the action is validated or applied.
+"""
+
+
+ParameterDatetimeValue: typing_extensions.TypeAlias = typing_extensions.Annotated[
+ typing.Union["NowDatetimeValue", "FixedDatetimeValue", "RelativeDatetimeValue"],
+ pydantic.Field(discriminator="type"),
+]
+"""A datetime bound value."""
+
+
+ParameterEvaluatedConstraint: typing_extensions.TypeAlias = typing_extensions.Annotated[
+ typing.Union[
+ "StructEvaluatedConstraint",
+ "OneOfConstraint",
+ "ArrayEvaluatedConstraint",
+ "GroupMemberConstraint",
+ "ObjectPropertyValueConstraint",
+ "RangeConstraint",
+ "ArraySizeConstraint",
+ "ObjectQueryResultConstraint",
+ "StringLengthConstraint",
+ "StringRegexMatchConstraint",
+ "UnevaluableConstraint",
+ ],
+ pydantic.Field(discriminator="type"),
+]
+"""
+A constraint that an action parameter value must satisfy in order to be considered valid.
+Constraints can be configured on action parameters in the **Ontology Manager**.
+Applicable constraints are determined dynamically based on parameter inputs.
+Parameter values are evaluated against the final set of constraints.
+
+The type of the constraint.
+| Type | Description |
+|-----------------------|---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|
+| `arraySize` | The parameter expects an array of values and the size of the array must fall within the defined range. |
+| `groupMember` | The parameter value must be the user id of a member belonging to at least one of the groups defined by the constraint. |
+| `objectPropertyValue` | The parameter value must be a property value of an object found within an object set. |
+| `objectQueryResult` | The parameter value must be the primary key of an object found within an object set. |
+| `oneOf` | The parameter has a manually predefined set of options. |
+| `range` | The parameter value must be within the defined range. |
+| `stringLength` | The parameter value must have a length within the defined range. |
+| `stringRegexMatch` | The parameter value must match a predefined regular expression. |
+| `unevaluable` | The parameter cannot be evaluated because it depends on another parameter or object set that can't be evaluated. This can happen when a parameter's allowed values are defined by another parameter that is missing or invalid. |
+"""
+
+
+class ParameterEvaluationResult(core.ModelBase):
+ """Represents the validity of a parameter against the configured constraints."""
+
+ result: ValidationResult
+ evaluated_constraints: typing.List[ParameterEvaluatedConstraint] = pydantic.Field(alias=str("evaluatedConstraints")) # type: ignore[literal-required]
+ required: bool
+ """Represents whether the parameter is a required input to the action."""
+
+ default_value: typing.Optional[DataValue] = pydantic.Field(alias=str("defaultValue"), default=None) # type: ignore[literal-required]
+
+
+ParameterId: typing_extensions.TypeAlias = str
+"""
+The unique identifier of the parameter. Parameters are used as inputs when an action or query is applied.
+Parameters can be viewed and managed in the **Ontology Manager**.
+"""
+
+
+class ParameterIdArgument(core.ModelBase):
+ """Represents a parameter ID argument in a logic rule."""
+
+ parameter_id: ParameterId = pydantic.Field(alias=str("parameterId")) # type: ignore[literal-required]
+ type: typing.Literal["parameterId"] = "parameterId"
+
+
+class ParameterLengthConstraintValue(core.ModelBase):
+ """
+ The bound is the number of elements in another list parameter's value on the same action type. Clients
+ should tolerate a reference that cannot be resolved, as the referenced parameter is not itself guaranteed
+ to be surfaced.
+ """
+
+ parameter_id: ParameterId = pydantic.Field(alias=str("parameterId")) # type: ignore[literal-required]
+ type: typing.Literal["parameterLength"] = "parameterLength"
+
+
+class ParameterNameActionTypesQueryV2(core.ModelBase):
+ """Returns action types with a parameter whose name matches the given string predicate."""
+
+ value: FullTextStringPredicateV2
+ type: typing.Literal["parameterName"] = "parameterName"
+
+
+class ParameterOption(core.ModelBase):
+ """A possible value for the parameter. This is defined in the **Ontology Manager** by Actions admins."""
+
+ display_name: typing.Optional[core_models.DisplayName] = pydantic.Field(alias=str("displayName"), default=None) # type: ignore[literal-required]
+ value: typing.Optional[typing.Any] = None
+ """An allowed configured value for a parameter within an action."""
+
+
+class ParameterRidActionTypesQueryV2(core.ModelBase):
+ """Returns action types with a parameter matching the given parameter rid."""
+
+ value: ActionParameterRid
+ type: typing.Literal["parameterRid"] = "parameterRid"
+
+
+class ParameterValueConstraintValue(core.ModelBase):
+ """
+ The bound is the value of another parameter on the same action type. Clients should tolerate a reference
+ that cannot be resolved, as the referenced parameter is not itself guaranteed to be surfaced.
+ """
+
+ parameter_id: ParameterId = pydantic.Field(alias=str("parameterId")) # type: ignore[literal-required]
+ type: typing.Literal["parameterValue"] = "parameterValue"
+
+
+class PermissionModelActionTypesQueryV2(core.ModelBase):
+ """Returns action types with the given permission model."""
+
+ value: ActionTypePermissionModelFilter
+ type: typing.Literal["permissionModel"] = "permissionModel"
+
+
+Plaintext: typing_extensions.TypeAlias = str
+"""Plaintext"""
+
+
+class PostTransactionEditsRequest(core.ModelBase):
+ """The request payload for staging edits to a transaction."""
+
+ edits: typing.List[TransactionEdit]
+
+
+class PostTransactionEditsResponse(core.ModelBase):
+ """PostTransactionEditsResponse"""
+
+
+class PreciseDuration(core.ModelBase):
+ """A measurement of duration."""
+
+ value: int
+ """The duration value."""
+
+ unit: PreciseTimeUnit
+ type: typing.Literal["duration"] = "duration"
+
+
+PreciseTimeUnit: typing_extensions.TypeAlias = typing.Literal[
+ "NANOSECONDS", "SECONDS", "MINUTES", "HOURS", "DAYS", "WEEKS"
+]
+"""The unit of a fixed-width duration. Each day is 24 hours and each week is 7 days."""
+
+
+class PrefixOnLastTokenRule(core.ModelBase):
+ """
+ Matches intervals containing all the terms, using exact match for all but the last term, and prefix match for
+ the last term. Ordering of the terms in the query is preserved.
+ """
+
+ query: str
+ type: typing.Literal["prefixOnLastToken"] = "prefixOnLastToken"
+
+
+class PrimaryKeyPropertySelector(core.ModelBase):
+ """Specifies the primary key property of an object type which is present on all object types."""
+
+ type: typing.Literal["primaryKeyProperty"] = "primaryKeyProperty"
+
+
+PrimaryKeyValue: typing_extensions.TypeAlias = typing.Any
+"""Represents the primary key value that is used as a unique identifier for an object."""
+
+
+PrimaryKeyValueV2: typing_extensions.TypeAlias = typing_extensions.Annotated[
+ typing.Union[
+ "DateValue",
+ "StringValue",
+ "TimestampValue",
+ "BooleanValue",
+ "IntegerValue",
+ "DoubleValue",
+ "LongValue",
+ ],
+ pydantic.Field(discriminator="type"),
+]
+"""PrimaryKeyValueV2"""
+
+
+PropertyApiName: typing_extensions.TypeAlias = str
+"""
+The name of the property in the API. To find the API name for your property, use the `Get object type`
+endpoint or check the **Ontology Manager**.
+"""
+
+
+class PropertyApiNameSelector(core.ModelBase):
+ """A property api name that references properties to query on."""
+
+ api_name: PropertyApiName = pydantic.Field(alias=str("apiName")) # type: ignore[literal-required]
+ type: typing.Literal["property"] = "property"
+
+
+class PropertyBooleanFormattingRule(core.ModelBase):
+ """Formatting configuration for boolean property values."""
+
+ value_if_true: str = pydantic.Field(alias=str("valueIfTrue")) # type: ignore[literal-required]
+ """Value to display if this boolean is true"""
+
+ value_if_false: str = pydantic.Field(alias=str("valueIfFalse")) # type: ignore[literal-required]
+ """Value to display if this boolean is false"""
+
+ type: typing.Literal["boolean"] = "boolean"
+
+
+class PropertyDateFormattingRule(core.ModelBase):
+ """Formatting configuration for date property values."""
+
+ format: DatetimeFormat
+ type: typing.Literal["date"] = "date"
+
+
+PropertyFilter: typing_extensions.TypeAlias = str
+"""
+Represents a filter used on properties.
+
+Endpoints that accept this supports optional parameters that have the form:
+`properties.{propertyApiName}.{propertyFilter}={propertyValueEscapedString}` to filter the returned objects.
+For instance, you may use `properties.firstName.eq=John` to find objects that contain a property called
+"firstName" that has the exact value of "John".
+
+The following are a list of supported property filters:
+
+- `properties.{propertyApiName}.contains` - supported on arrays and can be used to filter array properties
+ that have at least one of the provided values. If multiple query parameters are provided, then objects
+ that have any of the given values for the specified property will be matched.
+- `properties.{propertyApiName}.eq` - used to filter objects that have the exact value for the provided
+ property. If multiple query parameters are provided, then objects that have any of the given values
+ will be matched. For instance, if the user provides a request by doing
+ `?properties.firstName.eq=John&properties.firstName.eq=Anna`, then objects that have a firstName property
+ of either John or Anna will be matched. This filter is supported on all property types except Arrays.
+- `properties.{propertyApiName}.neq` - used to filter objects that do not have the provided property values.
+ Similar to the `eq` filter, if multiple values are provided, then objects that have any of the given values
+ will be excluded from the result.
+- `properties.{propertyApiName}.lt`, `properties.{propertyApiName}.lte`, `properties.{propertyApiName}.gt`
+ `properties.{propertyApiName}.gte` - represent less than, less than or equal to, greater than, and greater
+ than or equal to respectively. These are supported on date, timestamp, byte, integer, long, double, decimal.
+- `properties.{propertyApiName}.isNull` - used to filter objects where the provided property is (or is not) null.
+ This filter is supported on all property types.
+"""
+
+
+PropertyId: typing_extensions.TypeAlias = str
+"""
+The immutable ID of a property. Property IDs are only used to identify properties in the **Ontology Manager**
+application and assign them API names. In every other case, API names should be used instead of property IDs.
+"""
+
+
+PropertyIdentifier: typing_extensions.TypeAlias = typing_extensions.Annotated[
+ typing.Union[
+ "PropertyApiNameSelector",
+ "StructFieldSelector",
+ "PropertyWithLoadLevelSelector",
+ "TitlePropertySelector",
+ "PrimaryKeyPropertySelector",
+ ],
+ pydantic.Field(discriminator="type"),
+]
+"""An identifier used to select properties or struct fields."""
+
+
+class PropertyImplementation(core.ModelBase):
+ """PropertyImplementation"""
+
+ property_api_name: PropertyApiName = pydantic.Field(alias=str("propertyApiName")) # type: ignore[literal-required]
+ type: typing.Literal["property"] = "property"
+
+
+class PropertyKnownTypeFormattingRule(core.ModelBase):
+ """Formatting configuration for known Foundry types."""
+
+ known_type: KnownType = pydantic.Field(alias=str("knownType")) # type: ignore[literal-required]
+ type: typing.Literal["knownType"] = "knownType"
+
+
+PropertyLoadLevel: typing_extensions.TypeAlias = typing_extensions.Annotated[
+ typing.Union[
+ "ApplyReducersAndExtractMainValueLoadLevel",
+ "ApplyReducersLoadLevel",
+ "ExtractMainValueLoadLevel",
+ "NoLoadLevel",
+ ],
+ pydantic.Field(discriminator="type"),
+]
+"""
+The load level of the property:
+- APPLY_REDUCERS: Returns a single value of an array as configured in the ontology.
+- EXTRACT_MAIN_VALUE: Returns the main value of a struct as configured in the ontology.
+- APPLY_REDUCERS_AND_EXTRACT_MAIN_VALUE: Performs both to return the reduced main value.
+- NO_LOAD_LEVEL: Returns the property as-is, without applying reducers or extracting a struct main value.
+"""
+
+
+class PropertyMarkingSummary(core.ModelBase):
+ """All marking requirements applicable to a property value."""
+
+ conjunctive: typing.Optional[ConjunctiveMarkingSummary] = None
+ disjunctive: typing.Optional[DisjunctiveMarkingSummary] = None
+ container_conjunctive: typing.Optional[ContainerConjunctiveMarkingSummary] = pydantic.Field(alias=str("containerConjunctive"), default=None) # type: ignore[literal-required]
+ container_disjunctive: typing.Optional[ContainerDisjunctiveMarkingSummary] = pydantic.Field(alias=str("containerDisjunctive"), default=None) # type: ignore[literal-required]
+ type: typing.Literal["propertyMarkingSummary"] = "propertyMarkingSummary"
+
+
+class PropertyNumberFormattingRule(core.ModelBase):
+ """Wrapper for numeric formatting options."""
+
+ number_type: PropertyNumberFormattingRuleType = pydantic.Field(alias=str("numberType")) # type: ignore[literal-required]
+ type: typing.Literal["number"] = "number"
+
+
+PropertyNumberFormattingRuleType: typing_extensions.TypeAlias = typing_extensions.Annotated[
+ typing.Union[
+ "NumberFormatStandard",
+ "NumberFormatDuration",
+ "NumberFormatFixedValues",
+ "NumberFormatAffix",
+ "NumberFormatScale",
+ "NumberFormatCurrency",
+ "NumberFormatStandardUnit",
+ "NumberFormatCustomUnit",
+ "NumberFormatRatio",
+ ],
+ pydantic.Field(discriminator="type"),
+]
+"""PropertyNumberFormattingRuleType"""
+
+
+PropertyOrStructFieldOfPropertyImplementation: typing_extensions.TypeAlias = (
+ typing_extensions.Annotated[
+ typing.Union["StructFieldOfPropertyImplementation", "PropertyImplementation"],
+ pydantic.Field(discriminator="type"),
+ ]
+)
+"""PropertyOrStructFieldOfPropertyImplementation"""
+
+
+class PropertySecurities(core.ModelBase):
+ """A disjunctive set of security results for a property value."""
+
+ disjunction: typing.List[PropertySecurity]
+
+
+PropertySecurity: typing_extensions.TypeAlias = typing_extensions.Annotated[
+ typing.Union["PropertyMarkingSummary", "UnsupportedPolicy", "ErrorComputingSecurity"],
+ pydantic.Field(discriminator="type"),
+]
+"""PropertySecurity"""
+
+
+class PropertyTimestampFormattingRule(core.ModelBase):
+ """Formatting configuration for timestamp property values."""
+
+ format: DatetimeFormat
+ display_timezone: DatetimeTimezone = pydantic.Field(alias=str("displayTimezone")) # type: ignore[literal-required]
+ type: typing.Literal["timestamp"] = "timestamp"
+
+
+PropertyTypeApiName: typing_extensions.TypeAlias = str
+"""PropertyTypeApiName"""
+
+
+PropertyTypeMappingInfo: typing_extensions.TypeAlias = typing_extensions.Annotated[
+ typing.Union["StructPropertyMapping", "ColumnPropertyMapping", "EditOnlyPropertyMapping"],
+ pydantic.Field(discriminator="type"),
+]
+"""
+Describes how a single object type property is bound to its backing tabular datasource. A property may be backed
+by a single column, by a struct (with nested field mappings), or be edit-only (no backing column even though it
+is permissioned to the tabular datasource).
+"""
+
+
+class PropertyTypeReference(core.ModelBase):
+ """PropertyTypeReference"""
+
+ property_api_name: str = pydantic.Field(alias=str("propertyApiName")) # type: ignore[literal-required]
+ """The API name of the PropertyType"""
+
+ type: typing.Literal["propertyType"] = "propertyType"
+
+
+PropertyTypeReferenceOrStringConstant: typing_extensions.TypeAlias = typing_extensions.Annotated[
+ typing.Union["StringConstant", "PropertyTypeReference"], pydantic.Field(discriminator="type")
+]
+"""PropertyTypeReferenceOrStringConstant"""
+
+
+PropertyTypeRid: typing_extensions.TypeAlias = core.RID
+"""The unique resource identifier of a property."""
+
+
+PropertyTypeStatus: typing_extensions.TypeAlias = typing_extensions.Annotated[
+ typing.Union[
+ "DeprecatedPropertyTypeStatus",
+ "ActivePropertyTypeStatus",
+ "ExperimentalPropertyTypeStatus",
+ "ExamplePropertyTypeStatus",
+ ],
+ pydantic.Field(discriminator="type"),
+]
+"""The status to indicate whether the PropertyType is either Experimental, Active, Deprecated, or Example."""
+
+
+PropertyTypeVisibility: typing_extensions.TypeAlias = typing.Literal[
+ "NORMAL", "PROMINENT", "HIDDEN"
+]
+"""PropertyTypeVisibility"""
+
+
+class PropertyV2(core.ModelBase):
+ """Details about some property of an object."""
+
+ description: typing.Optional[str] = None
+ display_name: typing.Optional[core_models.DisplayName] = pydantic.Field(alias=str("displayName"), default=None) # type: ignore[literal-required]
+ data_type: ObjectPropertyType = pydantic.Field(alias=str("dataType")) # type: ignore[literal-required]
+ rid: PropertyTypeRid
+ status: typing.Optional[PropertyTypeStatus] = None
+ visibility: typing.Optional[PropertyTypeVisibility] = None
+ value_type_api_name: typing.Optional[ValueTypeApiName] = pydantic.Field(alias=str("valueTypeApiName"), default=None) # type: ignore[literal-required]
+ value_formatting: typing.Optional[PropertyValueFormattingRule] = pydantic.Field(alias=str("valueFormatting"), default=None) # type: ignore[literal-required]
+ type_classes: typing.Optional[typing.List[TypeClass]] = pydantic.Field(alias=str("typeClasses"), default=None) # type: ignore[literal-required]
+
+
+PropertyValue: typing_extensions.TypeAlias = typing.Any
+"""
+Represents the value of a property in the following format.
+
+| Type | JSON encoding | Example |
+|---------------------------------------------------------------------------------------------------------------------------|-------------------------------------------------------------|----------------------------------------------------------------------------------------------------|
+| Array | array | `["alpha", "bravo", "charlie"]` |
+| [Attachment](https://palantir.com/docs/foundry/api/v2/ontologies-v2-resources/attachment-properties/attachment-property-basics/) | JSON encoded `AttachmentProperty` object | `{"rid":"ri.blobster.main.attachment.2f944bae-5851-4204-8615-920c969a9f2e"}` |
+| Boolean | boolean | `true` |
+| Byte | number | `31` |
+| CipherText | string | `"CIPHER::ri.bellaso.main.cipher-channel.e414ab9e-b606-499a-a0e1-844fa296ba7e::unzjs3VifsTxuIpf1fH1CJ7OaPBr2bzMMdozPaZJtCii8vVG60yXIEmzoOJaEl9mfFFe::CIPHER"` |
+| Date | ISO 8601 extended local date string | `"2021-05-01"` |
+| Decimal | string | `"2.718281828"` |
+| Double | number | `3.14159265` |
+| Float | number | `3.14159265` |
+| GeoPoint | geojson | `{"type":"Point","coordinates":[102.0,0.5]}` |
+| GeoShape | geojson | `{"type":"LineString","coordinates":[[102.0,0.0],[103.0,1.0],[104.0,0.0],[105.0,1.0]]}` |
+| Integer | number | `238940` |
+| Long | string | `"58319870951433"` |
+| [MediaReference](https://palantir.com/docs/foundry/api/v2/ontologies-v2-resources/media-reference-properties/media-reference-property-basics/)| JSON encoded `MediaReference` object | `{"mimeType":"application/pdf","reference":{"type":"mediaSetViewItem","mediaSetViewItem":{"mediaSetRid":"ri.mio.main.media-set.4153d42f-ca4b-4e42-8ca5-8e6aa7edb642","mediaSetViewRid":"ri.mio.main.view.82a798ad-d637-4595-acc6-987bcf16629b","mediaItemRid":"ri.mio.main.media-item.001ec98b-1620-4814-9e17-8e9c4e536225"}}}` |
+| Secured Property Value | JSON encoded `SecuredPropertyValue` object | `{"value": 10, "propertySecurityIndex" : 5}` |
+| Short | number | `8739` |
+| String | string | `"Call me Ishmael"` |
+| Struct | JSON object of struct field API name -> value | {"firstName": "Alex", "lastName": "Karp"} |
+| Timestamp | ISO 8601 extended offset date-time string in UTC zone | `"2021-01-04T05:00:00Z"` |
+| [Timeseries](https://palantir.com/docs/foundry/api/v2/ontologies-v2-resources/time-series-properties/time-series-property-basics/) | JSON encoded `TimeseriesProperty` object or seriesId string | `{"seriesId": "wellPressureSeriesId", "syncRid": ri.time-series-catalog.main.sync.04f5ac1f-91bf-44f9-a51f-4f34e06e42df"}` or `{"templateRid": "ri.codex-emu.main.template.367cac64-e53b-4653-b111-f61856a63df9", "templateVersion": "0.0.0"}` or `"wellPressureSeriesId"`| |
+| Vector | array | `[0.1, 0.3, 0.02, 0.05 , 0.8, 0.4]` |
+
+Note that for backwards compatibility, the Boolean, Byte, Double, Float, Integer, and Short types can also be encoded as JSON strings.
+"""
+
+
+PropertyValueEscapedString: typing_extensions.TypeAlias = str
+"""Represents the value of a property in string format. This is used in URL parameters."""
+
+
+PropertyValueFormattingRule: typing_extensions.TypeAlias = typing_extensions.Annotated[
+ typing.Union[
+ "PropertyDateFormattingRule",
+ "PropertyNumberFormattingRule",
+ "PropertyBooleanFormattingRule",
+ "PropertyKnownTypeFormattingRule",
+ "PropertyTimestampFormattingRule",
+ ],
+ pydantic.Field(discriminator="type"),
+]
+"""
+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
+"""
+
+
+class PropertyWithLoadLevelSelector(core.ModelBase):
+ """
+ A combination of a property identifier and the load level to apply to the property. You can select a reduced
+ value for arrays and the main value for structs. If the provided load level cannot be applied to the property
+ type, then it will be ignored. This selector is experimental and may not work in filters or sorts.
+ """
+
+ property_identifier: PropertyIdentifier = pydantic.Field(alias=str("propertyIdentifier")) # type: ignore[literal-required]
+ load_level: PropertyLoadLevel = pydantic.Field(alias=str("loadLevel")) # type: ignore[literal-required]
+ type: typing.Literal["propertyWithLoadLevel"] = "propertyWithLoadLevel"
+
+
+class QosError(core.ModelBase):
+ """An error indicating that the subscribe request should be attempted on a different node."""
+
+ type: typing.Literal["qos"] = "qos"
+
+
+class QueryAggregation(core.ModelBase):
+ """QueryAggregation"""
+
+ key: typing.Any
+ value: typing.Any
+
+
+QueryAggregationKeyType: typing_extensions.TypeAlias = typing_extensions.Annotated[
+ typing.Union[
+ core_models.DateType,
+ core_models.BooleanType,
+ core_models.StringType,
+ core_models.DoubleType,
+ "QueryAggregationRangeType",
+ core_models.IntegerType,
+ core_models.TimestampType,
+ ],
+ pydantic.Field(discriminator="type"),
+]
+"""A union of all the types supported by query aggregation keys."""
+
+
+QueryAggregationRangeSubType: typing_extensions.TypeAlias = typing_extensions.Annotated[
+ typing.Union[
+ core_models.DateType,
+ core_models.DoubleType,
+ core_models.IntegerType,
+ core_models.TimestampType,
+ ],
+ pydantic.Field(discriminator="type"),
+]
+"""A union of all the types supported by query aggregation ranges."""
+
+
+class QueryAggregationRangeType(core.ModelBase):
+ """QueryAggregationRangeType"""
+
+ sub_type: QueryAggregationRangeSubType = pydantic.Field(alias=str("subType")) # type: ignore[literal-required]
+ type: typing.Literal["range"] = "range"
+
+
+QueryAggregationValueType: typing_extensions.TypeAlias = typing_extensions.Annotated[
+ typing.Union[core_models.DateType, core_models.DoubleType, core_models.TimestampType],
+ pydantic.Field(discriminator="type"),
+]
+"""A union of all the types supported by query aggregation keys."""
+
+
+QueryApiName: typing_extensions.TypeAlias = str
+"""The name of the Query in the API."""
+
+
+class QueryArrayType(core.ModelBase):
+ """QueryArrayType"""
+
+ sub_type: QueryDataType = pydantic.Field(alias=str("subType")) # type: ignore[literal-required]
+ type: typing.Literal["array"] = "array"
+
+
+QueryDataType: typing_extensions.TypeAlias = typing_extensions.Annotated[
+ typing.Union[
+ core_models.DateType,
+ "OntologyInterfaceObjectType",
+ "QueryStructType",
+ core_models.StringType,
+ core_models.IntegerType,
+ "ThreeDimensionalAggregation",
+ core_models.FloatType,
+ core_models.LongType,
+ core_models.UnsupportedType,
+ core_models.AttachmentType,
+ "QueryArrayType",
+ "OntologyObjectSetType",
+ "TwoDimensionalAggregation",
+ "QueryTypeReferenceType",
+ core_models.TimestampType,
+ "QuerySetType",
+ core_models.VoidType,
+ "EntrySetType",
+ core_models.DoubleType,
+ "QueryUnionType",
+ core_models.BooleanType,
+ core_models.MediaReferenceType,
+ core_models.NullType,
+ "OntologyInterfaceObjectSetType",
+ "OntologyObjectType",
+ ],
+ pydantic.Field(discriminator="type"),
+]
+"""A union of all the types supported by Ontology Query parameters or outputs."""
+
+
+class QueryParameterV2(core.ModelBase):
+ """Details about a parameter of a query."""
+
+ description: typing.Optional[str] = None
+ data_type: QueryDataType = pydantic.Field(alias=str("dataType")) # type: ignore[literal-required]
+ required: bool
+
+
+QueryRuntimeErrorParameter: typing_extensions.TypeAlias = str
+"""QueryRuntimeErrorParameter"""
+
+
+class QuerySetType(core.ModelBase):
+ """QuerySetType"""
+
+ sub_type: QueryDataType = pydantic.Field(alias=str("subType")) # type: ignore[literal-required]
+ type: typing.Literal["set"] = "set"
+
+
+class QueryStructField(core.ModelBase):
+ """QueryStructField"""
+
+ name: core_models.StructFieldName
+ field_type: QueryDataType = pydantic.Field(alias=str("fieldType")) # type: ignore[literal-required]
+
+
+class QueryStructType(core.ModelBase):
+ """QueryStructType"""
+
+ fields: typing.List[QueryStructField]
+ type: typing.Literal["struct"] = "struct"
+
+
+class QueryThreeDimensionalAggregation(core.ModelBase):
+ """QueryThreeDimensionalAggregation"""
+
+ groups: typing.List[NestedQueryAggregation]
+
+
+class QueryTwoDimensionalAggregation(core.ModelBase):
+ """QueryTwoDimensionalAggregation"""
+
+ groups: typing.List[QueryAggregation]
+
+
+class QueryTypeReferenceType(core.ModelBase):
+ """
+ A reference to a type that is defined in the `typeReferences` map of the enclosing Query.
+ This enables support for recursive type definitions where a type may reference itself.
+ """
+
+ type_id: TypeReferenceIdentifier = pydantic.Field(alias=str("typeId")) # type: ignore[literal-required]
+ type: typing.Literal["typeReference"] = "typeReference"
+
+
+class QueryTypeV2(core.ModelBase):
+ """Represents a query type in the Ontology."""
+
+ api_name: QueryApiName = pydantic.Field(alias=str("apiName")) # type: ignore[literal-required]
+ description: typing.Optional[str] = None
+ display_name: typing.Optional[core_models.DisplayName] = pydantic.Field(alias=str("displayName"), default=None) # type: ignore[literal-required]
+ parameters: typing.Dict[ParameterId, QueryParameterV2]
+ output: QueryDataType
+ rid: FunctionRid
+ version: FunctionVersion
+ type_references: typing.Dict[TypeReferenceIdentifier, QueryDataType] = pydantic.Field(alias=str("typeReferences")) # type: ignore[literal-required]
+
+
+class QueryUnionType(core.ModelBase):
+ """QueryUnionType"""
+
+ union_types: typing.List[QueryDataType] = pydantic.Field(alias=str("unionTypes")) # type: ignore[literal-required]
+ type: typing.Literal["union"] = "union"
+
+
+class RangeAllowedValues(core.ModelBase):
+ """The parameter value must fall within the specified numeric range."""
+
+ gt: typing.Optional[ParameterConstraintValue] = None
+ gte: typing.Optional[ParameterConstraintValue] = None
+ lt: typing.Optional[ParameterConstraintValue] = None
+ lte: typing.Optional[ParameterConstraintValue] = None
+ type: typing.Literal["range"] = "range"
+
+
+class RangeConstraint(core.ModelBase):
+ """The parameter value must be within the defined range."""
+
+ lt: typing.Optional[typing.Any] = None
+ """Less than"""
+
+ lte: typing.Optional[typing.Any] = None
+ """Less than or equal"""
+
+ gt: typing.Optional[typing.Any] = None
+ """Greater than"""
+
+ gte: typing.Optional[typing.Any] = None
+ """Greater than or equal"""
+
+ type: typing.Literal["range"] = "range"
+
+
+class RangesConstraint(core.ModelBase):
+ """RangesConstraint"""
+
+ minimum_value: typing.Optional[PropertyValue] = pydantic.Field(alias=str("minimumValue"), default=None) # type: ignore[literal-required]
+ maximum_value: typing.Optional[PropertyValue] = pydantic.Field(alias=str("maximumValue"), default=None) # type: ignore[literal-required]
+ type: typing.Literal["range"] = "range"
+
+
+class Reason(core.ModelBase):
+ """Reason"""
+
+ reason: ReasonType
+ type: typing.Literal["reason"] = "reason"
+
+
+ReasonType: typing_extensions.TypeAlias = typing.Literal["USER_CLOSED", "CHANNEL_CLOSED"]
+"""Represents the reason a subscription was closed."""
+
+
+class ReferenceSigningOptions(core.ModelBase):
+ """Options for signing references in the response."""
+
+ sign_media_references: typing.Optional[bool] = pydantic.Field(alias=str("signMediaReferences"), default=None) # type: ignore[literal-required]
+ """
+ Deprecated and ignored. Media references backed by a media set view are signed by default:
+ the response includes a `token` on each `MediaReference` value that can be used to access the
+ referenced media item directly, enabling item-level access control (the caller needs access to
+ the object whose property holds the reference, not view access on the parent media set).
+
+ This field no longer has any effect; setting it to true or false is ignored. Arrays of media
+ references are not signed.
+ """
+
+
+class ReferenceUpdate(core.ModelBase):
+ """
+ The updated data value associated with an object instance's external reference. The object instance
+ is uniquely identified by an object type and a primary key. Note that the value of the property
+ field returns a dereferenced value rather than the reference itself.
+ """
+
+ object_type: ObjectTypeApiName = pydantic.Field(alias=str("objectType")) # type: ignore[literal-required]
+ primary_key: ObjectPrimaryKey = pydantic.Field(alias=str("primaryKey")) # type: ignore[literal-required]
+ property: PropertyApiName
+ value: ReferenceValue
+ type: typing.Literal["reference"] = "reference"
+
+
+class RefreshObjectSet(core.ModelBase):
+ """The list of updated Foundry Objects cannot be provided. The object set must be refreshed using Object Set Service."""
+
+ id: SubscriptionId
+ object_type: ObjectTypeApiName = pydantic.Field(alias=str("objectType")) # type: ignore[literal-required]
+ type: typing.Literal["refreshObjectSet"] = "refreshObjectSet"
+
+
+class RegexConstraint(core.ModelBase):
+ """RegexConstraint"""
+
+ pattern: str
+ partial_match: bool = pydantic.Field(alias=str("partialMatch")) # type: ignore[literal-required]
+ type: typing.Literal["regex"] = "regex"
+
+
+class RegexQuery(core.ModelBase):
+ """
+ Returns objects where the specified field matches the regex pattern provided. This applies to the non-analyzed
+ 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.
+ """
+
+ field: typing.Optional[PropertyApiName] = None
+ property_identifier: typing.Optional[PropertyIdentifier] = pydantic.Field(alias=str("propertyIdentifier"), default=None) # type: ignore[literal-required]
+ value: str
+ type: typing.Literal["regex"] = "regex"
+
+
+class RelativeDateRangeQuery(core.ModelBase):
+ """
+ Returns objects where the specified date or timestamp property falls within a relative date range.
+ The bounds are calculated relative to query execution time and rounded to midnight in the specified timezone.
+ """
+
+ field: typing.Optional[PropertyApiName] = None
+ """The property API name to filter on (either field or propertyIdentifier must be provided)."""
+
+ property_identifier: typing.Optional[PropertyIdentifier] = pydantic.Field(alias=str("propertyIdentifier"), default=None) # type: ignore[literal-required]
+ """The property identifier to filter on (either field or propertyIdentifier must be provided)."""
+
+ relative_start_time: typing.Optional[RelativeDateRangeBound] = pydantic.Field(alias=str("relativeStartTime"), default=None) # type: ignore[literal-required]
+ """
+ The lower bound relative to query time (inclusive). Negative values go into the past.
+ For example, { value: -7, timeUnit: DAY } means 7 days ago.
+ """
+
+ relative_end_time: typing.Optional[RelativeDateRangeBound] = pydantic.Field(alias=str("relativeEndTime"), default=None) # type: ignore[literal-required]
+ """
+ The upper bound relative to query time (exclusive). Negative values go into the past.
+ For example, { value: 1, timeUnit: MONTH } means the start of next month.
+ """
+
+ time_zone_id: str = pydantic.Field(alias=str("timeZoneId")) # type: ignore[literal-required]
+ """
+ Time zone ID for midnight calculation (e.g., "America/New_York", "Europe/London", "Etc/UTC").
+ See https://en.wikipedia.org/wiki/List_of_tz_database_time_zones for valid values.
+ """
+
+ type: typing.Literal["relativeDateRange"] = "relativeDateRange"
+
+
+RelativeDatetimeDuration: typing_extensions.TypeAlias = core.Long
+"""The magnitude of a relative datetime offset."""
+
+
+RelativeDatetimeTense: typing_extensions.TypeAlias = typing.Literal["FUTURE", "PAST"]
+"""Direction of a relative datetime offset."""
+
+
+RelativeDatetimeUnit: typing_extensions.TypeAlias = typing.Literal[
+ "SECOND", "MINUTE", "HOUR", "DAY", "WEEK"
+]
+"""Time unit for relative datetime offsets."""
+
+
+class RelativeDatetimeValue(core.ModelBase):
+ """A datetime expressed as an offset from the current time."""
+
+ duration: RelativeDatetimeDuration
+ unit: RelativeDatetimeUnit
+ tense: RelativeDatetimeTense
+ type: typing.Literal["relative"] = "relative"
+
+
+class RelativePointInTime(core.ModelBase):
+ """A point in time specified relative to query execution time."""
+
+ value: int
+ """The numeric value of the time offset. Negative values indicate the past, positive values the future."""
+
+ time_unit: RelativeTimeUnit = pydantic.Field(alias=str("timeUnit")) # type: ignore[literal-required]
+ """The unit of time for the value."""
+
+ type: typing.Literal["relativePoint"] = "relativePoint"
+
+
+class RelativeTime(core.ModelBase):
+ """A relative time, such as "3 days before" or "2 hours after" the current moment."""
+
+ when: RelativeTimeRelation
+ value: int
+ unit: RelativeTimeSeriesTimeUnit
+
+
+class RelativeTimeRange(core.ModelBase):
+ """A relative time range for a time series query."""
+
+ start_time: typing.Optional[RelativeTime] = pydantic.Field(alias=str("startTime"), default=None) # type: ignore[literal-required]
+ end_time: typing.Optional[RelativeTime] = pydantic.Field(alias=str("endTime"), default=None) # type: ignore[literal-required]
+ type: typing.Literal["relative"] = "relative"
+
+
+RelativeTimeRelation: typing_extensions.TypeAlias = typing.Literal["BEFORE", "AFTER"]
+"""RelativeTimeRelation"""
+
+
+RelativeTimeSeriesTimeUnit: typing_extensions.TypeAlias = typing.Literal[
+ "MILLISECONDS", "SECONDS", "MINUTES", "HOURS", "DAYS", "WEEKS", "MONTHS", "YEARS"
+]
+"""RelativeTimeSeriesTimeUnit"""
+
+
+RelativeTimeUnit: typing_extensions.TypeAlias = typing.Literal["DAY", "WEEK", "MONTH", "YEAR"]
+"""Units for relative time calculations."""
+
+
+RequestId: typing_extensions.TypeAlias = core.UUID
+"""Unique request id"""
+
+
+class ResolvedInterfacePropertyType(core.ModelBase):
+ """
+ An interface property type with additional fields to indicate constraints that need to be satisfied by
+ implementing object property types.
+ """
+
+ rid: InterfacePropertyTypeRid
+ api_name: InterfacePropertyApiName = pydantic.Field(alias=str("apiName")) # type: ignore[literal-required]
+ display_name: core_models.DisplayName = pydantic.Field(alias=str("displayName")) # type: ignore[literal-required]
+ description: typing.Optional[str] = None
+ """A short text that describes the InterfacePropertyType."""
+
+ data_type: ObjectPropertyType = pydantic.Field(alias=str("dataType")) # type: ignore[literal-required]
+ value_type_api_name: typing.Optional[ValueTypeApiName] = pydantic.Field(alias=str("valueTypeApiName"), default=None) # type: ignore[literal-required]
+ value_formatting: typing.Optional[PropertyValueFormattingRule] = pydantic.Field(alias=str("valueFormatting"), default=None) # type: ignore[literal-required]
+ require_implementation: bool = pydantic.Field(alias=str("requireImplementation")) # type: ignore[literal-required]
+ """Whether each implementing object type must declare an implementation for this property."""
+
+
+RestrictedViewRid: typing_extensions.TypeAlias = core.RID
+"""The RID of a Foundry restricted view."""
+
+
+ReturnEditsMode: typing_extensions.TypeAlias = typing.Literal[
+ "ALL", "ALL_V2_WITH_DELETIONS", "NONE"
+]
+"""If not specified, defaults to `NONE`."""
+
+
+class RevertActionEnabledActionTypesQueryV2(core.ModelBase):
+ """Returns action types based on whether they are revertible."""
+
+ value: bool
+ type: typing.Literal["revertActionEnabled"] = "revertActionEnabled"
+
+
+class RidConstraint(core.ModelBase):
+ """The string must be a valid RID (Resource Identifier)."""
+
+ type: typing.Literal["rid"] = "rid"
+
+
+class RollingAggregateWindowPoints(core.ModelBase):
+ """Number of points in each window."""
+
+ count: int
+ type: typing.Literal["pointsCount"] = "pointsCount"
+
+
+SdkPackageName: typing_extensions.TypeAlias = str
+"""SdkPackageName"""
+
+
+SdkPackageRid: typing_extensions.TypeAlias = core.RID
+"""SdkPackageRid"""
+
+
+SdkVersion: typing_extensions.TypeAlias = str
+"""SdkVersion"""
+
+
+class SearchActionTypesFullMetadataRequest(core.ModelBase):
+ """SearchActionTypesFullMetadataRequest"""
+
+ where: typing.Optional[ActionTypeSearchJsonQueryV2] = None
+ order_by: typing.Optional[SearchActionTypesOrderByV2] = pydantic.Field(alias=str("orderBy"), default=None) # type: ignore[literal-required]
+ fuzziness: typing.Optional[ActionTypeFuzziness] = None
+ page_size: typing.Optional[core_models.PageSize] = pydantic.Field(alias=str("pageSize"), default=None) # type: ignore[literal-required]
+ page_token: typing.Optional[core_models.PageToken] = pydantic.Field(alias=str("pageToken"), default=None) # type: ignore[literal-required]
+
+
+class SearchActionTypesFullMetadataResponse(core.ModelBase):
+ """SearchActionTypesFullMetadataResponse"""
+
+ data: typing.List[ActionTypeFullMetadata]
+ next_page_token: typing.Optional[core_models.PageToken] = pydantic.Field(alias=str("nextPageToken"), default=None) # type: ignore[literal-required]
+ total_count: core_models.TotalCount = pydantic.Field(alias=str("totalCount")) # type: ignore[literal-required]
+
+
+class SearchActionTypesOrderByV2(core.ModelBase):
+ """
+ Specifies the ordering of action type search results by a field and an ordering direction. If not provided,
+ results are ordered by relevance of the match.
+ """
+
+ field: ActionTypeSortByV2
+ direction: typing.Optional[str] = None
+ """Specifies the ordering direction (can be either `asc` or `desc`)"""
+
+
+class SearchActionTypesRequestV2(core.ModelBase):
+ """SearchActionTypesRequestV2"""
+
+ where: typing.Optional[ActionTypeSearchJsonQueryV2] = None
+ order_by: typing.Optional[SearchActionTypesOrderByV2] = pydantic.Field(alias=str("orderBy"), default=None) # type: ignore[literal-required]
+ fuzziness: typing.Optional[ActionTypeFuzziness] = None
+ page_size: typing.Optional[core_models.PageSize] = pydantic.Field(alias=str("pageSize"), default=None) # type: ignore[literal-required]
+ page_token: typing.Optional[core_models.PageToken] = pydantic.Field(alias=str("pageToken"), default=None) # type: ignore[literal-required]
+
+
+class SearchActionTypesResponseV2(core.ModelBase):
+ """SearchActionTypesResponseV2"""
+
+ data: typing.List[ActionTypeV2]
+ next_page_token: typing.Optional[core_models.PageToken] = pydantic.Field(alias=str("nextPageToken"), default=None) # type: ignore[literal-required]
+ total_count: core_models.TotalCount = pydantic.Field(alias=str("totalCount")) # type: ignore[literal-required]
+
+
+SearchJsonQueryV2: typing_extensions.TypeAlias = typing_extensions.Annotated[
+ typing.Union[
+ "LtQueryV2",
+ "DoesNotIntersectBoundingBoxQuery",
+ "RelativeDateRangeQuery",
+ "WildcardQuery",
+ "WithinDistanceOfQuery",
+ "WithinBoundingBoxQuery",
+ "NotQueryV2",
+ "IntersectsBoundingBoxQuery",
+ "AndQueryV2",
+ "ContainsAllTermsInOrderPrefixLastTerm",
+ "GteQueryV2",
+ "ContainsAllTermsInOrderQuery",
+ "WithinPolygonQuery",
+ "IntersectsPolygonQuery",
+ "LteQueryV2",
+ "OrQueryV2",
+ "InQuery",
+ "DoesNotIntersectPolygonQuery",
+ "EqualsQueryV2",
+ "ContainsAllTermsQuery",
+ "GtQueryV2",
+ "ContainsQueryV2",
+ "RegexQuery",
+ "IsNullQueryV2",
+ "ContainsAnyTermQuery",
+ "IntervalQuery",
+ "GeoShapeV2Query",
+ "StartsWithQuery",
+ ],
+ pydantic.Field(discriminator="type"),
+]
+"""SearchJsonQueryV2"""
+
+
+class SearchObjectsForInterfaceRequest(core.ModelBase):
+ """SearchObjectsForInterfaceRequest"""
+
+ where: typing.Optional[SearchJsonQueryV2] = None
+ order_by: typing.Optional[SearchOrderByV2] = pydantic.Field(alias=str("orderBy"), default=None) # type: ignore[literal-required]
+ augmented_properties: typing.Dict[ObjectTypeApiName, typing.List[PropertyApiName]] = pydantic.Field(alias=str("augmentedProperties")) # type: ignore[literal-required]
+ """
+ A map from object type API name to a list of property type API names. For each returned object, if the
+ object’s object type is a key in the map, then we augment the response for that object type with the list
+ of properties specified in the value.
+ """
+
+ augmented_shared_property_types: typing.Dict[InterfaceTypeApiName, typing.List[SharedPropertyTypeApiName]] = pydantic.Field(alias=str("augmentedSharedPropertyTypes")) # type: ignore[literal-required]
+ """
+ A map from interface type API name to a list of shared property type API names. For each returned object, if
+ the object implements an interface that is a key in the map, then we augment the response for that object
+ type with the list of properties specified in the value.
+ """
+
+ augmented_interface_property_types: typing.Dict[InterfaceTypeApiName, typing.List[InterfacePropertyApiName]] = pydantic.Field(alias=str("augmentedInterfacePropertyTypes")) # type: ignore[literal-required]
+ """
+ A map from interface type API name to a list of interface property type API names. For each returned object,
+ if the object implements an interface that is a key in the map, then we augment the response for that object
+ type with the list of properties specified in the value.
+ """
+
+ selected_shared_property_types: typing.List[SharedPropertyTypeApiName] = pydantic.Field(alias=str("selectedSharedPropertyTypes")) # type: ignore[literal-required]
+ """
+ A list of shared property type API names of the interface type that should be included in the response.
+ Omit this parameter to include all properties of the interface type in the response.
+ """
+
+ selected_interface_property_types: typing.List[InterfacePropertyApiName] = pydantic.Field(alias=str("selectedInterfacePropertyTypes")) # type: ignore[literal-required]
+ """
+ A list of interface property type API names of the interface type that should be included in the response.
+ Omit this parameter to include all properties of the interface type in the response.
+ """
+
+ selected_object_types: typing.List[ObjectTypeApiName] = pydantic.Field(alias=str("selectedObjectTypes")) # type: ignore[literal-required]
+ """
+ A list of object type API names that should be included in the response. If non-empty, object types that are
+ not mentioned will not be included in the response even if they implement the specified interface. Omit the
+ parameter to include all object types.
+ """
+
+ other_interface_types: typing.List[InterfaceTypeApiName] = pydantic.Field(alias=str("otherInterfaceTypes")) # type: ignore[literal-required]
+ """
+ A list of interface type API names. Object types must implement all the mentioned interfaces in order to be
+ included in the response.
+ """
+
+ page_size: typing.Optional[core_models.PageSize] = pydantic.Field(alias=str("pageSize"), default=None) # type: ignore[literal-required]
+ page_token: typing.Optional[core_models.PageToken] = pydantic.Field(alias=str("pageToken"), default=None) # type: ignore[literal-required]
+
+
+class SearchObjectsRequestV2(core.ModelBase):
+ """SearchObjectsRequestV2"""
+
+ where: typing.Optional[SearchJsonQueryV2] = None
+ order_by: typing.Optional[SearchOrderByV2] = pydantic.Field(alias=str("orderBy"), default=None) # type: ignore[literal-required]
+ page_size: typing.Optional[core_models.PageSize] = pydantic.Field(alias=str("pageSize"), default=None) # type: ignore[literal-required]
+ page_token: typing.Optional[core_models.PageToken] = pydantic.Field(alias=str("pageToken"), default=None) # type: ignore[literal-required]
+ select: typing.List[PropertyApiName]
+ """The API names of the object type properties to include in the response."""
+
+ select_v2: typing.Optional[typing.List[PropertyIdentifier]] = pydantic.Field(alias=str("selectV2"), default=None) # type: ignore[literal-required]
+ """
+ The identifiers of the properties to include in the response. Only selectV2 or select should be populated,
+ but not both.
+ """
+
+ default_load_level: typing.Optional[PropertyLoadLevel] = pydantic.Field(alias=str("defaultLoadLevel"), default=None) # type: ignore[literal-required]
+ exclude_rid: typing.Optional[bool] = pydantic.Field(alias=str("excludeRid"), default=None) # type: ignore[literal-required]
+ """
+ A flag to exclude the retrieval of the `__rid` property.
+ Setting this to true may improve performance of this endpoint for object types in OSV2.
+ """
+
+ snapshot: typing.Optional[bool] = None
+ """
+ A flag to use snapshot consistency when paging.
+ Setting this to true will give you a consistent view from before you start paging through the results, ensuring you do not get duplicate or missing items.
+ Setting this to false will let new results enter as you page, but you may encounter duplicate or missing items.
+ This defaults to false if not specified, which means you will always get the latest results.
+ """
+
+ reference_signing_options: typing.Optional[ReferenceSigningOptions] = pydantic.Field(alias=str("referenceSigningOptions"), default=None) # type: ignore[literal-required]
+
+
+class SearchObjectsResponseV2(core.ModelBase):
+ """SearchObjectsResponseV2"""
+
+ data: typing.List[OntologyObjectV2]
+ next_page_token: typing.Optional[core_models.PageToken] = pydantic.Field(alias=str("nextPageToken"), default=None) # type: ignore[literal-required]
+ total_count: core_models.TotalCount = pydantic.Field(alias=str("totalCount")) # type: ignore[literal-required]
+
+
+SearchOrderByType: typing_extensions.TypeAlias = typing.Literal["fields", "relevance"]
+"""SearchOrderByType"""
+
+
+class SearchOrderByV2(core.ModelBase):
+ """
+ Specifies the ordering of search results by a field and an ordering direction, or by relevance.
+ If the `fields` array is provided, `orderType` is automatically set to `fields`.
+ If this object is omitted entirely, the ordering is unspecified.
+
+ Setting `orderType` to `relevance` requests that results are sorted by decreasing relevance score.
+ For queries that include text search filters (e.g. `containsAllTerms`, `containsAnyTerm`,
+ `containsAllTermsInOrder`, `containsAllTermsInOrderPrefixLastTerm`) or `nearestNeighbors`, the
+ relevance score reflects how well each object matches the query. For other queries, the ordering
+ is unspecified.
+
+ When paging through results ordered by relevance, ordering is not guaranteed to be consistent
+ across pages: an object may appear on multiple pages or be skipped entirely. Use a single page
+ when result completeness is required.
+
+ Relevance ordering can be expensive and should only be used when required.
+ """
+
+ order_type: typing.Optional[SearchOrderByType] = pydantic.Field(alias=str("orderType"), default=None) # type: ignore[literal-required]
+ fields: typing.List[SearchOrderingV2]
+
+
+class SearchOrderingV2(core.ModelBase):
+ """SearchOrderingV2"""
+
+ field: PropertyApiName
+ direction: typing.Optional[str] = None
+ """Specifies the ordering direction (can be either `asc` or `desc`)"""
+
+
+class SectionRidActionTypesQueryV2(core.ModelBase):
+ """Returns action types with a section matching the given section rid."""
+
+ value: ActionSectionRid
+ type: typing.Literal["sectionRid"] = "sectionRid"
+
+
+SelectedPropertyApiName: typing_extensions.TypeAlias = str
+"""
+By default, whenever an object is requested, all of its properties are returned, except for properties of the
+following types:
+- Vector
+
+The response can be filtered to only include certain properties using the `properties` query parameter. Note
+that ontology object set endpoints refer to this parameter as `select`.
+
+Properties to include can be specified in one of two ways.
+
+- A comma delimited list as the value for the `properties` query parameter
+ `properties={property1ApiName},{property2ApiName}`
+- Multiple `properties` query parameters.
+ `properties={property1ApiName}&properties={property2ApiName}`
+
+The primary key of the object will always be returned even if it wasn't specified in the `properties` values.
+
+Unknown properties specified in the `properties` list will result in a `PropertiesNotFound` error.
+
+To find the API name for your property, use the `Get object type` endpoint or check the **Ontology Manager**.
+"""
+
+
+class SelectedPropertyApproximateDistinctAggregation(core.ModelBase):
+ """Computes an approximate number of distinct values for the provided field."""
+
+ selected_property_api_name: PropertyApiName = pydantic.Field(alias=str("selectedPropertyApiName")) # type: ignore[literal-required]
+ type: typing.Literal["approximateDistinct"] = "approximateDistinct"
+
+
+class SelectedPropertyApproximatePercentileAggregation(core.ModelBase):
+ """Computes the approximate percentile value for the provided field."""
+
+ selected_property_api_name: PropertyApiName = pydantic.Field(alias=str("selectedPropertyApiName")) # type: ignore[literal-required]
+ approximate_percentile: float = pydantic.Field(alias=str("approximatePercentile")) # type: ignore[literal-required]
+ type: typing.Literal["approximatePercentile"] = "approximatePercentile"
+
+
+class SelectedPropertyAvgAggregation(core.ModelBase):
+ """Computes the average value for the provided field."""
+
+ selected_property_api_name: PropertyApiName = pydantic.Field(alias=str("selectedPropertyApiName")) # type: ignore[literal-required]
+ type: typing.Literal["avg"] = "avg"
+
+
+class SelectedPropertyCollectListAggregation(core.ModelBase):
+ """
+ Lists all values of a property up to the specified limit. The maximum supported limit is 100, by default.
+
+ NOTE: A separate count aggregation should be used to determine the total count of values, to account for
+ a possible truncation of the returned list.
+
+ Ignores objects for which a property is absent, so the returned list will contain non-null values only.
+ Returns an empty list when none of the objects have values for a provided property.
+ """
+
+ selected_property_api_name: PropertyApiName = pydantic.Field(alias=str("selectedPropertyApiName")) # type: ignore[literal-required]
+ limit: int
+ """Maximum number of values to collect. The maximum supported limit is 100."""
+
+ type: typing.Literal["collectList"] = "collectList"
+
+
+class SelectedPropertyCollectSetAggregation(core.ModelBase):
+ """
+ Lists all distinct values of a property up to the specified limit. The maximum supported limit is 100.
+
+ NOTE: A separate cardinality / exactCardinality aggregation should be used to determine the total count of
+ values, to account for a possible truncation of the returned set.
+
+ Ignores objects for which a property is absent, so the returned list will contain non-null values only.
+ Returns an empty list when none of the objects have values for a provided property.
+ """
+
+ selected_property_api_name: PropertyApiName = pydantic.Field(alias=str("selectedPropertyApiName")) # type: ignore[literal-required]
+ limit: int
+ """Maximum number of values to collect. The maximum supported limit is 100."""
+
+ type: typing.Literal["collectSet"] = "collectSet"
+
+
+class SelectedPropertyCountAggregation(core.ModelBase):
+ """Computes the total count of objects."""
+
+ type: typing.Literal["count"] = "count"
+
+
+class SelectedPropertyExactDistinctAggregation(core.ModelBase):
+ """Computes an exact number of distinct values for the provided field. May be slower than an approximate distinct aggregation."""
+
+ selected_property_api_name: PropertyApiName = pydantic.Field(alias=str("selectedPropertyApiName")) # type: ignore[literal-required]
+ type: typing.Literal["exactDistinct"] = "exactDistinct"
+
+
+class SelectedPropertyExpression(core.ModelBase):
+ """Definition for a selected property over a MethodObjectSet."""
+
+ object_set: MethodObjectSet = pydantic.Field(alias=str("objectSet")) # type: ignore[literal-required]
+ operation: SelectedPropertyOperation
+ type: typing.Literal["selection"] = "selection"
+
+
+class SelectedPropertyMaxAggregation(core.ModelBase):
+ """Computes the maximum value for the provided field."""
+
+ selected_property_api_name: PropertyApiName = pydantic.Field(alias=str("selectedPropertyApiName")) # type: ignore[literal-required]
+ type: typing.Literal["max"] = "max"
+
+
+class SelectedPropertyMinAggregation(core.ModelBase):
+ """Computes the minimum value for the provided field."""
+
+ selected_property_api_name: PropertyApiName = pydantic.Field(alias=str("selectedPropertyApiName")) # type: ignore[literal-required]
+ type: typing.Literal["min"] = "min"
+
+
+SelectedPropertyOperation: typing_extensions.TypeAlias = typing_extensions.Annotated[
+ typing.Union[
+ "SelectedPropertyApproximateDistinctAggregation",
+ "SelectedPropertyMinAggregation",
+ "SelectedPropertyAvgAggregation",
+ "SelectedPropertyMaxAggregation",
+ "SelectedPropertyApproximatePercentileAggregation",
+ "GetSelectedPropertyOperation",
+ "SelectedPropertyCountAggregation",
+ "SelectedPropertySumAggregation",
+ "SelectedPropertyCollectListAggregation",
+ "SelectedPropertyExactDistinctAggregation",
+ "SelectedPropertyCollectSetAggregation",
+ ],
+ pydantic.Field(discriminator="type"),
+]
+"""Operation on a selected property, can be an aggregation function or retrieval of a single selected property"""
+
+
+class SelectedPropertySumAggregation(core.ModelBase):
+ """Computes the sum of values for the provided field."""
+
+ selected_property_api_name: PropertyApiName = pydantic.Field(alias=str("selectedPropertyApiName")) # type: ignore[literal-required]
+ type: typing.Literal["sum"] = "sum"
+
+
+class SharedPropertyType(core.ModelBase):
+ """A property type that can be shared across object types."""
+
+ rid: SharedPropertyTypeRid
+ api_name: SharedPropertyTypeApiName = pydantic.Field(alias=str("apiName")) # type: ignore[literal-required]
+ display_name: core_models.DisplayName = pydantic.Field(alias=str("displayName")) # type: ignore[literal-required]
+ description: typing.Optional[str] = None
+ """A short text that describes the SharedPropertyType."""
+
+ data_type: ObjectPropertyType = pydantic.Field(alias=str("dataType")) # type: ignore[literal-required]
+ value_type_api_name: typing.Optional[ValueTypeApiName] = pydantic.Field(alias=str("valueTypeApiName"), default=None) # type: ignore[literal-required]
+ value_formatting: typing.Optional[PropertyValueFormattingRule] = pydantic.Field(alias=str("valueFormatting"), default=None) # type: ignore[literal-required]
+ type_classes: typing.Optional[typing.List[TypeClass]] = pydantic.Field(alias=str("typeClasses"), default=None) # type: ignore[literal-required]
+
+
+SharedPropertyTypeApiName: typing_extensions.TypeAlias = str
+"""
+The name of the shared property type in the API in lowerCamelCase format. To find the API name for your
+shared property type, use the `List shared property types` endpoint or check the **Ontology Manager**.
+"""
+
+
+SharedPropertyTypeRid: typing_extensions.TypeAlias = core.RID
+"""The unique resource identifier of an shared property type, useful for interacting with other Foundry APIs."""
+
+
+SpatialFilterMode: typing_extensions.TypeAlias = typing.Literal[
+ "INTERSECTS", "DISJOINT", "WITHIN", "CONTAINS"
+]
+"""
+The spatial relation operator for a GeoShapeV2Query. INTERSECTS matches objects that intersect the provided
+geometry, DISJOINT matches objects that do not intersect the provided geometry, WITHIN matches objects that
+lie within the provided geometry, and CONTAINS matches objects that contain the provided geometry.
+"""
+
+
+class StartsWithQuery(core.ModelBase):
+ """
+ Deprecated alias for `containsAllTermsInOrderPrefixLastTerm`, which is preferred because the name `startsWith` is misleading.
+ Returns objects where the specified field starts with the provided value. Allows you to specify a property to
+ query on by a variety of means. Either `field` or `propertyIdentifier` must be supplied, but not both.
+ """
+
+ field: typing.Optional[PropertyApiName] = None
+ property_identifier: typing.Optional[PropertyIdentifier] = pydantic.Field(alias=str("propertyIdentifier"), default=None) # type: ignore[literal-required]
+ value: str
+ type: typing.Literal["startsWith"] = "startsWith"
+
+
+class StaticArgument(core.ModelBase):
+ """Represents a static argument in a logic rule."""
+
+ value: DataValue
+ type: typing.Literal["staticValue"] = "staticValue"
+
+
+class StaticConstraintValue(core.ModelBase):
+ """A literal constraint value."""
+
+ value: DataValue
+ type: typing.Literal["static"] = "static"
+
+
+class StatusActionTypesQueryV2(core.ModelBase):
+ """Returns action types with the given status."""
+
+ value: ActionTypeStatusFilter
+ type: typing.Literal["status"] = "status"
+
+
+StreamMessage: typing_extensions.TypeAlias = typing_extensions.Annotated[
+ typing.Union[
+ "ObjectSetUpdates", "RefreshObjectSet", "SubscriptionClosed", "ObjectSetSubscribeResponses"
+ ],
+ pydantic.Field(discriminator="type"),
+]
+"""StreamMessage"""
+
+
+StreamRid: typing_extensions.TypeAlias = core.RID
+"""The RID of a Foundry stream."""
+
+
+class StreamTimeSeriesPointsRequest(core.ModelBase):
+ """StreamTimeSeriesPointsRequest"""
+
+ range: typing.Optional[TimeRange] = None
+ aggregate: typing.Optional[AggregateTimeSeries] = None
+
+
+class StreamTimeSeriesValuesRequest(core.ModelBase):
+ """StreamTimeSeriesValuesRequest"""
+
+ range: typing.Optional[TimeRange] = None
+
+
+StreamingOutputFormat: typing_extensions.TypeAlias = typing.Literal["JSON", "ARROW"]
+"""
+Which format to serialize the binary stream in.
+ARROW is more efficient for streaming a large sized response.
+"""
+
+
+class StringConstant(core.ModelBase):
+ """StringConstant"""
+
+ value: str
+ type: typing.Literal["constant"] = "constant"
+
+
+class StringLengthConstraint(core.ModelBase):
+ """
+ The parameter value must have a length within the defined range.
+ *This range is always inclusive.*
+ """
+
+ lt: typing.Optional[typing.Any] = None
+ """Less than"""
+
+ lte: typing.Optional[typing.Any] = None
+ """Less than or equal"""
+
+ gt: typing.Optional[typing.Any] = None
+ """Greater than"""
+
+ gte: typing.Optional[typing.Any] = None
+ """Greater than or equal"""
+
+ type: typing.Literal["stringLength"] = "stringLength"
+
+
+class StringRegexMatchConstraint(core.ModelBase):
+ """The parameter value must match a predefined regular expression."""
+
+ regex: str
+ """The regular expression configured in the **Ontology Manager**."""
+
+ configured_failure_message: typing.Optional[str] = pydantic.Field(alias=str("configuredFailureMessage"), default=None) # type: ignore[literal-required]
+ """
+ The message indicating that the regular expression was not matched.
+ This is configured per parameter in the **Ontology Manager**.
+ """
+
+ type: typing.Literal["stringRegexMatch"] = "stringRegexMatch"
+
+
+class StringValue(core.ModelBase):
+ """StringValue"""
+
+ value: str
+ type: typing.Literal["stringValue"] = "stringValue"
+
+
+class StructConstraint(core.ModelBase):
+ """StructConstraint"""
+
+ properties: typing.Dict[PropertyApiName, ValueTypeApiName]
+ """A map of the properties of the struct type to the value type applied to that property."""
+
+ type: typing.Literal["struct"] = "struct"
+
+
+class StructEvaluatedConstraint(core.ModelBase):
+ """Represents the validity of a singleton struct parameter."""
+
+ struct_fields: typing.Dict[StructParameterFieldApiName, StructFieldEvaluationResult] = pydantic.Field(alias=str("structFields")) # type: ignore[literal-required]
+ type: typing.Literal["struct"] = "struct"
+
+
+StructFieldApiName: typing_extensions.TypeAlias = str
+"""The name of a struct field in the Ontology."""
+
+
+StructFieldArgument: typing_extensions.TypeAlias = typing_extensions.Annotated[
+ typing.Union["StructListParameterFieldArgument", "StructParameterFieldArgument"],
+ pydantic.Field(discriminator="type"),
+]
+"""Represents an argument used for an individual struct field."""
+
+
+StructFieldEvaluatedConstraint: typing_extensions.TypeAlias = typing_extensions.Annotated[
+ typing.Union[
+ "OneOfConstraint",
+ "RangeConstraint",
+ "ObjectQueryResultConstraint",
+ "StringLengthConstraint",
+ "StringRegexMatchConstraint",
+ ],
+ pydantic.Field(discriminator="type"),
+]
+"""
+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**.
+Applicable constraints are determined dynamically based on parameter inputs.
+Parameter values are evaluated against the final set of constraints.
+
+The type of the constraint.
+| Type | Description |
+|-----------------------|---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|
+| `oneOf` | The struct parameter field has a manually predefined set of options. |
+| `range` | The struct parameter field value must be within the defined range. |
+| `stringLength` | The struct parameter field value must have a length within the defined range. |
+| `stringRegexMatch` | The struct parameter field value must match a predefined regular expression. |
+| `objectQueryResult` | The struct parameter field value must be the primary key of an object found within an object set. |
+"""
+
+
+class StructFieldEvaluationResult(core.ModelBase):
+ """Represents the validity of a struct parameter's fields against the configured constraints."""
+
+ result: ValidationResult
+ evaluated_constraints: typing.List[StructFieldEvaluatedConstraint] = pydantic.Field(alias=str("evaluatedConstraints")) # type: ignore[literal-required]
+ required: bool
+ """Represents whether the parameter is a required input to the action."""
+
+
+class StructFieldOfPropertyImplementation(core.ModelBase):
+ """StructFieldOfPropertyImplementation"""
+
+ property_api_name: PropertyApiName = pydantic.Field(alias=str("propertyApiName")) # type: ignore[literal-required]
+ struct_field_api_name: StructFieldApiName = pydantic.Field(alias=str("structFieldApiName")) # type: ignore[literal-required]
+ type: typing.Literal["structFieldOfProperty"] = "structFieldOfProperty"
+
+
+class StructFieldPropertyMapping(core.ModelBase):
+ """A single struct field's mapping where `apiName` is the name of a struct field."""
+
+ api_name: StructFieldApiName = pydantic.Field(alias=str("apiName")) # type: ignore[literal-required]
+
+
+class StructFieldSelector(core.ModelBase):
+ """
+ A combination of a property identifier and the load level to apply to the property. You can select a reduced
+ value for arrays and the main value for structs. If the provided load level cannot be applied to the property
+ type, then it will be ignored. This selector is experimental and may not work in filters or sorts.
+ """
+
+ property_api_name: PropertyApiName = pydantic.Field(alias=str("propertyApiName")) # type: ignore[literal-required]
+ struct_field_api_name: StructFieldApiName = pydantic.Field(alias=str("structFieldApiName")) # type: ignore[literal-required]
+ type: typing.Literal["structField"] = "structField"
+
+
+class StructFieldType(core.ModelBase):
+ """StructFieldType"""
+
+ api_name: StructFieldApiName = pydantic.Field(alias=str("apiName")) # type: ignore[literal-required]
+ rid: StructFieldTypeRid
+ data_type: ObjectPropertyType = pydantic.Field(alias=str("dataType")) # type: ignore[literal-required]
+ type_classes: typing.Optional[typing.List[TypeClass]] = pydantic.Field(alias=str("typeClasses"), default=None) # type: ignore[literal-required]
+
+
+StructFieldTypeRid: typing_extensions.TypeAlias = core.RID
+"""The unique resource identifier of a struct field, useful for interacting with other Foundry APIs."""
+
+
+class StructListParameterFieldArgument(core.ModelBase):
+ """Represents a struct list parameter field argument in a logic rule."""
+
+ parameter_id: ParameterId = pydantic.Field(alias=str("parameterId")) # type: ignore[literal-required]
+ struct_parameter_field_api_name: StructParameterFieldApiName = pydantic.Field(alias=str("structParameterFieldApiName")) # type: ignore[literal-required]
+ type: typing.Literal["structListParameterFieldValue"] = "structListParameterFieldValue"
+
+
+StructParameterFieldApiName: typing_extensions.TypeAlias = str
+"""The unique identifier of the struct parameter field."""
+
+
+class StructParameterFieldArgument(core.ModelBase):
+ """Represents a struct parameter field argument in a logic rule."""
+
+ parameter_id: ParameterId = pydantic.Field(alias=str("parameterId")) # type: ignore[literal-required]
+ struct_parameter_field_api_name: StructParameterFieldApiName = pydantic.Field(alias=str("structParameterFieldApiName")) # type: ignore[literal-required]
+ type: typing.Literal["structParameterFieldValue"] = "structParameterFieldValue"
+
+
+class StructPropertyMapping(core.ModelBase):
+ """A mapping from the backing column struct field names to a struct property's fields."""
+
+ column: ColumnName
+ fields: typing.Dict[core_models.StructFieldName, StructFieldPropertyMapping]
+ type: typing.Literal["struct"] = "struct"
+
+
+class StructType(core.ModelBase):
+ """StructType"""
+
+ struct_field_types: typing.List[StructFieldType] = pydantic.Field(alias=str("structFieldTypes")) # type: ignore[literal-required]
+ main_value: typing.Optional[StructTypeMainValue] = pydantic.Field(alias=str("mainValue"), default=None) # type: ignore[literal-required]
+ type: typing.Literal["struct"] = "struct"
+
+
+class StructTypeMainValue(core.ModelBase):
+ """StructTypeMainValue"""
+
+ main_value_type: ObjectPropertyType = pydantic.Field(alias=str("mainValueType")) # type: ignore[literal-required]
+ fields: typing.List[StructFieldApiName]
+ """The fields which comprise the main value of the struct."""
+
+
+class SubmissionCriteriaEvaluation(core.ModelBase):
+ """
+ Contains the status of the **submission criteria**.
+ **Submission criteria** are the prerequisites that need to be satisfied before an Action can be applied.
+ These are configured in the **Ontology Manager**.
+ """
+
+ configured_failure_message: typing.Optional[str] = pydantic.Field(alias=str("configuredFailureMessage"), default=None) # type: ignore[literal-required]
+ """
+ The message indicating one of the **submission criteria** was not satisfied.
+ This is configured per **submission criteria** in the **Ontology Manager**.
+ """
+
+ result: ValidationResult
+
+
+class SubscriptionClosed(core.ModelBase):
+ """The subscription has been closed due to an irrecoverable error during its lifecycle."""
+
+ id: SubscriptionId
+ cause: SubscriptionClosureCause
+ type: typing.Literal["subscriptionClosed"] = "subscriptionClosed"
+
+
+SubscriptionClosureCause: typing_extensions.TypeAlias = typing_extensions.Annotated[
+ typing.Union["Reason", "Error"], pydantic.Field(discriminator="type")
+]
+"""SubscriptionClosureCause"""
+
+
+class SubscriptionError(core.ModelBase):
+ """SubscriptionError"""
+
+ errors: typing.List[Error]
+ type: typing.Literal["error"] = "error"
+
+
+SubscriptionId: typing_extensions.TypeAlias = core.UUID
+"""A unique identifier used to associate subscription requests with responses."""
+
+
+class SubscriptionSuccess(core.ModelBase):
+ """SubscriptionSuccess"""
+
+ id: SubscriptionId
+ type: typing.Literal["success"] = "success"
+
+
+class SubtractPropertyExpression(core.ModelBase):
+ """Subtracts the right numeric value from the left numeric value."""
+
+ left: DerivedPropertyDefinition
+ right: DerivedPropertyDefinition
+ type: typing.Literal["subtract"] = "subtract"
+
+
+class SumAggregationV2(core.ModelBase):
+ """
+ Computes the sum of values for the provided field.
+ Either `field` or `propertyIdentifier` must be supplied, but not both.
+ """
+
+ field: typing.Optional[PropertyApiName] = None
+ property_identifier: typing.Optional[PropertyIdentifier] = pydantic.Field(alias=str("propertyIdentifier"), default=None) # type: ignore[literal-required]
+ name: typing.Optional[AggregationMetricName] = None
+ direction: typing.Optional[OrderByDirection] = None
+ type: typing.Literal["sum"] = "sum"
+
+
+class SyncApplyActionResponseV2(core.ModelBase):
+ """SyncApplyActionResponseV2"""
+
+ operation_id: typing.Optional[core.RID] = pydantic.Field(alias=str("operationId"), default=None) # type: ignore[literal-required]
+ validation: typing.Optional[ValidateActionResponseV2] = None
+ edits: typing.Optional[ActionResults] = None
+
+
+class SynchronousWebhookOutputArgument(core.ModelBase):
+ """Represents a synchronous webhook output argument in a logic rule."""
+
+ webhook_output_param_name: str = pydantic.Field(alias=str("webhookOutputParamName")) # type: ignore[literal-required]
+ """The name of the webhook output parameter."""
+
+ type: typing.Literal["synchronousWebhookOutput"] = "synchronousWebhookOutput"
+
+
+TableRid: typing_extensions.TypeAlias = core.RID
+"""The RID of a Foundry table."""
+
+
+class TextAllowedValues(core.ModelBase):
+ """
+ The parameter value (a string) must satisfy the configured length bounds and/or regex
+ pattern.
+ """
+
+ gte: typing.Optional[int] = None
+ """Character length greater than or equal."""
+
+ lte: typing.Optional[int] = None
+ """Character length less than or equal."""
+
+ regex: typing.Optional[str] = None
+ """The regular expression. Format and supported syntax match Elasticsearch regex semantics."""
+
+ configured_failure_message: typing.Optional[str] = pydantic.Field(alias=str("configuredFailureMessage"), default=None) # type: ignore[literal-required]
+ """Message returned when the value does not match the pattern."""
+
+ type: typing.Literal["text"] = "text"
+
+
+class ThreeDimensionalAggregation(core.ModelBase):
+ """ThreeDimensionalAggregation"""
+
+ key_type: QueryAggregationKeyType = pydantic.Field(alias=str("keyType")) # type: ignore[literal-required]
+ value_type: TwoDimensionalAggregation = pydantic.Field(alias=str("valueType")) # type: ignore[literal-required]
+ type: typing.Literal["threeDimensionalAggregation"] = "threeDimensionalAggregation"
+
+
+class TimeCodeFormat(core.ModelBase):
+ """Formats the duration in a timecode format."""
+
+ type: typing.Literal["timecode"] = "timecode"
+
+
+TimeRange: typing_extensions.TypeAlias = typing_extensions.Annotated[
+ typing.Union["AbsoluteTimeRange", "RelativeTimeRange"], pydantic.Field(discriminator="type")
+]
+"""An absolute or relative range for a time series query."""
+
+
+TimeSeriesAggregationMethod: typing_extensions.TypeAlias = typing.Literal[
+ "SUM",
+ "MEAN",
+ "STANDARD_DEVIATION",
+ "MAX",
+ "MIN",
+ "PERCENT_CHANGE",
+ "DIFFERENCE",
+ "PRODUCT",
+ "COUNT",
+ "FIRST",
+ "LAST",
+]
+"""The aggregation function to use for aggregating time series data."""
+
+
+TimeSeriesAggregationStrategy: typing_extensions.TypeAlias = typing_extensions.Annotated[
+ typing.Union[
+ "TimeSeriesRollingAggregate", "TimeSeriesPeriodicAggregate", "TimeSeriesCumulativeAggregate"
+ ],
+ pydantic.Field(discriminator="type"),
+]
+"""
+CUMULATIVE aggregates all points up to the current point.
+ROLLING aggregates all points in a rolling window whose size is either the specified number of points or
+time duration.
+PERIODIC aggregates all points in specified time windows.
+"""
+
+
+class TimeSeriesCumulativeAggregate(core.ModelBase):
+ """
+ The cumulative aggregate is calculated progressively for each point in the input time series,
+ considering all preceding points up to and including the current point.
+ """
+
+ type: typing.Literal["cumulative"] = "cumulative"
+
+
+class TimeSeriesPeriodicAggregate(core.ModelBase):
+ """
+ Aggregates values over discrete, periodic windows for a given time series.
+
+ A periodic window divides the time series into windows of fixed durations.
+ For each window, an aggregate function is applied to the points within that window. The result is a time series
+ with values representing the aggregate for each window. Windows with no data points are not included
+ in the output.
+
+ Periodic aggregation is useful for downsampling a continuous stream of data to larger granularities such as
+ hourly, daily, monthly.
+ """
+
+ window_size: PreciseDuration = pydantic.Field(alias=str("windowSize")) # type: ignore[literal-required]
+ alignment_timestamp: typing.Optional[core.AwareDatetime] = pydantic.Field(alias=str("alignmentTimestamp"), default=None) # type: ignore[literal-required]
+ """
+ The timestamp used to align the result, such that ticks in the result time series will lie at integer
+ multiples of the window duration from the alignment timestamp.
+
+ Default is the first epoch timestamp (January 1, 1970, 00:00:00 UTC) so that all aggregated points have
+ timestamps at midnight UTC at the start of each window duration.
+
+ For example, for a weekly aggregate with alignment timestamp 5 January, 8:33PM,
+ each aggregated timestamp will lie on the 7 day intervals at 8:33PM starting at 5 January.
+ """
+
+ window_type: TimeSeriesWindowType = pydantic.Field(alias=str("windowType")) # type: ignore[literal-required]
+ type: typing.Literal["periodic"] = "periodic"
+
+
+class TimeSeriesPoint(core.ModelBase):
+ """A time and value pair."""
+
+ time: core.AwareDatetime
+ """An ISO 8601 timestamp"""
+
+ value: typing.Any
+ """An object which is either an enum String or a double number."""
+
+
+class TimeSeriesRollingAggregate(core.ModelBase):
+ """TimeSeriesRollingAggregate"""
+
+ window_size: TimeSeriesRollingAggregateWindow = pydantic.Field(alias=str("windowSize")) # type: ignore[literal-required]
+ type: typing.Literal["rolling"] = "rolling"
+
+
+TimeSeriesRollingAggregateWindow: typing_extensions.TypeAlias = typing_extensions.Annotated[
+ typing.Union["PreciseDuration", "RollingAggregateWindowPoints"],
+ pydantic.Field(discriminator="type"),
+]
+"""
+A rolling window is a moving subset of data points that ends at the current timestamp (inclusive)
+and spans a specified duration (window size). As new data points are added, old points fall out of the
+window if they are outside the specified duration.
+
+Rolling windows are commonly used for smoothing data, detecting trends, and reducing noise
+in time series analysis.
+"""
+
+
+TimeSeriesWindowType: typing_extensions.TypeAlias = typing.Literal["START", "END"]
+"""TimeSeriesWindowType"""
+
+
+TimeUnit: typing_extensions.TypeAlias = typing.Literal[
+ "MILLISECONDS", "SECONDS", "MINUTES", "HOURS", "DAYS", "WEEKS", "MONTHS", "YEARS", "QUARTERS"
+]
+"""TimeUnit"""
+
+
+class TimeseriesEntry(core.ModelBase):
+ """A time and value pair."""
+
+ time: core.AwareDatetime
+ """An ISO 8601 timestamp"""
+
+ value: typing.Any
+ """An object which is either an enum String, double number, or a geopoint."""
+
+
+TimeseriesSyncRid: typing_extensions.TypeAlias = core.RID
+"""The RID identifying a time series sync."""
+
+
+class TimestampValue(core.ModelBase):
+ """TimestampValue"""
+
+ value: core.AwareDatetime
+ type: typing.Literal["timestampValue"] = "timestampValue"
+
+
+class TitlePropertySelector(core.ModelBase):
+ """Specifies the title property of an object type which is present on all object types."""
+
+ type: typing.Literal["titleProperty"] = "titleProperty"
+
+
+TransactionEdit: typing_extensions.TypeAlias = typing_extensions.Annotated[
+ typing.Union[
+ "ModifyObjectEdit", "DeleteObjectEdit", "AddObjectEdit", "DeleteLinkEdit", "AddLinkEdit"
+ ],
+ pydantic.Field(discriminator="type"),
+]
+"""TransactionEdit"""
+
+
+class TwoDimensionalAggregation(core.ModelBase):
+ """TwoDimensionalAggregation"""
+
+ key_type: QueryAggregationKeyType = pydantic.Field(alias=str("keyType")) # type: ignore[literal-required]
+ value_type: QueryAggregationValueType = pydantic.Field(alias=str("valueType")) # type: ignore[literal-required]
+ type: typing.Literal["twoDimensionalAggregation"] = "twoDimensionalAggregation"
+
+
+class TypeClass(core.ModelBase):
+ """Additional metadata that can be interpreted by user applications that interact with the Ontology"""
+
+ kind: str
+ """A namespace for the type class."""
+
+ name: str
+ """The value of the type class."""
+
+
+class TypeClassPredicateV2(core.ModelBase):
+ """
+ A predicate for matching type classes. Matches a type class when `kind`, and `name` if provided, match the
+ corresponding attribute of the type class. If `name` is empty, only `kind` is required to match. You can
+ search for both parameter type classes and action type type classes.
+ """
+
+ kind: str
+ """Exact match predicate for the `kind` attribute of a type class."""
+
+ name: typing.Optional[str] = None
+ """Exact match predicate for the `name` attribute of a type class."""
+
+
+class TypeClassesActionTypesQueryV2(core.ModelBase):
+ """Returns action types whose type class satisfies the given type class predicate."""
+
+ value: TypeClassPredicateV2
+ type: typing.Literal["typeClasses"] = "typeClasses"
+
+
+TypeReferenceIdentifier: typing_extensions.TypeAlias = str
+"""
+The unique identifier of a type reference. This identifier is used to look up the
+type definition in the `typeReferences` map of the enclosing Query.
+"""
+
+
+class UnevaluableConstraint(core.ModelBase):
+ """
+ The parameter cannot be evaluated because it depends on another parameter or object set that can't be evaluated.
+ This can happen when a parameter's allowed values are defined by another parameter that is missing or invalid.
+ """
+
+ type: typing.Literal["unevaluable"] = "unevaluable"
+
+
+class UniqueIdentifierArgument(core.ModelBase):
+ """Represents a unique identifier argument in a logic rule."""
+
+ link_id: typing.Optional[core.UUID] = pydantic.Field(alias=str("linkId"), default=None) # type: ignore[literal-required]
+ """
+ By default all UniqueIdentifier Logic Rule arguments will generate different UUID.
+ If the linkId is present all Logic Rules with the same linkId will all have the same uuid generated as the value.
+ """
+
+ type: typing.Literal["uniqueIdentifier"] = "uniqueIdentifier"
+
+
+UniqueIdentifierLinkId: typing_extensions.TypeAlias = core.UUID
+"""A reference to a UniqueIdentifierArgument linkId defined for this action type."""
+
+
+UniqueIdentifierValue: typing_extensions.TypeAlias = core.UUID
+"""
+An override value to be used for a UniqueIdentifier action parameter, instead of
+the value being automatically generated.
+"""
+
+
+class UnsupportedPolicy(core.ModelBase):
+ """Indicates the property is backed by a restricted view that does not support property securities."""
+
+ type: typing.Literal["unsupportedPolicy"] = "unsupportedPolicy"
+
+
+class UuidConstraint(core.ModelBase):
+ """The string must be a valid UUID (Universally Unique Identifier)."""
+
+ type: typing.Literal["uuid"] = "uuid"
+
+
+class ValidateActionResponseV2(core.ModelBase):
+ """ValidateActionResponseV2"""
+
+ result: ValidationResult
+ submission_criteria: typing.List[SubmissionCriteriaEvaluation] = pydantic.Field(alias=str("submissionCriteria")) # type: ignore[literal-required]
+ parameters: typing.Dict[ParameterId, ParameterEvaluationResult]
+
+
+ValidationResult: typing_extensions.TypeAlias = typing.Literal["VALID", "INVALID"]
+"""Represents the state of a validation."""
+
+
+ValueType: typing_extensions.TypeAlias = str
+"""
+A string indicating the type of each data value. Note that these types can be nested, for example an array of
+structs.
+
+| Type | JSON value |
+|---------------------|-------------------------------------------------------------------------------------------------------------------|
+| Array | `Array<T>`, where `T` is the type of the array elements, e.g. `Array<String>`. |
+| Attachment | `Attachment` |
+| Boolean | `Boolean` |
+| Byte | `Byte` |
+| CipherText | `CipherText` |
+| Date | `LocalDate` |
+| Decimal | `Decimal` |
+| Double | `Double` |
+| Float | `Float` |
+| Integer | `Integer` |
+| Long | `Long` |
+| Marking | `Marking` |
+| OntologyObject | `OntologyObject<T>` where `T` is the API name of the referenced object type. |
+| Short | `Short` |
+| String | `String` |
+| Struct | `Struct<T>` where `T` contains field name and type pairs, e.g. `Struct<{ firstName: String, lastName: string }>` |
+| Timeseries | `TimeSeries<T>` where `T` is either `String` for an enum series or `Double` for a numeric series. |
+| Timestamp | `Timestamp` |
+"""
+
+
+class ValueTypeAllowedValues(core.ModelBase):
+ """The parameter value must conform to the referenced value type."""
+
+ api_name: ValueTypeApiName = pydantic.Field(alias=str("apiName")) # type: ignore[literal-required]
+ rid: ValueTypeRid
+ version_id: ValueTypeVersionId = pydantic.Field(alias=str("versionId")) # type: ignore[literal-required]
+ type: typing.Literal["valueType"] = "valueType"
+
+
+ValueTypeApiName: typing_extensions.TypeAlias = str
+"""The name of the value type in the API in camelCase format."""
+
+
+class ValueTypeArrayType(core.ModelBase):
+ """ValueTypeArrayType"""
+
+ sub_type: typing.Optional[ValueTypeFieldType] = pydantic.Field(alias=str("subType"), default=None) # type: ignore[literal-required]
+ type: typing.Literal["array"] = "array"
+
+
+ValueTypeConstraint: typing_extensions.TypeAlias = typing_extensions.Annotated[
+ typing.Union[
+ "StructConstraint",
+ "RegexConstraint",
+ core_models.UnsupportedType,
+ "ArrayConstraint",
+ "LengthConstraint",
+ "RangesConstraint",
+ "RidConstraint",
+ "UuidConstraint",
+ "EnumConstraint",
+ ],
+ pydantic.Field(discriminator="type"),
+]
+"""ValueTypeConstraint"""
+
+
+class ValueTypeDecimalType(core.ModelBase):
+ """ValueTypeDecimalType"""
+
+ type: typing.Literal["decimal"] = "decimal"
+
+
+ValueTypeFieldType: typing_extensions.TypeAlias = typing_extensions.Annotated[
+ typing.Union[
+ core_models.DateType,
+ "ValueTypeStructType",
+ core_models.StringType,
+ core_models.ByteType,
+ core_models.DoubleType,
+ "ValueTypeOptionalType",
+ core_models.IntegerType,
+ "ValueTypeUnionType",
+ core_models.FloatType,
+ core_models.LongType,
+ "ValueTypeReferenceType",
+ core_models.BooleanType,
+ "ValueTypeArrayType",
+ core_models.BinaryType,
+ core_models.ShortType,
+ "ValueTypeDecimalType",
+ "ValueTypeMapType",
+ core_models.TimestampType,
+ ],
+ pydantic.Field(discriminator="type"),
+]
+"""ValueTypeFieldType"""
+
+
+class ValueTypeMapType(core.ModelBase):
+ """ValueTypeMapType"""
+
+ key_type: typing.Optional[ValueTypeFieldType] = pydantic.Field(alias=str("keyType"), default=None) # type: ignore[literal-required]
+ value_type: typing.Optional[ValueTypeFieldType] = pydantic.Field(alias=str("valueType"), default=None) # type: ignore[literal-required]
+ type: typing.Literal["map"] = "map"
+
+
+class ValueTypeOptionalType(core.ModelBase):
+ """ValueTypeOptionalType"""
+
+ wrapped_type: typing.Optional[ValueTypeFieldType] = pydantic.Field(alias=str("wrappedType"), default=None) # type: ignore[literal-required]
+ type: typing.Literal["optional"] = "optional"
+
+
+class ValueTypeReferenceType(core.ModelBase):
+ """ValueTypeReferenceType"""
+
+ type: typing.Literal["reference"] = "reference"
+
+
+ValueTypeRid: typing_extensions.TypeAlias = core.RID
+"""ValueTypeRid"""
+
+
+ValueTypeStatus: typing_extensions.TypeAlias = typing.Literal["ACTIVE", "DEPRECATED"]
+"""ValueTypeStatus"""
+
+
+class ValueTypeStructField(core.ModelBase):
+ """ValueTypeStructField"""
+
+ name: typing.Optional[core_models.StructFieldName] = None
+ field_type: typing.Optional[ValueTypeFieldType] = pydantic.Field(alias=str("fieldType"), default=None) # type: ignore[literal-required]
+
+
+class ValueTypeStructType(core.ModelBase):
+ """ValueTypeStructType"""
+
+ fields: typing.List[ValueTypeStructField]
+ type: typing.Literal["struct"] = "struct"
+
+
+class ValueTypeUnionType(core.ModelBase):
+ """ValueTypeUnionType"""
+
+ member_types: typing.List[ValueTypeFieldType] = pydantic.Field(alias=str("memberTypes")) # type: ignore[literal-required]
+ type: typing.Literal["union"] = "union"
+
+
+ValueTypeVersionId: typing_extensions.TypeAlias = core.UUID
+"""ValueTypeVersionId"""
+
+
+VersionedQueryTypeApiName: typing_extensions.TypeAlias = str
+"""
+The name of the Query in the API and an optional version identifier separated by a colon.
+If the API name contains a colon, then a version identifier of either "latest" or a semantic version must
+be included.
+If the API does not contain a colon, then either the version identifier must be excluded or a version
+identifier of a semantic version must be included.
+Examples: 'myGroup:myFunction:latest', 'myGroup:myFunction:1.0.0', 'myFunction', 'myFunction:2.0.0'
+"""
+
+
+WebhookRid: typing_extensions.TypeAlias = core.RID
+"""The unique resource identifier of a webhook, useful for interacting with other Foundry APIs."""
+
+
+class WebhookRidActionTypesQueryV2(core.ModelBase):
+ """Returns action types which reference the webhook with the given rid."""
+
+ value: WebhookRid
+ type: typing.Literal["webhookRid"] = "webhookRid"
+
+
+class WildcardQuery(core.ModelBase):
+ """
+ Returns objects where the specified field matches the wildcard pattern provided.
+ Either `field` or `propertyIdentifier` can be supplied, but not both.
+ """
+
+ field: typing.Optional[PropertyApiName] = None
+ property_identifier: typing.Optional[PropertyIdentifier] = pydantic.Field(alias=str("propertyIdentifier"), default=None) # type: ignore[literal-required]
+ value: str
+ type: typing.Literal["wildcard"] = "wildcard"
+
+
+class WithinBoundingBoxQuery(core.ModelBase):
+ """
+ Returns objects where the specified field contains a point within the bounding box provided. Allows you to
+ specify a property to query on by a variety of means. Either `field` or `propertyIdentifier` must be supplied,
+ but not both.
+ """
+
+ field: typing.Optional[PropertyApiName] = None
+ property_identifier: typing.Optional[PropertyIdentifier] = pydantic.Field(alias=str("propertyIdentifier"), default=None) # type: ignore[literal-required]
+ value: BoundingBoxValue
+ type: typing.Literal["withinBoundingBox"] = "withinBoundingBox"
+
+
+class WithinDistanceOfQuery(core.ModelBase):
+ """
+ Returns objects where the specified field contains a point within the distance provided of the center point.
+ Allows you to specify a property to query on by a variety of means. Either `field` or `propertyIdentifier`
+ must be supplied, but not both.
+ """
+
+ field: typing.Optional[PropertyApiName] = None
+ property_identifier: typing.Optional[PropertyIdentifier] = pydantic.Field(alias=str("propertyIdentifier"), default=None) # type: ignore[literal-required]
+ value: CenterPoint
+ type: typing.Literal["withinDistanceOf"] = "withinDistanceOf"
+
+
+class WithinPolygonQuery(core.ModelBase):
+ """
+ Returns objects where the specified field contains a point within the polygon provided. Allows you to specify a
+ property to query on by a variety of means. Either `field` or `propertyIdentifier` must be supplied, but not
+ both.
+ """
+
+ field: typing.Optional[PropertyApiName] = None
+ property_identifier: typing.Optional[PropertyIdentifier] = pydantic.Field(alias=str("propertyIdentifier"), default=None) # type: ignore[literal-required]
+ value: PolygonValue
+ type: typing.Literal["withinPolygon"] = "withinPolygon"
+
+
+ArrayEntryEvaluatedConstraint: typing_extensions.TypeAlias = StructEvaluatedConstraint
+"""Evaluated constraints for entries of array parameters for which per-entry evaluation is supported."""
+
+
+CenterPointTypes: typing_extensions.TypeAlias = geo_models.GeoPoint
+"""CenterPointTypes"""
+
+
+Icon: typing_extensions.TypeAlias = BlueprintIcon
+"""A union currently only consisting of the BlueprintIcon (more icon types may be added in the future)."""
+
+
+MethodObjectSet: typing_extensions.TypeAlias = ObjectSet
+"""MethodObjectSet"""
+
+
+OntologyBase: typing_extensions.TypeAlias = OntologyBaseBranch
+"""The base used to initialize a scenario."""
+
+
+PolygonValue: typing_extensions.TypeAlias = geo_models.Polygon
+"""PolygonValue"""
+
+
+ReferenceValue: typing_extensions.TypeAlias = GeotimeSeriesValue
+"""Resolved data values pointed to by a reference."""
+
+
+RelativeDateRangeBound: typing_extensions.TypeAlias = RelativePointInTime
+"""Specifies a bound for a relative date range query."""
+
+
+WithinBoundingBoxPoint: typing_extensions.TypeAlias = geo_models.GeoPoint
+"""WithinBoundingBoxPoint"""
+
+
+core.resolve_forward_references_in_module(__name__)
+
+__all__ = [
+ "AbsoluteTimeRange",
+ "AbsoluteValuePropertyExpression",
+ "ActionExecutionTime",
+ "ActionLogicRule",
+ "ActionParameterArrayType",
+ "ActionParameterRid",
+ "ActionParameterType",
+ "ActionParameterV2",
+ "ActionParameterValidation",
+ "ActionParameterValidationBlock",
+ "ActionResults",
+ "ActionRid",
+ "ActionSectionRid",
+ "ActionTypeApiName",
+ "ActionTypeApiNameActionTypesQueryV2",
+ "ActionTypeDescriptionActionTypesQueryV2",
+ "ActionTypeDisplayNameActionTypesQueryV2",
+ "ActionTypeFullMetadata",
+ "ActionTypeFuzziness",
+ "ActionTypeLogicRuleTypeFilter",
+ "ActionTypePermissionModelFilter",
+ "ActionTypeRid",
+ "ActionTypeRidActionTypesQueryV2",
+ "ActionTypeSearchJsonQueryV2",
+ "ActionTypeSortByV2",
+ "ActionTypeStatusFilter",
+ "ActionTypeV2",
+ "ActivePropertyTypeStatus",
+ "AddLink",
+ "AddLinkEdit",
+ "AddObject",
+ "AddObjectEdit",
+ "AddPropertyExpression",
+ "AffectedInterfaceTypeRidActionTypesQueryV2",
+ "AffectedLinkTypeRidActionTypesQueryV2",
+ "AffectedObjectTypeRidActionTypesQueryV2",
+ "Affix",
+ "AggregateObjectSetRequestV2",
+ "AggregateObjectsRequestV2",
+ "AggregateObjectsResponseItemV2",
+ "AggregateObjectsResponseV2",
+ "AggregateTimeSeries",
+ "AggregationAccuracy",
+ "AggregationAccuracyRequest",
+ "AggregationDurationGroupingV2",
+ "AggregationExactGroupingV2",
+ "AggregationFixedWidthGroupingV2",
+ "AggregationGroupByV2",
+ "AggregationGroupKeyV2",
+ "AggregationGroupValueV2",
+ "AggregationMetricName",
+ "AggregationMetricResultV2",
+ "AggregationRangeV2",
+ "AggregationRangesGroupingV2",
+ "AggregationV2",
+ "AllOfRule",
+ "AndActionTypesQueryV2",
+ "AndQueryV2",
+ "AnyOfRule",
+ "ApplyActionMode",
+ "ApplyActionOverrides",
+ "ApplyActionRequestOptions",
+ "ApplyActionRequestV2",
+ "ApplyActionWithOverridesRequest",
+ "ApplyReducersAndExtractMainValueLoadLevel",
+ "ApplyReducersLoadLevel",
+ "ApplyScenarioLogicRule",
+ "ApplyScenarioRule",
+ "ApproximateDistinctAggregationV2",
+ "ApproximatePercentileAggregationV2",
+ "Arg",
+ "ArrayConstraint",
+ "ArrayEntryEvaluatedConstraint",
+ "ArrayEvaluatedConstraint",
+ "ArraySizeConstraint",
+ "ArtifactRepositoryRid",
+ "AttachmentAllowedValues",
+ "AttachmentMetadataResponse",
+ "AttachmentRid",
+ "AttachmentV2",
+ "AvgAggregationV2",
+ "BatchActionObjectEdit",
+ "BatchActionObjectEdits",
+ "BatchActionResults",
+ "BatchApplyActionRequestItem",
+ "BatchApplyActionRequestItemWithOverrides",
+ "BatchApplyActionRequestOptions",
+ "BatchApplyActionRequestV2",
+ "BatchApplyActionResponseV2",
+ "BatchApplyActionWithOverridesRequest",
+ "BatchReturnEditsMode",
+ "BatchedFunctionLogicRule",
+ "BlueprintIcon",
+ "BooleanValue",
+ "BoundingBoxValue",
+ "CenterPoint",
+ "CenterPointTypes",
+ "CipherChannelStrategy",
+ "CipherText",
+ "ColumnName",
+ "ColumnPropertyMapping",
+ "ConjunctiveMarkingSummary",
+ "ContainerConjunctiveMarkingSummary",
+ "ContainerDisjunctiveMarkingSummary",
+ "ContainsAllTermsInOrderPrefixLastTerm",
+ "ContainsAllTermsInOrderQuery",
+ "ContainsAllTermsQuery",
+ "ContainsAnyTermQuery",
+ "ContainsQueryV2",
+ "CountAggregationV2",
+ "CountObjectsResponseV2",
+ "CreateEdit",
+ "CreateInterfaceLinkLogicRule",
+ "CreateInterfaceLogicRule",
+ "CreateInterfaceObjectRule",
+ "CreateLinkLogicRule",
+ "CreateLinkRule",
+ "CreateObjectLogicRule",
+ "CreateObjectRule",
+ "CreateOntologyScenarioRequest",
+ "CreateOntologyScenarioResponse",
+ "CreateOrModifyObjectLogicRule",
+ "CreateOrModifyObjectLogicRuleV2",
+ "CreateTemporaryObjectSetRequestV2",
+ "CreateTemporaryObjectSetResponseV2",
+ "CurrentTimeArgument",
+ "CurrentUserArgument",
+ "DataValue",
+ "DatasourceBranchId",
+ "DatasourceRid",
+ "DateValue",
+ "DatetimeAllowedValues",
+ "DatetimeFormat",
+ "DatetimeLocalizedFormat",
+ "DatetimeLocalizedFormatType",
+ "DatetimeStringFormat",
+ "DatetimeTimezone",
+ "DatetimeTimezoneStatic",
+ "DatetimeTimezoneUser",
+ "DecryptionResult",
+ "DeleteEdit",
+ "DeleteInterfaceLinkLogicRule",
+ "DeleteInterfaceObjectRule",
+ "DeleteLink",
+ "DeleteLinkEdit",
+ "DeleteLinkLogicRule",
+ "DeleteLinkRule",
+ "DeleteObject",
+ "DeleteObjectEdit",
+ "DeleteObjectLogicRule",
+ "DeleteObjectRule",
+ "DeprecatedPropertyTypeStatus",
+ "DerivedPropertyApiName",
+ "DerivedPropertyDefinition",
+ "DirectSourceRid",
+ "DisjunctiveMarkingSummary",
+ "DividePropertyExpression",
+ "DoesNotIntersectBoundingBoxQuery",
+ "DoesNotIntersectPolygonQuery",
+ "DoubleValue",
+ "DoubleVector",
+ "DurationBaseValue",
+ "DurationFormatStyle",
+ "DurationPrecision",
+ "EditHistoryEdit",
+ "EditOnlyPropertyMapping",
+ "EditsHistoryFilter",
+ "EditsHistoryOperationIdsFilter",
+ "EditsHistorySortOrder",
+ "EditsHistoryTimestampFilter",
+ "EncryptionRequest",
+ "EncryptionResult",
+ "EntrySetType",
+ "EnumConstraint",
+ "EqualsQueryV2",
+ "Error",
+ "ErrorComputingSecurity",
+ "ErrorName",
+ "ExactDistinctAggregationV2",
+ "ExamplePropertyTypeStatus",
+ "ExecuteQueryRequest",
+ "ExecuteQueryResponse",
+ "ExperimentalPropertyTypeStatus",
+ "ExtractDatePart",
+ "ExtractMainValueLoadLevel",
+ "ExtractPropertyExpression",
+ "FilterValue",
+ "FixedDatetimeValue",
+ "FixedValuesMapKey",
+ "FullTextStringContainsPredicate",
+ "FullTextStringExactPredicate",
+ "FullTextStringPredicateV2",
+ "FunctionLogicRule",
+ "FunctionParameterName",
+ "FunctionRid",
+ "FunctionRidActionTypesQueryV2",
+ "FunctionVersion",
+ "FuzzinessAuto",
+ "FuzzinessOff",
+ "FuzzyRule",
+ "FuzzyV2",
+ "GeoJsonString",
+ "GeoShapeV2Geometry",
+ "GeoShapeV2Query",
+ "GeotemporalSeriesEntry",
+ "GeotimeSeriesIntegrationRid",
+ "GeotimeSeriesValue",
+ "GetActionTypeByRidBatchRequest",
+ "GetActionTypeByRidBatchRequestElement",
+ "GetActionTypeByRidBatchResponse",
+ "GetActionTypeFullMetadataBatchRequest",
+ "GetActionTypeFullMetadataBatchRequestElement",
+ "GetActionTypeFullMetadataBatchResponse",
+ "GetObjectTypeByRidBatchRequest",
+ "GetObjectTypeByRidBatchRequestElement",
+ "GetObjectTypeByRidBatchResponse",
+ "GetObjectTypeFullMetadataBatchRequest",
+ "GetObjectTypeFullMetadataBatchRequestElement",
+ "GetObjectTypeFullMetadataBatchResponse",
+ "GetOutgoingLinkTypesByObjectTypeRidBatchRequest",
+ "GetOutgoingLinkTypesByObjectTypeRidBatchRequestElement",
+ "GetOutgoingLinkTypesByObjectTypeRidBatchResponse",
+ "GetQueryTypeByRidBatchRequest",
+ "GetQueryTypeByRidBatchRequestElement",
+ "GetQueryTypeByRidBatchResponse",
+ "GetSelectedPropertyOperation",
+ "GreatestPropertyExpression",
+ "GroupMemberConstraint",
+ "GtQueryV2",
+ "GteQueryV2",
+ "HasActionLogActionTypesQueryV2",
+ "HasNotificationActionTypesQueryV2",
+ "HasWebhookActionTypesQueryV2",
+ "HumanReadableFormat",
+ "Icon",
+ "InQuery",
+ "InputObjectTypeRidActionTypesQueryV2",
+ "IntegerValue",
+ "InterfaceActionTypeConstraintApiName",
+ "InterfaceDefinedPropertyType",
+ "InterfaceLinkType",
+ "InterfaceLinkTypeApiName",
+ "InterfaceLinkTypeCardinality",
+ "InterfaceLinkTypeLinkedEntityApiName",
+ "InterfaceLinkTypeRid",
+ "InterfaceParameterPropertyArgument",
+ "InterfacePropertyApiName",
+ "InterfacePropertyLocalPropertyImplementation",
+ "InterfacePropertyReducedPropertyImplementation",
+ "InterfacePropertyStructFieldImplementation",
+ "InterfacePropertyStructImplementation",
+ "InterfacePropertyStructImplementationMapping",
+ "InterfacePropertyType",
+ "InterfacePropertyTypeImplementation",
+ "InterfacePropertyTypeRid",
+ "InterfaceSharedPropertyType",
+ "InterfaceToObjectTypeMapping",
+ "InterfaceToObjectTypeMappingV2",
+ "InterfaceToObjectTypeMappings",
+ "InterfaceToObjectTypeMappingsV2",
+ "InterfaceType",
+ "InterfaceTypeApiName",
+ "InterfaceTypeRid",
+ "IntersectsBoundingBoxQuery",
+ "IntersectsPolygonQuery",
+ "IntervalQuery",
+ "IntervalQueryRule",
+ "IsNullQueryV2",
+ "KnownType",
+ "LeastPropertyExpression",
+ "LengthConstraint",
+ "LinkSideObject",
+ "LinkTypeApiName",
+ "LinkTypeId",
+ "LinkTypeRid",
+ "LinkTypeSideCardinality",
+ "LinkTypeSideV2",
+ "LinkedInterfaceTypeApiName",
+ "LinkedObjectLocator",
+ "LinkedObjectTypeApiName",
+ "LinksFromObject",
+ "ListActionTypesFullMetadataResponse",
+ "ListActionTypesResponseV2",
+ "ListAttachmentsResponseV2",
+ "ListInterfaceLinkedObjectsResponse",
+ "ListInterfaceTypesResponse",
+ "ListLinkedObjectsResponseV2",
+ "ListObjectTypesV2Response",
+ "ListObjectsForInterfaceResponse",
+ "ListObjectsResponseV2",
+ "ListOntologiesV2Response",
+ "ListOntologyValueTypesResponse",
+ "ListOutgoingInterfaceLinkTypesResponse",
+ "ListOutgoingLinkTypesResponseV2",
+ "ListQueryTypesResponseV2",
+ "ListScenarioConflictingObjectsResponse",
+ "ListScenarioEditedEntityTypesResponse",
+ "ListScenarioEditedLinkTypesResponse",
+ "ListScenarioEditedLinksResponse",
+ "ListScenarioEditedObjectTypesResponse",
+ "ListScenarioEditedObjectsResponse",
+ "LoadGeotemporalSeriesRequest",
+ "LoadGeotemporalSeriesResponse",
+ "LoadObjectSetLinksRequestV2",
+ "LoadObjectSetLinksResponseV2",
+ "LoadObjectSetRequestV2",
+ "LoadObjectSetResponseV2",
+ "LoadObjectSetV2MultipleObjectTypesRequest",
+ "LoadObjectSetV2MultipleObjectTypesResponse",
+ "LoadObjectSetV2ObjectsOrInterfacesRequest",
+ "LoadObjectSetV2ObjectsOrInterfacesResponse",
+ "LoadOntologyMetadataRequest",
+ "LogicRule",
+ "LogicRuleActionTypesQueryV2",
+ "LogicRuleArgument",
+ "LongValue",
+ "LtQueryV2",
+ "LteQueryV2",
+ "MarkdownAllowedValues",
+ "MarkingId",
+ "MatchRule",
+ "MaxAggregationV2",
+ "MediaMetadata",
+ "MethodObjectSet",
+ "MinAggregationV2",
+ "ModifyEdit",
+ "ModifyInterfaceLogicRule",
+ "ModifyInterfaceObjectRule",
+ "ModifyObject",
+ "ModifyObjectEdit",
+ "ModifyObjectLogicRule",
+ "ModifyObjectRule",
+ "MultiplyPropertyExpression",
+ "MustBeEmptyAllowedValues",
+ "NearestNeighborsQuery",
+ "NearestNeighborsQueryText",
+ "NegatePropertyExpression",
+ "NestedInterfacePropertyTypeImplementation",
+ "NestedQueryAggregation",
+ "NoLoadLevel",
+ "NotQueryV2",
+ "NowDatetimeValue",
+ "NumberFormatAffix",
+ "NumberFormatCurrency",
+ "NumberFormatCurrencyStyle",
+ "NumberFormatCustomUnit",
+ "NumberFormatDuration",
+ "NumberFormatFixedValues",
+ "NumberFormatNotation",
+ "NumberFormatOptions",
+ "NumberFormatRatio",
+ "NumberFormatScale",
+ "NumberFormatStandard",
+ "NumberFormatStandardUnit",
+ "NumberRatioType",
+ "NumberRoundingMode",
+ "NumberScaleType",
+ "ObjectEdit",
+ "ObjectEditHistoryEntry",
+ "ObjectEdits",
+ "ObjectLoadingResponseOptions",
+ "ObjectLocator",
+ "ObjectParameterPropertyArgument",
+ "ObjectPrimaryKey",
+ "ObjectPrimaryKeyV2",
+ "ObjectPropertyType",
+ "ObjectPropertyValueConstraint",
+ "ObjectQueryResultConstraint",
+ "ObjectRid",
+ "ObjectSet",
+ "ObjectSetAsBaseObjectTypesType",
+ "ObjectSetAsTypeType",
+ "ObjectSetBaseType",
+ "ObjectSetFilterType",
+ "ObjectSetInterfaceBaseType",
+ "ObjectSetInterfaceLinkSearchAroundType",
+ "ObjectSetIntersectionType",
+ "ObjectSetMethodInputType",
+ "ObjectSetNearestNeighborsType",
+ "ObjectSetReferenceType",
+ "ObjectSetRid",
+ "ObjectSetSearchAroundType",
+ "ObjectSetStaticType",
+ "ObjectSetStreamSubscribeRequest",
+ "ObjectSetStreamSubscribeRequests",
+ "ObjectSetSubscribeResponse",
+ "ObjectSetSubscribeResponses",
+ "ObjectSetSubtractType",
+ "ObjectSetUnionType",
+ "ObjectSetUpdate",
+ "ObjectSetUpdates",
+ "ObjectSetWithPropertiesType",
+ "ObjectState",
+ "ObjectTypeApiName",
+ "ObjectTypeDatasetDatasource",
+ "ObjectTypeDatasource",
+ "ObjectTypeDatasourceDefinition",
+ "ObjectTypeDirectDatasource",
+ "ObjectTypeEdits",
+ "ObjectTypeEditsHistoryRequest",
+ "ObjectTypeEditsHistoryResponse",
+ "ObjectTypeEditsOnlyDatasource",
+ "ObjectTypeFullMetadata",
+ "ObjectTypeGeotimeSeriesDatasource",
+ "ObjectTypeId",
+ "ObjectTypeInterfaceImplementation",
+ "ObjectTypeLinkTypeApiNameMapping",
+ "ObjectTypeMediaSetViewDatasource",
+ "ObjectTypeRestrictedViewDatasource",
+ "ObjectTypeRid",
+ "ObjectTypeStreamDatasource",
+ "ObjectTypeTableDatasource",
+ "ObjectTypeTimeSeriesDatasource",
+ "ObjectTypeUnsupportedDatasource",
+ "ObjectTypeV2",
+ "ObjectTypeVisibility",
+ "ObjectUpdate",
+ "OneOfAllowedValues",
+ "OneOfConstraint",
+ "OntologyApiName",
+ "OntologyArrayType",
+ "OntologyBase",
+ "OntologyBaseBranch",
+ "OntologyDataType",
+ "OntologyFullMetadata",
+ "OntologyIdentifier",
+ "OntologyInterfaceObjectSetType",
+ "OntologyInterfaceObjectType",
+ "OntologyMapType",
+ "OntologyObjectArrayType",
+ "OntologyObjectArrayTypeReducer",
+ "OntologyObjectArrayTypeReducerSortDirection",
+ "OntologyObjectSetType",
+ "OntologyObjectType",
+ "OntologyObjectTypeReferenceType",
+ "OntologyObjectV2",
+ "OntologyRid",
+ "OntologyScenarioRid",
+ "OntologySetType",
+ "OntologyStructField",
+ "OntologyStructType",
+ "OntologyTransactionId",
+ "OntologyV2",
+ "OntologyValueType",
+ "OrActionTypesQueryV2",
+ "OrQueryV2",
+ "OrderBy",
+ "OrderByDirection",
+ "ParameterAllowedValueOption",
+ "ParameterAllowedValues",
+ "ParameterArraySize",
+ "ParameterConstraintValue",
+ "ParameterDatetimeValue",
+ "ParameterEvaluatedConstraint",
+ "ParameterEvaluationResult",
+ "ParameterId",
+ "ParameterIdArgument",
+ "ParameterLengthConstraintValue",
+ "ParameterNameActionTypesQueryV2",
+ "ParameterOption",
+ "ParameterRidActionTypesQueryV2",
+ "ParameterValueConstraintValue",
+ "PermissionModelActionTypesQueryV2",
+ "Plaintext",
+ "PolygonValue",
+ "PostTransactionEditsRequest",
+ "PostTransactionEditsResponse",
+ "PreciseDuration",
+ "PreciseTimeUnit",
+ "PrefixOnLastTokenRule",
+ "PrimaryKeyPropertySelector",
+ "PrimaryKeyValue",
+ "PrimaryKeyValueV2",
+ "PropertyApiName",
+ "PropertyApiNameSelector",
+ "PropertyBooleanFormattingRule",
+ "PropertyDateFormattingRule",
+ "PropertyFilter",
+ "PropertyId",
+ "PropertyIdentifier",
+ "PropertyImplementation",
+ "PropertyKnownTypeFormattingRule",
+ "PropertyLoadLevel",
+ "PropertyMarkingSummary",
+ "PropertyNumberFormattingRule",
+ "PropertyNumberFormattingRuleType",
+ "PropertyOrStructFieldOfPropertyImplementation",
+ "PropertySecurities",
+ "PropertySecurity",
+ "PropertyTimestampFormattingRule",
+ "PropertyTypeApiName",
+ "PropertyTypeMappingInfo",
+ "PropertyTypeReference",
+ "PropertyTypeReferenceOrStringConstant",
+ "PropertyTypeRid",
+ "PropertyTypeStatus",
+ "PropertyTypeVisibility",
+ "PropertyV2",
+ "PropertyValue",
+ "PropertyValueEscapedString",
+ "PropertyValueFormattingRule",
+ "PropertyWithLoadLevelSelector",
+ "QosError",
+ "QueryAggregation",
+ "QueryAggregationKeyType",
+ "QueryAggregationRangeSubType",
+ "QueryAggregationRangeType",
+ "QueryAggregationValueType",
+ "QueryApiName",
+ "QueryArrayType",
+ "QueryDataType",
+ "QueryParameterV2",
+ "QueryRuntimeErrorParameter",
+ "QuerySetType",
+ "QueryStructField",
+ "QueryStructType",
+ "QueryThreeDimensionalAggregation",
+ "QueryTwoDimensionalAggregation",
+ "QueryTypeReferenceType",
+ "QueryTypeV2",
+ "QueryUnionType",
+ "RangeAllowedValues",
+ "RangeConstraint",
+ "RangesConstraint",
+ "Reason",
+ "ReasonType",
+ "ReferenceSigningOptions",
+ "ReferenceUpdate",
+ "ReferenceValue",
+ "RefreshObjectSet",
+ "RegexConstraint",
+ "RegexQuery",
+ "RelativeDateRangeBound",
+ "RelativeDateRangeQuery",
+ "RelativeDatetimeDuration",
+ "RelativeDatetimeTense",
+ "RelativeDatetimeUnit",
+ "RelativeDatetimeValue",
+ "RelativePointInTime",
+ "RelativeTime",
+ "RelativeTimeRange",
+ "RelativeTimeRelation",
+ "RelativeTimeSeriesTimeUnit",
+ "RelativeTimeUnit",
+ "RequestId",
+ "ResolvedInterfacePropertyType",
+ "RestrictedViewRid",
+ "ReturnEditsMode",
+ "RevertActionEnabledActionTypesQueryV2",
+ "RidConstraint",
+ "RollingAggregateWindowPoints",
+ "SdkPackageName",
+ "SdkPackageRid",
+ "SdkVersion",
+ "SearchActionTypesFullMetadataRequest",
+ "SearchActionTypesFullMetadataResponse",
+ "SearchActionTypesOrderByV2",
+ "SearchActionTypesRequestV2",
+ "SearchActionTypesResponseV2",
+ "SearchJsonQueryV2",
+ "SearchObjectsForInterfaceRequest",
+ "SearchObjectsRequestV2",
+ "SearchObjectsResponseV2",
+ "SearchOrderByType",
+ "SearchOrderByV2",
+ "SearchOrderingV2",
+ "SectionRidActionTypesQueryV2",
+ "SelectedPropertyApiName",
+ "SelectedPropertyApproximateDistinctAggregation",
+ "SelectedPropertyApproximatePercentileAggregation",
+ "SelectedPropertyAvgAggregation",
+ "SelectedPropertyCollectListAggregation",
+ "SelectedPropertyCollectSetAggregation",
+ "SelectedPropertyCountAggregation",
+ "SelectedPropertyExactDistinctAggregation",
+ "SelectedPropertyExpression",
+ "SelectedPropertyMaxAggregation",
+ "SelectedPropertyMinAggregation",
+ "SelectedPropertyOperation",
+ "SelectedPropertySumAggregation",
+ "SharedPropertyType",
+ "SharedPropertyTypeApiName",
+ "SharedPropertyTypeRid",
+ "SpatialFilterMode",
+ "StartsWithQuery",
+ "StaticArgument",
+ "StaticConstraintValue",
+ "StatusActionTypesQueryV2",
+ "StreamMessage",
+ "StreamRid",
+ "StreamTimeSeriesPointsRequest",
+ "StreamTimeSeriesValuesRequest",
+ "StreamingOutputFormat",
+ "StringConstant",
+ "StringLengthConstraint",
+ "StringRegexMatchConstraint",
+ "StringValue",
+ "StructConstraint",
+ "StructEvaluatedConstraint",
+ "StructFieldApiName",
+ "StructFieldArgument",
+ "StructFieldEvaluatedConstraint",
+ "StructFieldEvaluationResult",
+ "StructFieldOfPropertyImplementation",
+ "StructFieldPropertyMapping",
+ "StructFieldSelector",
+ "StructFieldType",
+ "StructFieldTypeRid",
+ "StructListParameterFieldArgument",
+ "StructParameterFieldApiName",
+ "StructParameterFieldArgument",
+ "StructPropertyMapping",
+ "StructType",
+ "StructTypeMainValue",
+ "SubmissionCriteriaEvaluation",
+ "SubscriptionClosed",
+ "SubscriptionClosureCause",
+ "SubscriptionError",
+ "SubscriptionId",
+ "SubscriptionSuccess",
+ "SubtractPropertyExpression",
+ "SumAggregationV2",
+ "SyncApplyActionResponseV2",
+ "SynchronousWebhookOutputArgument",
+ "TableRid",
+ "TextAllowedValues",
+ "ThreeDimensionalAggregation",
+ "TimeCodeFormat",
+ "TimeRange",
+ "TimeSeriesAggregationMethod",
+ "TimeSeriesAggregationStrategy",
+ "TimeSeriesCumulativeAggregate",
+ "TimeSeriesPeriodicAggregate",
+ "TimeSeriesPoint",
+ "TimeSeriesRollingAggregate",
+ "TimeSeriesRollingAggregateWindow",
+ "TimeSeriesWindowType",
+ "TimeUnit",
+ "TimeseriesEntry",
+ "TimeseriesSyncRid",
+ "TimestampValue",
+ "TitlePropertySelector",
+ "TransactionEdit",
+ "TwoDimensionalAggregation",
+ "TypeClass",
+ "TypeClassPredicateV2",
+ "TypeClassesActionTypesQueryV2",
+ "TypeReferenceIdentifier",
+ "UnevaluableConstraint",
+ "UniqueIdentifierArgument",
+ "UniqueIdentifierLinkId",
+ "UniqueIdentifierValue",
+ "UnsupportedPolicy",
+ "UuidConstraint",
+ "ValidateActionResponseV2",
+ "ValidationResult",
+ "ValueType",
+ "ValueTypeAllowedValues",
+ "ValueTypeApiName",
+ "ValueTypeArrayType",
+ "ValueTypeConstraint",
+ "ValueTypeDecimalType",
+ "ValueTypeFieldType",
+ "ValueTypeMapType",
+ "ValueTypeOptionalType",
+ "ValueTypeReferenceType",
+ "ValueTypeRid",
+ "ValueTypeStatus",
+ "ValueTypeStructField",
+ "ValueTypeStructType",
+ "ValueTypeUnionType",
+ "ValueTypeVersionId",
+ "VersionedQueryTypeApiName",
+ "WebhookRid",
+ "WebhookRidActionTypesQueryV2",
+ "WildcardQuery",
+ "WithinBoundingBoxPoint",
+ "WithinBoundingBoxQuery",
+ "WithinDistanceOfQuery",
+ "WithinPolygonQuery",
+]
diff --git a/case-studies/foundry-owl-crosswalk/vendor/objectTypeV2.ts b/case-studies/foundry-owl-crosswalk/vendor/objectTypeV2.ts
new file mode 100644
index 00000000..47fa47d8
--- /dev/null
+++ b/case-studies/foundry-owl-crosswalk/vendor/objectTypeV2.ts
@@ -0,0 +1,836 @@
+/*
+ * Copyright 2023 Palantir Technologies, Inc. All rights reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+import type { ObjectTypeV2 } from "@osdk/foundry.ontologies";
+
+export const employeeObjectType: ObjectTypeV2 = {
+ apiName: "Employee",
+ displayName: "Employee",
+ pluralDisplayName: "Employees",
+ aliases: [],
+ datasources: [],
+ icon: { type: "blueprint", color: "blue", name: "person" },
+ description: "A full-time or part-time \n\n employee of our firm",
+ primaryKey: "employeeId",
+ titleProperty: "fullName",
+ visibility: "NORMAL",
+ properties: {
+ employeeId: {
+ dataType: {
+ type: "integer",
+ },
+ rid: "rid",
+ typeClasses: [],
+ },
+ fullName: {
+ dataType: {
+ type: "string",
+ },
+ rid: "rid",
+ typeClasses: [],
+ },
+ office: {
+ description:
+ 'The unique "ID" of the employee\'s \\"primary\\" assigned office.\n This is some more text.',
+ dataType: {
+ type: "string",
+ },
+ rid: "rid",
+ typeClasses: [],
+ },
+ class: {
+ description: "",
+ dataType: {
+ type: "string",
+ },
+ rid: "rid",
+ typeClasses: [],
+ },
+ startDate: {
+ description:
+ "The date the employee was hired (most recently, if they were re-hired)",
+ dataType: {
+ type: "date",
+ },
+ rid: "rid",
+ typeClasses: [],
+ },
+ employeeStatus: {
+ description: "TimeSeries of the status of the employee",
+ dataType: {
+ type: "timeseries",
+ itemType: {
+ type: "string",
+ },
+ },
+ rid: "rid",
+ typeClasses: [],
+ },
+ employeeSensor: {
+ description: "TimeSeries sensor of the status of the employee",
+ dataType: {
+ type: "timeseries",
+ itemType: { type: "string" },
+ },
+ rid: "rid",
+ typeClasses: [],
+ },
+ employeeLocation: {
+ description: "Geotime series reference of the location of the employee",
+ dataType: {
+ type: "geotimeSeriesReference",
+ },
+ rid: "rid",
+ typeClasses: [],
+ },
+ skillSet: {
+ description: "The skills of the employee",
+ dataType: {
+ type: "string",
+ },
+ rid: "rid",
+ typeClasses: [],
+ },
+ skillSetEmbedding: {
+ description: "Vectorized skill set",
+ dataType: {
+ type: "vector",
+ dimension: 1536,
+ supportsSearchWith: [{ value: "COSINE_SIMILARITY" }],
+ embeddingModel: {
+ type: "lms",
+ value: "OPENAI_TEXT_EMBEDDING_ADA_002",
+ },
+ },
+ rid: "rid",
+ typeClasses: [],
+ },
+ favoriteRestaurants: {
+ dataType: {
+ type: "array",
+ subType: {
+ type: "string",
+ },
+ reducers: [],
+ },
+ rid: "rid",
+ typeClasses: [],
+ },
+ employeeProfile: {
+ description: "Employee profile with main value being the bio",
+ dataType: {
+ type: "struct",
+ structFieldTypes: [
+ {
+ apiName: "bio",
+ dataType: { type: "string" },
+ rid: "ri.struct.bio",
+ typeClasses: [],
+ },
+ {
+ apiName: "yearsExperience",
+ dataType: { type: "integer" },
+ rid: "ri.struct.yearsExperience",
+ typeClasses: [],
+ },
+ ],
+ mainValue: {
+ mainValueType: { type: "string" },
+ fields: ["bio"],
+ },
+ },
+ rid: "rid",
+ typeClasses: [],
+ },
+ performanceScores: {
+ description: "Array of performance scores with reducers",
+ dataType: {
+ type: "array",
+ subType: { type: "double" },
+ reducers: [{ direction: "DESCENDING_NULLS_LAST" }],
+ },
+ rid: "rid",
+ typeClasses: [],
+ },
+ },
+ rid: "ri.ontology.main.object-type.401ac022-89eb-4591-8b7e-0a912b9efb44",
+ status: "ACTIVE",
+} as const satisfies ObjectTypeV2;
+
+export const officeObjectType: ObjectTypeV2 = {
+ apiName: "Office",
+ displayName: "Office",
+ pluralDisplayName: "Office",
+ aliases: [],
+ datasources: [],
+ icon: { type: "blueprint", color: "blue", name: "office" },
+ description: "A office in our Company",
+ primaryKey: "officeId",
+ titleProperty: "officeId",
+ properties: {
+ officeId: {
+ dataType: {
+ type: "string",
+ },
+ rid: "rid",
+ typeClasses: [],
+ },
+ entrance: {
+ dataType: {
+ type: "geopoint",
+ },
+ rid: "rid",
+ typeClasses: [],
+ },
+ occupiedArea: {
+ description: "The occupied area of the Office",
+ dataType: {
+ type: "geoshape",
+ },
+ rid: "rid",
+ typeClasses: [],
+ },
+ name: {
+ description: "The Name of the Office",
+ dataType: {
+ type: "string",
+ },
+ rid: "rid",
+ typeClasses: [],
+ },
+ capacity: {
+ description: "The capacity of the Office",
+ dataType: {
+ type: "integer",
+ },
+ rid: "rid",
+ typeClasses: [],
+ },
+ },
+ rid: "ri.ontology.main.object-type.404ac022-89eb-4591-8b7e-1a912b9efb45",
+ status: "ACTIVE",
+} as const satisfies ObjectTypeV2;
+
+export const equipmentObjectType: ObjectTypeV2 = {
+ apiName: "equipment",
+ displayName: "Equipment",
+ pluralDisplayName: "Equipment",
+ aliases: [],
+ datasources: [],
+ icon: { type: "blueprint", color: "blue", name: "gear" },
+ primaryKey: "equipmentId",
+ titleProperty: "type",
+ properties: {
+ equipmentId: {
+ description: "The id of an equipment",
+ dataType: {
+ type: "string",
+ },
+ rid: "rid",
+ typeClasses: [],
+ },
+ type: {
+ dataType: {
+ type: "string",
+ },
+ rid: "rid",
+ typeClasses: [],
+ },
+ },
+ rid: "ri.ontology.main.object-type.808ac022-89eb-4591-8b7e-1a912b9efb45",
+ status: "ACTIVE",
+};
+
+export const objectTypeWithTimestampPrimaryKey: ObjectTypeV2 = {
+ apiName: "ObjectWithTimestampPrimaryKey",
+ displayName: "ObjectWithTimestampPrimaryKey",
+ pluralDisplayName: "ObjectWithTimestampPrimaryKeys",
+ aliases: [],
+ datasources: [],
+ icon: { type: "blueprint", color: "blue", name: "person" },
+ description: "Object Type With Timestamp Primary Key",
+ primaryKey: "timestamp",
+ titleProperty: "value",
+ properties: {
+ timestamp: {
+ dataType: {
+ type: "timestamp",
+ },
+ rid: "rid",
+ typeClasses: [],
+ },
+ value: {
+ dataType: {
+ type: "string",
+ },
+ rid: "rid",
+ typeClasses: [],
+ },
+ },
+ rid: "ri.ontology.main.object-type.32bb9402-9cab-4705-81bb-edb65a4a6806",
+ status: "ACTIVE",
+};
+
+export const objectTypeWithAllPropertyTypes: ObjectTypeV2 = {
+ apiName: "objectTypeWithAllPropertyTypes",
+ displayName: "objectTypeWithAllPropertyType",
+ pluralDisplayName: "objectTypeWithAllPropertyTypes",
+ aliases: [],
+ datasources: [],
+ icon: { type: "blueprint", color: "blue", name: "person" },
+ description: "An object type with all property types",
+ primaryKey: "id",
+ titleProperty: "string",
+ properties: {
+ id: {
+ dataType: {
+ type: "integer",
+ },
+ rid: "rid",
+ typeClasses: [],
+ },
+ string: {
+ dataType: {
+ type: "string",
+ },
+ rid: "rid",
+ typeClasses: [],
+ },
+ boolean: {
+ dataType: {
+ type: "boolean",
+ },
+ rid: "rid",
+ typeClasses: [],
+ },
+ date: {
+ dataType: {
+ type: "date",
+ },
+ rid: "rid",
+ typeClasses: [],
+ },
+ dateTime: {
+ dataType: {
+ type: "timestamp",
+ },
+ rid: "rid",
+ typeClasses: [],
+ },
+ decimal: {
+ dataType: {
+ type: "decimal",
+ },
+ rid: "rid",
+ typeClasses: [],
+ },
+ integer: {
+ dataType: {
+ type: "integer",
+ },
+ rid: "rid",
+ typeClasses: [],
+ },
+ long: {
+ dataType: {
+ type: "long",
+ },
+ rid: "rid",
+ typeClasses: [],
+ },
+ short: {
+ dataType: {
+ type: "short",
+ },
+ rid: "rid",
+ typeClasses: [],
+ },
+ float: {
+ dataType: {
+ type: "float",
+ },
+ rid: "rid",
+ typeClasses: [],
+ },
+ double: {
+ dataType: {
+ type: "double",
+ },
+ rid: "rid",
+ typeClasses: [],
+ },
+ byte: {
+ dataType: {
+ type: "byte",
+ },
+ rid: "rid",
+ typeClasses: [],
+ },
+ attachment: {
+ dataType: {
+ type: "attachment",
+ },
+ rid: "rid",
+ typeClasses: [],
+ },
+ attachment2: {
+ dataType: {
+ type: "attachment",
+ },
+ rid: "rid",
+ typeClasses: [],
+ },
+ geoPoint: {
+ dataType: {
+ type: "geopoint",
+ },
+ rid: "rid",
+ typeClasses: [],
+ },
+ geoShape: {
+ dataType: {
+ type: "geoshape",
+ },
+ rid: "rid",
+ typeClasses: [],
+ },
+ stringArray: {
+ dataType: {
+ type: "array",
+ subType: {
+ type: "string",
+ },
+ reducers: [],
+ },
+ rid: "rid",
+ typeClasses: [],
+ },
+ booleanArray: {
+ dataType: {
+ type: "array",
+ subType: {
+ type: "boolean",
+ },
+ reducers: [],
+ },
+ rid: "rid",
+ typeClasses: [],
+ },
+ dateArray: {
+ dataType: {
+ type: "array",
+ subType: {
+ type: "date",
+ },
+ reducers: [],
+ },
+ rid: "rid",
+ typeClasses: [],
+ },
+ dateTimeArray: {
+ dataType: {
+ type: "array",
+ subType: {
+ type: "timestamp",
+ },
+ reducers: [],
+ },
+ rid: "rid",
+ typeClasses: [],
+ },
+ decimalArray: {
+ dataType: {
+ type: "array",
+ subType: {
+ type: "decimal",
+ },
+ reducers: [],
+ },
+ rid: "rid",
+ typeClasses: [],
+ },
+ integerArray: {
+ dataType: {
+ type: "array",
+ subType: {
+ type: "integer",
+ },
+ reducers: [],
+ },
+ rid: "rid",
+ typeClasses: [],
+ },
+ longArray: {
+ dataType: {
+ type: "array",
+ subType: {
+ type: "long",
+ },
+ reducers: [],
+ },
+ rid: "rid",
+ typeClasses: [],
+ },
+ shortArray: {
+ dataType: {
+ type: "array",
+ subType: {
+ type: "short",
+ },
+ reducers: [],
+ },
+ rid: "rid",
+ typeClasses: [],
+ },
+ floatArray: {
+ dataType: {
+ type: "array",
+ subType: {
+ type: "float",
+ },
+ reducers: [],
+ },
+ rid: "rid",
+ typeClasses: [],
+ },
+ doubleArray: {
+ dataType: {
+ type: "array",
+ subType: {
+ type: "double",
+ },
+ reducers: [],
+ },
+ rid: "rid",
+ typeClasses: [],
+ },
+ byteArray: {
+ dataType: {
+ type: "array",
+ subType: {
+ type: "byte",
+ },
+ reducers: [],
+ },
+ rid: "rid",
+ typeClasses: [],
+ },
+ attachmentArray: {
+ dataType: {
+ type: "array",
+ subType: {
+ type: "attachment",
+ },
+ reducers: [],
+ },
+ rid: "rid",
+ typeClasses: [],
+ },
+ geoPointArray: {
+ dataType: {
+ type: "array",
+ subType: {
+ type: "geopoint",
+ },
+ reducers: [],
+ },
+ rid: "rid",
+ typeClasses: [],
+ },
+ geoShapeArray: {
+ dataType: {
+ type: "array",
+ subType: {
+ type: "geoshape",
+ },
+ reducers: [],
+ },
+ rid: "rid",
+ typeClasses: [],
+ },
+ mediaReference: {
+ dataType: {
+ type: "mediaReference",
+ },
+ rid: "rid",
+ typeClasses: [],
+ },
+ vector: {
+ dataType: {
+ type: "vector",
+ dimension: 100,
+ supportsSearchWith: [],
+ },
+ rid: "rid",
+ typeClasses: [],
+ },
+ cipherText: {
+ dataType: {
+ type: "cipherText",
+ },
+ rid: "rid",
+ typeClasses: [],
+ },
+ },
+ rid: "ri.ontology.main.object-type.401ac022-89eb-4591-8b7e-0a912b9efb44",
+ status: "ACTIVE",
+};
+
+export const ObjectTypesV2: ObjectTypeV2[] = [
+ employeeObjectType,
+ objectTypeWithAllPropertyTypes,
+ objectTypeWithTimestampPrimaryKey,
+ officeObjectType,
+ equipmentObjectType,
+];
+
+export const taskObjectType: ObjectTypeV2 = {
+ apiName: "Task",
+ displayName: "Task",
+ pluralDisplayName: "Tasks",
+ aliases: [],
+ datasources: [],
+ icon: { type: "blueprint", color: "blue", name: "box" },
+ primaryKey: "id",
+ properties: {
+ id: {
+ dataType: {
+ type: "integer",
+ },
+ rid: "rid",
+ typeClasses: [],
+ },
+
+ name: {
+ dataType: { type: "string" },
+ rid: "rid",
+ typeClasses: [],
+ },
+ },
+ status: "ACTIVE",
+ rid: "ri.task",
+ titleProperty: "name",
+};
+
+export const todoObjectType: ObjectTypeV2 = {
+ apiName: "Todo",
+ displayName: "Todo",
+ pluralDisplayName: "ManyTodo",
+ aliases: [],
+ datasources: [],
+ icon: { type: "blueprint", color: "blue", name: "box" },
+ primaryKey: "id",
+ properties: {
+ id: {
+ dataType: {
+ type: "integer",
+ },
+ rid: "rid",
+ typeClasses: [],
+ },
+ text: {
+ dataType: {
+ type: "string",
+ },
+ rid: "rid",
+ typeClasses: [],
+ },
+ },
+ rid: "ri.todo",
+ status: "ACTIVE",
+ titleProperty: "text",
+};
+
+export const personObjectType: ObjectTypeV2 = {
+ apiName: "Person",
+ displayName: "Person",
+ pluralDisplayName: "Persons",
+ aliases: [],
+ datasources: [],
+ icon: { type: "blueprint", color: "blue", name: "person" },
+ primaryKey: "id",
+ properties: {
+ id: {
+ dataType: {
+ type: "integer",
+ },
+ rid: "rid",
+ typeClasses: [],
+ },
+ name: {
+ dataType: {
+ type: "string",
+ },
+ rid: "rid",
+ typeClasses: [],
+ },
+ },
+ rid: "ri.person",
+ status: "ACTIVE",
+ titleProperty: "name",
+};
+
+export const BGaoNflPlayerObjectType: ObjectTypeV2 = {
+ apiName: "BgaoNflPlayer",
+ displayName: "id",
+ pluralDisplayName: "BgaoNflPlayers",
+ aliases: [],
+ datasources: [],
+ icon: { type: "blueprint", color: "blue", name: "box" },
+ primaryKey: "id",
+ properties: {
+ id: {
+ dataType: {
+ type: "string",
+ },
+ rid: "rid",
+ typeClasses: [],
+ },
+ gamesPlayed: {
+ dataType: {
+ type: "integer",
+ },
+ rid: "rid",
+ typeClasses: [],
+ },
+ name: {
+ dataType: {
+ type: "string",
+ },
+ rid: "rid",
+ typeClasses: [],
+ },
+ number: {
+ dataType: {
+ type: "integer",
+ },
+ rid: "rid",
+ typeClasses: [],
+ },
+ wikiUrl: {
+ dataType: {
+ type: "string",
+ },
+ rid: "rid",
+ typeClasses: [],
+ },
+ address: {
+ dataType: {
+ type: "struct",
+ structFieldTypes: [
+ {
+ apiName: "addressLine1",
+ dataType: {
+ type: "string",
+ },
+ rid: "ri.a.b.c.d",
+ typeClasses: [],
+ },
+ {
+ apiName: "addressLine2",
+ dataType: {
+ type: "string",
+ },
+ rid: "ri.a.b.c.d",
+ typeClasses: [],
+ },
+ {
+ apiName: "city",
+ dataType: {
+ type: "string",
+ },
+ rid: "ri.a.b.c.d",
+ typeClasses: [],
+ },
+ {
+ apiName: "state",
+ dataType: {
+ type: "string",
+ },
+ rid: "ri.a.b.c.d",
+ typeClasses: [],
+ },
+ {
+ apiName: "zipCode",
+ dataType: {
+ type: "integer",
+ },
+ rid: "ri.a.b.c.d",
+ typeClasses: [],
+ },
+ ],
+ },
+ rid: "rid",
+ typeClasses: [],
+ },
+ addressArray: {
+ dataType: {
+ type: "array",
+ subType: {
+ type: "struct",
+ structFieldTypes: [
+ {
+ apiName: "addressLine1",
+ dataType: {
+ type: "string",
+ },
+ rid: "ri.a.b.c.d",
+ typeClasses: [],
+ },
+ {
+ apiName: "addressLine2",
+ dataType: {
+ type: "string",
+ },
+ rid: "ri.a.b.c.d",
+ typeClasses: [],
+ },
+ {
+ apiName: "city",
+ dataType: {
+ type: "geoshape",
+ },
+ rid: "ri.a.b.c.d",
+ typeClasses: [],
+ },
+ {
+ apiName: "location",
+ dataType: {
+ type: "geopoint",
+ },
+ rid: "ri.a.b.c.d",
+ typeClasses: [],
+ },
+ {
+ apiName: "zipCode",
+ dataType: {
+ type: "integer",
+ },
+ rid: "ri.a.b.c.d",
+ typeClasses: [],
+ },
+ ],
+ },
+ reducers: [],
+ },
+ rid: "ri.a.b.c.structArray",
+ typeClasses: [],
+ },
+ },
+ rid: "ri.nflplayer",
+ status: "ACTIVE",
+ titleProperty: "name",
+};
diff --git a/case-studies/foundry-owl-crosswalk/vendor/spts.ts b/case-studies/foundry-owl-crosswalk/vendor/spts.ts
new file mode 100644
index 00000000..2703a4b0
--- /dev/null
+++ b/case-studies/foundry-owl-crosswalk/vendor/spts.ts
@@ -0,0 +1,28 @@
+/*
+ * Copyright 2024 Palantir Technologies, Inc. All rights reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+import type { SharedPropertyType } from "@osdk/foundry.ontologies";
+
+export const fooSpt: SharedPropertyType = {
+ rid: "ri.sharedPropertyType.main.sharedPropertyType.1",
+ apiName: "fooSpt",
+ dataType: {
+ type: "string",
+ },
+ displayName: "Foo",
+ description: "A foo",
+ typeClasses: [],
+} satisfies SharedPropertyType;
diff --git a/case-studies/foundry-owl-crosswalk/vendor_sources.py b/case-studies/foundry-owl-crosswalk/vendor_sources.py
new file mode 100644
index 00000000..72f35952
--- /dev/null
+++ b/case-studies/foundry-owl-crosswalk/vendor_sources.py
@@ -0,0 +1,90 @@
+"""Vendor Palantir's own published ontology definitions, with provenance.
+
+Ground truth for this case study is not a blog post or a marketing PDF. It is
+Palantir's own Apache-2.0 licensed SDK source: the platform SDK models that
+define what a Foundry Ontology is over the wire, and the OSDK test fixtures
+that Palantir uses to mock its own API.
+"""
+import hashlib
+import json
+import pathlib
+import urllib.request
+
+HERE = pathlib.Path(__file__).parent
+VENDOR = HERE / "vendor"
+
+SOURCES = {
+ "models.py": (
+ "https://raw.githubusercontent.com/palantir/foundry-platform-python/"
+ "develop/foundry_sdk/v2/ontologies/models.py",
+ "palantir/foundry-platform-python",
+ "Apache-2.0",
+ "Wire model definitions for the v2 Ontologies API.",
+ ),
+ "core_models.py": (
+ "https://raw.githubusercontent.com/palantir/foundry-platform-python/"
+ "develop/foundry_sdk/v2/core/models.py",
+ "palantir/foundry-platform-python",
+ "Apache-2.0",
+ "Core wire models: the scalar property data types.",
+ ),
+ "objectTypeV2.ts": (
+ "https://raw.githubusercontent.com/palantir/osdk-ts/"
+ "main/packages/shared.test/src/stubs/objectTypeV2.ts",
+ "palantir/osdk-ts",
+ "Apache-2.0",
+ "Object type fixtures used by Palantir to mock the Foundry API.",
+ ),
+ "linkTypes.ts": (
+ "https://raw.githubusercontent.com/palantir/osdk-ts/"
+ "main/packages/shared.test/src/stubs/linkTypes.ts",
+ "palantir/osdk-ts",
+ "Apache-2.0",
+ "Link type fixtures used by Palantir to mock the Foundry API.",
+ ),
+ "spts.ts": (
+ "https://raw.githubusercontent.com/palantir/osdk-ts/"
+ "main/packages/shared.test/src/stubs/spts.ts",
+ "palantir/osdk-ts",
+ "Apache-2.0",
+ "Shared property type fixture.",
+ ),
+ "interfaceTypes.ts": (
+ "https://raw.githubusercontent.com/palantir/osdk-ts/"
+ "main/packages/shared.test/src/stubs/interfaceTypes.ts",
+ "palantir/osdk-ts",
+ "Apache-2.0",
+ "Interface type fixtures.",
+ ),
+}
+
+
+def main() -> None:
+ VENDOR.mkdir(exist_ok=True)
+ manifest = []
+ for name, (url, repo, licence, note) in SOURCES.items():
+ target = VENDOR / name
+ if not target.exists():
+ with urllib.request.urlopen(url, timeout=60) as response:
+ target.write_bytes(response.read())
+ payload = target.read_bytes()
+ manifest.append(
+ {
+ "file": name,
+ "url": url,
+ "repository": repo,
+ "licence": licence,
+ "note": note,
+ "bytes": len(payload),
+ "sha256": hashlib.sha256(payload).hexdigest(),
+ }
+ )
+ (HERE / "data" / "palantir-sources.json").write_text(
+ json.dumps({"sources": manifest}, indent=2) + "\n"
+ )
+ for entry in manifest:
+ print(f"{entry['file']:20s} {entry['bytes']:>8d} bytes {entry['sha256'][:16]}")
+
+
+if __name__ == "__main__":
+ main()