@croct/sdk 0.17.11 → 0.18.0

package/trackingEvents.d.cts

@@ -0,0 +1,309 @@
+import { Patch } from './patch.cjs';
+import { DistributiveOmit, Optional } from './utilityTypes.cjs';
+import '@croct/json';
+
+type ProductDetails = {
+    productId: string;
+    sku?: string;
+    name: string;
+    category?: string;
+    brand?: string;
+    variant?: string;
+    displayPrice: number;
+    originalPrice?: number;
+    url?: string;
+    imageUrl?: string;
+};
+type CartItem = {
+    index: number;
+    product: ProductDetails;
+    quantity: number;
+    total: number;
+    discount?: number;
+    coupon?: string;
+};
+type Cart = {
+    currency: string;
+    items: CartItem[];
+    subtotal?: number;
+    shippingPrice?: number;
+    taxes?: {
+        [key: string]: number;
+    };
+    costs?: {
+        [key: string]: number;
+    };
+    discount?: number;
+    total: number;
+    coupon?: string;
+    lastUpdateTime: number;
+};
+type OrderItem = {
+    index: number;
+    product: ProductDetails;
+    quantity?: number;
+    total: number;
+    discount?: number;
+    coupon?: string;
+};
+type OrderStatus = 'placed' | 'paid' | 'completed';
+type Order = {
+    orderId: string;
+    currency: string;
+    items: OrderItem[];
+    subtotal?: number;
+    shippingPrice?: number;
+    taxes?: {
+        [key: string]: number;
+    };
+    costs?: {
+        [key: string]: number;
+    };
+    discount?: number;
+    total: number;
+    coupon?: string;
+    paymentMethod?: string;
+    installments?: number;
+    status?: OrderStatus;
+};
+type Gender = 'male' | 'female' | 'neutral' | 'unknown';
+declare const pageEventTypes: readonly ["pageLoaded", "pageOpened"];
+declare const tabEventTypes: readonly ["tabOpened", "tabUrlChanged", "tabVisibilityChanged"];
+declare const cartEventTypes: readonly ["cartModified", "cartViewed", "checkoutStarted"];
+declare const ecommerceEventTypes: readonly ["cartModified", "cartViewed", "checkoutStarted", "orderPlaced", "productViewed"];
+declare const identifiedUserEventTypes: string[];
+declare const userEventTypes: readonly [...string[], "userProfileChanged"];
+declare const miscEventTypes: readonly ["nothingChanged", "sessionAttributesChanged", "goalCompleted", "interestShown", "postViewed", "eventOccurred", "linkOpened"];
+declare const eventTypes: readonly ["pageLoaded", "pageOpened", "cartModified", "cartViewed", "checkoutStarted", "orderPlaced", "productViewed", ...string[], "userProfileChanged", "nothingChanged", "sessionAttributesChanged", "goalCompleted", "interestShown", "postViewed", "eventOccurred", "linkOpened"];
+interface BaseEvent {
+    type: string;
+}
+interface UserProfileChanged extends BaseEvent {
+    type: 'userProfileChanged';
+    patch: Patch;
+}
+type Primitive = null | string | number | boolean;
+type PrimitiveMap = {
+    [member: string]: Primitive;
+};
+type PrimitiveArray = Primitive[];
+type TwoLevelMap = {
+    [member: string]: Primitive | PrimitiveMap | PrimitiveArray;
+};
+type TwoLevelArray = PrimitiveArray | PrimitiveMap[] | PrimitiveArray[];
+type CustomAttribute = Primitive | TwoLevelMap | TwoLevelArray;
+type UserProfile = {
+    firstName?: string;
+    lastName?: string;
+    birthDate?: string;
+    gender?: Gender;
+    email?: string;
+    alternateEmail?: string;
+    phone?: string;
+    alternatePhone?: string;
+    address?: {
+        street?: string;
+        district?: string;
+        city?: string;
+        region?: string;
+        country?: string;
+        postalCode?: string;
+    };
+    avatar?: string;
+    company?: string;
+    companyUrl?: string;
+    jobTitle?: string;
+    interests?: string[];
+    activities?: string[];
+    custom?: {
+        [member: string]: CustomAttribute;
+    };
+};
+interface UserSignedUp extends BaseEvent {
+    type: 'userSignedUp';
+    userId: string;
+    profile?: UserProfile;
+}
+interface UserSignedIn extends BaseEvent {
+    type: 'userSignedIn';
+    userId: string;
+}
+interface UserSignedOut extends BaseEvent {
+    type: 'userSignedOut';
+    userId: string;
+}
+type IdentifiedUserEvent = UserSignedIn | UserSignedOut | UserSignedUp;
+type UserEvent = UserProfileChanged | IdentifiedUserEvent;
+type CartEventType = typeof cartEventTypes[number];
+interface BaseCartEvent extends BaseEvent {
+    type: CartEventType;
+    cart: Cart;
+}
+interface CartViewed extends BaseCartEvent {
+    type: 'cartViewed';
+}
+interface CartModified extends BaseCartEvent {
+    type: 'cartModified';
+}
+interface CheckoutStarted extends BaseCartEvent {
+    type: 'checkoutStarted';
+    orderId?: string;
+}
+type CartEvent = CartModified | CartViewed | CheckoutStarted;
+interface OrderPlaced extends BaseEvent {
+    type: 'orderPlaced';
+    order: Order;
+}
+interface ProductViewed extends BaseEvent {
+    type: 'productViewed';
+    product: ProductDetails;
+}
+type EcommerceEvent = OrderPlaced | ProductViewed | CartEvent;
+/**
+ * Tab event
+ */
+type TabEventType = typeof tabEventTypes[number];
+interface BaseTabEvent extends BaseEvent {
+    type: TabEventType;
+    tabId: string;
+}
+interface TabOpened extends BaseTabEvent {
+    type: 'tabOpened';
+}
+interface TabUrlChanged extends BaseTabEvent {
+    type: 'tabUrlChanged';
+    url: string;
+}
+interface TabVisibilityChanged extends BaseTabEvent {
+    type: 'tabVisibilityChanged';
+    visibility: 'visible' | 'hidden';
+}
+type TabEvent = TabVisibilityChanged | TabUrlChanged | TabOpened;
+type PageEventType = typeof pageEventTypes[number];
+interface BasePageEvent extends BaseEvent {
+    type: PageEventType;
+    url: string;
+}
+interface PageOpened extends BasePageEvent {
+    type: 'pageOpened';
+    referrer?: string;
+}
+interface PageLoaded extends BasePageEvent {
+    type: 'pageLoaded';
+    title: string;
+    lastModifiedTime: number;
+}
+type PageEvent = PageLoaded | PageOpened;
+interface NothingChanged extends BaseEvent {
+    type: 'nothingChanged';
+    sinceTime: number;
+}
+interface SessionAttributesChanged extends BaseEvent {
+    type: 'sessionAttributesChanged';
+    patch: Patch;
+}
+interface GoalCompleted extends BaseEvent {
+    type: 'goalCompleted';
+    goalId: string;
+    value?: number;
+    currency?: string;
+}
+interface InterestShown extends BaseEvent {
+    type: 'interestShown';
+    interests: string[];
+}
+interface PostDetails {
+    postId: string;
+    url?: string;
+    title: string;
+    tags?: string[];
+    categories?: string[];
+    authors?: string[];
+    publishTime: number;
+    updateTime?: number;
+}
+interface PostViewed extends BaseEvent {
+    type: 'postViewed';
+    post: PostDetails;
+}
+interface EventOccurred extends BaseEvent {
+    type: 'eventOccurred';
+    name: string;
+    details?: {
+        [key: string]: string | number | boolean | null;
+    };
+}
+interface LinkOpened extends BaseEvent {
+    type: 'linkOpened';
+    link: string;
+}
+type MiscEvent = NothingChanged | SessionAttributesChanged | EventOccurred | GoalCompleted | InterestShown | PostViewed | LinkOpened;
+type EventMap = {
+    tabVisibilityChanged: TabVisibilityChanged;
+    tabUrlChanged: TabUrlChanged;
+    tabOpened: TabOpened;
+    pageLoaded: PageLoaded;
+    pageOpened: PageOpened;
+    userSignedIn: UserSignedIn;
+    userSignedOut: UserSignedOut;
+    userSignedUp: UserSignedUp;
+    userProfileChanged: UserProfileChanged;
+    productViewed: ProductViewed;
+    cartViewed: CartViewed;
+    cartModified: CartModified;
+    checkoutStarted: CheckoutStarted;
+    orderPlaced: OrderPlaced;
+    nothingChanged: NothingChanged;
+    sessionAttributesChanged: SessionAttributesChanged;
+    goalCompleted: GoalCompleted;
+    interestShown: InterestShown;
+    postViewed: PostViewed;
+    eventOccurred: EventOccurred;
+    linkOpened: LinkOpened;
+};
+type TrackingEventType = keyof EventMap;
+type TrackingEvent<T extends TrackingEventType = TrackingEventType> = T extends TrackingEventType ? EventMap[T] : EventMap[TrackingEventType];
+/**
+ * Partial Events
+ */
+type CartPartialEvent<T extends CartEvent = CartEvent> = DistributiveOmit<T, 'cart'> & Record<'cart', Optional<Cart, 'lastUpdateTime'>>;
+type PartialTrackingEvent = Exclude<TrackingEvent, PageEvent | TabEvent | CartEvent> | CartPartialEvent;
+/**
+ * External Events
+ */
+type ExternalEventMap = {
+    cartModified: CartPartialEvent<CartModified>;
+    cartViewed: CartPartialEvent<CartViewed>;
+    checkoutStarted: CartPartialEvent<CheckoutStarted>;
+    orderPlaced: OrderPlaced;
+    productViewed: ProductViewed;
+    userSignedUp: UserSignedUp;
+    goalCompleted: GoalCompleted;
+    interestShown: InterestShown;
+    postViewed: PostViewed;
+    linkOpened: LinkOpened;
+    eventOccurred: EventOccurred;
+};
+type ExternalTrackingEventType = keyof ExternalEventMap;
+type ExternalTrackingEvent<T extends ExternalTrackingEventType = ExternalTrackingEventType> = T extends ExternalTrackingEventType ? ExternalEventMap[T] : ExternalEventMap[ExternalTrackingEventType];
+type ExternalTrackingEventPayload<T extends ExternalTrackingEventType> = Omit<ExternalEventMap[T], 'type'>;
+declare function isIdentifiedUserEvent(event: TrackingEvent): event is IdentifiedUserEvent;
+declare function isCartPartialEvent(event: PartialTrackingEvent): event is CartPartialEvent;
+type TrackingEventContext = {
+    tabId: string;
+    url: string;
+    metadata?: {
+        [key: string]: string;
+    };
+};
+type BeaconPayload = Exclude<TrackingEvent, IdentifiedUserEvent> | DistributiveOmit<Exclude<IdentifiedUserEvent, UserSignedUp>, 'userId'> & Record<'externalUserId', IdentifiedUserEvent['userId']> | Omit<UserSignedUp, 'userId' | 'profile'> & Record<'externalUserId', IdentifiedUserEvent['userId']> & {
+    patch?: Patch;
+};
+type Beacon = {
+    timestamp: number;
+    token?: string;
+    context: TrackingEventContext;
+    payload: BeaconPayload;
+};
+
+export { type Beacon, type BeaconPayload, type Cart, type CartEvent, type CartEventType, type CartItem, type CartModified, type CartViewed, type CheckoutStarted, type EcommerceEvent, type EventOccurred, type ExternalTrackingEvent, type ExternalTrackingEventPayload, type ExternalTrackingEventType, type Gender, type GoalCompleted, type IdentifiedUserEvent, type InterestShown, type LinkOpened, type MiscEvent, type NothingChanged, type Order, type OrderItem, type OrderPlaced, type OrderStatus, type PageEvent, type PageEventType, type PageLoaded, type PageOpened, type PartialTrackingEvent, type PostDetails, type PostViewed, type ProductDetails, type ProductViewed, type SessionAttributesChanged, type TabEvent, type TabEventType, type TabOpened, type TabUrlChanged, type TabVisibilityChanged, type TrackingEvent, type TrackingEventContext, type TrackingEventType, type UserEvent, type UserProfile, type UserProfileChanged, type UserSignedIn, type UserSignedOut, type UserSignedUp, cartEventTypes, ecommerceEventTypes, eventTypes, identifiedUserEventTypes, isCartPartialEvent, isIdentifiedUserEvent, miscEventTypes, pageEventTypes, tabEventTypes, userEventTypes };

