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

package/build/cjs/ObjectSet-k8HXHoJt.d.cts

@@ -0,0 +1,1015 @@
+import { Point, BBox, Polygon } from 'geojson';
+import { SingleKeyObject } from 'type-fest';
+
+interface Attachment {
+    rid: string;
+    /**
+     * Fetches metadata for an attachment
+     */
+    fetchMetadata(): Promise<AttachmentMetadata>;
+    /**
+     * Fetches actual content of attachment in Blob form
+     */
+    fetchContents(): Promise<Response>;
+}
+interface AttachmentUpload {
+    readonly name: string;
+    readonly data: Blob;
+}
+interface AttachmentMetadata {
+    rid: string;
+    filename: string;
+    sizeBytes: number;
+    mediaType: string;
+}
+
+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
+ */
+interface MediaMetadata {
+    path?: string;
+    sizeBytes: number;
+    mediaType: string;
+}
+
+type TimeSeriesQuery = {
+    $before: number;
+    $unit: keyof typeof TimeseriesDurationMapping;
+    $after?: never;
+    $startTime?: never;
+    $endTime?: never;
+} | {
+    $after: number;
+    $unit: keyof typeof TimeseriesDurationMapping;
+    $before?: never;
+    $startTime?: never;
+    $endTime?: never;
+} | {
+    $startTime: string;
+    $endTime?: string;
+    $before?: never;
+    $after?: never;
+    $unit?: never;
+} | {
+    $startTime?: string;
+    $endTime: string;
+    $before?: never;
+    $after?: never;
+    $unit?: never;
+};
+declare const TimeseriesDurationMapping: {
+    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";
+    ms: "MILLISECONDS";
+    milliseconds: "MILLISECONDS";
+};
+interface TimeSeriesPoint<T extends string | number | GeoJSON.Point> {
+    time: string;
+    value: T;
+}
+interface TimeSeriesProperty<T extends number | string> {
+    /**
+     * Queries the first point of the Timeseries
+     */
+    readonly getFirstPoint: () => Promise<TimeSeriesPoint<T>>;
+    /**
+     * Queries the last point of the Timeseries
+     */
+    readonly getLastPoint: () => Promise<TimeSeriesPoint<T>>;
+    /**
+       * Loads all points, within the given time range if that's provided
+       * @param query - a query representing either an absolute or relative range of time
+       * @example
+       *  const points = await employee.employeeStatus?.getAllPoints({
+          $after: 1,
+          $unit: "month",
+        });
+       */
+    readonly getAllPoints: (query?: TimeSeriesQuery) => Promise<Array<TimeSeriesPoint<T>>>;
+    /**
+       * Returns an async iterator to load all points
+       * within the given time range if that's provided
+       * @param query - a query representing either an absolute or relative range of time
+       * @example
+       *  const iterator = employee.employeeStatus?.asyncIter({
+          $after: 1,
+          $unit: "month",
+        });
+        for await (const point of iterator) {
+            // Handle time series point
+        }
+       */
+    readonly asyncIterPoints: (query?: TimeSeriesQuery) => AsyncGenerator<TimeSeriesPoint<T>>;
+}
+interface GeotimeSeriesProperty<T extends GeoJSON.Point> {
+    /**
+     * Queries the last point of the Geotime series
+     */
+    readonly getLatestValue: () => Promise<TimeSeriesPoint<T> | undefined>;
+    /**
+       * Loads all points, within the given time range if that's provided
+       * @param query - a query representing either an absolute or relative range of time
+       * @example
+       *  const points = await employee.employeeStatus?.getAllPoints({
+          $after: 1,
+          $unit: "month",
+        });
+       */
+    readonly getAllValues: (query?: TimeSeriesQuery) => Promise<Array<TimeSeriesPoint<T>>>;
+    /**
+       * Returns an async iterator to load all points
+       * within the given time range if that's provided
+       * @param query - a query representing either an absolute or relative range of time
+       * @example
+       *  const iterator = employee.employeeStatus?.asyncIter({
+          $after: 1,
+          $unit: "month",
+        });
+        for await (const point of iterator) {
+            // Handle time series point
+        }
+       */
+    readonly asyncIterValues: (query?: TimeSeriesQuery) => AsyncGenerator<TimeSeriesPoint<T>>;
+    /**
+     * The most recently fetched value for the latest point in the GTSR.
+     * This will not be loaded automatically upon object load, but will be refreshed every time
+     * getLatestValue() is called
+     */
+    readonly lastFetchedValue: TimeSeriesPoint<T> | undefined;
+}
+
+/**
+ * Map from the PropertyDefinition type to the typescript type that we return
+ */
+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>;
+}
+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
+ */
+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>;
+}
+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;
+
+interface OsdkMetadata {
+    extraUserAgent: string;
+}
+
+type PrimaryKeyTypes = "string" | "datetime" | "double" | "boolean" | "integer" | "timestamp" | "short" | "long" | "byte";
+
+type VersionString<Major extends number, Minor extends number, Patch extends number> = `${Major}.${Minor}.${Patch}`;
+
+type WirePropertyTypes = SimpleWirePropertyTypes | Record<string, SimpleWirePropertyTypes>;
+type SimpleWirePropertyTypes = "string" | "datetime" | "double" | "boolean" | "integer" | "timestamp" | "short" | "long" | "float" | "decimal" | "byte" | "marking" | "mediaReference" | "numericTimeseries" | "stringTimeseries" | "sensorTimeseries" | "attachment" | "geopoint" | "geoshape" | "geotimeSeriesReference";
+
+type CompileTimeMetadata<T extends {
+    __DefinitionMetadata?: {};
+}> = NonNullable<T["__DefinitionMetadata"]>;
+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;
+    /**
+     * Represents the "super interfaces" of this object.
+     *
+     * Optional because they may not exist on legacy.
+     */
+    implements?: ReadonlyArray<string>;
+};
+interface ObjectInterfaceCompileDefinition {
+    type: "object" | "interface";
+    objectSet?: any;
+    props?: any;
+    strictProps?: any;
+    linksType?: any;
+}
+interface VersionBound<V extends VersionString<any, any, any>> {
+    __expectedClientVersion?: V;
+}
+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>>;
+}
+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;
+    }
+}
+interface ObjectTypeDefinition {
+    type: "object";
+    apiName: string;
+    osdkMetadata?: OsdkMetadata;
+    __DefinitionMetadata?: ObjectMetadata & ObjectInterfaceCompileDefinition;
+}
+type ObjectTypeLinkKeysFrom2<Q extends ObjectTypeDefinition> = keyof CompileTimeMetadata<Q>["links"] & string;
+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;
+}
+type ReleaseStatus = "ACTIVE" | "EXPERIMENTAL" | "DEPRECATED";
+type ObjectTypeVisibility = "NORMAL" | "PROMINENT" | "HIDDEN";
+type BlueprintIcon = {
+    type: "blueprint";
+    color: string;
+    name: string;
+};
+type Icon = BlueprintIcon;
+
+interface InterfaceMetadata extends ObjectInterfaceBaseMetadata {
+    type: "interface";
+    implementedBy?: ReadonlyArray<string>;
+}
+interface InterfaceDefinition {
+    type: "interface";
+    apiName: string;
+    osdkMetadata?: OsdkMetadata;
+    __DefinitionMetadata?: InterfaceMetadata & ObjectInterfaceCompileDefinition;
+}
+
+type ObjectOrInterfaceDefinition = ObjectTypeDefinition | InterfaceDefinition;
+type PropertyKeys<O extends ObjectOrInterfaceDefinition> = keyof NonNullable<O["__DefinitionMetadata"]>["properties"] & string;
+
+type StringAggregateOption = "approximateDistinct" | "exactDistinct";
+type NumericAggregateOption = "min" | "max" | "sum" | "avg" | "approximateDistinct" | "exactDistinct";
+type AGG_FOR_TYPE<T> = number extends T ? NumericAggregateOption : string extends T ? StringAggregateOption : never;
+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;
+});
+type AggregatableKeys<Q extends ObjectOrInterfaceDefinition> = keyof {
+    [P in PropertyKeys<Q>]: any;
+};
+
+interface GroupByMapper {
+    string: StringGroupByValue;
+    short: NumericGroupByValue;
+    float: NumericGroupByValue;
+    decimal: NumericGroupByValue;
+    byte: NumericGroupByValue;
+    double: NumericGroupByValue;
+    integer: NumericGroupByValue;
+    timestamp: TimestampGroupByValue;
+    datetime: DateGroupByValue;
+    boolean: BooleanGroupByValue;
+}
+
+type GroupByClause<Q extends ObjectOrInterfaceDefinition> = {
+    [P in AggregatableKeys<Q>]?: GroupByEntry<Q, P>;
+};
+type BaseGroupByValue = "exact" | {
+    $exactWithLimit: number;
+};
+type GroupByRange<T> = [T, T];
+type StringGroupByValue = BaseGroupByValue;
+type NumericGroupByValue = BaseGroupByValue | {
+    $fixedWidth: number;
+} | {
+    $ranges: GroupByRange<number>[];
+};
+type TimestampGroupByValue = BaseGroupByValue | {
+    $ranges: GroupByRange<string>[];
+} | {
+    $duration: TimestampDurationGroupBy;
+};
+type DateGroupByValue = BaseGroupByValue | {
+    $ranges: GroupByRange<string>[];
+} | {
+    $duration: DatetimeDurationGroupBy;
+};
+type BooleanGroupByValue = BaseGroupByValue;
+type TimestampTimeUnits = DateTimeUnits | "SECONDS" | "MINUTES" | "HOURS";
+type DateTimeUnits = "DAYS" | "WEEKS" | "MONTHS" | "YEARS" | "QUARTERS";
+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;
+type AllGroupByValues = GroupByMapper[keyof GroupByMapper];
+
+type UnorderedAggregationClause<Q extends ObjectOrInterfaceDefinition> = {
+    [AK in ValidAggregationKeys<Q>]?: "unordered";
+};
+type OrderedAggregationClause<Q extends ObjectOrInterfaceDefinition> = {
+    [AK in ValidAggregationKeys<Q>]?: "unordered" | "asc" | "desc";
+};
+type AggregationClause<Q extends ObjectOrInterfaceDefinition> = UnorderedAggregationClause<Q> | OrderedAggregationClause<Q>;
+
+type NullabilityAdherence = false | "throw" | "drop";
+declare namespace NullabilityAdherence {
+    type Default = "throw";
+}
+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;
+}
+interface OrderByArg<Q extends ObjectOrInterfaceDefinition, L extends PropertyKeys<Q> = PropertyKeys<Q>> {
+    $orderBy?: {
+        [K in L]?: "asc" | "desc";
+    };
+}
+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>;
+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;
+}
+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;
+}
+type Augment<X extends ObjectOrInterfaceDefinition, T extends string> = {
+    [K in CompileTimeMetadata<X>["apiName"]]: T[];
+};
+type Augments = Record<string, string[]>;
+
+type ErrorResult = {
+    error: Error;
+    value?: never;
+};
+type OkResult<V> = {
+    value: V;
+    error?: never;
+};
+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
+ */
+declare function isOk<X>(a: Result<X>): a is OkResult<X>;
+
+/** The $link container to get from one object type to its linked objects */
+type OsdkObjectLinksObject<O extends ObjectTypeDefinition> = ObjectTypeLinkKeysFrom2<O> extends never ? never : {
+    readonly [L in ObjectTypeLinkKeysFrom2<O>]: OsdkObjectLinksEntry<O, L>;
+};
+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;
+type DefaultToFalse<B extends boolean | undefined> = false extends B ? false : undefined extends B ? false : true;
+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>>>;
+}
+
+interface PageResult<T> {
+    data: T[];
+    nextPageToken: string | undefined;
+    totalCount: string;
+}
+
+/** exposed for a test */
+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
+ */
+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
+ */
+type SingleOsdkResult<Q extends ObjectOrInterfaceDefinition, L extends PropertyKeys<Q>, R extends boolean, S extends NullabilityAdherence> = Osdk.Instance<Q, ExtractOptions<R, S>, L>;
+
+type OsdkObjectPrimaryKeyType<Q extends ObjectTypeDefinition> = PropertyValueWireToClient[CompileTimeMetadata<Q>["primaryKeyType"]];
+
+type OsdkBase<Q extends ObjectOrInterfaceDefinition> = {
+    readonly $apiName: Q["apiName"];
+    readonly $objectType: string;
+    readonly $primaryKey: PrimaryKeyType<Q>;
+    readonly $title: string | undefined;
+};
+type PrimaryKeyType<Q extends ObjectOrInterfaceDefinition> = (Q extends ObjectTypeDefinition ? OsdkObjectPrimaryKeyType<Q> : unknown) & PropertyValueWireToClient[PrimaryKeyTypes];
+
+type SpecialOsdkPropParams = "$all" | "$rid" | "$strict" | "$notStrict";
+type ValidOsdkPropParams<Q extends ObjectOrInterfaceDefinition> = SpecialOsdkPropParams | PropertyKeys<Q>;
+type ApiNameAsString<T extends ObjectOrInterfaceDefinition> = CompileTimeMetadata<T>["apiName"];
+type JustProps<T extends ObjectOrInterfaceDefinition, P extends ValidOsdkPropParams<T>> = P extends "$all" ? PropertyKeys<T> : Exclude<P, SpecialOsdkPropParams>;
+type PropMapToObject<FROM extends ObjectOrInterfaceDefinition, TO extends ObjectTypeDefinition> = NonNullable<CompileTimeMetadata<TO>["interfaceMap"]>[ApiNameAsString<FROM>];
+type MapPropNamesToObjectType<FROM extends ObjectOrInterfaceDefinition, TO extends ObjectTypeDefinition, P extends ValidOsdkPropParams<FROM>> = PropMapToObject<FROM, TO>[JustProps<FROM, P> & keyof PropMapToObject<FROM, TO>];
+type PropMapToInterface<FROM extends ObjectTypeDefinition, TO extends InterfaceDefinition> = NonNullable<CompileTimeMetadata<FROM>["inverseInterfaceMap"]>[ApiNameAsString<TO>];
+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
+ */
+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 */
+type ValidToFrom<FROM extends ObjectOrInterfaceDefinition> = FROM extends InterfaceDefinition ? ObjectOrInterfaceDefinition : InterfaceDefinition;
+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">;
+type IsAny<T> = unknown extends T ? [keyof T] extends [never] ? false : true : false;
+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`
+ */
+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>>;
+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 exactly `true` should always be `never`.
+ */
+type ExtractRidOption<R extends boolean> = IsNever<R> extends true ? never : DefaultToFalse<R> extends false ? never : "$rid";
+type ExtractOptions<R extends boolean, S extends NullabilityAdherence = NullabilityAdherence.Default> = ExtractRidOption<R>;
+
+type Just<Z extends keyof V, V> = {
+    [k in Z]: V[k];
+} & {
+    [k in keyof V as k extends Z ? never : k]?: never;
+};
+
+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>> {
+    }
+}
+type ArrayFilter<T> = ArrayFilter.$contains<T> | ArrayFilter.$isNull<T>;
+
+type BaseFilterOptions<T> = {
+    "$eq": T;
+    "$ne": T;
+    "$isNull": boolean;
+    "$in": ReadonlyArray<T>;
+};
+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>> {
+    }
+}
+type BaseFilter<T> = BaseFilter.$eq<T> | BaseFilter.$ne<T> | BaseFilter.$in<T> | BaseFilter.$isNull<T>;
+
+interface BooleanFilterOptions extends BaseFilterOptions<boolean> {
+}
+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> {
+    }
+}
+type BooleanFilter = boolean | BooleanFilter.$eq | BooleanFilter.$ne | BooleanFilter.$in | BooleanFilter.$isNull;
+
+interface DatetimeFilterOptions extends BaseFilterOptions<string> {
+    "$gt": string;
+    "$gte": string;
+    "$lt": string;
+    "$lte": string;
+}
+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> {
+    }
+}
+type DatetimeFilter = string | DatetimeFilter.$eq | DatetimeFilter.$ne | DatetimeFilter.$isNull | DatetimeFilter.$in | DatetimeFilter.$gt | DatetimeFilter.$gte | DatetimeFilter.$lt | DatetimeFilter.$lte;
+
+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;
+}
+declare namespace GeoFilter {
+    interface $within extends Just<"$within", GeoFilterOptions> {
+    }
+    interface $intersects extends Just<"$intersects", GeoFilterOptions> {
+    }
+    interface $isNull extends Just<"$isNull", GeoFilterOptions> {
+    }
+}
+type GeoFilter = GeoFilter.$within | GeoFilter.$intersects | GeoFilter.$isNull;
+
+interface NumberFilterOptions extends BaseFilterOptions<number> {
+    "$gt": number;
+    "$gte": number;
+    "$lt": number;
+    "$lte": number;
+}
+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> {
+    }
+}
+type NumberFilter = number | NumberFilter.$eq | NumberFilter.$ne | NumberFilter.$isNull | NumberFilter.$in | NumberFilter.$gt | NumberFilter.$gte | NumberFilter.$lt | NumberFilter.$lte;
+
+interface StringFilterOptions extends BaseFilterOptions<string> {
+    "$startsWith": string;
+    "$containsAllTermsInOrder": string;
+    "$containsAnyTerm": string | {
+        term: string;
+        fuzzySearch?: boolean;
+    };
+    "$containsAllTerms": string | {
+        term: string;
+        fuzzySearch?: boolean;
+    };
+    "$in": ReadonlyArray<string>;
+}
+declare namespace StringFilter {
+    interface $eq extends Just<"$eq", StringFilterOptions> {
+    }
+    interface $ne extends Just<"$ne", StringFilterOptions> {
+    }
+    interface $isNull extends Just<"$isNull", StringFilterOptions> {
+    }
+    interface $startsWith extends Just<"$startsWith", StringFilterOptions> {
+    }
+    interface $containsAllTermsInOrder extends Just<"$containsAllTermsInOrder", StringFilterOptions> {
+    }
+    interface $containsAnyTerm extends Just<"$containsAnyTerm", StringFilterOptions> {
+    }
+    interface $containsAllTerms extends Just<"$containsAllTerms", StringFilterOptions> {
+    }
+    interface $in extends Just<"$in", StringFilterOptions> {
+    }
+}
+type StringFilter = string | StringFilter.$eq | StringFilter.$ne | StringFilter.$isNull | StringFilter.$in | StringFilter.$startsWith | StringFilter.$containsAllTermsInOrder | StringFilter.$containsAnyTerm | StringFilter.$containsAllTerms;
+
+type PossibleWhereClauseFilters = "$gt" | "$eq" | "$ne" | "$isNull" | "$contains" | "$gte" | "$lt" | "$lte" | "$within" | "$in" | "$intersects" | "$startsWith" | "$containsAllTermsInOrder" | "$containsAnyTerm" | "$containsAllTerms";
+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";
+};
+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;
+};
+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>);
+interface AndWhereClause<T extends ObjectOrInterfaceDefinition> {
+    $and: WhereClause<T>[];
+}
+interface OrWhereClause<T extends ObjectOrInterfaceDefinition> {
+    $or: WhereClause<T>[];
+}
+interface NotWhereClause<T extends ObjectOrInterfaceDefinition> {
+    $not: WhereClause<T>;
+}
+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]>;
+});
+
+type AggregateOpts<Q extends ObjectOrInterfaceDefinition> = {
+    $select: UnorderedAggregationClause<Q> | OrderedAggregationClause<Q>;
+    $where?: WhereClause<Q>;
+    $groupBy?: GroupByClause<Q>;
+};
+
+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>;
+});
+
+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 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`
+ */
+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"]>>>>;
+
+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;
+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]>;
+    };
+};
+
+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>)[];
+
+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>>}`;
+
+type LinkNames<Q extends ObjectOrInterfaceDefinition> = keyof CompileTimeMetadata<Q>["links"] & string;
+type LinkedType<Q extends ObjectOrInterfaceDefinition, L extends LinkNames<Q>> = NonNullable<CompileTimeMetadata<Q>["links"][L]["__OsdkLinkTargetType"]>;
+
+interface BaseObjectSet<Q extends ObjectOrInterfaceDefinition> {
+    readonly $objectSetInternals: {
+        def: Q;
+    };
+}
+
+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.
+ */
+interface ObjectSetListenerOptions<O extends ObjectOrInterfaceDefinition, P extends PropertyKeys<O> = PropertyKeys<O>> {
+    properties?: Array<P>;
+}
+
+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>>;
+}
+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;
+    };
+}
+
+export { type VersionBound as $, type Attachment as A, type FetchPageResult as B, type SingleOsdkResult as C, DistanceUnitMapping as D, type MediaMetadata as E, type FetchPageArgs as F, type GeoFilterOptions as G, isOk as H, type InterfaceDefinition as I, type Result as J, type BaseObjectSet as K, type ObjectSetListener as L, type Media as M, NullabilityAdherence as N, type ObjectTypeDefinition as O, type PropertyValueWireToClient as P, type ObjectSetListenerOptions as Q, type ReleaseStatus as R, type SingleLinkAccessor as S, type InterfaceMetadata as T, type ObjectOrInterfaceDefinition as U, type ValidAggregationKeys as V, type WhereClause as W, type PropertyKeys as X, type CompileTimeMetadata as Y, ObjectMetadata as Z, type PropertyDef as _, type AttachmentUpload as a, type SimpleWirePropertyTypes as a0, type WirePropertyTypes as a1, type PrimaryKeyType as a2, type ConvertProps as a3, Osdk as a4, type PageResult as a5, TimeseriesDurationMapping as a6, type GeotimeSeriesProperty as a7, type TimeSeriesPoint as a8, type TimeSeriesProperty as a9, type TimeSeriesQuery as aa, type LinkedType as ab, type LinkNames as ac, type ExtractOptions as ad, type MinimalObjectSet as ae, type OsdkBase as b, type OsdkObjectPrimaryKeyType as c, type ObjectSet as d, type OsdkMetadata as e, type PrimaryKeyTypes as f, type AggregateOpts as g, type AggregateOptsThatErrorsAndDisallowsOrderingWithMultipleGroupBy as h, type AggregationResultsWithGroups as i, type AggregationResultsWithoutGroups as j, type AggregationClause as k, type AggregationsResults as l, type GeoFilter_Intersects as m, type GeoFilter_Within as n, type PossibleWhereClauseFilters as o, type OsdkObjectPropertyType as p, type OsdkObjectLinksObject as q, DurationMapping as r, type AllGroupByValues as s, type GroupByClause as t, type GroupByRange as u, type AsyncIterArgs as v, type Augment as w, type Augments as x, type SelectArg as y, type SelectArgToKeys as z };