@osdk/faux 0.1.0-beta.1

package/build/cjs/index.d.cts

@@ -0,0 +1,562 @@
+import * as OntologiesV2$1 from '@osdk/foundry.ontologies';
+import { ActionParameterV2, ParameterId, ActionTypeV2, ActionTypeApiName, ObjectTypeV2, PropertyV2, ApplyActionRequestV2, ActionParameterType, AttachmentRid, Ontology, OntologyV2, Actions as Actions$1, ActionTypesV2 as ActionTypesV2$1, AttachmentPropertiesV2 as AttachmentPropertiesV2$1, Attachments as Attachments$1, LinkedObjectsV2 as LinkedObjectsV2$1, MediaReferenceProperties as MediaReferenceProperties$1, ObjectTypesV2 as ObjectTypesV2$1, OntologiesV2 as OntologiesV2$2, OntologyInterfaces as OntologyInterfaces$1, OntologyObjectSets as OntologyObjectSets$1, OntologyObjectsV2 as OntologyObjectsV2$1, Queries as Queries$1, QueryTypes as QueryTypes$1, TimeSeriesPropertiesV2 as TimeSeriesPropertiesV2$1, TimeSeriesValueBankProperties as TimeSeriesValueBankProperties$1 } from '@osdk/foundry.ontologies';
+import { Merge, ReadonlyDeep } from 'type-fest';
+import { ActionDefinition, ActionMetadata, ActionParam, DataValueClientToWire, ApplyActionOptions, ActionReturnTypeForOptions, ApplyBatchActionOptions, ObjectMetadata, PropertyValueWireToClient, PropertyDef, ObjectTypeDefinition, CompileTimeMetadata, PrimaryKeyType, Logger } from '@osdk/api';
+import { ObjectTypeNotFound, LinkTypeNotFound as LinkTypeNotFound$1, OntologyNotFound, ObjectNotFound, QueryNotFound, ActionNotFound, ApplyActionFailed, QueryEncounteredUserFacingError, InvalidContentType, AttachmentSizeExceededLimit, AttachmentNotFound } from '@osdk/internal.foundry.ontologies';
+import { MediaType, MediaItemRid, MediaReference } from '@osdk/foundry.core';
+import { RequestHandler, DefaultBodyType, PathParams, HttpResponseResolver, RequestHandlerOptions, HttpHandler } from 'msw';
+import * as msw from 'msw';
+export { msw };
+
+type SimpleActionParamTypes = "string" | "integer" | "boolean";
+type TH_ActionParameterV2<T extends SimpleActionParamTypes, R extends boolean> = {
+    dataType: {
+        type: T;
+    };
+    required: R;
+} & ActionParameterV2;
+declare function createActionParameterV2<T extends SimpleActionParamTypes, R extends boolean>(type: T, required: R): TH_ActionParameterV2<T, R>;
+
+interface TH_ActionTypeV2<P extends Record<ParameterId, ActionParameterV2>> extends ActionTypeV2 {
+    parameters: P;
+}
+declare function createAction<P extends Record<ParameterId, ActionParameterV2>>({ apiName, parameters, rid, operations, status, description, }: Partial<Omit<ActionTypeV2, "apiName" | "parameters">> & {
+    apiName: ActionTypeApiName;
+    parameters: P;
+}): TH_ActionTypeV2<P>;
+
+/**
+ * Helper type for converting a "const" `ActionTypeV2` into a "const"
+ * `ActionDefinition` for compile time checks
+ */
+interface TH_ActionDefinition<X extends TH_ActionTypeV2<Record<ParameterId, ActionParameterV2>>> extends ActionDefinition<any> {
+    __DefinitionMetadata: TH_ActionMetadata<X>;
+}
+interface TH_ActionMetadata<X extends TH_ActionTypeV2<Record<ParameterId, ActionParameterV2>>> extends ActionMetadata {
+    parameters: X extends TH_ActionTypeV2<infer P> ? {
+        [K in keyof P]: P[K] extends TH_ActionParameterV2<infer APT, infer R> ? (APT extends "string" | "integer" ? {
+            multiplicity: false;
+            nullable: R extends true ? false : true;
+            type: APT;
+        } : never) : never;
+    } : never;
+    signatures: Signatures<TH_ActionMetadata<X>["parameters"]>;
+}
+interface Signatures<X extends Record<any, ActionMetadata.Parameter<any>>> {
+    applyAction: ActionSignature<X>;
+    batchApplyAction: <A extends OsdkActionParameters<X>[], OP extends ApplyBatchActionOptions>(args: A, options?: OP) => Promise<ActionReturnTypeForOptions<OP>>;
+}
+type BaseType<APD extends Pick<ActionMetadata.Parameter<any>, "type">> = APD["type"] extends ActionMetadata.DataType.Object<infer TTargetType> ? ActionParam.ObjectType<TTargetType> : APD["type"] extends ActionMetadata.DataType.ObjectSet<infer TTargetType> ? ActionParam.ObjectSetType<TTargetType> : APD["type"] extends ActionMetadata.DataType.Struct<infer TStructType> ? ActionParam.StructType<TStructType> : APD["type"] extends keyof DataValueClientToWire ? ActionParam.PrimitiveType<APD["type"]> : never;
+type ActionSignature<X extends Record<any, ActionMetadata.Parameter<any>>> = <A extends OsdkActionParameters<X>, OP extends ApplyActionOptions>(args: A, options?: OP) => Promise<ActionReturnTypeForOptions<OP>>;
+type ActionParametersDefinition = Record<any, ActionMetadata.Parameter<any>>;
+type OsdkActionParameters<X extends ActionParametersDefinition> = PartialBy<FullParams<X>, NullableParamKeys<X>>;
+type NullableParamKeys<T extends Record<string, {
+    nullable?: boolean;
+}>> = keyof {
+    [K in keyof T as T[K]["nullable"] extends true ? K : never]: "";
+};
+type FullParams<X extends ActionParametersDefinition> = {
+    [P in keyof X]: MaybeArrayType<X[P]>;
+};
+type PartialBy<T, K extends keyof T> = Omit<T, K> & Partial<Pick<T, K>>;
+type MaybeArrayType<APD extends ActionMetadata.Parameter<any>> = APD["multiplicity"] extends true ? Array<BaseType<APD>> : BaseType<APD>;
+
+declare function actionTypeBuilder<P extends Record<ParameterId, ActionParameterV2> = {}>(action: TH_ActionTypeV2<P> | string): ActionTypeBuilder<P>;
+declare function createActionRid(): string;
+type NEW_P<P extends Record<ParameterId, ActionParameterV2>, K extends ParameterId, V extends ActionParameterV2> = Merge<P, {
+    [KK in K]: V;
+}>;
+interface ActionTypeBuilderResult<P extends Record<ParameterId, ActionParameterV2> = {}> {
+    actionTypeV2: TH_ActionTypeV2<P>;
+    actionDefinition: TH_ActionDefinition<TH_ActionTypeV2<P>>;
+}
+declare class ActionTypeBuilder<P extends Record<ParameterId, ActionParameterV2> = {}> {
+    private action;
+    constructor(action: TH_ActionTypeV2<P> | string);
+    addParameter<K extends ParameterId, V extends ActionParameterV2 | SimpleActionParamTypes, R extends boolean = false>(paramId: K, parameter: V, required?: R | false): ActionTypeBuilder<NEW_P<P, K, V extends SimpleActionParamTypes ? TH_ActionParameterV2<V, R> : never>>;
+    build(): ActionTypeBuilderResult<P>;
+}
+
+type PropertyV2ToWirePropertyTypes<T extends PropertyV2> = T["dataType"]["type"] extends "array" ? never : T["dataType"]["type"] extends "date" ? "timestamp" : Exclude<T["dataType"]["type"], "array" | "date" | "struct" | "cipherText" | "timeseries" | "vector">;
+type ToObjectTypeDefinition<T extends ObjectTypeV2> = {
+    type: "object";
+    apiName: T["apiName"];
+    __DefinitionMetadata: Omit<ObjectMetadata, "properties"> & {
+        props: {
+            [key in keyof T["properties"] & string]?: PropertyValueWireToClient[PropertyV2ToWirePropertyTypes<T["properties"][key]>];
+        } & {
+            [key in T["primaryKey"]]: PropertyValueWireToClient[PropertyV2ToWirePropertyTypes<T["properties"][key]>];
+        };
+        properties: {
+            [key in keyof T["properties"] & string]: PropertyDef<PropertyV2ToWirePropertyTypes<T["properties"][key]>>;
+        };
+    };
+};
+
+type JustProps<T extends ObjectTypeV2 | ObjectTypeDefinition> = CompileTimeMetadata<T extends ObjectTypeV2 ? ToObjectTypeDefinition<T> : T>["props"];
+
+type TH_ActionParameterType_Primitive<X extends ActionParameterType> = X extends {
+    type: "attachment";
+} ? AttachmentRid : ActionParam.PrimitiveType<Exclude<X["type"], "object" | "array" | "objectSet" | "interfaceObject" | "attachment" | "vector">>;
+type TH_ActionParameterType<X extends ActionParameterType> = X extends {
+    type: "array";
+} ? TH_ActionParameterType_Primitive<Extract<X, {
+    type: "array";
+}>["subType"]>[] : X extends {
+    type: "object";
+} ? string | number | boolean : X extends {
+    type: "objectSet";
+} ? string : X extends {
+    type: "interfaceObject";
+} ? {
+    objectTypeApiName: string;
+    primaryKeyValue: string;
+} : TH_ActionParameterType_Primitive<X>;
+type TH_Parameters<X extends Record<ParameterId, ActionParameterV2>> = {
+    [K in keyof X & string as X[K]["required"] extends true ? K : never]: TH_ActionParameterType<X[K]["dataType"]>;
+} & {
+    [K in keyof X & string as X[K]["required"] extends true ? never : K]?: TH_ActionParameterType<X[K]["dataType"]>;
+};
+type TH_ApplyActionRequestV2<X extends ActionTypeV2> = Omit<ApplyActionRequestV2, "parameters"> & {
+    parameters: TH_Parameters<X["parameters"]>;
+};
+
+interface TypeHelper_Property<Q extends ObjectMetadata.Property> extends OntologiesV2$1.PropertyV2 {
+    dataType: OntologiesV2$1.ObjectPropertyType & {
+        type: Q["type"];
+    };
+}
+type TypeHelper_Properties<Q extends ObjectTypeDefinition> = {
+    [K in keyof CompileTimeMetadata<Q>["properties"]]: TypeHelper_Property<CompileTimeMetadata<Q>["properties"][K]>;
+};
+interface TypeHelper_ObjectType<Q extends ObjectTypeDefinition> extends OntologiesV2$1.ObjectTypeV2 {
+    apiName: Q["apiName"];
+    primaryKey: CompileTimeMetadata<Q>["primaryKeyApiName"];
+    titleProperty: CompileTimeMetadata<Q>["titleProperty"];
+    properties: TypeHelper_Properties<Q>;
+}
+interface TH_ObjectTypeFullMetadata<Q extends ObjectTypeDefinition> extends OntologiesV2$1.ObjectTypeFullMetadata {
+    objectType: TypeHelper_ObjectType<Q>;
+}
+
+type index$1_ActionTypeBuilderResult<P extends Record<ParameterId, ActionParameterV2> = {}> = ActionTypeBuilderResult<P>;
+type index$1_JustProps<T extends ObjectTypeV2 | ObjectTypeDefinition> = JustProps<T>;
+declare const index$1_actionTypeBuilder: typeof actionTypeBuilder;
+declare const index$1_createActionParameterV2: typeof createActionParameterV2;
+declare const index$1_createActionRid: typeof createActionRid;
+declare namespace index$1 {
+  export { type TH_ActionDefinition as ActionDefinition, type TH_ActionMetadata as ActionMetadata, type TH_ActionParameterV2 as ActionParameterV2, type index$1_ActionTypeBuilderResult as ActionTypeBuilderResult, type TH_ActionTypeV2 as ActionTypeV2, type TH_ApplyActionRequestV2 as ApplyActionRequestV2, type index$1_JustProps as JustProps, type TH_ObjectTypeFullMetadata as ObjectTypeFullMetadata, index$1_actionTypeBuilder as actionTypeBuilder, index$1_createActionParameterV2 as createActionParameterV2, index$1_createActionRid as createActionRid, createAction as createActionType };
+}
+
+interface BaseAPIError {
+    errorCode: string;
+    errorName: string;
+    errorInstanceId: string;
+    parameters: Record<string, any>;
+}
+declare function isBaseApiError(error: any): error is BaseAPIError;
+
+declare function ObjectTypeDoesNotExistError(objectType: string): ObjectTypeNotFound;
+declare function LinkTypeNotFound(objectType: string, linkType: string): LinkTypeNotFound$1;
+declare function OntologyNotFoundError(ontology: string): OntologyNotFound;
+declare function ObjectNotFoundError(objectType: string, primaryKey: string): ObjectNotFound;
+declare function QueryNotFoundError(queryApiName: string): QueryNotFound;
+declare function ActionNotFoundError(): ActionNotFound;
+declare function InvalidRequest(errorName: string): BaseAPIError;
+declare const ApplyActionFailedError: ApplyActionFailed;
+declare const ExecuteQueryFailedError: QueryEncounteredUserFacingError;
+declare const InvalidContentTypeError: InvalidContentType;
+declare const AttachmentSizeExceededLimitError: AttachmentSizeExceededLimit;
+declare const AttachmentNotFoundError: AttachmentNotFound;
+
+declare const errors_ActionNotFoundError: typeof ActionNotFoundError;
+declare const errors_ApplyActionFailedError: typeof ApplyActionFailedError;
+declare const errors_AttachmentNotFoundError: typeof AttachmentNotFoundError;
+declare const errors_AttachmentSizeExceededLimitError: typeof AttachmentSizeExceededLimitError;
+declare const errors_ExecuteQueryFailedError: typeof ExecuteQueryFailedError;
+declare const errors_InvalidContentTypeError: typeof InvalidContentTypeError;
+declare const errors_InvalidRequest: typeof InvalidRequest;
+declare const errors_LinkTypeNotFound: typeof LinkTypeNotFound;
+declare const errors_ObjectNotFoundError: typeof ObjectNotFoundError;
+declare const errors_ObjectTypeDoesNotExistError: typeof ObjectTypeDoesNotExistError;
+declare const errors_OntologyNotFoundError: typeof OntologyNotFoundError;
+declare const errors_QueryNotFoundError: typeof QueryNotFoundError;
+declare namespace errors {
+  export { errors_ActionNotFoundError as ActionNotFoundError, errors_ApplyActionFailedError as ApplyActionFailedError, errors_AttachmentNotFoundError as AttachmentNotFoundError, errors_AttachmentSizeExceededLimitError as AttachmentSizeExceededLimitError, errors_ExecuteQueryFailedError as ExecuteQueryFailedError, errors_InvalidContentTypeError as InvalidContentTypeError, errors_InvalidRequest as InvalidRequest, errors_LinkTypeNotFound as LinkTypeNotFound, errors_ObjectNotFoundError as ObjectNotFoundError, errors_ObjectTypeDoesNotExistError as ObjectTypeDoesNotExistError, errors_OntologyNotFoundError as OntologyNotFoundError, errors_QueryNotFoundError as QueryNotFoundError };
+}
+
+interface FauxAttachmentInfo extends Omit<OntologiesV2$1.AttachmentV2, "sizeBytes"> {
+    buffer: ArrayBuffer;
+}
+declare class FauxAttachmentStore {
+    #private;
+    registerAttachment(attachment: FauxAttachmentInfo): OntologiesV2$1.AttachmentV2;
+    getAttachmentMetadataByRid(attachmentRid: string): OntologiesV2$1.AttachmentV2;
+    getAttachmentBuffer(attachmentRid: string): ArrayBuffer;
+}
+
+/**
+ * A simplified type safe version of `OntologyObjectV2` that adds a tiny bit
+ * more strictness in that it declares the meaning of values for the `__` prefix
+ * props.
+ */
+interface BaseServerObject extends OntologiesV2$1.OntologyObjectV2 {
+    __rid?: string;
+    __primaryKey: string | number | boolean;
+    __apiName: OntologiesV2$1.ObjectTypeApiName;
+    __title?: string;
+    [key: string]: unknown;
+}
+
+interface PagedBodyResponse<T> {
+    nextPageToken?: string;
+    data: T[];
+}
+interface PagedBodyResponseWithTotal<T> extends PagedBodyResponse<T> {
+    totalCount: string;
+}
+
+interface FauxQueryImpl {
+    (req: OntologiesV2$1.ExecuteQueryRequest, fauxDataStore: FauxDataStore): OntologiesV2$1.ExecuteQueryResponse;
+}
+
+/**
+ * Currently Unsupported Concepts:
+ * - many:many links.
+ */
+declare class FauxOntology {
+    #private;
+    constructor(ontology: OntologiesV2$1.OntologyV2);
+    get apiName(): OntologiesV2$1.OntologyApiName;
+    getOntologyFullMetadata(): OntologiesV2$1.OntologyFullMetadata;
+    getFilteredOntologyMetadata(request: OntologiesV2$1.LoadOntologyMetadataRequest): OntologiesV2$1.OntologyFullMetadata;
+    getAllInterfaceTypes(): OntologiesV2$1.InterfaceType[];
+    getAllObjectTypes(): OntologiesV2$1.ObjectTypeFullMetadata[];
+    getAllActionTypes(): OntologiesV2$1.ActionTypeV2[];
+    getAllQueryTypes(): OntologiesV2$1.QueryTypeV2[];
+    getInterfaceType(interfaceType: string): OntologiesV2$1.InterfaceType;
+    getObjectTypeFullMetadata(objectTypeApiName: string): OntologiesV2$1.ObjectTypeFullMetadata | undefined;
+    getObjectTypeFullMetadataOrThrow(objectTypeApiName: string): OntologiesV2$1.ObjectTypeFullMetadata;
+    getActionDef(actionTypeApiName: string): OntologiesV2$1.ActionTypeV2;
+    getActionImpl(actionTypeApiName: string): FauxActionImpl;
+    getQueryDef(queryTypeApiNameAndVersion: string): OntologiesV2$1.QueryTypeV2;
+    getQueryImpl(queryTypeApiName: string, version?: string): FauxQueryImpl;
+    getInterfaceToObjectTypeMappings(objectApiNames: Iterable<OntologiesV2$1.ObjectTypeApiName>): Record<OntologiesV2$1.InterfaceTypeApiName, OntologiesV2$1.InterfaceToObjectTypeMappings>;
+    getLinkTypeSideV2(objectTypeApiName: string, linkTypeName: string): OntologiesV2$1.LinkTypeSideV2;
+    getOtherLinkTypeSideV2OrThrow(objectTypeApiName: string, linkTypeName: string): OntologiesV2$1.LinkTypeSideV2;
+    getBothLinkTypeSides(leftObjectType: string, leftLinkName: string, rightObjectType: string): [OntologiesV2$1.LinkTypeSideV2, OntologiesV2$1.LinkTypeSideV2];
+    registerObjectType<Q extends ObjectTypeDefinition>(def: TH_ObjectTypeFullMetadata<Q>): void;
+    registerObjectType(def: ReadonlyDeep<OntologiesV2$1.ObjectTypeFullMetadata>): void;
+    registerActionType<Q extends OntologiesV2$1.ActionTypeV2>(def: Q, implementation?: FauxActionImpl<Q>): void;
+    registerActionType(def: OntologiesV2$1.ActionTypeV2, implementation?: FauxActionImpl): void;
+    registerQueryType(def: OntologiesV2$1.QueryTypeV2, implementation?: FauxQueryImpl): void;
+    registerInterfaceType(def: OntologiesV2$1.InterfaceType): void;
+    registerSharedPropertyType(def: OntologiesV2$1.SharedPropertyType): void;
+}
+
+interface MediaMetadataAndContent {
+    content: ArrayBuffer;
+    mediaRef: MediaReference;
+    metaData: OntologiesV2$1.MediaMetadata;
+}
+type ObjectTypeCreatableWithoutApiName<T extends ObjectTypeDefinition> = OrUndefinedToOptional<JustProps<T>>;
+/**
+ * Represents the properties needed to create an object, specifically,
+ * the properties of the object and the $apiName
+ */
+type ObjectTypeCreatable<T extends ObjectTypeDefinition> = ObjectTypeCreatableWithoutApiName<T> & {
+    $apiName: CompileTimeMetadata<T>["apiName"];
+};
+/**
+ * Helper type for converting `foo: string | undefined` into `foo?: string`
+ */
+type OrUndefinedToOptional<T extends object> = {
+    [K in keyof T as T[K] extends undefined ? K : never]?: T[K];
+} & {
+    [K in keyof T as T[K] extends undefined ? never : K]?: T[K];
+};
+declare class FauxDataStore {
+    #private;
+    constructor(fauxOntology: FauxOntology, attachments: FauxAttachmentStore);
+    /**
+     * Removes all data that is associated with a namespace/ontology.
+     *
+     * Note: does not clear `attachments` nor does it clear the ontology itself.
+     */
+    clear(): void;
+    get ontology(): FauxOntology;
+    /**
+     * Version for use in places like @osdk/client.
+     *
+     * @param obj An `Osdk.Instance` like object for the ObjectType in the generics
+     */
+    registerObject<T extends ObjectTypeDefinition>(objectType: T, obj: ObjectTypeCreatable<T> | ObjectTypeCreatableWithoutApiName<T>): void;
+    /**
+     * Version of register object generally used in shared.test
+     * @param obj A raw server side representation of an object
+     *
+     * Don't use, its too easy to end up with an any.
+     */
+    registerObject(obj: BaseServerObject): void;
+    replaceObjectOrThrow(x: BaseServerObject): void;
+    /** Throws if the object does not already exist */
+    unregisterObjectOrThrow(objectType: string, primaryKey: string | number | boolean): void;
+    registerLink(src: BaseServerObject, srcLinkName: string, dst: BaseServerObject, destLinkName: string): void;
+    unregisterLink(src: BaseServerObject, srcLinkName: string, dst: BaseServerObject, dstLinkName: string): void;
+    registerTimeSeriesData(objectType: OntologiesV2$1.ObjectTypeApiName, primaryKey: string, property: OntologiesV2$1.PropertyApiName, data: OntologiesV2$1.TimeSeriesPoint[]): void;
+    getTimeSeriesData(objectType: OntologiesV2$1.ObjectTypeApiName, primaryKey: string, property: OntologiesV2$1.PropertyApiName, filter?: OntologiesV2$1.StreamTimeSeriesPointsRequest): OntologiesV2$1.TimeSeriesPoint[];
+    registerMedia(objectType: OntologiesV2$1.ObjectTypeApiName, property: OntologiesV2$1.PropertyApiName, content: ArrayBuffer, mediaType: MediaType, path: string | undefined, mediaItemRid?: MediaItemRid): MediaReference;
+    getMediaOrThrow(objectType: OntologiesV2$1.ObjectTypeApiName, primaryKey: string, property: OntologiesV2$1.PropertyApiName): MediaMetadataAndContent;
+    getObject(apiName: string, primaryKey: string | number | boolean): BaseServerObject | undefined;
+    getObjectOrThrow(apiName: string, primaryKey: string | number | boolean): BaseServerObject;
+    getObjectByRid(rid: string): BaseServerObject | undefined;
+    getLinksOrThrow(apiName: string, primaryKey: string | number | boolean, linkApiName: string): BaseServerObject[];
+    getLinkOrThrow(objectType: string, primaryKey: string | number | boolean, linkType: string, targetPrimaryKey: string | number | boolean): BaseServerObject;
+    getObjectsOfType(apiName: string): Iterable<BaseServerObject>;
+    getObjectsFromObjectSet(parsedBody: OntologiesV2$1.LoadObjectSetV2MultipleObjectTypesRequest | OntologiesV2$1.LoadObjectSetRequestV2): PagedBodyResponseWithTotal<BaseServerObject>;
+    getAttachmentMetadata(objectType: string, primaryKey: string | number | boolean, propertyName: string): OntologiesV2$1.AttachmentV2;
+    getAttachmentBuffer(objectType: string, primaryKey: string | number | boolean, propertyName: string): ArrayBuffer;
+    applyAction(actionTypeApiName: string, req: OntologiesV2$1.ApplyActionRequestV2): OntologiesV2$1.SyncApplyActionResponseV2;
+    batchApplyAction(actionTypeApiName: string, batchReq: OntologiesV2$1.BatchApplyActionRequestV2): OntologiesV2$1.BatchApplyActionResponseV2;
+}
+
+/**
+ * This is separate from the FauxDataStore so that we can in the future support
+ * this not-committing on errors. That functionality just does not exist at the moment
+ */
+declare class FauxDataStoreBatch {
+    #private;
+    objectEdits: OntologiesV2$1.ObjectEdits;
+    constructor(fauxDataStore: FauxDataStore);
+    getObject: (objectType: string, primaryKey: string | number | boolean) => BaseServerObject;
+    addObject<T extends ObjectTypeDefinition>(objectType: T["apiName"], primaryKey: PrimaryKeyType<T>, update: Omit<JustProps<T>, CompileTimeMetadata<T>["primaryKeyApiName"]>): void;
+    addObject(objectType: string, primaryKey: string | number | boolean, object: BaseServerObject): void;
+    modifyObject<T extends ObjectTypeDefinition>(objectType: T["apiName"], primaryKey: PrimaryKeyType<T>, update: Partial<JustProps<T>>): void;
+    modifyObject(objectType: string, primaryKey: string | number | boolean, update: Partial<BaseServerObject>): void;
+    deleteObject: (objectType: string, primaryKey: string | number | boolean) => void;
+    addLink: (leftObjectType: string, leftPrimaryKey: string | number | boolean, leftLinkName: string, rightObjectType: string, rightPrimaryKey: string | number | boolean) => void;
+    removeLink: (leftObjectType: string, leftPrimaryKey: string | number | boolean, leftLinkName: string, rightObjectType: string, rightPrimaryKey: string | number | boolean) => void;
+}
+
+type FauxActionImpl<Q extends OntologiesV2$1.ActionTypeV2 = OntologiesV2$1.ActionTypeV2> = (batch: FauxDataStoreBatch, payload: TH_ApplyActionRequestV2<Q>, ctx: {
+    def: Q;
+    attachments: FauxAttachmentStore;
+}) => unknown;
+
+declare class FauxFoundry {
+    #private;
+    readonly attachments: FauxAttachmentStore;
+    readonly baseUrl: string;
+    readonly defaultOntologyRid: any;
+    readonly logger: Logger | undefined;
+    constructor(baseUrl: string, defaultOntology?: Ontology, { logger }?: {
+        logger?: Logger;
+    });
+    get handlers(): RequestHandler[];
+    getDefaultOntology(): FauxOntology;
+    getDefaultDataStore(): FauxDataStore;
+    createOntology(metadata: OntologyV2): FauxOntology;
+    registerOntology(ontology: FauxOntology): void;
+    getOntology(ontologyApiNameOrRid: string): FauxOntology;
+    setDataStore(ontologyApiNameOrRid: string, fauxDataStore: FauxDataStore): void;
+    getDataStore(ontologyApiNameOrRid: string): FauxDataStore;
+    getEveryOntology(): FauxOntology[];
+}
+
+declare function authHandlerMiddleware<TReqBody extends DefaultBodyType = DefaultBodyType, TPathParams extends PathParams<string> = PathParams<string>>(handler: HttpResponseResolver<TPathParams, TReqBody>): HttpResponseResolver<TPathParams, TReqBody>;
+
+declare class OpenApiCallError extends Error {
+    status: number;
+    json: {
+        errorCode: string;
+        errorName: string;
+        errorInstanceId: string;
+        parameters: Record<string, unknown>;
+    };
+    constructor(status: number, json: {
+        errorCode: string;
+        errorName: string;
+        errorInstanceId: string;
+        parameters: Record<string, unknown>;
+    });
+}
+type SkipStringParams<T extends any[]> = T extends [infer A, ...infer B] ? A extends string ? SkipStringParams<B> : T : T;
+/**
+ * This relies on a trick that generally our query params and header params are optional therefore
+ * the body can generally be assumed to be the first payload following the strings which are path
+ * params.
+ *
+ * This will also fail if your body is defined as a string as that will get interpreted as a path param.
+ * If this happens, you cannot use the helper. Sorry
+ */
+type ExtractBody<X extends ((reqCall: any, ...args: any[]) => Promise<any>)> = undefined extends SkipStringParams<ParamsAfterReqCall<X>>[0] ? never : SkipStringParams<ParamsAfterReqCall<X>>[0];
+type ExtractResponse<X extends ((...args: any[]) => Promise<any>)> = Awaited<ReturnType<X>>;
+type ParamsAfterReqCall<T extends (reqCall: any, ...args: any[]) => Promise<any>> = T extends (reqCall: any, ...args: infer Z) => Promise<any> ? Z : never;
+type RestImpl<URL_PARAMS extends string, REQ_BODY extends DefaultBodyType, RESP_BODY extends DefaultBodyType> = (info: Parameters<HttpResponseResolver<Record<URL_PARAMS, string>, REQ_BODY, RESP_BODY | BaseAPIError>>[0]) => RESP_BODY | Promise<RESP_BODY>;
+type CallFactory<URL_PARAMS extends string, X extends ((...args: any[]) => Promise<any>)> = (baseUrl: string, restImpl: RestImpl<URL_PARAMS, ExtractBody<X>, ExtractResponse<X>>, options?: RequestHandlerOptions) => HttpHandler;
+
+declare const applyBatch: CallFactory<"ontologyApiName" | "actionType", typeof Actions$1.applyBatch>;
+declare const apply: CallFactory<"ontologyApiName" | "actionType", typeof Actions$1.apply>;
+
+declare const Actions_apply: typeof apply;
+declare const Actions_applyBatch: typeof applyBatch;
+declare namespace Actions {
+  export { Actions_apply as apply, Actions_applyBatch as applyBatch };
+}
+
+declare const list$5: CallFactory<"ontologyApiName", typeof ActionTypesV2$1.list>;
+declare const get$6: CallFactory<"ontologyApiName" | "actionTypeApiName", typeof ActionTypesV2$1.get>;
+
+declare namespace ActionTypesV2 {
+  export { get$6 as get, list$5 as list };
+}
+
+declare const getAttachment: CallFactory<"ontologyApiName" | "objectType" | "primaryKey" | "propertyName", typeof AttachmentPropertiesV2$1.getAttachment>;
+declare const readAttachment: CallFactory<"ontologyApiName" | "objectType" | "primaryKey" | "propertyName", typeof AttachmentPropertiesV2$1.readAttachment>;
+
+declare const AttachmentPropertiesV2_getAttachment: typeof getAttachment;
+declare const AttachmentPropertiesV2_readAttachment: typeof readAttachment;
+declare namespace AttachmentPropertiesV2 {
+  export { AttachmentPropertiesV2_getAttachment as getAttachment, AttachmentPropertiesV2_readAttachment as readAttachment };
+}
+
+declare const upload$1: CallFactory<never, typeof Attachments$1.upload>;
+declare const get$5: CallFactory<"attachmentRid", typeof Attachments$1.get>;
+declare const read: CallFactory<"attachmentRid", typeof Attachments$1.read>;
+
+declare const Attachments_read: typeof read;
+declare namespace Attachments {
+  export { get$5 as get, Attachments_read as read, upload$1 as upload };
+}
+
+declare const listLinkedObjects: CallFactory<"ontologyApiName" | "objectType" | "primaryKey" | "linkType", typeof LinkedObjectsV2$1.listLinkedObjects>;
+declare const getLinkedObject: CallFactory<"ontologyApiName" | "objectType" | "primaryKey" | "linkType" | "targetPrimaryKey", typeof LinkedObjectsV2$1.getLinkedObject>;
+
+declare const LinkedObjectsV2_getLinkedObject: typeof getLinkedObject;
+declare const LinkedObjectsV2_listLinkedObjects: typeof listLinkedObjects;
+declare namespace LinkedObjectsV2 {
+  export { LinkedObjectsV2_getLinkedObject as getLinkedObject, LinkedObjectsV2_listLinkedObjects as listLinkedObjects };
+}
+
+declare const getMediaMetadata: CallFactory<"ontologyApiName" | "objectType" | "primaryKey" | "propertyName", typeof MediaReferenceProperties$1.getMediaMetadata>;
+declare const getMediaContent: CallFactory<"ontologyApiName" | "objectType" | "primaryKey" | "propertyName", typeof MediaReferenceProperties$1.getMediaContent>;
+declare const upload: CallFactory<"ontologyApiName" | "objectType" | "propertyName", typeof MediaReferenceProperties$1.upload>;
+
+declare const MediaReferenceProperties_getMediaContent: typeof getMediaContent;
+declare const MediaReferenceProperties_getMediaMetadata: typeof getMediaMetadata;
+declare const MediaReferenceProperties_upload: typeof upload;
+declare namespace MediaReferenceProperties {
+  export { MediaReferenceProperties_getMediaContent as getMediaContent, MediaReferenceProperties_getMediaMetadata as getMediaMetadata, MediaReferenceProperties_upload as upload };
+}
+
+declare const get$4: CallFactory<"ontologyApiName" | "objectTypeApiName", typeof ObjectTypesV2$1.get>;
+declare const getFullMetadata$1: CallFactory<"ontologyApiName" | "objectTypeApiName", typeof ObjectTypesV2$1.getFullMetadata>;
+declare const getOutgoingLinkType: CallFactory<"ontology" | "objectType" | "linkType", typeof ObjectTypesV2$1.getOutgoingLinkType>;
+declare const listOutgoingLinkTypes: CallFactory<"ontology" | "objectType", typeof ObjectTypesV2$1.listOutgoingLinkTypes>;
+declare const list$4: CallFactory<"ontologyApiName", typeof ObjectTypesV2$1.list>;
+
+declare const ObjectTypesV2_getOutgoingLinkType: typeof getOutgoingLinkType;
+declare const ObjectTypesV2_listOutgoingLinkTypes: typeof listOutgoingLinkTypes;
+declare namespace ObjectTypesV2 {
+  export { get$4 as get, getFullMetadata$1 as getFullMetadata, ObjectTypesV2_getOutgoingLinkType as getOutgoingLinkType, list$4 as list, ObjectTypesV2_listOutgoingLinkTypes as listOutgoingLinkTypes };
+}
+
+declare const getFullMetadata: CallFactory<"ontologyApiName", typeof OntologiesV2$2.getFullMetadata>;
+declare const loadMetadata: CallFactory<"ontologyApiName", typeof OntologiesV2$2.loadMetadata>;
+declare const list$3: CallFactory<never, typeof OntologiesV2$2.list>;
+/**
+ * Get specified Ontology
+ */
+declare const get$3: CallFactory<"ontologyRid", typeof OntologiesV2$2.get>;
+
+declare const OntologiesV2_getFullMetadata: typeof getFullMetadata;
+declare const OntologiesV2_loadMetadata: typeof loadMetadata;
+declare namespace OntologiesV2 {
+  export { get$3 as get, OntologiesV2_getFullMetadata as getFullMetadata, list$3 as list, OntologiesV2_loadMetadata as loadMetadata };
+}
+
+declare const list$2: CallFactory<"ontologyApiName", typeof OntologyInterfaces$1.list>;
+declare const get$2: CallFactory<"ontologyApiName" | "interfaceType", typeof OntologyInterfaces$1.get>;
+
+declare namespace OntologyInterfaces {
+  export { get$2 as get, list$2 as list };
+}
+
+declare const load: CallFactory<"ontologyApiName", typeof OntologyObjectSets$1.load>;
+declare const aggregate: CallFactory<"ontologyApiName", typeof OntologyObjectSets$1.aggregate>;
+declare const loadMultipleObjectTypes: CallFactory<"ontologyApiName", typeof OntologyObjectSets$1.loadMultipleObjectTypes>;
+
+declare const OntologyObjectSets_aggregate: typeof aggregate;
+declare const OntologyObjectSets_load: typeof load;
+declare const OntologyObjectSets_loadMultipleObjectTypes: typeof loadMultipleObjectTypes;
+declare namespace OntologyObjectSets {
+  export { OntologyObjectSets_aggregate as aggregate, OntologyObjectSets_load as load, OntologyObjectSets_loadMultipleObjectTypes as loadMultipleObjectTypes };
+}
+
+declare const get$1: CallFactory<"ontologyApiName" | "objectType" | "primaryKey", typeof OntologyObjectsV2$1.get>;
+declare const list$1: CallFactory<"ontologyApiName" | "objectType", typeof OntologyObjectsV2$1.list>;
+
+declare namespace OntologyObjectsV2 {
+  export { get$1 as get, list$1 as list };
+}
+
+declare const execute: CallFactory<"ontologyApiName" | "queryApiName", typeof Queries$1.execute>;
+
+declare const Queries_execute: typeof execute;
+declare namespace Queries {
+  export { Queries_execute as execute };
+}
+
+declare const get: CallFactory<"ontologyApiName" | "queryTypeApiName", typeof QueryTypes$1.get>;
+declare const list: CallFactory<"ontologyApiName", typeof QueryTypes$1.list>;
+
+declare const QueryTypes_get: typeof get;
+declare const QueryTypes_list: typeof list;
+declare namespace QueryTypes {
+  export { QueryTypes_get as get, QueryTypes_list as list };
+}
+
+declare const getFirstPoint: CallFactory<"ontologyApiName" | "objectType" | "primaryKey" | "propertyName", typeof TimeSeriesPropertiesV2$1.getFirstPoint>;
+declare const getLastPoint: CallFactory<"ontologyApiName" | "objectType" | "primaryKey" | "propertyName", typeof TimeSeriesPropertiesV2$1.getLastPoint>;
+declare const streamPoints: CallFactory<"ontologyApiName" | "objectType" | "primaryKey" | "propertyName", typeof TimeSeriesPropertiesV2$1.streamPoints>;
+
+declare const TimeSeriesPropertiesV2_getFirstPoint: typeof getFirstPoint;
+declare const TimeSeriesPropertiesV2_getLastPoint: typeof getLastPoint;
+declare const TimeSeriesPropertiesV2_streamPoints: typeof streamPoints;
+declare namespace TimeSeriesPropertiesV2 {
+  export { TimeSeriesPropertiesV2_getFirstPoint as getFirstPoint, TimeSeriesPropertiesV2_getLastPoint as getLastPoint, TimeSeriesPropertiesV2_streamPoints as streamPoints };
+}
+
+declare const getLatestValue: CallFactory<"ontologyApiName" | "objectType" | "primaryKey" | "propertyName", typeof TimeSeriesValueBankProperties$1.getLatestValue>;
+declare const streamValues: CallFactory<"ontologyApiName" | "objectType" | "primaryKey" | "propertyName", typeof TimeSeriesValueBankProperties$1.streamValues>;
+
+declare const TimeSeriesValueBankProperties_getLatestValue: typeof getLatestValue;
+declare const TimeSeriesValueBankProperties_streamValues: typeof streamValues;
+declare namespace TimeSeriesValueBankProperties {
+  export { TimeSeriesValueBankProperties_getLatestValue as getLatestValue, TimeSeriesValueBankProperties_streamValues as streamValues };
+}
+
+declare const index_ActionTypesV2: typeof ActionTypesV2;
+declare const index_Actions: typeof Actions;
+declare const index_AttachmentPropertiesV2: typeof AttachmentPropertiesV2;
+declare const index_Attachments: typeof Attachments;
+declare const index_LinkedObjectsV2: typeof LinkedObjectsV2;
+declare const index_MediaReferenceProperties: typeof MediaReferenceProperties;
+declare const index_ObjectTypesV2: typeof ObjectTypesV2;
+declare const index_OntologiesV2: typeof OntologiesV2;
+declare const index_OntologyInterfaces: typeof OntologyInterfaces;
+declare const index_OntologyObjectSets: typeof OntologyObjectSets;
+declare const index_OntologyObjectsV2: typeof OntologyObjectsV2;
+declare const index_Queries: typeof Queries;
+declare const index_QueryTypes: typeof QueryTypes;
+declare const index_TimeSeriesPropertiesV2: typeof TimeSeriesPropertiesV2;
+declare const index_TimeSeriesValueBankProperties: typeof TimeSeriesValueBankProperties;
+declare namespace index {
+  export { index_ActionTypesV2 as ActionTypesV2, index_Actions as Actions, index_AttachmentPropertiesV2 as AttachmentPropertiesV2, index_Attachments as Attachments, index_LinkedObjectsV2 as LinkedObjectsV2, index_MediaReferenceProperties as MediaReferenceProperties, index_ObjectTypesV2 as ObjectTypesV2, index_OntologiesV2 as OntologiesV2, index_OntologyInterfaces as OntologyInterfaces, index_OntologyObjectSets as OntologyObjectSets, index_OntologyObjectsV2 as OntologyObjectsV2, index_Queries as Queries, index_QueryTypes as QueryTypes, index_TimeSeriesPropertiesV2 as TimeSeriesPropertiesV2, index_TimeSeriesValueBankProperties as TimeSeriesValueBankProperties };
+}
+
+declare function withoutRid<T extends {
+    __rid?: any;
+}>(o: T): Omit<T, "__rid">;
+
+export { type BaseAPIError, errors as Errors, type FauxActionImpl, FauxDataStore, FauxDataStoreBatch, FauxFoundry, FauxOntology, index as MockOntologiesV2, OpenApiCallError, index$1 as TypeHelpers, authHandlerMiddleware, isBaseApiError, withoutRid };

