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

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

@@ -0,0 +1,215 @@
+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 { DerivedProperty } from "../derivedProperties/DerivedProperty.js";
+import type { AsyncIterArgs, Augments, FetchPageArgs, NullabilityAdherence, SelectArg } from "../object/FetchPageArgs.js";
+import type { Result } from "../object/Result.js";
+import type { DerivedObjectOrInterfaceDefinition, ObjectOrInterfaceDefinition, PropertyKeys } from "../ontology/ObjectOrInterface.js";
+import type { CompileTimeMetadata, ObjectTypeDefinition } from "../ontology/ObjectTypeDefinition.js";
+import type { SimplePropertyDef } from "../ontology/SimplePropertyDef.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 { ObjectSetSubscription } from "./ObjectSetListener.js";
+type MergeObjectSet<
+	Q extends ObjectOrInterfaceDefinition,
+	D extends ObjectSet<Q> | Record<string, SimplePropertyDef> = {}
+> = D extends Record<string, SimplePropertyDef> ? DerivedObjectOrInterfaceDefinition.WithDerivedProperties<Q, D> : Q;
+type ExtractRdp<D extends ObjectSet<any, any> | Record<string, SimplePropertyDef>> = D extends Record<string, SimplePropertyDef> ? D : {};
+export interface MinimalObjectSet<
+	Q extends ObjectOrInterfaceDefinition,
+	RDPs extends Record<string, SimplePropertyDef> = {}
+> extends BaseObjectSet<Q>, FetchPage<Q, RDPs>, AsyncIter<Q, RDPs>, Where<Q, RDPs> {}
+interface FetchPage<
+	Q extends ObjectOrInterfaceDefinition,
+	RDPs extends Record<string, SimplePropertyDef> = {}
+> {
+	/**
+	* 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, RDPs>,
+		R extends boolean,
+		const A extends Augments,
+		S extends NullabilityAdherence = NullabilityAdherence.Default
+	>(args?: FetchPageArgs<Q, L, R, A, S>) => Promise<PageResult<Osdk.Instance<Q, ExtractOptions<R, S>, PropertyKeys<Q> extends L ? PropertyKeys<Q> : PropertyKeys<Q> & L, { [K in Extract<keyof RDPs, L>] : RDPs[K] }>>>;
+	/**
+	* 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, RDPs>,
+		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>, PropertyKeys<Q> extends L ? PropertyKeys<Q> : PropertyKeys<Q> & L, { [K in Extract<keyof RDPs, L>] : RDPs[K] }>>>>;
+}
+interface Where<
+	Q extends ObjectOrInterfaceDefinition,
+	RDPs extends Record<string, SimplePropertyDef> = {}
+> {
+	/**
+	* 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<MergeObjectSet<Q, RDPs>>) => this;
+}
+interface AsyncIter<
+	Q extends ObjectOrInterfaceDefinition,
+	RDPs extends Record<string, SimplePropertyDef> = {}
+> {
+	/**
+	* 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, RDPs>,
+		R extends boolean,
+		const A extends Augments,
+		S extends NullabilityAdherence = NullabilityAdherence.Default
+	>(args?: AsyncIterArgs<Q, L, R, A, S>) => AsyncIterableIterator<Osdk.Instance<Q, ExtractOptions<R, S>, PropertyKeys<Q> extends L ? PropertyKeys<Q> : PropertyKeys<Q> & L, { [K in Extract<keyof RDPs, L>] : RDPs[K] }>>;
+}
+interface WithProperties<
+	Q extends ObjectOrInterfaceDefinition = any,
+	RDPs extends Record<string, SimplePropertyDef> = {}
+> {
+	readonly withProperties: <NEW extends Record<string, SimplePropertyDef>>(clause: { [K in keyof NEW] : DerivedProperty.Selector<Q, NEW[K]> }) => ObjectSet<Q, { [NN in keyof NEW | keyof RDPs] : NN extends keyof NEW ? NEW[NN] : NN extends keyof RDPs ? RDPs[NN] : never }>;
+}
+export interface ObjectSet<
+	Q extends ObjectOrInterfaceDefinition = any,
+	UNUSED_OR_RDP extends ObjectSet<Q, any> | Record<string, SimplePropertyDef> = ObjectSet<Q, any>
+> extends ObjectSetCleanedTypes<Q, ExtractRdp<UNUSED_OR_RDP>, MergeObjectSet<Q, UNUSED_OR_RDP>> {}
+interface Aggregate<Q extends ObjectOrInterfaceDefinition> {
+	/**
+	* 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>>;
+}
+interface SetArithmetic<Q extends ObjectOrInterfaceDefinition> {
+	/**
+	* 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;
+}
+interface PivotTo<Q extends ObjectOrInterfaceDefinition> {
+	/**
+	* 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"];
+}
+interface FetchOne<
+	Q extends ObjectOrInterfaceDefinition,
+	RDPs extends Record<string, SimplePropertyDef>
+> {
+	/**
+	* Fetches one object with the specified primary key, without a result wrapper
+	*/
+	readonly fetchOne: Q extends ObjectTypeDefinition ? <
+		const L extends PropertyKeys<Q, RDPs>,
+		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>, PropertyKeys<Q> extends L ? PropertyKeys<Q> : PropertyKeys<Q> & L, { [K in Extract<keyof RDPs, L>] : RDPs[K] }>> : never;
+	/**
+	* Fetches one object with the specified primary key, with a result wrapper
+	*/
+	readonly fetchOneWithErrors: Q extends ObjectTypeDefinition ? <
+		L extends PropertyKeys<Q, RDPs>,
+		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>, PropertyKeys<Q> extends L ? PropertyKeys<Q> : PropertyKeys<Q> & L, { [K in Extract<keyof RDPs, L>] : RDPs[K] }>>> : never;
+}
+interface Subscribe<Q extends ObjectOrInterfaceDefinition> {
+	/**
+	* 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: ObjectSetSubscription.Listener<Q, P>, opts?: ObjectSetSubscription.Options<Q, P>) => { unsubscribe: () => void };
+}
+interface ObjectSetCleanedTypes<
+	Q extends ObjectOrInterfaceDefinition,
+	D extends Record<string, SimplePropertyDef>,
+	MERGED extends ObjectOrInterfaceDefinition
+> extends MinimalObjectSet<Q, D>, WithProperties<Q, D>, Aggregate<MERGED>, SetArithmetic<MERGED>, PivotTo<MERGED>, FetchOne<Q, D>, Subscribe<MERGED> {}
+export {};

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

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

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

@@ -0,0 +1,43 @@
+import type { ObjectOrInterfaceDefinition, PropertyKeys } from "../ontology/ObjectOrInterface.js";
+import type { Osdk } from "../OsdkObjectFrom.js";
+export declare namespace ObjectSetSubscription {
+	interface Listener<
+		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;
+	}
+	interface Options<
+		O extends ObjectOrInterfaceDefinition,
+		P extends PropertyKeys<O> = PropertyKeys<O>
+	> {
+		properties?: Array<P>;
+	}
+}
+type ObjectUpdate<
+	O extends ObjectOrInterfaceDefinition,
+	P extends PropertyKeys<O>
+> = {
+	object: Osdk.Instance<O, never, P>;
+	state: "ADDED_OR_UPDATED" | "REMOVED";
+};
+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: DataType.BaseActionParameterTypes | DataType.Object<any> | DataType.ObjectSet<any> | DataType.Interface<any> | DataType.Struct<any>;
+		description?: string;
+		multiplicity?: boolean;
+		nullable?: boolean;
+	}
+	namespace DataType {
+		type BaseActionParameterTypes = "boolean" | "string" | "integer" | "long" | "double" | "datetime" | "timestamp" | "attachment" | "marking" | "mediaReference" | "objectType";
+		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, DataType.BaseActionParameterTypes>> {
+			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;
+}

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/types/ontology/ObjectOrInterface.d.ts

@@ -0,0 +1,17 @@
+import type { InterfaceDefinition } from "./InterfaceDefinition.js";
+import type { ObjectTypeDefinition } from "./ObjectTypeDefinition.js";
+import type { SimplePropertyDef } from "./SimplePropertyDef.js";
+export type ObjectOrInterfaceDefinition = ObjectTypeDefinition | InterfaceDefinition;
+export declare namespace DerivedObjectOrInterfaceDefinition {
+	type WithDerivedProperties<
+		K extends ObjectOrInterfaceDefinition,
+		D extends Record<string, SimplePropertyDef>
+	> = { __DefinitionMetadata: {
+		properties: { [T in keyof D] : SimplePropertyDef.ToPropertyDef<D[T]> };
+		props: { [T in keyof D] : SimplePropertyDef.ToRuntimeProperty<D[T]> };
+	} } & K;
+}
+export type PropertyKeys<
+	O extends ObjectOrInterfaceDefinition,
+	RDPs extends Record<string, SimplePropertyDef> = {}
+> = (keyof NonNullable<O["__DefinitionMetadata"]>["properties"] | keyof RDPs) & string;

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/{browser → 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/SimplePropertyDef.d.ts

@@ -0,0 +1,18 @@
+import type { GetClientPropertyValueFromWire } from "../mapping/PropertyValueMapping.js";
+import type { ObjectMetadata, PropertyDef } from "./ObjectTypeDefinition.js";
+import type { WirePropertyTypes } from "./WirePropertyTypes.js";
+export type SimplePropertyDef = WirePropertyTypes | undefined | Array<WirePropertyTypes>;
+export declare namespace SimplePropertyDef {
+	type Make<
+		T extends WirePropertyTypes,
+		N extends boolean | undefined,
+		M extends boolean | undefined
+	> = M extends true ? N extends true ? Array<T> | undefined : Array<T> : N extends true ? T | undefined : T;
+	type FromPropertyMetadata<P extends ObjectMetadata.Property> = Make<P["type"], P["nullable"], P["multiplicity"]>;
+	type ExtractMultiplicity<T extends WirePropertyTypes | undefined | Array<WirePropertyTypes>> = NonNullable<T> extends Array<any> ? "array" : "single";
+	type ExtractWirePropertyType<T extends SimplePropertyDef> = T extends Array<infer Z> ? NonNullable<Z> : NonNullable<T>;
+	type ExtractNullable<T extends SimplePropertyDef> = [undefined] extends [T] ? "nullable" : [[undefined]] extends [T] ? "nullable" : "non-nullable";
+	type ToPropertyDef<S extends SimplePropertyDef> = PropertyDef<SimplePropertyDef.ExtractWirePropertyType<S>, SimplePropertyDef.ExtractNullable<S>, SimplePropertyDef.ExtractMultiplicity<S>>;
+	type ExtractRuntimeBaseType<S extends SimplePropertyDef> = GetClientPropertyValueFromWire<SimplePropertyDef.ExtractWirePropertyType<S>>;
+	type ToRuntimeProperty<S extends SimplePropertyDef> = ExtractMultiplicity<S> extends "array" ? ExtractNullable<S> extends "nullable" ? Array<ExtractRuntimeBaseType<S>> | undefined : Array<ExtractRuntimeBaseType<S>> : ExtractNullable<S> extends "nullable" ? ExtractRuntimeBaseType<S> | undefined : ExtractRuntimeBaseType<S>;
+}

package/build/types/ontology/SimplePropertyDef.test.d.ts

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

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/types/ontology/WirePropertyTypes.d.ts

@@ -0,0 +1,2 @@
+export type WirePropertyTypes = BaseWirePropertyTypes | Record<string, BaseWirePropertyTypes>;
+export type BaseWirePropertyTypes = "string" | "datetime" | "double" | "boolean" | "integer" | "timestamp" | "short" | "long" | "float" | "decimal" | "byte" | "marking" | "mediaReference" | "numericTimeseries" | "stringTimeseries" | "sensorTimeseries" | "attachment" | "geopoint" | "geoshape" | "geotimeSeriesReference";

package/build/types/public/unstable.d.ts

@@ -0,0 +1,6 @@
+export type  { Experiment, ExperimentFns } from "../experimental/Experiment.js";
+export { __EXPERIMENTAL__NOT_SUPPORTED_YET__createMediaReference } from "../experimental/createMediaReference.js";
+export { __EXPERIMENTAL__NOT_SUPPORTED_YET__fetchOneByRid } from "../experimental/fetchOneByRid.js";
+export { __EXPERIMENTAL__NOT_SUPPORTED_YET__getBulkLinks } from "../experimental/getBulkLinks.js";
+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>;
+}