@osdk/api 2.1.0-beta.23 → 2.1.0-beta.25

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

package/build/types/objectSet/BulkLinkResult.d.ts

@@ -0,0 +1,7 @@
+import type { OsdkBase } from "../OsdkBase.js";
+export interface EXPERIMENTAL_BulkLinkResult {
+	object: OsdkBase<any>;
+	linkApiName: string;
+	otherObjectApiName: string | undefined;
+	otherObjectPk: unknown;
+}

package/build/types/objectSet/ObjectSet.d.ts

@@ -0,0 +1,170 @@
+import type { AggregateOpts } from "../aggregate/AggregateOpts.js";
+import type { AggregateOptsThatErrorsAndDisallowsOrderingWithMultipleGroupBy } from "../aggregate/AggregateOptsThatErrors.js";
+import type { AggregationsResults } from "../aggregate/AggregationsResults.js";
+import type { WhereClause } from "../aggregate/WhereClause.js";
+import type { AsyncIterArgs, Augments, FetchPageArgs, NullabilityAdherence, SelectArg } from "../object/FetchPageArgs.js";
+import type { SingleOsdkResult } from "../object/FetchPageResult.js";
+import type { Result } from "../object/Result.js";
+import type { InterfaceDefinition } from "../ontology/InterfaceDefinition.js";
+import type { ObjectOrInterfaceDefinition, PropertyKeys } from "../ontology/ObjectOrInterface.js";
+import type { CompileTimeMetadata, ObjectTypeDefinition } from "../ontology/ObjectTypeDefinition.js";
+import type { PrimaryKeyType } from "../OsdkBase.js";
+import type { ExtractOptions, Osdk } from "../OsdkObjectFrom.js";
+import type { PageResult } from "../PageResult.js";
+import type { LinkedType, LinkNames } from "../util/LinkUtils.js";
+import type { BaseObjectSet } from "./BaseObjectSet.js";
+import type { ObjectSetListener, ObjectSetListenerOptions } from "./ObjectSetListener.js";
+export interface MinimalObjectSet<Q extends ObjectOrInterfaceDefinition> extends BaseObjectSet<Q> {
+	/**
+	* Gets a page of objects of this type, with a result wrapper
+	* @param args - Args to specify next page token and page size, if applicable
+	* @example
+	*  const myObjs = await objectSet.fetchPage({
+	$pageSize: 10,
+	$nextPageToken: "nextPage"
+	});
+	const myObjsResult = myObjs.data;
+	
+	* @returns a page of objects
+	*/
+	readonly fetchPage: <
+		L extends PropertyKeys<Q>,
+		R extends boolean,
+		const A extends Augments,
+		S extends NullabilityAdherence = NullabilityAdherence.Default
+	>(args?: FetchPageArgs<Q, L, R, A, S>) => Promise<PageResult<PropertyKeys<Q> extends L ? Osdk.Instance<Q, ExtractOptions<R, S>> : Osdk.Instance<Q, ExtractOptions<R, S>, L>>>;
+	/**
+	* Gets a page of objects of this type, with a result wrapper
+	* @param args - Args to specify next page token and page size, if applicable
+	* @example
+	*  const myObjs = await objectSet.fetchPage({
+	$pageSize: 10,
+	$nextPageToken: "nextPage"
+	});
+	
+	if(isOk(myObjs)){
+	const myObjsResult = myObjs.value.data;
+	}
+	* @returns a page of objects, wrapped in a result wrapper
+	*/
+	readonly fetchPageWithErrors: <
+		L extends PropertyKeys<Q>,
+		R extends boolean,
+		const A extends Augments,
+		S extends NullabilityAdherence = NullabilityAdherence.Default
+	>(args?: FetchPageArgs<Q, L, R, A, S>) => Promise<Result<PageResult<Osdk.Instance<Q, ExtractOptions<R, S>, L>>>>;
+	/**
+	* Allows you to filter an object set with a given clause
+	* @param clause - Takes a filter clause
+	* @example
+	* await client(Office).where({
+	meetingRooms: { $contains: "Grand Central" },
+	meetingRoomCapacities: { $contains: 30 },
+	});
+	* @returns an objectSet
+	*/
+	readonly where: (clause: WhereClause<Q>) => this;
+	/**
+	* Returns an async iterator to load all objects of this type
+	* @example
+	* for await (const obj of myObjectSet.asyncIter()){
+	* // Handle obj
+	* }
+	* @returns an async iterator to load all objects
+	*/
+	readonly asyncIter: <
+		L extends PropertyKeys<Q>,
+		R extends boolean,
+		const A extends Augments,
+		S extends NullabilityAdherence = NullabilityAdherence.Default
+	>(args?: AsyncIterArgs<Q, L, R, A, S>) => AsyncIterableIterator<SingleOsdkResult<Q, L, R, S>>;
+}
+export interface InterfaceObjectSet<Q extends InterfaceDefinition> extends MinimalObjectSet<Q> {}
+export interface ObjectSet<
+	Q extends ObjectOrInterfaceDefinition = any,
+	_UNUSED = any
+> extends MinimalObjectSet<Q> {
+	/**
+	* Aggregate on a field in an object type
+	* @param req - an aggregation request where you can select fields and choose how to aggregate, e.g., max, min, avg, and also choose
+	* whether or not you order your results. You can also specify a groupBy field to group your aggregations
+	* @example
+	* const testAggregateCountWithGroups = await client(BoundariesUsState)
+	.aggregate({
+	$select: {
+	$count: "unordered",
+	"latitude:max": "unordered",
+	"latitude:min": "unordered",
+	"latitude:avg": "unordered",
+	},
+	$groupBy: {
+	usState: "exact",
+	longitude: {
+	$fixedWidth: 10,
+	},
+	},
+	});
+	
+	* @returns aggregation results, sorted in the groups based on the groupBy clause (if applicable)
+	*/
+	readonly aggregate: <AO extends AggregateOpts<Q>>(req: AggregateOptsThatErrorsAndDisallowsOrderingWithMultipleGroupBy<Q, AO>) => Promise<AggregationsResults<Q, AO>>;
+	/**
+	* Unions object sets together
+	* @param objectSets - objectSets you want to union with
+	* @example
+	* const unionObjectSet = complexFilteredEmployeeObjectSet.union(
+	simpleFilteredEmployeeObjectSet,
+	);
+	* @returns the unioned object set
+	*/
+	readonly union: (...objectSets: ReadonlyArray<CompileTimeMetadata<Q>["objectSet"]>) => this;
+	/**
+	* Computes the intersection of object sets
+	* @param objectSets - objectSets you want to intersect with
+	* @example
+	* const intersectedObjectSet = complexFilteredEmployeeObjectSet.intersect(
+	simpleFilteredEmployeeObjectSet,
+	);
+	* @returns the intersected object set
+	*/
+	readonly intersect: (...objectSets: ReadonlyArray<CompileTimeMetadata<Q>["objectSet"]>) => this;
+	/**
+	* Computes the subtraction of object sets
+	* @param objectSets - objectSets you want to subtract from
+	* @example
+	* const subtractObjectSet = complexFilteredEmployeeObjectSet.subtract(
+	simpleFilteredEmployeeObjectSet,
+	);
+	* @returns the subtract object set
+	*/
+	readonly subtract: (...objectSets: ReadonlyArray<CompileTimeMetadata<Q>["objectSet"]>) => this;
+	/**
+	* Pivots the object set over to all its linked objects of the specified type
+	* @param type - The linked object type you want to pivot to
+	* @returns an object set of the specified linked type
+	*/
+	readonly pivotTo: <L extends LinkNames<Q>>(type: L) => CompileTimeMetadata<LinkedType<Q, L>>["objectSet"];
+	/**
+	* Fetches one object with the specified primary key, without a result wrapper
+	*/
+	readonly fetchOne: Q extends ObjectTypeDefinition ? <
+		const L extends PropertyKeys<Q>,
+		const R extends boolean,
+		const S extends false | "throw" = NullabilityAdherence.Default
+	>(primaryKey: PrimaryKeyType<Q>, options?: SelectArg<Q, L, R, S>) => Promise<Osdk.Instance<Q, ExtractOptions<R, S>, L>> : never;
+	/**
+	* Fetches one object with the specified primary key, with a result wrapper
+	*/
+	readonly fetchOneWithErrors: Q extends ObjectTypeDefinition ? <
+		L extends PropertyKeys<Q>,
+		R extends boolean,
+		S extends false | "throw" = NullabilityAdherence.Default
+	>(primaryKey: PrimaryKeyType<Q>, options?: SelectArg<Q, L, R, S>) => Promise<Result<Osdk.Instance<Q, ExtractOptions<R, S>, L>>> : never;
+	/**
+	* Request updates when the objects in an object set are added, updated, or removed.
+	* @param listener - The handlers to be executed during the lifecycle of the subscription.
+	* @param opts - Options to modify what properties are returned on subscription updates.
+	* @returns an object containing a function to unsubscribe.
+	*/
+	readonly subscribe: <const P extends PropertyKeys<Q>>(listener: ObjectSetListener<Q, P>, opts?: ObjectSetListenerOptions<Q, P>) => { unsubscribe: () => void };
+}