package/build/esm/BaseError.js

@@ -0,0 +1,21 @@
+/*
+ * 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.
+ */
+
+// These are the shape of the errors that come back from the API.
+export function isBaseApiError(error) {
+  return error && typeof error === "object" && "errorCode" in error && "errorName" in error && "errorInstanceId" in error;
+}
+//# sourceMappingURL=BaseError.js.map

package/build/esm/BaseError.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"BaseError.js","names":["isBaseApiError","error"],"sources":["BaseError.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\nexport interface BaseAPIError {\n  errorCode: string;\n  errorName: string;\n  errorInstanceId: string;\n  parameters: Record<string, any>;\n}\n\n// These are the shape of the errors that come back from the API.\nexport function isBaseApiError(error: any): error is BaseAPIError {\n  return (\n    error && typeof error === \"object\" && \"errorCode\" in error\n    && \"errorName\" in error && \"errorInstanceId\" in error\n  );\n}\n"],"mappings":"AAAA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AASA;AACA,OAAO,SAASA,cAAcA,CAACC,KAAU,EAAyB;EAChE,OACEA,KAAK,IAAI,OAAOA,KAAK,KAAK,QAAQ,IAAI,WAAW,IAAIA,KAAK,IACvD,WAAW,IAAIA,KAAK,IAAI,iBAAiB,IAAIA,KAAK;AAEzD","ignoreList":[]}