package/trackingEvents.js

@@ -59,4 +59,3 @@ export {
   tabEventTypes,
   userEventTypes
 };
-//# sourceMappingURL=trackingEvents.js.map

package/transformer.cjs

@@ -27,4 +27,3 @@ const encodeJson = function encodeJson2(input) {
 0 && (module.exports = {
   encodeJson
 });
-//# sourceMappingURL=transformer.cjs.map

package/transformer.d.cts

@@ -0,0 +1,6 @@
+interface Transformer<I, O> {
+    (input: I): Promise<O>;
+}
+declare const encodeJson: Transformer<any, string>;
+
+export { type Transformer, encodeJson };

package/transformer.js

@@ -4,4 +4,3 @@ const encodeJson = function encodeJson2(input) {
 export {
   encodeJson
 };
-//# sourceMappingURL=transformer.js.map

package/utilityTypes.cjs

@@ -13,4 +13,3 @@ var __copyProps = (to, from, except, desc) => {
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 var utilityTypes_exports = {};
 module.exports = __toCommonJS(utilityTypes_exports);
-//# sourceMappingURL=utilityTypes.cjs.map

package/utilityTypes.d.cts

@@ -0,0 +1,4 @@
+type DistributiveOmit<T, K extends keyof T> = T extends unknown ? Omit<T, K> : never;
+type Optional<T, K extends keyof T> = Omit<T, K> & Partial<Pick<T, K>>;
+
+export type { DistributiveOmit, Optional };

package/utilityTypes.js

@@ -1 +0,0 @@
-//# sourceMappingURL=utilityTypes.js.map

package/uuid.cjs

@@ -52,4 +52,3 @@ function uuid4(sortable = false) {
 0 && (module.exports = {
   uuid4
 });
-//# sourceMappingURL=uuid.cjs.map

package/uuid.d.cts

@@ -0,0 +1,3 @@
+declare function uuid4(sortable?: boolean): string;
+
+export { uuid4 };

package/uuid.js

@@ -29,4 +29,3 @@ function uuid4(sortable = false) {
 export {
   uuid4
 };
-//# sourceMappingURL=uuid.js.map

package/validation/arrayType.cjs

@@ -20,8 +20,8 @@ __export(arrayType_exports, {
   ArrayType: () => ArrayType
 });
 module.exports = __toCommonJS(arrayType_exports);
-var import_schema = require("./schema");
-var import_violation = require("./violation");
+var import_schema = require('./schema.cjs');
+var import_violation = require('./violation.cjs');
 class ArrayType {
   constructor(definition = {}) {
     this.definition = {
@@ -72,4 +72,3 @@ class ArrayType {
 0 && (module.exports = {
   ArrayType
 });
-//# sourceMappingURL=arrayType.cjs.map

package/validation/arrayType.d.cts

@@ -0,0 +1,16 @@
+import { TypeSchema, Schema } from './schema.cjs';
+
+type ArrayDefinition = {
+    minItems: number;
+    maxItems: number;
+    items?: Schema;
+};
+declare class ArrayType implements TypeSchema {
+    private readonly definition;
+    constructor(definition?: Partial<ArrayDefinition>);
+    getTypes(): string[];
+    isValidType(value: unknown): value is unknown[];
+    validate(value: unknown, path?: string[]): void;
+}
+
+export { ArrayType };

package/validation/arrayType.js

@@ -1,5 +1,5 @@
-import { Violation } from "./schema";
-import { describe, formatPath } from "./violation";
+import { Violation } from "./schema.js";
+import { describe, formatPath } from "./violation.js";
 class ArrayType {
   constructor(definition = {}) {
     this.definition = {
@@ -49,4 +49,3 @@ class ArrayType {
 export {
   ArrayType
 };
-//# sourceMappingURL=arrayType.js.map

package/validation/booleanType.cjs

@@ -20,8 +20,8 @@ __export(booleanType_exports, {
   BooleanType: () => BooleanType
 });
 module.exports = __toCommonJS(booleanType_exports);
-var import_schema = require("./schema");
-var import_violation = require("./violation");
+var import_schema = require('./schema.cjs');
+var import_violation = require('./violation.cjs');
 class BooleanType {
   getTypes() {
     return ["boolean"];
@@ -43,4 +43,3 @@ class BooleanType {
 0 && (module.exports = {
   BooleanType
 });
-//# sourceMappingURL=booleanType.cjs.map

package/validation/booleanType.d.cts

@@ -0,0 +1,9 @@
+import { TypeSchema } from './schema.cjs';
+
+declare class BooleanType implements TypeSchema {
+    getTypes(): string[];
+    isValidType(value: unknown): value is boolean;
+    validate(value: unknown, path?: string[]): void;
+}
+
+export { BooleanType };

package/validation/booleanType.js

@@ -1,5 +1,5 @@
-import { Violation } from "./schema";
-import { describe, formatPath } from "./violation";
+import { Violation } from "./schema.js";
+import { describe, formatPath } from "./violation.js";
 class BooleanType {
   getTypes() {
     return ["boolean"];
@@ -20,4 +20,3 @@ class BooleanType {
 export {
   BooleanType
 };
-//# sourceMappingURL=booleanType.js.map

package/validation/functionType.cjs

@@ -20,8 +20,8 @@ __export(functionType_exports, {
   FunctionType: () => FunctionType
 });
 module.exports = __toCommonJS(functionType_exports);
-var import_schema = require("./schema");
-var import_violation = require("./violation");
+var import_schema = require('./schema.cjs');
+var import_violation = require('./violation.cjs');
 class FunctionType {
   getTypes() {
     return ["function"];
@@ -43,4 +43,3 @@ class FunctionType {
 0 && (module.exports = {
   FunctionType
 });
-//# sourceMappingURL=functionType.cjs.map

package/validation/functionType.d.cts

@@ -0,0 +1,9 @@
+import { TypeSchema } from './schema.cjs';
+
+declare class FunctionType implements TypeSchema {
+    getTypes(): string[];
+    isValidType(value: unknown): value is boolean;
+    validate(value: unknown, path?: string[]): void;
+}
+
+export { FunctionType };

package/validation/functionType.js

@@ -1,5 +1,5 @@
-import { Violation } from "./schema";
-import { describe, formatPath } from "./violation";
+import { Violation } from "./schema.js";
+import { describe, formatPath } from "./violation.js";
 class FunctionType {
   getTypes() {
     return ["function"];
@@ -20,4 +20,3 @@ class FunctionType {
 export {
   FunctionType
 };
-//# sourceMappingURL=functionType.js.map

package/validation/index.cjs

@@ -33,18 +33,18 @@ __export(validation_exports, {
   UnionType: () => import_unionType.UnionType
 });
 module.exports = __toCommonJS(validation_exports);
-__reExport(validation_exports, require("./schema"), module.exports);
-__reExport(validation_exports, require("./violation"), module.exports);
-var import_arrayType = require("./arrayType");
-var import_booleanType = require("./booleanType");
-var import_functionType = require("./functionType");
-var import_jsonType = require("./jsonType");
-var import_mixedSchema = require("./mixedSchema");
-var import_nullType = require("./nullType");
-var import_numberType = require("./numberType");
-var import_objectType = require("./objectType");
-var import_stringType = require("./stringType");
-var import_unionType = require("./unionType");
+__reExport(validation_exports, require('./schema.cjs'), module.exports);
+__reExport(validation_exports, require('./violation.cjs'), module.exports);
+var import_arrayType = require('./arrayType.cjs');
+var import_booleanType = require('./booleanType.cjs');
+var import_functionType = require('./functionType.cjs');
+var import_jsonType = require('./jsonType.cjs');
+var import_mixedSchema = require('./mixedSchema.cjs');
+var import_nullType = require('./nullType.cjs');
+var import_numberType = require('./numberType.cjs');
+var import_objectType = require('./objectType.cjs');
+var import_stringType = require('./stringType.cjs');
+var import_unionType = require('./unionType.cjs');
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   ArrayType,
@@ -60,7 +60,6 @@ var import_unionType = require("./unionType");
   ObjectType,
   StringType,
   UnionType,
-  ...require("./schema"),
-  ...require("./violation")
+  ...require('./schema.cjs'),
+  ...require('./violation.cjs')
 });
-//# sourceMappingURL=index.cjs.map

package/validation/index.d.cts

@@ -0,0 +1,12 @@
+export { Schema, TypeSchema, Violation } from './schema.cjs';
+export { describe, formatPath } from './violation.cjs';
+export { ArrayType } from './arrayType.cjs';
+export { BooleanType } from './booleanType.cjs';
+export { FunctionType } from './functionType.cjs';
+export { JsonArrayType, JsonObjectType, JsonPrimitiveType, JsonType } from './jsonType.cjs';
+export { MixedSchema } from './mixedSchema.cjs';
+export { NullType } from './nullType.cjs';
+export { NumberType } from './numberType.cjs';
+export { ObjectType } from './objectType.cjs';
+export { StringType } from './stringType.cjs';
+export { UnionType } from './unionType.cjs';

package/validation/index.js

@@ -1,15 +1,15 @@
-export * from "./schema";
-export * from "./violation";
-import { ArrayType } from "./arrayType";
-import { BooleanType } from "./booleanType";
-import { FunctionType } from "./functionType";
-import { JsonType, JsonArrayType, JsonObjectType, JsonPrimitiveType } from "./jsonType";
-import { MixedSchema } from "./mixedSchema";
-import { NullType } from "./nullType";
-import { NumberType } from "./numberType";
-import { ObjectType } from "./objectType";
-import { StringType } from "./stringType";
-import { UnionType } from "./unionType";
+export * from "./schema.js";
+export * from "./violation.js";
+import { ArrayType } from "./arrayType.js";
+import { BooleanType } from "./booleanType.js";
+import { FunctionType } from "./functionType.js";
+import { JsonType, JsonArrayType, JsonObjectType, JsonPrimitiveType } from "./jsonType.js";
+import { MixedSchema } from "./mixedSchema.js";
+import { NullType } from "./nullType.js";
+import { NumberType } from "./numberType.js";
+import { ObjectType } from "./objectType.js";
+import { StringType } from "./stringType.js";
+import { UnionType } from "./unionType.js";
 export {
   ArrayType,
   BooleanType,
@@ -25,4 +25,3 @@ export {
   StringType,
   UnionType
 };
-//# sourceMappingURL=index.js.map

package/validation/jsonType.cjs

@@ -23,8 +23,8 @@ __export(jsonType_exports, {
   JsonType: () => JsonType
 });
 module.exports = __toCommonJS(jsonType_exports);
-var import_schema = require("./schema");
-var import_violation = require("./violation");
+var import_schema = require('./schema.cjs');
+var import_violation = require('./violation.cjs');
 function isJsonPrimitive(value) {
   return value === null || typeof value === "string" || typeof value === "boolean" || typeof value === "number";
 }
@@ -139,4 +139,3 @@ class JsonType {
   JsonPrimitiveType,
   JsonType
 });
-//# sourceMappingURL=jsonType.cjs.map

package/validation/jsonType.d.cts

@@ -0,0 +1,35 @@
+import { TypeSchema, Schema } from './schema.cjs';
+
+type JsonObjectDefinition = {
+    properties?: Schema;
+    propertyNames?: Schema;
+};
+declare class JsonObjectType implements TypeSchema {
+    private readonly definition;
+    constructor(definition?: JsonObjectDefinition);
+    getTypes(): string[];
+    isValidType(value: unknown): boolean;
+    validate(value: unknown, path?: string[]): void;
+}
+type JsonArrayDefinition = {
+    items?: Schema;
+};
+declare class JsonArrayType implements TypeSchema {
+    private readonly definition;
+    constructor(definition?: JsonArrayDefinition);
+    getTypes(): string[];
+    isValidType(value: unknown): boolean;
+    validate(value: unknown, path?: string[]): void;
+}
+declare class JsonPrimitiveType implements TypeSchema {
+    getTypes(): string[];
+    isValidType(value: unknown): boolean;
+    validate(value: unknown, path?: string[]): void;
+}
+declare class JsonType implements TypeSchema {
+    getTypes(): string[];
+    isValidType(value: unknown): boolean;
+    validate(value: unknown, path?: string[]): void;
+}
+
+export { JsonArrayType, JsonObjectType, JsonPrimitiveType, JsonType };

package/validation/jsonType.js

@@ -1,5 +1,5 @@
-import { Violation } from "./schema";
-import { describe, formatPath } from "./violation";
+import { Violation } from "./schema.js";
+import { describe, formatPath } from "./violation.js";
 function isJsonPrimitive(value) {
   return value === null || typeof value === "string" || typeof value === "boolean" || typeof value === "number";
 }
@@ -113,4 +113,3 @@ export {
   JsonPrimitiveType,
   JsonType
 };
-//# sourceMappingURL=jsonType.js.map

package/validation/mixedSchema.cjs

@@ -28,4 +28,3 @@ class MixedSchema {
 0 && (module.exports = {
   MixedSchema
 });
-//# sourceMappingURL=mixedSchema.cjs.map

package/validation/mixedSchema.d.cts

@@ -0,0 +1,7 @@
+import { Schema } from './schema.cjs';
+
+declare class MixedSchema implements Schema {
+    validate(): void;
+}
+
+export { MixedSchema };