package/build/types/objectSet/ObjectSetListener.d.ts

@@ -0,0 +1,47 @@
+import type { ObjectOrInterfaceDefinition, PropertyKeys } from "../ontology/ObjectOrInterface.js";
+import type { Osdk } from "../OsdkObjectFrom.js";
+export interface ObjectSetListener<
+	O extends ObjectOrInterfaceDefinition,
+	P extends PropertyKeys<O> = PropertyKeys<O>
+> {
+	/**
+	* Specific objects have changed and can be immediately updated
+	*/
+	onChange?: (objectUpdate: ObjectUpdate<O, P>) => void;
+	/**
+	* The subscription has been successfully established and updates can be expected to be received.
+	*/
+	onSuccessfulSubscription?: () => void;
+	/**
+	* The ObjectSet has become outdated and should be re-fetched in its entirety.
+	* This is also sent when the subscription is first initialized.
+	*/
+	onOutOfDate?: () => void;
+	/**
+	* There was a fatal error with the subscription process. The subscription will close or will not be established.
+	*/
+	onError?: (errors: {
+		subscriptionClosed: boolean;
+		error: any;
+	}) => void;
+}
+type ObjectUpdate<
+	O extends ObjectOrInterfaceDefinition,
+	P extends PropertyKeys<O>
+> = {
+	object: Osdk.Instance<O, never, P>;
+	state: "ADDED_OR_UPDATED" | "REMOVED";
+};
+/**
+* Options for subscribing to an ObjectSet.
+*
+* properties - The properties to request a subscription for. Requesting specific properties limits the possible properties
+* that can be returned from the subscription. If not provided, all properties will be requested and potentially be returned on updates.
+*/
+export interface ObjectSetListenerOptions<
+	O extends ObjectOrInterfaceDefinition,
+	P extends PropertyKeys<O> = PropertyKeys<O>
+> {
+	properties?: Array<P>;
+}
+export {};