package/build/esm/FauxFoundry/BaseOsdkObjectType.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=BaseOsdkObjectType.js.map

package/build/esm/FauxFoundry/BaseOsdkObjectType.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"BaseOsdkObjectType.js","names":[],"sources":["BaseOsdkObjectType.ts"],"sourcesContent":["/*\n * Copyright 2025 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\nexport interface BaseOsdkObjectType {\n  $apiName: string;\n  $primaryKey: string | number | boolean;\n\n  [key: string]: string | number | boolean | undefined;\n}\n"],"mappings":"","ignoreList":[]}

package/build/esm/FauxFoundry/BaseServerObject.js

@@ -0,0 +1,30 @@
+/*
+ * Copyright 2025 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.
+ */
+
+/**
+ * A simplified type safe version of `OntologyObjectV2` that adds a tiny bit
+ * more strictness in that it declares the meaning of values for the `__` prefix
+ * props.
+ */
+
+/**
+ * Helpful for distinguishing between an object that looks like it is for the server (__apiName)
+ * vs one that is for the client ($apiName).
+ */
+export function isBaseServerObject(obj) {
+  return typeof obj === "object" && obj != null && "__primaryKey" in obj && "__apiName" in obj && !("$apiName" in obj) && !("$primaryKey" in obj);
+}
+//# sourceMappingURL=BaseServerObject.js.map

