@osdk/api 2.1.0-beta.3 → 2.1.0-beta.30

package/build/types/actions/ActionResults.d.ts

@@ -0,0 +1,70 @@
+export type ActionResults = (ObjectEdits | LargeScaleObjectEdits) & { editedObjectTypes: Array<String> };
+interface ObjectEdits {
+	type: "edits";
+	addedObjects: Array<ObjectReference>;
+	modifiedObjects: Array<ObjectReference>;
+	addedLinks: Array<LinkReference>;
+	deletedObjectsCount: number;
+	deletedLinksCount: number;
+}
+interface LargeScaleObjectEdits {
+	type: "largeScaleEdits";
+	addedObjects?: never;
+	modifiedObjects?: never;
+	addedLinks?: never;
+	deletedObjectsCount?: never;
+	deletedLinksCount?: never;
+}
+type LinkReference = {
+	linkTypeApiNameAtoB: string;
+	linkTypeApiNameBtoA: string;
+	aSideObject: ObjectReference;
+	bSideObject: ObjectReference;
+};
+interface ObjectReference {
+	primaryKey: string | number;
+	objectType: string;
+}
+export interface ValidateActionResponseV2 {
+	result: "VALID" | "INVALID";
+	submissionCriteria: Array<{
+		configuredFailureMessage?: string;
+		result: "VALID" | "INVALID";
+	}>;
+	parameters: Record<string, {
+		result: "VALID" | "INVALID";
+		evaluatedConstraints: Array<ParameterEvaluatedConstraint>;
+		required: boolean;
+	}>;
+}
+type ParameterEvaluatedConstraint = {
+	type: "arraySize";
+	lt?: any;
+	lte?: any;
+	gt?: any;
+	gte?: any;
+} | { type: "groupMember" } | { type: "objectPropertyValue" } | { type: "objectQueryResult" } | {
+	type: "oneOf";
+	options: Array<{
+		displayName?: string;
+		value?: any;
+	}>;
+	otherValuesAllowed: boolean;
+} | {
+	type: "range";
+	lt?: any;
+	lte?: any;
+	gt?: any;
+	gte?: any;
+} | {
+	type: "stringLength";
+	lt?: any;
+	lte?: any;
+	gt?: any;
+	gte?: any;
+} | {
+	type: "stringRegexMatch";
+	regex: string;
+	configuredFailureMessage?: string;
+} | { type: "unevaluable" };
+export {};

package/build/types/actions/ActionReturnTypeForOptions.d.ts

@@ -0,0 +1,2 @@
+import type { ActionEditResponse, ActionValidationResponse, ApplyActionOptions, ApplyBatchActionOptions } from "./Actions.js";
+export type ActionReturnTypeForOptions<Op extends ApplyActionOptions | ApplyBatchActionOptions> = Op extends { $validateOnly: true } ? ActionValidationResponse : Op extends { $returnEdits: true } ? ActionEditResponse : undefined;

package/build/types/actions/Actions.d.ts

@@ -0,0 +1,30 @@
+import type { DataValueClientToWire } from "../mapping/DataValueMapping.js";
+import type { ObjectSet } from "../objectSet/ObjectSet.js";
+import type { InterfaceDefinition } from "../ontology/InterfaceDefinition.js";
+import type { ObjectTypeDefinition } from "../ontology/ObjectTypeDefinition.js";
+import type { OsdkBase } from "../OsdkBase.js";
+import type { OsdkObjectPrimaryKeyType } from "../OsdkObjectPrimaryKeyType.js";
+import type { ActionResults, ValidateActionResponseV2 } from "./ActionResults.js";
+export type ApplyActionOptions = {
+	$returnEdits?: true;
+	$validateOnly?: false;
+} | {
+	$validateOnly?: true;
+	$returnEdits?: false;
+};
+export type ApplyBatchActionOptions = { $returnEdits?: boolean };
+/**
+* Helper types for converting action definition parameter types to typescript types
+*/
+export declare namespace ActionParam {
+	type PrimitiveType<T extends keyof DataValueClientToWire> = DataValueClientToWire[T];
+	type ObjectType<T extends ObjectTypeDefinition> = OsdkBase<T> | OsdkObjectPrimaryKeyType<T>;
+	type ObjectSetType<T extends ObjectTypeDefinition> = ObjectSet<T>;
+	type InterfaceType<T extends InterfaceDefinition> = {
+		$objectType: NonNullable<T["__DefinitionMetadata"]> extends { implementedBy: infer U } ? (U extends ReadonlyArray<string> ? U[number] : string) : string;
+		$primaryKey: string | number;
+	};
+	type StructType<T extends Record<string, keyof DataValueClientToWire>> = { [K in keyof T] : DataValueClientToWire[T[K]] };
+}
+export type ActionEditResponse = ActionResults;
+export type ActionValidationResponse = ValidateActionResponseV2;

package/build/types/aggregate/AggregatableKeys.d.ts