package/build/types/ontology/ActionDefinition.d.ts

@@ -0,0 +1,55 @@
+import type { OsdkMetadata } from "../OsdkMetadata.js";
+import type { InterfaceDefinition } from "./InterfaceDefinition.js";
+import type { ObjectTypeDefinition, ReleaseStatus } from "./ObjectTypeDefinition.js";
+export interface ActionMetadata {
+	type: "action";
+	apiName: string;
+	description?: string;
+	displayName?: string;
+	parameters: Record<any, ActionMetadata.Parameter<any>>;
+	modifiedEntities?: Partial<Record<any, {
+		created: boolean;
+		modified: boolean;
+	}>>;
+	status: ReleaseStatus;
+	rid: string;
+}
+export declare namespace ActionMetadata {
+	interface Parameter<T_Target extends ObjectTypeDefinition = never> {
+		type: ValidBaseActionParameterTypes | DataType.Object<any> | DataType.ObjectSet<any> | DataType.Interface<any> | DataType.Struct<any>;
+		description?: string;
+		multiplicity?: boolean;
+		nullable?: boolean;
+	}
+	namespace DataType {
+		interface Object<T_Target extends ObjectTypeDefinition = never> {
+			__OsdkTargetType?: T_Target;
+			type: "object";
+			object: T_Target["apiName"];
+		}
+		interface Interface<T_Target extends InterfaceDefinition = never> {
+			__OsdkTargetType?: T_Target;
+			type: "interface";
+			interface: T_Target["apiName"];
+		}
+		interface ObjectSet<T_Target extends ObjectTypeDefinition = never> {
+			__OsdkTargetType?: T_Target;
+			type: "objectSet";
+			objectSet: T_Target["apiName"];
+		}
+		interface Struct<T extends Record<string, ValidBaseActionParameterTypes>> {
+			type: "struct";
+			struct: T;
+		}
+	}
+}
+export interface ActionCompileTimeMetadata<T> {
+	signatures: T;
+}
+export interface ActionDefinition<T_signatures = never> {
+	type: "action";
+	apiName: string;
+	osdkMetadata?: OsdkMetadata;
+	__DefinitionMetadata?: ActionCompileTimeMetadata<T_signatures> & ActionMetadata;
+}
+export type ValidBaseActionParameterTypes = "boolean" | "string" | "integer" | "long" | "double" | "datetime" | "timestamp" | "attachment" | "marking" | "objectType";