package/build/esm/FauxFoundry/BaseServerObject.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"BaseServerObject.js","names":["isBaseServerObject","obj"],"sources":["BaseServerObject.ts"],"sourcesContent":["/*\n * Copyright 2025 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 * as OntologiesV2 from \"@osdk/foundry.ontologies\";\n\n/**\n * A simplified type safe version of `OntologyObjectV2` that adds a tiny bit\n * more strictness in that it declares the meaning of values for the `__` prefix\n * props.\n */\nexport interface BaseServerObject extends OntologiesV2.OntologyObjectV2 {\n  __rid?: string;\n  __primaryKey: string | number | boolean;\n  __apiName: OntologiesV2.ObjectTypeApiName;\n  __title?: string;\n\n  [key: string]: unknown;\n}\n\n/**\n * Helpful for distinguishing between an object that looks like it is for the server (__apiName)\n * vs one that is for the client ($apiName).\n */\nexport function isBaseServerObject(obj: unknown): obj is BaseServerObject {\n  return (\n    typeof obj === \"object\"\n    && obj != null\n    && \"__primaryKey\" in obj\n    && \"__apiName\" in obj\n    && !(\"$apiName\" in obj)\n    && !(\"$primaryKey\" in obj)\n  );\n}\n"],"mappings":"AAAA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAIA;AACA;AACA;AACA;AACA;;AAUA;AACA;AACA;AACA;AACA,OAAO,SAASA,kBAAkBA,CAACC,GAAY,EAA2B;EACxE,OACE,OAAOA,GAAG,KAAK,QAAQ,IACpBA,GAAG,IAAI,IAAI,IACX,cAAc,IAAIA,GAAG,IACrB,WAAW,IAAIA,GAAG,IAClB,EAAE,UAAU,IAAIA,GAAG,CAAC,IACpB,EAAE,aAAa,IAAIA,GAAG,CAAC;AAE9B","ignoreList":[]}

package/build/esm/FauxFoundry/FauxActionImpl.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=FauxActionImpl.js.map

package/build/esm/FauxFoundry/FauxActionImpl.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"FauxActionImpl.js","names":[],"sources":["FauxActionImpl.ts"],"sourcesContent":["/*\n * Copyright 2025 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 * as OntologiesV2 from \"@osdk/foundry.ontologies\";\nimport type { FauxAttachmentStore } from \"./FauxAttachmentStore.js\";\nimport type { FauxDataStoreBatch } from \"./FauxDataStoreBatch.js\";\nimport type { TH_ApplyActionRequestV2 } from \"./typeHelpers/TH_ApplyActionRequestV2.js\";\n\nexport type FauxActionImpl<\n  Q extends OntologiesV2.ActionTypeV2 = OntologiesV2.ActionTypeV2,\n> = (\n  batch: FauxDataStoreBatch,\n  payload: TH_ApplyActionRequestV2<Q>,\n  ctx: {\n    def: Q;\n    attachments: FauxAttachmentStore;\n  },\n) => unknown;\n"],"mappings":"","ignoreList":[]}