@@ -0,0 +1,16 @@
+import type { NumericWithPropAggregateOption, StringWithPropAggregateOption } from "../derivedProperties/WithPropertiesAggregationOptions.js";
+import type { GetWirePropertyValueFromClient } from "../mapping/PropertyValueMapping.js";
+import type { ObjectOrInterfaceDefinition, PropertyKeys } from "../ontology/ObjectOrInterface.js";
+import type { CompileTimeMetadata } from "../ontology/ObjectTypeDefinition.js";
+export type StringAggregateOption = "approximateDistinct" | "exactDistinct";
+export type NumericAggregateOption = "min" | "max" | "sum" | "avg" | "approximateDistinct" | "exactDistinct";
+type AGG_FOR_TYPE<
+	T,
+	U extends boolean
+> = number extends T ? U extends true ? NumericAggregateOption : NumericWithPropAggregateOption : string extends T ? U extends true ? StringAggregateOption : StringWithPropAggregateOption : never;
+export type ValidAggregationKeys<
+	Q extends ObjectOrInterfaceDefinition,
+	R extends "aggregate" | "withPropertiesAggregate" = "aggregate"
+> = keyof ({ [KK in AggregatableKeys<Q> as `${KK & string}:${AGG_FOR_TYPE<GetWirePropertyValueFromClient<CompileTimeMetadata<Q>["properties"][KK]["type"]>, R extends "aggregate" ? true : false>}`]? : any } & { $count?: any });
+export type AggregatableKeys<Q extends ObjectOrInterfaceDefinition> = keyof { [P in PropertyKeys<Q>] : any };
+export {};

package/build/{browser → types}/aggregate/AggregateOpts.d.ts

@@ -1,10 +1,7 @@
 import type { GroupByClause } from "../groupby/GroupByClause.js";
 import type { ObjectOrInterfaceDefinition } from "../ontology/ObjectOrInterface.js";
 import type { OrderedAggregationClause, UnorderedAggregationClause } from "./AggregationsClause.js";
-import type { WhereClause } from "./WhereClause.js";
 export type AggregateOpts<Q extends ObjectOrInterfaceDefinition> = {
-    $select: UnorderedAggregationClause<Q> | OrderedAggregationClause<Q>;
-    $where?: WhereClause<Q>;
-    $groupBy?: GroupByClause<Q>;
+	$select: UnorderedAggregationClause<Q> | OrderedAggregationClause<Q>;
+	$groupBy?: GroupByClause<Q>;
 };
-//# sourceMappingURL=AggregateOpts.d.ts.map

package/build/types/aggregate/AggregateOptsThatErrors.d.ts

@@ -0,0 +1,17 @@
+import type { SingleKeyObject } from "type-fest";
+import type { GroupByClause } from "../groupby/GroupByClause.js";
+import type { ObjectOrInterfaceDefinition } from "../ontology/ObjectOrInterface.js";
+import type { AggregateOpts } from "./AggregateOpts.js";
+import type { UnorderedAggregationClause } from "./AggregationsClause.js";
+export type AggregateOptsThatErrorsAndDisallowsOrderingWithMultipleGroupBy<
+	Q extends ObjectOrInterfaceDefinition,
+	AO extends AggregateOpts<Q>
+> = SingleKeyObject<AO["$groupBy"]> extends never ? (AO["$select"] extends UnorderedAggregationClause<Q> ? AggregateOptsThatErrors<Q, AO> : {} extends AO["$groupBy"] ? AggregateOptsThatErrors<Q, AO> : {
+	$groupBy: AO["$groupBy"];
+	$select: UnorderedAggregationClause<Q>;
+}) : AggregateOptsThatErrors<Q, AO>;
+type AggregateOptsThatErrors<
+	Q extends ObjectOrInterfaceDefinition,
+	AO extends AggregateOpts<Q>
+> = AO & { $select: Pick<AO["$select"], keyof AggregateOpts<Q>["$select"] & keyof AO["$select"]> & Record<Exclude<keyof AO["$select"], keyof AggregateOpts<Q>["$select"]>, never> } & (unknown extends AO["$groupBy"] ? {} : Exclude<AO["$groupBy"], undefined> extends never ? {} : { $groupBy: Pick<AO["$groupBy"], keyof GroupByClause<Q> & keyof AO["$groupBy"]> & Record<Exclude<keyof AO["$groupBy"], keyof GroupByClause<Q>>, never> });
+export {};

package/build/types/aggregate/AggregationResultsWithGroups.d.ts