package/build/{esm → types}/ontology/InterfaceDefinition.d.ts

@@ -1,12 +1,12 @@
 import type { OsdkMetadata } from "../OsdkMetadata.js";
 import type { ObjectInterfaceBaseMetadata, ObjectInterfaceCompileDefinition } from "./ObjectTypeDefinition.js";
 export interface InterfaceMetadata extends ObjectInterfaceBaseMetadata {
-    type: "interface";
+	type: "interface";
+	implementedBy?: ReadonlyArray<string>;
 }
 export interface InterfaceDefinition {
-    type: "interface";
-    apiName: string;
-    osdkMetadata?: OsdkMetadata;
-    __DefinitionMetadata?: InterfaceMetadata & ObjectInterfaceCompileDefinition;
+	type: "interface";
+	apiName: string;
+	osdkMetadata?: OsdkMetadata;
+	__DefinitionMetadata?: InterfaceMetadata & ObjectInterfaceCompileDefinition;
 }
-//# sourceMappingURL=InterfaceDefinition.d.ts.map

package/build/{browser → types}/ontology/ObjectOrInterface.d.ts

@@ -2,4 +2,3 @@ import type { InterfaceDefinition } from "./InterfaceDefinition.js";
 import type { ObjectTypeDefinition } from "./ObjectTypeDefinition.js";
 export type ObjectOrInterfaceDefinition = ObjectTypeDefinition | InterfaceDefinition;
 export type PropertyKeys<O extends ObjectOrInterfaceDefinition> = keyof NonNullable<O["__DefinitionMetadata"]>["properties"] & string;
-//# sourceMappingURL=ObjectOrInterface.d.ts.map

package/build/types/ontology/ObjectTypeDefinition.d.ts

