@osdk/api 2.1.0-beta.22 → 2.1.0-beta.24

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

@@ -11,66 +11,59 @@ 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;
+	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 "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>);
 export interface AndWhereClause<T extends ObjectOrInterfaceDefinition> {
-    $and: WhereClause<T>[];
+	$and: WhereClause<T>[];
 }
 export interface OrWhereClause<T extends ObjectOrInterfaceDefinition> {
-    $or: WhereClause<T>[];
+	$or: WhereClause<T>[];
 }
 export interface NotWhereClause<T extends ObjectOrInterfaceDefinition> {
-    $not: WhereClause<T>;
+	$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 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 {};
-//# sourceMappingURL=WhereClause.d.ts.map

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/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/{esm → types}/experimental/fetchOneByRid.d.ts

@@ -3,9 +3,11 @@ 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;
-}>;
+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 {};
-//# sourceMappingURL=fetchOneByRid.d.ts.map

package/build/{esm → types}/experimental/getBulkLinks.d.ts

@@ -3,8 +3,5 @@ import type { ObjectOrInterfaceDefinition } from "../ontology/ObjectOrInterface.
 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 declare const __EXPERIMENTAL__NOT_SUPPORTED_YET__getBulkLinks: Experiment<"2.0.8", "__EXPERIMENTAL__NOT_SUPPORTED_YET__getBulkLinks", { getBulkLinks: getBulkLinksFn }>;
 export {};
-//# sourceMappingURL=getBulkLinks.d.ts.map

package/build/{browser → types}/experimental/subscribe.d.ts

@@ -2,11 +2,9 @@ import type { ObjectSet } from "../objectSet/ObjectSet.js";
 import type { ObjectSetListener, ObjectSetListenerOptions } from "../objectSet/ObjectSetListener.js";
 import type { ObjectOrInterfaceDefinition, PropertyKeys } from "../ontology/ObjectOrInterface.js";
 import type { Experiment } from "./Experiment.js";
-type subscribeFn = <Q extends ObjectOrInterfaceDefinition, const P extends PropertyKeys<Q>>(objectSet: ObjectSet<Q>, listener: ObjectSetListener<Q, P>, opts?: ObjectSetListenerOptions<Q, P>) => {
-    unsubscribe: () => void;
-};
-export declare const __EXPERIMENTAL__NOT_SUPPORTED_YET_subscribe: Experiment<"2.1.0", "__EXPERIMENTAL__NOT_SUPPORTED_YET_subscribe", {
-    subscribe: subscribeFn;
-}>;
+type subscribeFn = <
+	Q extends ObjectOrInterfaceDefinition,
+	const P extends PropertyKeys<Q>
+>(objectSet: ObjectSet<Q>, listener: ObjectSetListener<Q, P>, opts?: ObjectSetListenerOptions<Q, P>) => { unsubscribe: () => void };
+export declare const __EXPERIMENTAL__NOT_SUPPORTED_YET_subscribe: Experiment<"2.1.0", "__EXPERIMENTAL__NOT_SUPPORTED_YET_subscribe", { subscribe: subscribeFn }>;
 export {};
-//# sourceMappingURL=subscribe.d.ts.map

package/build/types/groupby/GroupByClause.d.ts