@@ -0,0 +1,14 @@
+import type { OsdkObjectPropertyType } from "../Definitions.js";
+import type { GroupByClause, GroupByRange } from "../groupby/GroupByClause.js";
+import type { ObjectOrInterfaceDefinition, PropertyKeys } from "../ontology/ObjectOrInterface.js";
+import type { CompileTimeMetadata } from "../ontology/ObjectTypeDefinition.js";
+import type { AggregationResultsWithoutGroups } from "./AggregationResultsWithoutGroups.js";
+import type { OrderedAggregationClause, UnorderedAggregationClause } from "./AggregationsClause.js";
+export type AggregationResultsWithGroups<
+	Q extends ObjectOrInterfaceDefinition,
+	A extends UnorderedAggregationClause<Q> | OrderedAggregationClause<Q>,
+	G extends GroupByClause<Q> | undefined
+> = ({ $group: { [P in keyof G & PropertyKeys<Q>] : G[P] extends { $ranges: GroupByRange<infer T>[] } ? {
+	startValue: T;
+	endValue: T;
+} : OsdkObjectPropertyType<CompileTimeMetadata<Q>["properties"][P], true> } } & AggregationResultsWithoutGroups<Q, A>)[];

package/build/types/aggregate/AggregationResultsWithoutGroups.d.ts

@@ -0,0 +1,14 @@
+import type { OsdkObjectPropertyType } from "../Definitions.js";
+import type { ObjectOrInterfaceDefinition } from "../ontology/ObjectOrInterface.js";
+import type { CompileTimeMetadata } from "../ontology/ObjectTypeDefinition.js";
+import type { OrderedAggregationClause, UnorderedAggregationClause } from "./AggregationsClause.js";
+type ExtractPropName<T extends string> = T extends `${infer PropName}:${string}` ? PropName : T extends "$count" ? T : never;
+type ExtractMetricNameForPropName<
+	T,
+	PropName extends string
+> = T extends `${PropName}:${infer MetricName}` ? MetricName : never;
+export type AggregationResultsWithoutGroups<
+	Q extends ObjectOrInterfaceDefinition,
+	AC extends UnorderedAggregationClause<Q> | OrderedAggregationClause<Q>
+> = { [PropName in ExtractPropName<keyof AC & string>] : PropName extends "$count" ? number : { [MetricName in ExtractMetricNameForPropName<keyof AC & string, PropName>] : MetricName extends "approximateDistinct" | "exactDistinct" ? number : OsdkObjectPropertyType<CompileTimeMetadata<Q>["properties"][PropName]> } };
+export {};

package/build/{esm → types}/aggregate/AggregationsClause.d.ts

@@ -1,10 +1,5 @@
 import type { ObjectOrInterfaceDefinition } from "../ontology/ObjectOrInterface.js";
 import type { ValidAggregationKeys } from "./AggregatableKeys.js";
-export type UnorderedAggregationClause<Q extends ObjectOrInterfaceDefinition> = {
-    [AK in ValidAggregationKeys<Q>]?: "unordered";
-};
-export type OrderedAggregationClause<Q extends ObjectOrInterfaceDefinition> = {
-    [AK in ValidAggregationKeys<Q>]?: "unordered" | "asc" | "desc";
-};
+export type UnorderedAggregationClause<Q extends ObjectOrInterfaceDefinition> = { [AK in ValidAggregationKeys<Q>]? : "unordered" };
+export type OrderedAggregationClause<Q extends ObjectOrInterfaceDefinition> = { [AK in ValidAggregationKeys<Q>]? : "unordered" | "asc" | "desc" };
 export type AggregationClause<Q extends ObjectOrInterfaceDefinition> = UnorderedAggregationClause<Q> | OrderedAggregationClause<Q>;
-//# sourceMappingURL=AggregationsClause.d.ts.map

package/build/types/aggregate/AggregationsClause.test.d.ts

@@ -0,0 +1,34 @@
+import type { AggregatableKeys } from "./AggregatableKeys.js";
+import type { UnorderedAggregationClause } from "./AggregationsClause.js";
+export type huh = AggregatableKeys<{
+	metadata: any;
+	objects: { Todo: {
+		type: "object";
+		apiName: "Todo";
+		primaryKeyApiName: "id";
+		primaryKeyType: "double";
+		links: {};
+		properties: {
+			text: { type: "string" };
+			id: { type: "double" };
+		};
+	} };
+	actions: {};
+	queries: {};
+}["objects"]["Todo"]>;
+export type Q = UnorderedAggregationClause<{
+	metadata: any;
+	objects: { Todo: {
+		type: "object";
+		apiName: "Todo";
+		primaryKeyApiName: "id";
+		primaryKeyType: "double";
+		links: {};
+		properties: {
+			text: { type: "string" };
+			id: { type: "double" };
+		};
+	} };
+	actions: {};
+	queries: {};
+}["objects"]["Todo"]>;

package/build/types/aggregate/AggregationsResults.d.ts

