Plan, apply and roll back changes to a production ontology, with a blast radius report and a proof an auditor can re-check.
Rust ai-nativedescription-logicsformal-verificationinfrastructure-as-codeisabelle-languageknowledge-graphleanlean4mcpmcp-serverontologyowlowl2reasoningrustshaclsparqltheorem-proving
Add Foundry Ontology to OWL crosswalk case study
FABIOTESSb9c67233fa70
diff --git a/.gitignore b/.gitignoreindex 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/.gitignorenew file mode 100644index 00000000..52c3ff7d--- /dev/null+++ b/case-studies/foundry-owl-crosswalk/.gitignore@@ -0,0 +1,2 @@+# Outreach drafts name real recipients. Never publish them.+OUTREACH.mddiff --git a/case-studies/foundry-owl-crosswalk/README.md b/case-studies/foundry-owl-crosswalk/README.mdnew file mode 100644index 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.pynew file mode 100644index 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.jsonnew file mode 100644index 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.jsonnew file mode 100644index 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.jsonnew file mode 100644index 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.jsonnew file mode 100644index 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.jsonnew file mode 100644index 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.pynew file mode 100644index 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.pynew file mode 100644index 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.pynew file mode 100644index 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 += [+ "",+ "",+ "",+ "### 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'])} |",+ "",+ "",+ "",+ "### 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 += [+ "",+ "",+ "",+ "### 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.svgnew file mode 100644index 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.mdnew file mode 100644index 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 |++++### 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 |++++### 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 |++++### 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.ttlnew file mode 100644index 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.svgnew file mode 100644index 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.svgnew file mode 100644index 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.pynew file mode 100644index 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.pynew file mode 100644index 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.pynew file mode 100644index 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.tsnew file mode 100644index 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.tsnew file mode 100644index 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.pynew file mode 100644index 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 <= numNeighbors <= 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 <= Threshold <= 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.tsnew file mode 100644index 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.tsnew file mode 100644index 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.pynew file mode 100644index 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()