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

package/build/esm/timeseries/timeseries.js

@@ -13,6 +13,7 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
+
 import { TimeDurationMapping } from "../mapping/DurationMapping.js";
 export const TimeseriesDurationMapping = {
   "ms": "MILLISECONDS",

package/build/esm/timeseries/timeseries.js.map

@@ -1 +1 @@
-{"version":3,"file":"timeseries.js","names":["TimeDurationMapping","TimeseriesDurationMapping"],"sources":["timeseries.js"],"sourcesContent":["/*\n * Copyright 2024 Palantir Technologies, Inc. All rights reserved.\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *     http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\nimport { TimeDurationMapping } from \"../mapping/DurationMapping.js\";\nexport const TimeseriesDurationMapping = {\n    \"ms\": \"MILLISECONDS\",\n    \"milliseconds\": \"MILLISECONDS\",\n    ...TimeDurationMapping,\n};\n"],"mappings":"AAAA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,SAASA,mBAAmB,QAAQ,+BAA+B;AACnE,OAAO,MAAMC,yBAAyB,GAAG;EACrC,IAAI,EAAE,cAAc;EACpB,cAAc,EAAE,cAAc;EAC9B,GAAGD;AACP,CAAC","ignoreList":[]}
+{"version":3,"file":"timeseries.js","names":["TimeDurationMapping","TimeseriesDurationMapping"],"sources":["timeseries.ts"],"sourcesContent":["/*\n * Copyright 2024 Palantir Technologies, Inc. All rights reserved.\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *     http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\nimport { TimeDurationMapping } from \"../mapping/DurationMapping.js\";\n\nexport type TimeSeriesQuery =\n  | {\n    $before: number;\n    $unit: keyof typeof TimeseriesDurationMapping;\n    $after?: never;\n    $startTime?: never;\n    $endTime?: never;\n  }\n  | {\n    $after: number;\n    $unit: keyof typeof TimeseriesDurationMapping;\n    $before?: never;\n    $startTime?: never;\n    $endTime?: never;\n  }\n  | {\n    $startTime: string;\n    $endTime?: string;\n    $before?: never;\n    $after?: never;\n    $unit?: never;\n  }\n  | {\n    $startTime?: string;\n    $endTime: string;\n    $before?: never;\n    $after?: never;\n    $unit?: never;\n  };\n\nexport type TimeseriesDurationUnits =\n  | \"YEARS\"\n  | \"MONTHS\"\n  | \"WEEKS\"\n  | \"DAYS\"\n  | \"HOURS\"\n  | \"MINUTES\"\n  | \"SECONDS\"\n  | \"MILLISECONDS\";\n\nexport const TimeseriesDurationMapping: {\n  sec: \"SECONDS\";\n  seconds: \"SECONDS\";\n  min: \"MINUTES\";\n  minute: \"MINUTES\";\n  minutes: \"MINUTES\";\n  hr: \"HOURS\";\n  hrs: \"HOURS\";\n  hour: \"HOURS\";\n  hours: \"HOURS\";\n  day: \"DAYS\";\n  days: \"DAYS\";\n  wk: \"WEEKS\";\n  week: \"WEEKS\";\n  weeks: \"WEEKS\";\n  mos: \"MONTHS\";\n  month: \"MONTHS\";\n  months: \"MONTHS\";\n  yr: \"YEARS\";\n  year: \"YEARS\";\n  years: \"YEARS\";\n  ms: \"MILLISECONDS\";\n  milliseconds: \"MILLISECONDS\";\n} = {\n  \"ms\": \"MILLISECONDS\",\n  \"milliseconds\": \"MILLISECONDS\",\n  ...TimeDurationMapping,\n} satisfies Record<string, TimeseriesDurationUnits>;\n\nexport interface TimeSeriesPoint<T extends string | number | GeoJSON.Point> {\n  time: string;\n  value: T;\n}\n\nexport interface TimeSeriesProperty<T extends number | string> {\n  /**\n   * Queries the first point of the Timeseries\n   */\n  readonly getFirstPoint: () => Promise<TimeSeriesPoint<T>>;\n  /**\n   * Queries the last point of the Timeseries\n   */\n  readonly getLastPoint: () => Promise<TimeSeriesPoint<T>>;\n  /**\n     * Loads all points, within the given time range if that's provided\n     * @param query - a query representing either an absolute or relative range of time\n     * @example\n     *  const points = await employee.employeeStatus?.getAllPoints({\n        $after: 1,\n        $unit: \"month\",\n      });\n     */\n  readonly getAllPoints: (\n    query?: TimeSeriesQuery,\n  ) => Promise<Array<TimeSeriesPoint<T>>>;\n  /**\n     * Returns an async iterator to load all points\n     * within the given time range if that's provided\n     * @param query - a query representing either an absolute or relative range of time\n     * @example\n     *  const iterator = employee.employeeStatus?.asyncIter({\n        $after: 1,\n        $unit: \"month\",\n      });\n      for await (const point of iterator) {\n          // Handle time series point\n      }\n     */\n  readonly asyncIterPoints: (\n    query?: TimeSeriesQuery,\n  ) => AsyncGenerator<TimeSeriesPoint<T>>;\n}\n\nexport interface GeotimeSeriesProperty<T extends GeoJSON.Point> {\n  /**\n   * Queries the last point of the Geotime series\n   */\n  readonly getLatestValue: () => Promise<TimeSeriesPoint<T> | undefined>;\n  /**\n     * Loads all points, within the given time range if that's provided\n     * @param query - a query representing either an absolute or relative range of time\n     * @example\n     *  const points = await employee.employeeStatus?.getAllPoints({\n        $after: 1,\n        $unit: \"month\",\n      });\n     */\n  readonly getAllValues: (\n    query?: TimeSeriesQuery,\n  ) => Promise<Array<TimeSeriesPoint<T>>>;\n  /**\n     * Returns an async iterator to load all points\n     * within the given time range if that's provided\n     * @param query - a query representing either an absolute or relative range of time\n     * @example\n     *  const iterator = employee.employeeStatus?.asyncIter({\n        $after: 1,\n        $unit: \"month\",\n      });\n      for await (const point of iterator) {\n          // Handle time series point\n      }\n     */\n  readonly asyncIterValues: (\n    query?: TimeSeriesQuery,\n  ) => AsyncGenerator<TimeSeriesPoint<T>>;\n\n  /**\n   * The most recently fetched value for the latest point in the GTSR.\n   * This will not be loaded automatically upon object load, but will be refreshed every time\n   * getLatestValue() is called\n   */\n  readonly lastFetchedValue: TimeSeriesPoint<T> | undefined;\n}\n"],"mappings":"AAAA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA,SAASA,mBAAmB,QAAQ,+BAA+B;AA0CnE,OAAO,MAAMC,yBAuBZ,GAAG;EACF,IAAI,EAAE,cAAc;EACpB,cAAc,EAAE,cAAc;EAC9B,GAAGD;AACL,CAAmD","ignoreList":[]}

package/build/esm/util/LinkUtils.js

@@ -1,17 +1,2 @@
-/*
- * Copyright 2023 Palantir Technologies, Inc. All rights reserved.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
 export {};
 //# sourceMappingURL=LinkUtils.js.map

package/build/esm/util/LinkUtils.js.map

@@ -1 +1 @@
-{"version":3,"file":"LinkUtils.js","names":[],"sources":["LinkUtils.js"],"sourcesContent":["/*\n * Copyright 2023 Palantir Technologies, Inc. All rights reserved.\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *     http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\nexport {};\n"],"mappings":"AAAA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA","ignoreList":[]}
+{"version":3,"file":"LinkUtils.js","names":[],"sources":["LinkUtils.ts"],"sourcesContent":["/*\n * Copyright 2023 Palantir Technologies, Inc. All rights reserved.\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *     http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\nimport type { ObjectOrInterfaceDefinition } from \"../ontology/ObjectOrInterface.js\";\nimport type { CompileTimeMetadata } from \"../ontology/ObjectTypeDefinition.js\";\n\nexport type LinkNames<Q extends ObjectOrInterfaceDefinition> =\n  & keyof CompileTimeMetadata<Q>[\"links\"]\n  & string;\n\nexport type LinkedType<\n  Q extends ObjectOrInterfaceDefinition,\n  L extends LinkNames<Q>,\n> = NonNullable<CompileTimeMetadata<Q>[\"links\"][L][\"__OsdkLinkTargetType\"]>;\n"],"mappings":"","ignoreList":[]}

package/build/types/Definitions.d.ts

@@ -0,0 +1,22 @@
+import type { GetClientPropertyValueFromWire } from "./mapping/PropertyValueMapping.js";
+import type { ObjectMetadata } from "./ontology/ObjectTypeDefinition.js";
+type MaybeArray<
+	T extends { multiplicity?: boolean | undefined },
+	U
+> = T["multiplicity"] extends true ? Array<U> : U;
+type MaybeNullable<
+	T extends ObjectMetadata.Property,
+	U
+> = T["nullable"] extends true ? U | undefined : U;
+type Raw<T> = T extends Array<any> ? T[0] : T;
+type Converted<T> = T extends Array<any> ? T[1] : T;
+/**
+* @param {T} ObjectMetadata.Property in literal form
+* @param {STRICTLY_ENFORCE_NULLABLE}  S for strict. If false, always `|undefined`
+*/
+export type OsdkObjectPropertyType<
+	T extends ObjectMetadata.Property,
+	STRICTLY_ENFORCE_NULLABLE extends boolean = true
+> = STRICTLY_ENFORCE_NULLABLE extends false ? MaybeArray<T, Converted<GetClientPropertyValueFromWire<T["type"]>>> | undefined : MaybeNullable<T, MaybeArray<T, Converted<GetClientPropertyValueFromWire<T["type"]>>>>;
+export type OsdkObjectRawPropertyType<T extends ObjectMetadata.Property> = MaybeNullable<T, MaybeArray<T, Raw<GetClientPropertyValueFromWire<T["type"]>>>>;
+export {};

package/build/{esm → types}/OsdkBase.d.ts

@@ -4,10 +4,9 @@ import type { ObjectTypeDefinition } from "./ontology/ObjectTypeDefinition.js";
 import type { PrimaryKeyTypes } from "./ontology/PrimaryKeyTypes.js";
 import type { OsdkObjectPrimaryKeyType } from "./OsdkObjectPrimaryKeyType.js";
 export type OsdkBase<Q extends ObjectOrInterfaceDefinition> = {
-    readonly $apiName: Q["apiName"];
-    readonly $objectType: string;
-    readonly $primaryKey: PrimaryKeyType<Q>;
-    readonly $title: string | undefined;
+	readonly $apiName: Q["apiName"];
+	readonly $objectType: string;
+	readonly $primaryKey: PrimaryKeyType<Q>;
+	readonly $title: string | undefined;
 };
 export type PrimaryKeyType<Q extends ObjectOrInterfaceDefinition> = (Q extends ObjectTypeDefinition ? OsdkObjectPrimaryKeyType<Q> : unknown) & PropertyValueWireToClient[PrimaryKeyTypes];
-//# sourceMappingURL=OsdkBase.d.ts.map

package/build/types/OsdkMetadata.d.ts

@@ -0,0 +1,3 @@
+export interface OsdkMetadata {
+	extraUserAgent: string;
+}

package/build/{browser → types}/OsdkObject.d.ts

@@ -1,11 +1,10 @@
 import type { PropertyValueWireToClient } from "./mapping/PropertyValueMapping.js";
 import type { PrimaryKeyTypes } from "./ontology/PrimaryKeyTypes.js";
 /**
- * @deprecated Use OsdkBase
- */
+* @deprecated Use OsdkBase
+*/
 export type OsdkObject<N extends string> = {
-    readonly $apiName: N;
-    readonly $objectType: string;
-    readonly $primaryKey: PropertyValueWireToClient[PrimaryKeyTypes];
+	readonly $apiName: N;
+	readonly $objectType: string;
+	readonly $primaryKey: PropertyValueWireToClient[PrimaryKeyTypes];
 };
-//# sourceMappingURL=OsdkObject.d.ts.map

package/build/types/OsdkObjectFrom.d.ts

@@ -0,0 +1,91 @@
+import type { DefaultToFalse, OsdkObjectLinksObject } from "./definitions/LinkDefinitions.js";
+import type { NullabilityAdherence } from "./object/FetchPageArgs.js";
+import type { UnionIfTrue } from "./object/FetchPageResult.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 { OsdkBase } from "./OsdkBase.js";
+type SpecialOsdkPropParams = "$all" | "$rid" | "$strict" | "$notStrict";
+type ValidOsdkPropParams<Q extends ObjectOrInterfaceDefinition> = SpecialOsdkPropParams | PropertyKeys<Q>;
+export type ApiNameAsString<T extends ObjectOrInterfaceDefinition> = CompileTimeMetadata<T>["apiName"];
+export type JustProps<
+	T extends ObjectOrInterfaceDefinition,
+	P extends ValidOsdkPropParams<T>
+> = P extends "$all" ? PropertyKeys<T> : Exclude<P, SpecialOsdkPropParams>;
+export type PropMapToObject<
+	FROM extends ObjectOrInterfaceDefinition,
+	TO extends ObjectTypeDefinition
+> = NonNullable<CompileTimeMetadata<TO>["interfaceMap"]>[ApiNameAsString<FROM>];
+export type MapPropNamesToObjectType<
+	FROM extends ObjectOrInterfaceDefinition,
+	TO extends ObjectTypeDefinition,
+	P extends ValidOsdkPropParams<FROM>
+> = PropMapToObject<FROM, TO>[JustProps<FROM, P> & keyof PropMapToObject<FROM, TO>];
+export type PropMapToInterface<
+	FROM extends ObjectTypeDefinition,
+	TO extends InterfaceDefinition
+> = NonNullable<CompileTimeMetadata<FROM>["inverseInterfaceMap"]>[ApiNameAsString<TO>];
+export type MapPropNamesToInterface<
+	FROM extends ObjectTypeDefinition,
+	TO extends InterfaceDefinition,
+	P extends ValidOsdkPropParams<FROM>
+> = PropMapToInterface<FROM, TO>[JustProps<FROM, P> & keyof PropMapToInterface<FROM, TO>];
+/**
+* @param FROM - the interface or object type to convert from
+* @param TO - the interface or object type to convert to
+* @param P - the property(s) to convert
+*/
+export type ConvertProps<
+	FROM extends ObjectOrInterfaceDefinition,
+	TO extends ValidToFrom<FROM>,
+	P extends ValidOsdkPropParams<FROM>
+> = TO extends FROM ? P : TO extends ObjectTypeDefinition ? (UnionIfTrue<MapPropNamesToObjectType<FROM, TO, P>, P extends "$rid" ? true : false, "$rid">) : TO extends InterfaceDefinition ? FROM extends ObjectTypeDefinition ? (UnionIfTrue<MapPropNamesToInterface<FROM, TO, P>, P extends "$rid" ? true : false, "$rid">) : never : never;
+/** DO NOT EXPORT FROM PACKAGE */
+export type ValidToFrom<FROM extends ObjectOrInterfaceDefinition> = FROM extends InterfaceDefinition ? ObjectOrInterfaceDefinition : InterfaceDefinition;
+export type IsNever<T> = [T] extends [never] ? true : false;
+type ExtractPropsKeysFromOldPropsStyle<
+	Q extends ObjectOrInterfaceDefinition,
+	P extends ValidOsdkPropParams<Q>
+> = P extends "$all" ? PropertyKeys<Q> : Exclude<P, "$strict" | "$notStrict" | "$rid">;
+export type IsAny<T> = unknown extends T ? [keyof T] extends [never] ? false : true : false;
+export type GetPropsKeys<
+	Q extends ObjectOrInterfaceDefinition,
+	P extends PropertyKeys<Q>
+> = IsNever<P> extends true ? PropertyKeys<Q> : IsAny<P> extends true ? PropertyKeys<Q> : P;
+/**
+* Use `Osdk.Instance` or `YourType.OsdkInstance`
+*/
+export type Osdk<
+	Q extends ObjectOrInterfaceDefinition,
+	OPTIONS extends string = never,
+	P extends PropertyKeys<Q> = PropertyKeys<Q>
+> = IsNever<OPTIONS> extends true ? Osdk.Instance<Q, never, P> : IsAny<OPTIONS> extends true ? Osdk.Instance<Q, never, P> : (IsNever<Exclude<OPTIONS, "$rid">>) extends true ? Osdk.Instance<Q, OPTIONS & "$rid", P> : Osdk.Instance<Q, ("$rid" extends OPTIONS ? "$rid" : never), ExtractPropsKeysFromOldPropsStyle<Q, OPTIONS>>;
+export declare namespace Osdk {
+	type Instance<
+		Q extends ObjectOrInterfaceDefinition,
+		OPTIONS extends never | "$rid" = never,
+		P extends PropertyKeys<Q> = PropertyKeys<Q>
+	> = OsdkBase<Q> & Pick<CompileTimeMetadata<Q>["props"], GetPropsKeys<Q, P>> & {
+		readonly $link: Q extends { linksType?: any } ? Q["linksType"] : Q extends ObjectTypeDefinition ? OsdkObjectLinksObject<Q> : never;
+		readonly $as: <NEW_Q extends ValidToFrom<Q>>(type: NEW_Q | string) => Osdk.Instance<NEW_Q, OPTIONS, ConvertProps<Q, NEW_Q, P>>;
+	} & (IsNever<OPTIONS> extends true ? {} : IsAny<OPTIONS> extends true ? {} : "$rid" extends OPTIONS ? { readonly $rid: string } : {});
+}
+/**
+* NOT EXPORTED FROM PACKAGE
+*
+* Anything you throw at this that is not `false` should always be `never`.
+*
+* This is structured in a way that it should always short circuit to never early.
+*/
+export type ExtractStrictOption<S extends NullabilityAdherence> = IsNever<S> extends true ? never : "throw" extends S ? never : "drop" extends S ? never : "$notStrict";
+/**
+* NOT EXPORTED FROM PACKAGE
+*
+* Anything you throw at this that is not exactly `true` should always be `never`.
+*/
+export type ExtractRidOption<R extends boolean> = IsNever<R> extends true ? never : DefaultToFalse<R> extends false ? never : "$rid";
+export type ExtractOptions<
+	R extends boolean,
+	S extends NullabilityAdherence = NullabilityAdherence.Default
+> = ExtractRidOption<R>;
+export {};

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

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

package/build/{browser → types}/OsdkObjectPrimaryKeyType.d.ts

@@ -1,4 +1,3 @@
 import type { PropertyValueWireToClient } from "./mapping/PropertyValueMapping.js";
 import type { CompileTimeMetadata, ObjectTypeDefinition } from "./ontology/ObjectTypeDefinition.js";
 export type OsdkObjectPrimaryKeyType<Q extends ObjectTypeDefinition> = PropertyValueWireToClient[CompileTimeMetadata<Q>["primaryKeyType"]];
-//# sourceMappingURL=OsdkObjectPrimaryKeyType.d.ts.map

package/build/types/PageResult.d.ts

@@ -0,0 +1,5 @@
+export interface PageResult<T> {
+	data: T[];
+	nextPageToken: string | undefined;
+	totalCount: string;
+}

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

@@ -4,13 +4,6 @@ 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> = number extends T ? NumericAggregateOption : string extends T ? StringAggregateOption : never;
-export type ValidAggregationKeys<Q extends ObjectOrInterfaceDefinition> = keyof ({
-    [KK in AggregatableKeys<Q> as `${KK & string}:${AGG_FOR_TYPE<GetWirePropertyValueFromClient<CompileTimeMetadata<Q>["properties"][KK]["type"]>>}`]?: any;
-} & {
-    $count?: any;
-});
-export type AggregatableKeys<Q extends ObjectOrInterfaceDefinition> = keyof {
-    [P in PropertyKeys<Q>]: any;
-};
+export type ValidAggregationKeys<Q extends ObjectOrInterfaceDefinition> = keyof ({ [KK in AggregatableKeys<Q> as `${KK & string}:${AGG_FOR_TYPE<GetWirePropertyValueFromClient<CompileTimeMetadata<Q>["properties"][KK]["type"]>>}`]? : any } & { $count?: any });
+export type AggregatableKeys<Q extends ObjectOrInterfaceDefinition> = keyof { [P in PropertyKeys<Q>] : any };
 export {};
-//# sourceMappingURL=AggregatableKeys.d.ts.map

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

@@ -3,8 +3,7 @@ import type { ObjectOrInterfaceDefinition } from "../ontology/ObjectOrInterface.
 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>;
+	$where?: WhereClause<Q>;
+	$groupBy?: GroupByClause<Q>;
 };
-//# sourceMappingURL=AggregateOpts.d.ts.map

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

@@ -0,0 +1,18 @@
+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>;
+	$where?: AO["$where"];
+}) : 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/{browser → types}/aggregate/BooleanFilter.d.ts

@@ -1,17 +1,11 @@
 import type { BaseFilterOptions } from "./BaseFilter.js";
 import type { Just } from "./Just.js";
-interface BooleanFilterOptions extends BaseFilterOptions<boolean> {
-}
+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> {
-    }
+	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 {};
-//# sourceMappingURL=BooleanFilter.d.ts.map

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 {};