@@ -0,0 +1,9 @@
+import type { ObjectOrInterfaceDefinition } from "../ontology/ObjectOrInterface.js";
+import type { AggregatableKeys, ValidAggregationKeys } from "./AggregatableKeys.js";
+import type { AggregateOpts } from "./AggregateOpts.js";
+import type { AggregationResultsWithGroups } from "./AggregationResultsWithGroups.js";
+import type { AggregationResultsWithoutGroups } from "./AggregationResultsWithoutGroups.js";
+export type AggregationsResults<
+	Q extends ObjectOrInterfaceDefinition,
+	AO extends AggregateOpts<Q>
+> = Exclude<keyof AO["$select"], ValidAggregationKeys<Q>> extends never ? unknown extends AO["$groupBy"] ? AggregationResultsWithoutGroups<Q, AO["$select"]> : Exclude<AO["$groupBy"], undefined> extends never ? AggregationResultsWithoutGroups<Q, AO["$select"]> : Exclude<keyof AO["$groupBy"], AggregatableKeys<Q>> extends never ? AggregationResultsWithGroups<Q, AO["$select"], AO["$groupBy"]> : `Sorry, the following are not valid groups for an aggregation: ${Exclude<keyof AO["$groupBy"] & string, AggregatableKeys<Q>>}` : `Sorry, the following are not valid selectors for an aggregation: ${Exclude<keyof AO["$select"] & string, ValidAggregationKeys<Q>>}`;

package/build/types/aggregate/ArrayFilter.d.ts

@@ -0,0 +1,11 @@
+import type { Just } from "./Just.js";
+interface ArrayFilterOptions<T> {
+	"$contains": T;
+	"$isNull": boolean;
+}
+declare namespace ArrayFilter {
+	interface $contains<T> extends Just<"$contains", ArrayFilterOptions<T>> {}
+	interface $isNull<T> extends Just<"$isNull", ArrayFilterOptions<T>> {}
+}
+export type ArrayFilter<T> = ArrayFilter.$contains<T> | ArrayFilter.$isNull<T>;
+export {};

package/build/types/aggregate/BaseFilter.d.ts

@@ -0,0 +1,14 @@
+import type { Just } from "./Just.js";
+export type BaseFilterOptions<T> = {
+	"$eq": T;
+	"$ne": T;
+	"$isNull": boolean;
+	"$in": ReadonlyArray<T>;
+};
+export declare namespace BaseFilter {
+	interface $eq<T> extends Just<"$eq", BaseFilterOptions<T>> {}
+	interface $ne<T> extends Just<"$ne", BaseFilterOptions<T>> {}
+	interface $in<T> extends Just<"$in", BaseFilterOptions<T>> {}
+	interface $isNull<T> extends Just<"$isNull", BaseFilterOptions<T>> {}
+}
+export type BaseFilter<T> = BaseFilter.$eq<T> | BaseFilter.$ne<T> | BaseFilter.$in<T> | BaseFilter.$isNull<T>;

package/build/types/aggregate/BooleanFilter.d.ts

@@ -0,0 +1,11 @@
+import type { BaseFilterOptions } from "./BaseFilter.js";
+import type { Just } from "./Just.js";
+interface BooleanFilterOptions extends BaseFilterOptions<boolean> {}
+export declare namespace BooleanFilter {
+	interface $eq extends Just<"$eq", BooleanFilterOptions> {}
+	interface $ne extends Just<"$ne", BooleanFilterOptions> {}
+	interface $isNull extends Just<"$isNull", BooleanFilterOptions> {}
+	interface $in extends Just<"$in", BooleanFilterOptions> {}
+}
+export type BooleanFilter = boolean | BooleanFilter.$eq | BooleanFilter.$ne | BooleanFilter.$in | BooleanFilter.$isNull;
+export {};

package/build/types/aggregate/DatetimeFilter.d.ts

@@ -0,0 +1,19 @@
+import type { BaseFilterOptions } from "./BaseFilter.js";
+import type { Just } from "./Just.js";
+export interface DatetimeFilterOptions extends BaseFilterOptions<string> {
+	"$gt": string;
+	"$gte": string;
+	"$lt": string;
+	"$lte": string;
+}
+export declare namespace DatetimeFilter {
+	interface $eq extends Just<"$eq", DatetimeFilterOptions> {}
+	interface $ne extends Just<"$ne", DatetimeFilterOptions> {}
+	interface $isNull extends Just<"$isNull", DatetimeFilterOptions> {}
+	interface $gt extends Just<"$gt", DatetimeFilterOptions> {}
+	interface $gte extends Just<"$gte", DatetimeFilterOptions> {}
+	interface $lt extends Just<"$lt", DatetimeFilterOptions> {}
+	interface $lte extends Just<"$lte", DatetimeFilterOptions> {}
+	interface $in extends Just<"$in", DatetimeFilterOptions> {}
+}
+export type DatetimeFilter = string | DatetimeFilter.$eq | DatetimeFilter.$ne | DatetimeFilter.$isNull | DatetimeFilter.$in | DatetimeFilter.$gt | DatetimeFilter.$gte | DatetimeFilter.$lt | DatetimeFilter.$lte;

package/build/types/aggregate/GeoFilter.d.ts