@@ -0,0 +1,85 @@
+import type { OsdkMetadata } from "../OsdkMetadata.js";
+import type { ObjectOrInterfaceDefinition, PropertyKeys } from "./ObjectOrInterface.js";
+import type { PrimaryKeyTypes } from "./PrimaryKeyTypes.js";
+import type { VersionString } from "./VersionString.js";
+import type { WirePropertyTypes } from "./WirePropertyTypes.js";
+export type CompileTimeMetadata<T extends { __DefinitionMetadata?: {} }> = NonNullable<T["__DefinitionMetadata"]>;
+export type ObjectTypePropertyDefinitionFrom2<
+	Q extends ObjectOrInterfaceDefinition,
+	P extends PropertyKeys<Q>
+> = CompileTimeMetadata<Q>["properties"][P];
+export type ObjectInterfaceBaseMetadata = {
+	type: "object" | "interface";
+	apiName: string;
+	displayName: string;
+	description?: string;
+	properties: Record<any, ObjectMetadata.Property>;
+	links: Record<string, ObjectMetadata.Link<any, any>>;
+	rid: string;
+	implements?: ReadonlyArray<string>;
+};
+export interface ObjectInterfaceCompileDefinition {
+	type: "object" | "interface";
+	objectSet?: any;
+	props?: any;
+	strictProps?: any;
+	linksType?: any;
+}
+export interface VersionBound<V extends VersionString<any, any, any>> {
+	__expectedClientVersion?: V;
+}
+export interface ObjectMetadata extends ObjectInterfaceBaseMetadata {
+	type: "object";
+	primaryKeyApiName: keyof this["properties"];
+	titleProperty: keyof this["properties"];
+	primaryKeyType: PrimaryKeyTypes;
+	icon?: Icon;
+	visibility?: ObjectTypeVisibility;
+	pluralDisplayName: string;
+	status: ReleaseStatus;
+	interfaceMap: Record<string, Record<string, string>>;
+	inverseInterfaceMap: Record<string, Record<string, string>>;
+}
+export declare namespace ObjectMetadata {
+	interface Property {
+		readonly?: boolean;
+		displayName?: string;
+		description?: string;
+		type: WirePropertyTypes;
+		multiplicity?: boolean;
+		nullable?: boolean;
+	}
+	interface Link<
+		Q extends ObjectTypeDefinition,
+		M extends boolean
+	> {
+		__OsdkLinkTargetType?: Q;
+		targetType: Q["apiName"];
+		multiplicity: M;
+	}
+}
+export interface ObjectTypeDefinition {
+	type: "object";
+	apiName: string;
+	osdkMetadata?: OsdkMetadata;
+	__DefinitionMetadata?: ObjectMetadata & ObjectInterfaceCompileDefinition;
+}
+export type ObjectTypeLinkKeysFrom2<Q extends ObjectTypeDefinition> = keyof CompileTimeMetadata<Q>["links"] & string;
+export interface PropertyDef<
+	T extends WirePropertyTypes,
+	N extends "nullable" | "non-nullable" = "nullable",
+	M extends "array" | "single" = "single"
+> extends ObjectMetadata.Property {
+	type: T;
+	multiplicity: M extends "array" ? true : false;
+	nullable: N extends "nullable" ? true : false;
+}
+export type ReleaseStatus = "ACTIVE" | "EXPERIMENTAL" | "DEPRECATED";
+type ObjectTypeVisibility = "NORMAL" | "PROMINENT" | "HIDDEN";
+type BlueprintIcon = {
+	type: "blueprint";
+	color: string;
+	name: string;
+};
+type Icon = BlueprintIcon;
+export {};

package/build/types/ontology/OntologyMetadata.d.ts

@@ -0,0 +1,6 @@
+export interface OntologyMetadata<_NEVER_USED_KEPT_FOR_BACKCOMPAT = any> {
+	expectsClientVersion?: _NEVER_USED_KEPT_FOR_BACKCOMPAT;
+	ontologyRid: string;
+	ontologyApiName: string;
+	userAgent: string;
+}

package/build/{browser → types}/ontology/PrimaryKeyTypes.d.ts

@@ -1,2 +1 @@
 export type PrimaryKeyTypes = "string" | "datetime" | "double" | "boolean" | "integer" | "timestamp" | "short" | "long" | "byte";
-//# sourceMappingURL=PrimaryKeyTypes.d.ts.map

package/build/{esm → types}/ontology/QueryDefinition.d.ts