@@ -0,0 +1,57 @@
+import type { AggregatableKeys } from "../aggregate/AggregatableKeys.js";
+import type { ObjectOrInterfaceDefinition } from "../ontology/ObjectOrInterface.js";
+import type { CompileTimeMetadata } from "../ontology/ObjectTypeDefinition.js";
+import type { GroupByMapper } from "./GroupByMapper.js";
+export type GroupByClause<Q extends ObjectOrInterfaceDefinition> = { [P in AggregatableKeys<Q>]? : GroupByEntry<Q, P> };
+type BaseGroupByValue = "exact" | { $exactWithLimit: number };
+export type GroupByRange<T> = [T, T];
+export type StringGroupByValue = BaseGroupByValue;
+export type NumericGroupByValue = BaseGroupByValue | { $fixedWidth: number } | { $ranges: GroupByRange<number>[] };
+export type TimestampGroupByValue = BaseGroupByValue | { $ranges: GroupByRange<string>[] } | { $duration: TimestampDurationGroupBy };
+export type DateGroupByValue = BaseGroupByValue | { $ranges: GroupByRange<string>[] } | { $duration: DatetimeDurationGroupBy };
+export type BooleanGroupByValue = BaseGroupByValue;
+export type TimestampTimeUnits = DateTimeUnits | "SECONDS" | "MINUTES" | "HOURS";
+export type DateTimeUnits = "DAYS" | "WEEKS" | "MONTHS" | "YEARS" | "QUARTERS";
+export declare const DurationMapping: {
+	quarter: "QUARTERS";
+	quarters: "QUARTERS";
+	sec: "SECONDS";
+	seconds: "SECONDS";
+	min: "MINUTES";
+	minute: "MINUTES";
+	minutes: "MINUTES";
+	hr: "HOURS";
+	hrs: "HOURS";
+	hour: "HOURS";
+	hours: "HOURS";
+	day: "DAYS";
+	days: "DAYS";
+	wk: "WEEKS";
+	week: "WEEKS";
+	weeks: "WEEKS";
+	mos: "MONTHS";
+	month: "MONTHS";
+	months: "MONTHS";
+	yr: "YEARS";
+	year: "YEARS";
+	years: "YEARS";
+};
+interface TimeValueMapping {
+	SECONDS: number;
+	MINUTES: number;
+	HOURS: number;
+	DAYS: number;
+	WEEKS: 1;
+	MONTHS: 1;
+	YEARS: 1;
+	QUARTERS: 1;
+}
+type DurationGroupBy<A> = { [K in keyof typeof DurationMapping] : typeof DurationMapping[K] extends A ? [TimeValueMapping[typeof DurationMapping[K]], K] : never }[keyof typeof DurationMapping];
+type TimestampDurationGroupBy = DurationGroupBy<TimestampTimeUnits>;
+type DatetimeDurationGroupBy = DurationGroupBy<DateTimeUnits>;
+type GroupByEntry<
+	Q extends ObjectOrInterfaceDefinition,
+	P extends AggregatableKeys<Q>
+> = CompileTimeMetadata<Q>["properties"][P]["type"] extends keyof GroupByMapper ? GroupByMapper[CompileTimeMetadata<Q>["properties"][P]["type"]] : never;
+export type AllGroupByValues = GroupByMapper[keyof GroupByMapper];
+export {};

package/build/types/groupby/GroupByClause.test.d.ts