@@ -0,0 +1,35 @@
+import type { BBox, Point, Polygon } from "geojson";
+import type { Just } from "./Just.js";
+import type { DistanceUnitMapping } from "./WhereClause.js";
+export interface GeoFilterOptions {
+	"$within": {
+		$distance: [number, keyof typeof DistanceUnitMapping];
+		$of: [number, number] | Readonly<Point>;
+		$bbox?: never;
+		$polygon?: never;
+	} | {
+		$bbox: BBox;
+		$distance?: never;
+		$of?: never;
+		$polygon?: never;
+	} | BBox | {
+		$polygon: Polygon["coordinates"];
+		$bbox?: never;
+		$distance?: never;
+		$of?: never;
+	} | Polygon;
+	"$intersects": {
+		$bbox: BBox;
+		$polygon?: never;
+	} | BBox | {
+		$polygon: Polygon["coordinates"];
+		$bbox?: never;
+	} | Polygon;
+	"$isNull": boolean;
+}
+export declare namespace GeoFilter {
+	interface $within extends Just<"$within", GeoFilterOptions> {}
+	interface $intersects extends Just<"$intersects", GeoFilterOptions> {}
+	interface $isNull extends Just<"$isNull", GeoFilterOptions> {}
+}
+export type GeoFilter = GeoFilter.$within | GeoFilter.$intersects | GeoFilter.$isNull;

package/build/types/aggregate/Just.d.ts

@@ -0,0 +1,5 @@
+export type Just<
+	Z extends keyof V,
+	V
+> = { [k in Z] : V[k] } & { [k in keyof V as k extends Z ? never : k]? : never };
+export type NeverThese<V extends string | symbol | number> = { [k in V]? : never };

package/build/types/aggregate/NumberFilter.d.ts

@@ -0,0 +1,20 @@
+import type { BaseFilterOptions } from "./BaseFilter.js";
+import type { Just } from "./Just.js";
+interface NumberFilterOptions extends BaseFilterOptions<number> {
+	"$gt": number;
+	"$gte": number;
+	"$lt": number;
+	"$lte": number;
+}
+export declare namespace NumberFilter {
+	interface $eq extends Just<"$eq", NumberFilterOptions> {}
+	interface $ne extends Just<"$ne", NumberFilterOptions> {}
+	interface $isNull extends Just<"$isNull", NumberFilterOptions> {}
+	interface $gt extends Just<"$gt", NumberFilterOptions> {}
+	interface $gte extends Just<"$gte", NumberFilterOptions> {}
+	interface $lt extends Just<"$lt", NumberFilterOptions> {}
+	interface $lte extends Just<"$lte", NumberFilterOptions> {}
+	interface $in extends Just<"$in", NumberFilterOptions> {}
+}
+export type NumberFilter = number | NumberFilter.$eq | NumberFilter.$ne | NumberFilter.$isNull | NumberFilter.$in | NumberFilter.$gt | NumberFilter.$gte | NumberFilter.$lt | NumberFilter.$lte;
+export {};

package/build/types/aggregate/StringFilter.d.ts

@@ -0,0 +1,27 @@
+import type { BaseFilterOptions } from "./BaseFilter.js";
+import type { Just } from "./Just.js";
+interface StringFilterOptions extends BaseFilterOptions<string> {
+	"$startsWith": string;
+	"$containsAllTermsInOrder": string;
+	"$containsAnyTerm": string | {
+		term: string;
+		fuzzySearch?: boolean;
+	};
+	"$containsAllTerms": string | {
+		term: string;
+		fuzzySearch?: boolean;
+	};
+	"$in": ReadonlyArray<string>;
+}
+export declare namespace StringFilter {
+	interface $eq extends Just<"$eq", StringFilterOptions> {}
+	interface $ne extends Just<"$ne", StringFilterOptions> {}
+	interface $isNull extends Just<"$isNull", StringFilterOptions> {}
+	interface $startsWith extends Just<"$startsWith", StringFilterOptions> {}
+	interface $containsAllTermsInOrder extends Just<"$containsAllTermsInOrder", StringFilterOptions> {}
+	interface $containsAnyTerm extends Just<"$containsAnyTerm", StringFilterOptions> {}
+	interface $containsAllTerms extends Just<"$containsAllTerms", StringFilterOptions> {}
+	interface $in extends Just<"$in", StringFilterOptions> {}
+}
+export type StringFilter = string | StringFilter.$eq | StringFilter.$ne | StringFilter.$isNull | StringFilter.$in | StringFilter.$startsWith | StringFilter.$containsAllTermsInOrder | StringFilter.$containsAnyTerm | StringFilter.$containsAllTerms;
+export {};

package/build/types/aggregate/WhereClause.d.ts