@@ -1,68 +1,65 @@
 import type { OsdkMetadata } from "../OsdkMetadata.js";
 import type { ObjectTypeDefinition } from "./ObjectTypeDefinition.js";
 export interface QueryMetadata {
-    type: "query";
-    apiName: string;
-    description?: string;
-    displayName?: string;
-    version: string;
-    parameters: Record<string, QueryParameterDefinition<any>>;
-    output: QueryDataTypeDefinition;
-    rid: string;
+	type: "query";
+	apiName: string;
+	description?: string;
+	displayName?: string;
+	version: string;
+	parameters: Record<string, QueryParameterDefinition<any>>;
+	output: QueryDataTypeDefinition;
+	rid: string;
 }
 export interface QueryCompileTimeMetadata<T> {
-    signature: T;
+	signature: T;
 }
 export interface QueryDefinition<T = any> {
-    type: "query";
-    apiName: string;
-    osdkMetadata?: OsdkMetadata;
-    __DefinitionMetadata?: QueryCompileTimeMetadata<T> & QueryMetadata;
+	type: "query";
+	apiName: string;
+	osdkMetadata?: OsdkMetadata;
+	__DefinitionMetadata?: QueryCompileTimeMetadata<T> & QueryMetadata;
 }
-export type QueryParameterDefinition<T_Target extends ObjectTypeDefinition = any> = {
-    description?: string;
-} & QueryDataTypeDefinition<T_Target>;
+export type QueryParameterDefinition<T_Target extends ObjectTypeDefinition = any> = { description?: string } & QueryDataTypeDefinition<T_Target>;
 export type QueryDataTypeDefinition<T_Target extends ObjectTypeDefinition = any> = PrimitiveDataType | ObjectQueryDataType<T_Target> | ObjectSetQueryDataType<T_Target> | SetQueryDataType | UnionQueryDataType | StructQueryDataType | TwoDimensionalAggregationDataType | ThreeDimensionalAggregationDataType;
 export type BaseQueryDataTypeDefinition<T extends string> = {
-    multiplicity?: boolean;
-    nullable?: boolean;
-    type: T;
+	multiplicity?: boolean;
+	nullable?: boolean;
+	type: T;
 };
 export type WireQueryDataTypes = "double" | "float" | "integer" | "long" | "boolean" | "string" | "date" | "timestamp" | "attachment";
 export type PrimitiveDataType<Q extends WireQueryDataTypes = WireQueryDataTypes> = BaseQueryDataTypeDefinition<Q>;
 export interface ObjectQueryDataType<T_Target extends ObjectTypeDefinition = never> extends BaseQueryDataTypeDefinition<"object"> {
-    object: string;
-    __OsdkTargetType?: T_Target;
+	object: string;
+	__OsdkTargetType?: T_Target;
 }
 export interface ObjectSetQueryDataType<T_Target extends ObjectTypeDefinition = never> extends BaseQueryDataTypeDefinition<"objectSet"> {
-    objectSet: string;
-    __OsdkTargetType?: T_Target;
+	objectSet: string;
+	__OsdkTargetType?: T_Target;
 }
 export interface SetQueryDataType extends BaseQueryDataTypeDefinition<"set"> {
-    set: QueryDataTypeDefinition;
+	set: QueryDataTypeDefinition;
 }
 export interface UnionQueryDataType extends BaseQueryDataTypeDefinition<"union"> {
-    union: ReadonlyArray<QueryDataTypeDefinition>;
+	union: ReadonlyArray<QueryDataTypeDefinition>;
 }
 export interface StructQueryDataType extends BaseQueryDataTypeDefinition<"struct"> {
-    struct: Record<string, QueryDataTypeDefinition>;
+	struct: Record<string, QueryDataTypeDefinition>;
 }
 export interface TwoDimensionalAggregationDataType extends BaseQueryDataTypeDefinition<"twoDimensionalAggregation"> {
-    twoDimensionalAggregation: TwoDimensionalQueryAggregationDefinition;
+	twoDimensionalAggregation: TwoDimensionalQueryAggregationDefinition;
 }
 export interface ThreeDimensionalAggregationDataType extends BaseQueryDataTypeDefinition<"threeDimensionalAggregation"> {
-    threeDimensionalAggregation: ThreeDimensionalQueryAggregationDefinition;
+	threeDimensionalAggregation: ThreeDimensionalQueryAggregationDefinition;
 }
 export type AggregationKeyDataType<V = any> = SimpleAggregationKeyDataType<V> | RangeAggregationKeyDataType<V>;
 export interface SimpleAggregationKeyDataType<V = any> {
-    keyType: "boolean" | "string";
-    valueType: V;
+	keyType: "boolean" | "string";
+	valueType: V;
 }
 export interface RangeAggregationKeyDataType<V = any> {
-    keyType: "range";
-    keySubtype: "date" | "double" | "integer" | "timestamp";
-    valueType: V;
+	keyType: "range";
+	keySubtype: "date" | "double" | "integer" | "timestamp";
+	valueType: V;
 }
 export type TwoDimensionalQueryAggregationDefinition = AggregationKeyDataType<"date" | "double" | "timestamp">;
 export type ThreeDimensionalQueryAggregationDefinition = AggregationKeyDataType<TwoDimensionalQueryAggregationDefinition>;