@@ -0,0 +1,17 @@
+import type { GroupByClause } from "./GroupByClause.js";
+export type F = GroupByClause<{
+	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/groupby/GroupByMapper.d.ts

@@ -0,0 +1,13 @@
+import type { BooleanGroupByValue, DateGroupByValue, NumericGroupByValue, StringGroupByValue, TimestampGroupByValue } from "./GroupByClause.js";
+export interface GroupByMapper {
+	string: StringGroupByValue;
+	short: NumericGroupByValue;
+	float: NumericGroupByValue;
+	decimal: NumericGroupByValue;
+	byte: NumericGroupByValue;
+	double: NumericGroupByValue;
+	integer: NumericGroupByValue;
+	timestamp: TimestampGroupByValue;
+	datetime: DateGroupByValue;
+	boolean: BooleanGroupByValue;
+}

package/build/types/index.d.ts

@@ -0,0 +1,45 @@
+export type  { ActionReturnTypeForOptions } from "./actions/ActionReturnTypeForOptions.js";
+export type  { ActionEditResponse, ActionParam, ActionValidationResponse, ApplyActionOptions, ApplyBatchActionOptions } from "./actions/Actions.js";
+export type  { ValidAggregationKeys } from "./aggregate/AggregatableKeys.js";
+export type  { AggregateOpts } from "./aggregate/AggregateOpts.js";
+export type  { AggregateOptsThatErrorsAndDisallowsOrderingWithMultipleGroupBy } from "./aggregate/AggregateOptsThatErrors.js";
+export type  { AggregationResultsWithGroups } from "./aggregate/AggregationResultsWithGroups.js";
+export type  { AggregationResultsWithoutGroups } from "./aggregate/AggregationResultsWithoutGroups.js";
+export type  { AggregationClause } from "./aggregate/AggregationsClause.js";
+export type  { AggregationsResults } from "./aggregate/AggregationsResults.js";
+export type  { GeoFilterOptions } from "./aggregate/GeoFilter.js";
+export { DistanceUnitMapping } from "./aggregate/WhereClause.js";
+export type  { GeoFilter_Intersects, GeoFilter_Within, PossibleWhereClauseFilters, WhereClause } from "./aggregate/WhereClause.js";
+export type  { OsdkObjectPropertyType } from "./Definitions.js";
+export type  { OsdkObjectLinksObject, SingleLinkAccessor } from "./definitions/LinkDefinitions.js";
+export { DurationMapping } from "./groupby/GroupByClause.js";
+export type  { AllGroupByValues, GroupByClause, GroupByRange } from "./groupby/GroupByClause.js";
+export type  { AllowedBucketKeyTypes, AllowedBucketTypes, DataValueClientToWire, DataValueWireToClient } from "./mapping/DataValueMapping.js";
+export type  { PropertyValueWireToClient } from "./mapping/PropertyValueMapping.js";
+export type  { Attachment, AttachmentUpload } from "./object/Attachment.js";
+export type  { AsyncIterArgs, Augment, Augments, FetchPageArgs, NullabilityAdherence, SelectArg, SelectArgToKeys } from "./object/FetchPageArgs.js";
+export type  { FetchPageResult, SingleOsdkResult } from "./object/FetchPageResult.js";
+export type  { Media, MediaMetadata } from "./object/Media.js";
+export { isOk } from "./object/Result.js";
+export type  { Result } from "./object/Result.js";
+export type  { BaseObjectSet } from "./objectSet/BaseObjectSet.js";
+export type  { ObjectSet } from "./objectSet/ObjectSet.js";
+export type  { ObjectSetListener } from "./objectSet/ObjectSetListener.js";
+export type  { ObjectSetListenerOptions } from "./objectSet/ObjectSetListener.js";
+export type  { ActionDefinition, ActionMetadata, ValidBaseActionParameterTypes } from "./ontology/ActionDefinition.js";
+export type  { InterfaceDefinition, InterfaceMetadata } from "./ontology/InterfaceDefinition.js";
+export type  { ObjectOrInterfaceDefinition, PropertyKeys } from "./ontology/ObjectOrInterface.js";
+export type  { CompileTimeMetadata, ObjectMetadata, ObjectTypeDefinition, PropertyDef, VersionBound } from "./ontology/ObjectTypeDefinition.js";
+export type  { OntologyMetadata } from "./ontology/OntologyMetadata.js";
+export type  { PrimaryKeyTypes } from "./ontology/PrimaryKeyTypes.js";
+export type  { ObjectQueryDataType, ObjectSetQueryDataType, QueryDataTypeDefinition, QueryDefinition, QueryMetadata, QueryParameterDefinition, ThreeDimensionalQueryAggregationDefinition, TwoDimensionalQueryAggregationDefinition } from "./ontology/QueryDefinition.js";
+export type  { SimpleWirePropertyTypes, WirePropertyTypes } from "./ontology/WirePropertyTypes.js";
+export type  { OsdkBase, PrimaryKeyType } from "./OsdkBase.js";
+export type  { OsdkObject } from "./OsdkObject.js";
+export type  { ConvertProps, Osdk } from "./OsdkObjectFrom.js";
+export type  { PageResult } from "./PageResult.js";
+export type  { QueryParam, QueryResult } from "./queries/Queries.js";
+export { TimeseriesDurationMapping } from "./timeseries/timeseries.js";
+export type  { GeotimeSeriesProperty, TimeSeriesPoint, TimeSeriesProperty, TimeSeriesQuery } from "./timeseries/timeseries.js";
+export type  { LinkedType, LinkNames } from "./util/LinkUtils.js";
+export {};

package/build/types/junk.test.d.ts

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

package/build/types/mapping/DataValueMapping.d.ts

@@ -0,0 +1,70 @@
+import type { Attachment, AttachmentUpload } from "../object/Attachment.js";
+/**
+* Map from the DataValue type to the typescript type that we return
+*/
+export interface DataValueWireToClient {
+	attachment: Attachment;
+	boolean: boolean;
+	byte: number;
+	datetime: string;
+	decimal: string;
+	float: number;
+	double: number;
+	integer: number;
+	long: string;
+	marking: string;
+	null: null;
+	short: number;
+	string: string;
+	timestamp: string;
+	twoDimensionalAggregation: {
+		key: AllowedBucketKeyTypes;
+		value: AllowedBucketTypes;
+	}[];
+	threeDimensionalAggregation: {
+		key: AllowedBucketKeyTypes;
+		groups: {
+			key: AllowedBucketKeyTypes;
+			value: AllowedBucketTypes;
+		}[];
+	}[];
+	struct: Record<string, any>;
+	set: Set<any>;
+}
+/**
+* Map from the DataValue type to the typescript type that we accept
+*/
+export interface DataValueClientToWire {
+	attachment: string | AttachmentUpload | Blob & { readonly name: string };
+	boolean: boolean;
+	byte: number;
+	datetime: string;
+	decimal: string | number;
+	float: number;
+	double: number;
+	integer: number;
+	long: string | number;
+	marking: string;
+	null: null;
+	short: number;
+	string: string;
+	timestamp: string;
+	set: Set<any>;
+	twoDimensionalAggregation: {
+		key: AllowedBucketKeyTypes;
+		value: AllowedBucketTypes;
+	}[];
+	threeDimensionalAggregation: {
+		key: AllowedBucketKeyTypes;
+		groups: {
+			key: AllowedBucketKeyTypes;
+			value: AllowedBucketTypes;
+		}[];
+	}[];
+	struct: Record<string, any>;
+}
+export type AllowedBucketTypes = string | number | boolean;
+export type AllowedBucketKeyTypes = AllowedBucketTypes | {
+	startValue: AllowedBucketTypes;
+	endValue: AllowedBucketTypes;
+};

package/build/types/mapping/DurationMapping.d.ts

@@ -0,0 +1,22 @@
+export declare const TimeDurationMapping: {
+	sec: "SECONDS";
+	seconds: "SECONDS";
+	min: "MINUTES";
+	minute: "MINUTES";
+	minutes: "MINUTES";
+	hr: "HOURS";
+	hrs: "HOURS";
+	hour: "HOURS";
+	hours: "HOURS";
+	day: "DAYS";
+	days: "DAYS";
+	wk: "WEEKS";
+	week: "WEEKS";
+	weeks: "WEEKS";
+	mos: "MONTHS";
+	month: "MONTHS";
+	months: "MONTHS";
+	yr: "YEARS";
+	year: "YEARS";
+	years: "YEARS";
+};

package/build/types/mapping/PropertyValueMapping.d.ts

@@ -0,0 +1,55 @@
+import type { Attachment, AttachmentUpload } from "../object/Attachment.js";
+import type { Media } from "../object/Media.js";
+import type { GeotimeSeriesProperty, TimeSeriesProperty } from "../timeseries/timeseries.js";
+/**
+* Map from the PropertyDefinition type to the typescript type that we return
+*/
+export interface PropertyValueWireToClient {
+	attachment: Attachment;
+	boolean: boolean;
+	byte: number;
+	datetime: string;
+	decimal: string;
+	double: number;
+	float: number;
+	geopoint: GeoJSON.Point;
+	geoshape: GeoJSON.GeoJSON;
+	integer: number;
+	long: string;
+	marking: string;
+	mediaReference: Media;
+	short: number;
+	string: string;
+	timestamp: string;
+	numericTimeseries: TimeSeriesProperty<number>;
+	stringTimeseries: TimeSeriesProperty<string>;
+	sensorTimeseries: TimeSeriesProperty<string | number>;
+	geotimeSeriesReference: GeotimeSeriesProperty<GeoJSON.Point>;
+}
+export type GetClientPropertyValueFromWire<T extends keyof PropertyValueWireToClient | Record<string, keyof PropertyValueWireToClient>> = T extends keyof PropertyValueWireToClient ? PropertyValueWireToClient[T] : T extends Record<string, keyof PropertyValueWireToClient> ? { [K in keyof T] : PropertyValueWireToClient[T[K]] } : never;
+/**
+* Map from the PropertyDefinition type to the typescript type that we accept
+*/
+export interface PropertyValueClientToWire {
+	attachment: string | AttachmentUpload | Blob & { readonly name: string };
+	boolean: boolean;
+	byte: number;
+	datetime: string;
+	decimal: string | number;
+	double: number;
+	float: number;
+	geopoint: GeoJSON.Point;
+	geoshape: GeoJSON.GeoJSON;
+	integer: number;
+	long: string | number;
+	marking: string;
+	short: number;
+	string: string;
+	timestamp: string;
+	mediaReference: Media;
+	numericTimeseries: TimeSeriesProperty<number>;
+	stringTimeseries: TimeSeriesProperty<string>;
+	sensorTimeseries: TimeSeriesProperty<string | number>;
+	geotimeSeriesReference: GeotimeSeriesProperty<GeoJSON.Point>;
+}
+export type GetWirePropertyValueFromClient<T extends keyof PropertyValueClientToWire | Record<string, keyof PropertyValueClientToWire>> = T extends keyof PropertyValueClientToWire ? PropertyValueClientToWire[T] : T extends Record<string, keyof PropertyValueClientToWire> ? { [K in keyof T] : PropertyValueClientToWire[T[K]] } : never;

package/build/types/object/Attachment.d.ts

@@ -0,0 +1,21 @@
+export interface Attachment {
+	rid: string;
+	/**
+	* Fetches metadata for an attachment
+	*/
+	fetchMetadata(): Promise<AttachmentMetadata>;
+	/**
+	* Fetches actual content of attachment in Blob form
+	*/
+	fetchContents(): Promise<Response>;
+}
+export interface AttachmentUpload {
+	readonly name: string;
+	readonly data: Blob;
+}
+export interface AttachmentMetadata {
+	rid: string;
+	filename: string;
+	sizeBytes: number;
+	mediaType: string;
+}

package/build/types/object/FetchPageArgs.d.ts

@@ -0,0 +1,49 @@
+import type { ObjectOrInterfaceDefinition, PropertyKeys } from "../ontology/ObjectOrInterface.js";
+import type { CompileTimeMetadata } from "../ontology/ObjectTypeDefinition.js";
+export type NullabilityAdherence = false | "throw" | "drop";
+export declare namespace NullabilityAdherence {
+	type Default = "throw";
+}
+export interface SelectArg<
+	Q extends ObjectOrInterfaceDefinition,
+	L extends PropertyKeys<Q> = PropertyKeys<Q>,
+	R extends boolean = false,
+	S extends NullabilityAdherence = NullabilityAdherence.Default
+> {
+	$select?: readonly L[];
+	$includeRid?: R;
+}
+export interface OrderByArg<
+	Q extends ObjectOrInterfaceDefinition,
+	L extends PropertyKeys<Q> = PropertyKeys<Q>
+> {
+	$orderBy?: { [K in L]? : "asc" | "desc" };
+}
+export type SelectArgToKeys<
+	Q extends ObjectOrInterfaceDefinition,
+	A extends SelectArg<Q, any, any>
+> = A extends SelectArg<Q, never> ? PropertyKeys<Q> : A["$select"] extends readonly string[] ? A["$select"][number] : PropertyKeys<Q>;
+export interface FetchPageArgs<
+	Q extends ObjectOrInterfaceDefinition,
+	K extends PropertyKeys<Q> = PropertyKeys<Q>,
+	R extends boolean = false,
+	A extends Augments = never,
+	S extends NullabilityAdherence = NullabilityAdherence.Default
+> extends AsyncIterArgs<Q, K, R, A, S> {
+	$nextPageToken?: string;
+	$pageSize?: number;
+}
+export interface AsyncIterArgs<
+	Q extends ObjectOrInterfaceDefinition,
+	K extends PropertyKeys<Q> = PropertyKeys<Q>,
+	R extends boolean = false,
+	A extends Augments = never,
+	S extends NullabilityAdherence = NullabilityAdherence.Default
+> extends SelectArg<Q, K, R, S>, OrderByArg<Q, PropertyKeys<Q>> {
+	$__UNSTABLE_useOldInterfaceApis?: boolean;
+}
+export type Augment<
+	X extends ObjectOrInterfaceDefinition,
+	T extends string
+> = { [K in CompileTimeMetadata<X>["apiName"]] : T[] };
+export type Augments = Record<string, string[]>;

package/build/types/object/FetchPageResult.d.ts

@@ -0,0 +1,37 @@
+import type { ObjectOrInterfaceDefinition, PropertyKeys } from "../ontology/ObjectOrInterface.js";
+import type { ExtractOptions, IsNever, Osdk } from "../OsdkObjectFrom.js";
+import type { PageResult } from "../PageResult.js";
+import type { NullabilityAdherence } from "./FetchPageArgs.js";
+/** exposed for a test */
+export type RespectNullability<S extends NullabilityAdherence> = S extends false ? false : true;
+/** exposed for a test */
+export type UnionIfFalse<
+	S extends string,
+	JUST_S_IF_TRUE extends boolean,
+	E
+> = IsNever<S> extends true ? never : JUST_S_IF_TRUE extends true ? S : S | E;
+/** exposed for a test */
+export type UnionIfTrue<
+	S extends string,
+	UNION_IF_TRUE extends boolean,
+	E extends string
+> = IsNever<S> extends true ? never : UNION_IF_TRUE extends true ? S | E : S;
+/**
+* Helper type for converting fetch options into an Osdk object
+*/
+export type FetchPageResult<
+	Q extends ObjectOrInterfaceDefinition,
+	L extends PropertyKeys<Q>,
+	R extends boolean,
+	S extends NullabilityAdherence
+> = PageResult<PropertyKeys<Q> extends L ? Osdk.Instance<Q, ExtractOptions<R, S>> : Osdk.Instance<Q, ExtractOptions<R, S>, L>>;
+/**
+* Helper type for converting fetch options into an Osdk object
+*/
+export type SingleOsdkResult<
+	Q extends ObjectOrInterfaceDefinition,
+	L extends PropertyKeys<Q>,
+	R extends boolean,
+	S extends NullabilityAdherence
+> = Osdk.Instance<Q, ExtractOptions<R, S>, L>;
+export type IsAny<T> = unknown extends T ? [keyof T] extends [never] ? false : true : false;

package/build/types/object/Media.d.ts

@@ -0,0 +1,18 @@
+export interface Media {
+	/**
+	* Fetches metadata for media reference property
+	*/
+	fetchMetadata(): Promise<MediaMetadata>;
+	/**
+	* Fetches content of a media reference property
+	*/
+	fetchContents(): Promise<Response>;
+}
+/**
+* Metadata of a media item
+*/
+export interface MediaMetadata {
+	path?: string;
+	sizeBytes: number;
+	mediaType: string;
+}

package/build/types/object/ObjectDefinitions.test.d.ts

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

package/build/types/object/Result.d.ts

@@ -0,0 +1,21 @@
+export type ErrorResult = {
+	error: Error;
+	value?: never;
+};
+export type OkResult<V> = {
+	value: V;
+	error?: never;
+};
+export type Result<V> = OkResult<V> | ErrorResult;
+/**
+* Check if a result was successfully received
+* @param a - result wrapped value
+* @returns whether a result has a value in it
+*/
+export declare function isOk<X>(a: Result<X>): a is OkResult<X>;
+/**
+* Check if a result contains an error value
+* @param a Result wrapped value
+* @returns whether a result has an error in it
+*/
+export declare function isError<X>(a: Result<X>): a is ErrorResult;

package/build/{esm → types}/objectSet/BaseObjectSet.d.ts

@@ -1,7 +1,4 @@
 import type { ObjectOrInterfaceDefinition } from "../ontology/ObjectOrInterface.js";
 export interface BaseObjectSet<Q extends ObjectOrInterfaceDefinition> {
-    readonly $objectSetInternals: {
-        def: Q;
-    };
+	readonly $objectSetInternals: { def: Q };
 }
-//# sourceMappingURL=BaseObjectSet.d.ts.map