@@ -0,0 +1,73 @@
+import type { BBox, Point, Polygon } from "geojson";
+import type { ObjectOrInterfaceDefinition } from "../ontology/ObjectOrInterface.js";
+import type { CompileTimeMetadata, ObjectMetadata } from "../ontology/ObjectTypeDefinition.js";
+import type { BaseWirePropertyTypes } from "../ontology/WirePropertyTypes.js";
+import type { IsNever } from "../OsdkObjectFrom.js";
+import type { ArrayFilter } from "./ArrayFilter.js";
+import type { BaseFilter } from "./BaseFilter.js";
+import type { BooleanFilter } from "./BooleanFilter.js";
+import type { DatetimeFilter } from "./DatetimeFilter.js";
+import type { GeoFilter } from "./GeoFilter.js";
+import type { Just } from "./Just.js";
+import type { NumberFilter } from "./NumberFilter.js";
+import type { StringFilter } from "./StringFilter.js";
+export type PossibleWhereClauseFilters = "$gt" | "$eq" | "$ne" | "$isNull" | "$contains" | "$gte" | "$lt" | "$lte" | "$within" | "$in" | "$intersects" | "$startsWith" | "$containsAllTermsInOrder" | "$containsAnyTerm" | "$containsAllTerms";
+export declare const DistanceUnitMapping: {
+	centimeter: "CENTIMETERS";
+	centimeters: "CENTIMETERS";
+	cm: "CENTIMETERS";
+	meter: "METERS";
+	meters: "METERS";
+	m: "METERS";
+	kilometer: "KILOMETERS";
+	kilometers: "KILOMETERS";
+	km: "KILOMETERS";
+	inch: "INCHES";
+	inches: "INCHES";
+	foot: "FEET";
+	feet: "FEET";
+	yard: "YARDS";
+	yards: "YARDS";
+	mile: "MILES";
+	miles: "MILES";
+	nautical_mile: "NAUTICAL_MILES";
+	nauticalMile: "NAUTICAL_MILES";
+	"nautical miles": "NAUTICAL_MILES";
+};
+export type GeoFilter_Within = { "$within": {
+	$distance: [number, keyof typeof DistanceUnitMapping];
+	$of: [number, number] | Readonly<Point>;
+	$bbox?: never;
+	$polygon?: never;
+} | {
+	$bbox: BBox;
+	$distance?: never;
+	$of?: never;
+	$polygon?: never;
+} | BBox | {
+	$polygon: Polygon["coordinates"];
+	$bbox?: never;
+	$distance?: never;
+	$of?: never;
+} | Polygon };
+export type GeoFilter_Intersects = { "$intersects": {
+	$bbox: BBox;
+	$polygon?: never;
+} | BBox | {
+	$polygon: Polygon["coordinates"];
+	$bbox?: never;
+} | Polygon };
+type FilterFor<PD extends ObjectMetadata.Property> = PD["multiplicity"] extends true ? (PD["type"] extends "string" | "geopoint" | "geoshape" | "datetime" | "timestamp" ? ArrayFilter<string> : (PD["type"] extends boolean ? ArrayFilter<boolean> : ArrayFilter<number>)) : PD["type"] extends Record<string, BaseWirePropertyTypes> ? StructFilter<PD["type"]> | BaseFilter<string> : (PD["type"] extends "string" ? StringFilter : PD["type"] extends "geopoint" | "geoshape" ? GeoFilter : PD["type"] extends "datetime" | "timestamp" ? DatetimeFilter : PD["type"] extends "boolean" ? BooleanFilter : PD["type"] extends "double" | "integer" | "long" | "float" | "decimal" | "byte" ? NumberFilter : BaseFilter<string>);
+type StructFilterOpts<ST extends Record<string, BaseWirePropertyTypes>> = { [K in keyof ST]? : FilterFor<{ "type": ST[K] }> };
+type StructFilter<ST extends Record<string, BaseWirePropertyTypes>> = { [K in keyof ST] : Just<K, StructFilterOpts<ST>> }[keyof ST];
+export interface AndWhereClause<T extends ObjectOrInterfaceDefinition> {
+	$and: WhereClause<T>[];
+}
+export interface OrWhereClause<T extends ObjectOrInterfaceDefinition> {
+	$or: WhereClause<T>[];
+}
+export interface NotWhereClause<T extends ObjectOrInterfaceDefinition> {
+	$not: WhereClause<T>;
+}
+export type WhereClause<T extends ObjectOrInterfaceDefinition> = OrWhereClause<T> | AndWhereClause<T> | NotWhereClause<T> | (IsNever<keyof CompileTimeMetadata<T>["properties"]> extends true ? Record<string, never> : { [P in keyof CompileTimeMetadata<T>["properties"]]? : FilterFor<CompileTimeMetadata<T>["properties"][P]> });
+export {};

package/build/types/definitions/LinkDefinitions.d.ts