-//# sourceMappingURL=QueryDefinition.d.ts.map

package/build/types/ontology/VersionString.d.ts

@@ -0,0 +1,5 @@
+export type VersionString<
+	Major extends number,
+	Minor extends number,
+	Patch extends number
+> = `${Major}.${Minor}.${Patch}`;

package/build/{esm → types}/ontology/WirePropertyTypes.d.ts

@@ -1,3 +1,2 @@
 export type WirePropertyTypes = SimpleWirePropertyTypes | Record<string, SimpleWirePropertyTypes>;
 export type SimpleWirePropertyTypes = "string" | "datetime" | "double" | "boolean" | "integer" | "timestamp" | "short" | "long" | "float" | "decimal" | "byte" | "marking" | "mediaReference" | "numericTimeseries" | "stringTimeseries" | "sensorTimeseries" | "attachment" | "geopoint" | "geoshape" | "geotimeSeriesReference";
-//# sourceMappingURL=WirePropertyTypes.d.ts.map

package/build/{browser → types}/public/unstable.d.ts

@@ -1,7 +1,6 @@
-export type { Experiment, ExperimentFns } from "../experimental/Experiment.js";
+export type  { Experiment, ExperimentFns } from "../experimental/Experiment.js";
 export { __EXPERIMENTAL__NOT_SUPPORTED_YET__fetchOneByRid } from "../experimental/fetchOneByRid.js";
 export { __EXPERIMENTAL__NOT_SUPPORTED_YET__getBulkLinks } from "../experimental/getBulkLinks.js";
 export { __EXPERIMENTAL__NOT_SUPPORTED_YET_subscribe } from "../experimental/subscribe.js";
-export type { EXPERIMENTAL_BulkLinkResult } from "../objectSet/BulkLinkResult.js";
-export type { MinimalObjectSet } from "../objectSet/ObjectSet.js";
-//# sourceMappingURL=unstable.d.ts.map
+export type  { EXPERIMENTAL_BulkLinkResult } from "../objectSet/BulkLinkResult.js";
+export type  { MinimalObjectSet } from "../objectSet/ObjectSet.js";

package/build/types/queries/Queries.d.ts

@@ -0,0 +1,21 @@
+import type { DataValueClientToWire, DataValueWireToClient } from "../mapping/DataValueMapping.js";
+import type { ObjectSet } from "../objectSet/ObjectSet.js";
+import type { ObjectTypeDefinition } from "../ontology/ObjectTypeDefinition.js";
+import type { OsdkBase } from "../OsdkBase.js";
+import type { OsdkObjectPrimaryKeyType } from "../OsdkObjectPrimaryKeyType.js";
+/**
+* Helper types for converting query definition parameter types to typescript types
+*/
+export declare namespace QueryParam {
+	type PrimitiveType<T extends keyof DataValueClientToWire> = DataValueClientToWire[T];
+	type ObjectType<T extends ObjectTypeDefinition> = OsdkBase<T> | OsdkObjectPrimaryKeyType<T>;
+	type ObjectSetType<T extends ObjectTypeDefinition> = ObjectSet<T>;
+}
+/**
+* Helper types for converting query result types to typescript types
+*/
+export declare namespace QueryResult {
+	type PrimitiveType<T extends keyof DataValueClientToWire> = DataValueWireToClient[T];
+	type ObjectType<T extends ObjectTypeDefinition> = OsdkBase<T>;
+	type ObjectSetType<T extends ObjectTypeDefinition> = ObjectSet<T>;
+}