@@ -0,0 +1,21 @@
+import type { FetchPageArgs, SelectArg } from "../object/FetchPageArgs.js";
+import type { Result } from "../object/Result.js";
+import type { ObjectSet } from "../objectSet/ObjectSet.js";
+import type { PropertyKeys } from "../ontology/ObjectOrInterface.js";
+import type { CompileTimeMetadata, ObjectMetadata, ObjectTypeDefinition, ObjectTypeLinkKeysFrom2 } from "../ontology/ObjectTypeDefinition.js";
+import type { ExtractOptions, Osdk } from "../OsdkObjectFrom.js";
+/** The $link container to get from one object type to its linked objects */
+export type OsdkObjectLinksObject<O extends ObjectTypeDefinition> = ObjectTypeLinkKeysFrom2<O> extends never ? never : { readonly [L in ObjectTypeLinkKeysFrom2<O>] : OsdkObjectLinksEntry<O, L> };
+export type OsdkObjectLinksEntry<
+	Q extends ObjectTypeDefinition,
+	L extends ObjectTypeLinkKeysFrom2<Q>
+> = CompileTimeMetadata<Q>["links"][L] extends ObjectMetadata.Link<infer T, infer M> ? (M extends false ? SingleLinkAccessor<T> : ObjectSet<T>) : never;
+export type DefaultToFalse<B extends boolean | undefined> = false extends B ? false : undefined extends B ? false : true;
+export interface SingleLinkAccessor<T extends ObjectTypeDefinition> {
+	/** Load the linked object
+	*/
+	fetchOne: <const A extends SelectArg<T, PropertyKeys<T>, boolean>>(options?: A) => Promise<A extends FetchPageArgs<T, infer L, infer R, any, infer S> ? Osdk.Instance<T, ExtractOptions<R, S>, L> : Osdk.Instance<T>>;
+	/** Load the linked object, with a result wrapper
+	*/
+	fetchOneWithErrors: <const A extends SelectArg<T, PropertyKeys<T>, boolean>>(options?: A) => Promise<Result<A extends FetchPageArgs<T, infer L, infer R, any, infer S> ? Osdk.Instance<T, ExtractOptions<R, S>, L> : Osdk.Instance<T>>>;
+}

package/build/types/definitions/LinkDefinitions.test.d.ts

@@ -0,0 +1 @@
+export {};

package/build/types/derivedProperties/DerivedProperty.d.ts

@@ -0,0 +1,42 @@
+import type { ValidAggregationKeys } from "../aggregate/AggregatableKeys.js";
+import type { WhereClause } from "../aggregate/WhereClause.js";
+import type { ObjectOrInterfaceDefinition, PropertyKeys } from "../ontology/ObjectOrInterface.js";
+import type { CompileTimeMetadata } from "../ontology/ObjectTypeDefinition.js";
+import type { SimplePropertyDef } from "../ontology/SimplePropertyDef.js";
+import type { LinkedType, LinkNames } from "../util/LinkUtils.js";
+import type { CollectWithPropAggregations } from "./WithPropertiesAggregationOptions.js";
+export declare namespace DerivedProperty {
+	type SelectorResult<T extends SimplePropertyDef> = { type: T };
+	type Clause<Q extends ObjectOrInterfaceDefinition> = { [key: string]: Selector<Q, SimplePropertyDef> };
+	type Selector<
+		Q extends ObjectOrInterfaceDefinition,
+		T extends SimplePropertyDef
+	> = (baseObjectSet: DerivedProperty.Builder<Q, false>) => SelectorResult<T>;
+	interface Builder<
+		Q extends ObjectOrInterfaceDefinition,
+		CONSTRAINED extends boolean
+	> extends Filterable<Q, CONSTRAINED>, Pivotable<Q, CONSTRAINED> {}
+	interface AggregateBuilder<
+		Q extends ObjectOrInterfaceDefinition,
+		CONSTRAINED extends boolean
+	> extends Builder<Q, CONSTRAINED>, Aggregatable<Q> {}
+	interface SelectPropertyBuilder<
+		Q extends ObjectOrInterfaceDefinition,
+		CONSTRAINED extends boolean
+	> extends AggregateBuilder<Q, CONSTRAINED>, Selectable<Q> {}
+}
+type BuilderTypeFromConstraint<
+	Q extends ObjectOrInterfaceDefinition,
+	CONSTRAINED extends boolean
+> = CONSTRAINED extends true ? DerivedProperty.AggregateBuilder<Q, true> : DerivedProperty.SelectPropertyBuilder<Q, false>;
+type Filterable<
+	Q extends ObjectOrInterfaceDefinition,
+	CONSTRAINED extends boolean
+> = { readonly where: (clause: WhereClause<Q>) => BuilderTypeFromConstraint<Q, CONSTRAINED> };
+type Pivotable<
+	Q extends ObjectOrInterfaceDefinition,
+	CONSTRAINED extends boolean
+> = { readonly pivotTo: <L extends LinkNames<Q>>(type: L) => CONSTRAINED extends true ? DerivedProperty.AggregateBuilder<LinkedType<Q, L>, true> : NonNullable<CompileTimeMetadata<Q>["links"][L]["multiplicity"]> extends true ? DerivedProperty.AggregateBuilder<LinkedType<Q, L>, true> : DerivedProperty.SelectPropertyBuilder<LinkedType<Q, L>, false> };
+type Aggregatable<Q extends ObjectOrInterfaceDefinition> = { readonly aggregate: <V extends ValidAggregationKeys<Q, "withPropertiesAggregate">>(aggregationSpecifier: V, opts?: V extends `${any}:${infer P}` ? P extends CollectWithPropAggregations ? { limit: number } : P extends "approximatePercentile" ? { percentile: number } : never : never) => DerivedProperty.SelectorResult<V extends `${infer N}:${infer P}` ? P extends CollectWithPropAggregations ? Array<CompileTimeMetadata<Q>["properties"][N]["type"]> | undefined : P extends "approximateDistinct" | "exactDistinct" | "$count" ? "integer" | undefined : "double" | undefined : V extends "$count" ? "integer" | undefined : never> };
+type Selectable<Q extends ObjectOrInterfaceDefinition> = { readonly selectProperty: <R extends PropertyKeys<Q>>(propertyName: R) => DerivedProperty.SelectorResult<SimplePropertyDef.Make<CompileTimeMetadata<Q>["properties"][R]["type"], CompileTimeMetadata<Q>["properties"][R]["nullable"], CompileTimeMetadata<Q>["properties"][R]["multiplicity"]>> };
+export {};

package/build/types/derivedProperties/WithPropertiesAggregationOptions.d.ts

@@ -0,0 +1,4 @@
+export type CollectWithPropAggregations = "collectSet" | "collectList";
+export type BaseWithPropAggregations = "approximateDistinct" | "exactDistinct" | "approximatePercentile";
+export type StringWithPropAggregateOption = BaseWithPropAggregations | CollectWithPropAggregations;
+export type NumericWithPropAggregateOption = "min" | "max" | "sum" | "avg" | BaseWithPropAggregations | CollectWithPropAggregations;

package/build/types/experimental/Experiment.d.ts

@@ -0,0 +1,11 @@
+export type Experiment<
+	V extends string,
+	T extends string = string,
+	K extends Record<string, (...args: any[]) => any> = any
+> = {
+	type: "experiment";
+	name: T;
+	branded?: K;
+	version: V;
+};
+export type ExperimentFns<B extends Experiment<string, string>> = NonNullable<B["branded"]>;

package/build/types/experimental/createMediaReference.d.ts

@@ -0,0 +1,22 @@
+import type { MediaReference } from "../object/Media.js";
+import type { Experiment } from "./Experiment.js";
+/**
+* @experimental This feature is experimental and might change in the future.
+*
+* Uploads a media item to the media property of the specified object type.
+*
+* @param data - Data to upload as media item
+* @param fileName - Name that will be assigned as path to the uploaded media item.
+* @param objectTypeApi - Api name of the object type to which the media item will be uploaded.
+* @param propertyTypeApi - Api name of the media reference property of the corresponding object type to which the media item will be uploaded.
+*
+* @returns media reference of the uploaded media item.
+*/
+type createMediaReference = (args: {
+	data: Blob;
+	fileName: string;
+	objectTypeApi: string;
+	propertyTypeApi: string;
+}) => Promise<MediaReference>;
+export declare const __EXPERIMENTAL__NOT_SUPPORTED_YET__createMediaReference: Experiment<"2.1.0", "__EXPERIMENTAL__NOT_SUPPORTED_YET__createMediaReference", { createMediaReference: createMediaReference }>;
+export {};

package/build/types/experimental/fetchOneByRid.d.ts

@@ -0,0 +1,13 @@
+import type { NullabilityAdherence, SelectArg } from "../object/FetchPageArgs.js";
+import type { PropertyKeys } from "../ontology/ObjectOrInterface.js";
+import type { ObjectTypeDefinition } from "../ontology/ObjectTypeDefinition.js";
+import type { ExtractOptions, Osdk } from "../OsdkObjectFrom.js";
+import type { Experiment } from "./Experiment.js";
+type fetchOneByRidFn = <
+	Q extends ObjectTypeDefinition,
+	const L extends PropertyKeys<Q>,
+	const R extends boolean,
+	const S extends false | "throw" = NullabilityAdherence.Default
+>(objectType: Q, rid: string, options?: SelectArg<Q, L, R, S>) => Promise<Osdk.Instance<Q, ExtractOptions<R, S>, L>>;
+export declare const __EXPERIMENTAL__NOT_SUPPORTED_YET__fetchOneByRid: Experiment<"2.1.0", "__EXPERIMENTAL__NOT_SUPPORTED_YET__fetchOneByRid", { fetchOneByRid: fetchOneByRidFn }>;
+export {};

package/build/types/experimental/getBulkLinks.d.ts

@@ -0,0 +1,7 @@
+import type { EXPERIMENTAL_BulkLinkResult } from "../objectSet/BulkLinkResult.js";
+import type { ObjectOrInterfaceDefinition } from "../ontology/ObjectOrInterface.js";
+import type { Osdk } from "../OsdkObjectFrom.js";
+import type { Experiment } from "./Experiment.js";
+type getBulkLinksFn = <T extends ObjectOrInterfaceDefinition>(objs: Osdk.Instance<T>[], links: string[]) => AsyncGenerator<EXPERIMENTAL_BulkLinkResult, void, undefined>;
+export declare const __EXPERIMENTAL__NOT_SUPPORTED_YET__getBulkLinks: Experiment<"2.0.8", "__EXPERIMENTAL__NOT_SUPPORTED_YET__getBulkLinks", { getBulkLinks: getBulkLinksFn }>;
+export {};