@erxes/api-shared 0.0.0-stage → 3.2.19-2

package/dist/declarations/src/core-modules/segments/zodSchemas.d.ts

@@ -0,0 +1,532 @@
+import { z } from 'zod';
+import { SegmentNode } from "./nodes.js";
+import { TSegmentProducers } from "./types.js";
+export declare const SegmentNodeSchema: z.ZodType<SegmentNode>;
+export declare const SegmentBaseInput: z.ZodObject<{
+    subdomain: z.ZodString;
+    data: z.ZodOptional<z.ZodAny>;
+}, "strip", z.ZodTypeAny, {
+    subdomain: string;
+    data?: any;
+}, {
+    subdomain: string;
+    data?: any;
+}>;
+declare const EvaluateFieldsInputData: z.ZodObject<{
+    subjectType: z.ZodString;
+    subjectIds: z.ZodArray<z.ZodString, "many">;
+    timeZone: z.ZodOptional<z.ZodString>;
+    requests: z.ZodArray<z.ZodUnion<[z.ZodObject<{
+        kind: z.ZodLiteral<"field">;
+        ref: z.ZodString;
+        contentType: z.ZodString;
+        fieldKey: z.ZodString;
+    }, "strip", z.ZodTypeAny, {
+        kind: "field";
+        contentType: string;
+        ref: string;
+        fieldKey: string;
+    }, {
+        kind: "field";
+        contentType: string;
+        ref: string;
+        fieldKey: string;
+    }>, z.ZodObject<{
+        kind: z.ZodLiteral<"relation">;
+        ref: z.ZodString;
+        relationKey: z.ZodString;
+        measure: z.ZodUnion<[z.ZodObject<{
+            op: z.ZodEnum<["exists", "none", "count"]>;
+        }, "strip", z.ZodTypeAny, {
+            op: "count" | "exists" | "none";
+        }, {
+            op: "count" | "exists" | "none";
+        }>, z.ZodObject<{
+            op: z.ZodEnum<["sum", "avg", "min", "max"]>;
+            fieldKey: z.ZodString;
+        }, "strip", z.ZodTypeAny, {
+            fieldKey: string;
+            op: "max" | "min" | "sum" | "avg";
+        }, {
+            fieldKey: string;
+            op: "max" | "min" | "sum" | "avg";
+        }>]>;
+        child: z.ZodOptional<z.ZodType<SegmentNode, z.ZodTypeDef, SegmentNode>>;
+        edges: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodArray<z.ZodString, "many">>>;
+    }, "strip", z.ZodTypeAny, {
+        kind: "relation";
+        ref: string;
+        relationKey: string;
+        measure: {
+            op: "count" | "exists" | "none";
+        } | {
+            fieldKey: string;
+            op: "max" | "min" | "sum" | "avg";
+        };
+        child?: SegmentNode | undefined;
+        edges?: Record<string, string[]> | undefined;
+    }, {
+        kind: "relation";
+        ref: string;
+        relationKey: string;
+        measure: {
+            op: "count" | "exists" | "none";
+        } | {
+            fieldKey: string;
+            op: "max" | "min" | "sum" | "avg";
+        };
+        child?: SegmentNode | undefined;
+        edges?: Record<string, string[]> | undefined;
+    }>]>, "many">;
+}, "strip", z.ZodTypeAny, {
+    subjectType: string;
+    subjectIds: string[];
+    requests: ({
+        kind: "field";
+        contentType: string;
+        ref: string;
+        fieldKey: string;
+    } | {
+        kind: "relation";
+        ref: string;
+        relationKey: string;
+        measure: {
+            op: "count" | "exists" | "none";
+        } | {
+            fieldKey: string;
+            op: "max" | "min" | "sum" | "avg";
+        };
+        child?: SegmentNode | undefined;
+        edges?: Record<string, string[]> | undefined;
+    })[];
+    timeZone?: string | undefined;
+}, {
+    subjectType: string;
+    subjectIds: string[];
+    requests: ({
+        kind: "field";
+        contentType: string;
+        ref: string;
+        fieldKey: string;
+    } | {
+        kind: "relation";
+        ref: string;
+        relationKey: string;
+        measure: {
+            op: "count" | "exists" | "none";
+        } | {
+            fieldKey: string;
+            op: "max" | "min" | "sum" | "avg";
+        };
+        child?: SegmentNode | undefined;
+        edges?: Record<string, string[]> | undefined;
+    })[];
+    timeZone?: string | undefined;
+}>;
+export declare const EvaluateFieldsInput: z.ZodObject<z.objectUtil.extendShape<{
+    subdomain: z.ZodString;
+    data: z.ZodOptional<z.ZodAny>;
+}, {
+    data: z.ZodObject<{
+        subjectType: z.ZodString;
+        subjectIds: z.ZodArray<z.ZodString, "many">;
+        timeZone: z.ZodOptional<z.ZodString>;
+        requests: z.ZodArray<z.ZodUnion<[z.ZodObject<{
+            kind: z.ZodLiteral<"field">;
+            ref: z.ZodString;
+            contentType: z.ZodString;
+            fieldKey: z.ZodString;
+        }, "strip", z.ZodTypeAny, {
+            kind: "field";
+            contentType: string;
+            ref: string;
+            fieldKey: string;
+        }, {
+            kind: "field";
+            contentType: string;
+            ref: string;
+            fieldKey: string;
+        }>, z.ZodObject<{
+            kind: z.ZodLiteral<"relation">;
+            ref: z.ZodString;
+            relationKey: z.ZodString;
+            measure: z.ZodUnion<[z.ZodObject<{
+                op: z.ZodEnum<["exists", "none", "count"]>;
+            }, "strip", z.ZodTypeAny, {
+                op: "count" | "exists" | "none";
+            }, {
+                op: "count" | "exists" | "none";
+            }>, z.ZodObject<{
+                op: z.ZodEnum<["sum", "avg", "min", "max"]>;
+                fieldKey: z.ZodString;
+            }, "strip", z.ZodTypeAny, {
+                fieldKey: string;
+                op: "max" | "min" | "sum" | "avg";
+            }, {
+                fieldKey: string;
+                op: "max" | "min" | "sum" | "avg";
+            }>]>;
+            child: z.ZodOptional<z.ZodType<SegmentNode, z.ZodTypeDef, SegmentNode>>;
+            edges: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodArray<z.ZodString, "many">>>;
+        }, "strip", z.ZodTypeAny, {
+            kind: "relation";
+            ref: string;
+            relationKey: string;
+            measure: {
+                op: "count" | "exists" | "none";
+            } | {
+                fieldKey: string;
+                op: "max" | "min" | "sum" | "avg";
+            };
+            child?: SegmentNode | undefined;
+            edges?: Record<string, string[]> | undefined;
+        }, {
+            kind: "relation";
+            ref: string;
+            relationKey: string;
+            measure: {
+                op: "count" | "exists" | "none";
+            } | {
+                fieldKey: string;
+                op: "max" | "min" | "sum" | "avg";
+            };
+            child?: SegmentNode | undefined;
+            edges?: Record<string, string[]> | undefined;
+        }>]>, "many">;
+    }, "strip", z.ZodTypeAny, {
+        subjectType: string;
+        subjectIds: string[];
+        requests: ({
+            kind: "field";
+            contentType: string;
+            ref: string;
+            fieldKey: string;
+        } | {
+            kind: "relation";
+            ref: string;
+            relationKey: string;
+            measure: {
+                op: "count" | "exists" | "none";
+            } | {
+                fieldKey: string;
+                op: "max" | "min" | "sum" | "avg";
+            };
+            child?: SegmentNode | undefined;
+            edges?: Record<string, string[]> | undefined;
+        })[];
+        timeZone?: string | undefined;
+    }, {
+        subjectType: string;
+        subjectIds: string[];
+        requests: ({
+            kind: "field";
+            contentType: string;
+            ref: string;
+            fieldKey: string;
+        } | {
+            kind: "relation";
+            ref: string;
+            relationKey: string;
+            measure: {
+                op: "count" | "exists" | "none";
+            } | {
+                fieldKey: string;
+                op: "max" | "min" | "sum" | "avg";
+            };
+            child?: SegmentNode | undefined;
+            edges?: Record<string, string[]> | undefined;
+        })[];
+        timeZone?: string | undefined;
+    }>;
+}>, "strip", z.ZodTypeAny, {
+    data: {
+        subjectType: string;
+        subjectIds: string[];
+        requests: ({
+            kind: "field";
+            contentType: string;
+            ref: string;
+            fieldKey: string;
+        } | {
+            kind: "relation";
+            ref: string;
+            relationKey: string;
+            measure: {
+                op: "count" | "exists" | "none";
+            } | {
+                fieldKey: string;
+                op: "max" | "min" | "sum" | "avg";
+            };
+            child?: SegmentNode | undefined;
+            edges?: Record<string, string[]> | undefined;
+        })[];
+        timeZone?: string | undefined;
+    };
+    subdomain: string;
+}, {
+    data: {
+        subjectType: string;
+        subjectIds: string[];
+        requests: ({
+            kind: "field";
+            contentType: string;
+            ref: string;
+            fieldKey: string;
+        } | {
+            kind: "relation";
+            ref: string;
+            relationKey: string;
+            measure: {
+                op: "count" | "exists" | "none";
+            } | {
+                fieldKey: string;
+                op: "max" | "min" | "sum" | "avg";
+            };
+            child?: SegmentNode | undefined;
+            edges?: Record<string, string[]> | undefined;
+        })[];
+        timeZone?: string | undefined;
+    };
+    subdomain: string;
+}>;
+declare const SegmentMemberQueryInputData: z.ZodObject<{
+    contentType: z.ZodString;
+    node: z.ZodType<SegmentNode, z.ZodTypeDef, SegmentNode>;
+    ids: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+    timeZone: z.ZodOptional<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    contentType: string;
+    node: SegmentNode;
+    ids?: string[] | undefined;
+    timeZone?: string | undefined;
+}, {
+    contentType: string;
+    node: SegmentNode;
+    ids?: string[] | undefined;
+    timeZone?: string | undefined;
+}>;
+declare const ListSegmentMembersInputData: z.ZodObject<z.objectUtil.extendShape<{
+    contentType: z.ZodString;
+    node: z.ZodType<SegmentNode, z.ZodTypeDef, SegmentNode>;
+    ids: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+    timeZone: z.ZodOptional<z.ZodString>;
+}, {
+    cursor: z.ZodOptional<z.ZodString>;
+    limit: z.ZodOptional<z.ZodNumber>;
+}>, "strip", z.ZodTypeAny, {
+    contentType: string;
+    node: SegmentNode;
+    limit?: number | undefined;
+    ids?: string[] | undefined;
+    cursor?: string | undefined;
+    timeZone?: string | undefined;
+}, {
+    contentType: string;
+    node: SegmentNode;
+    limit?: number | undefined;
+    ids?: string[] | undefined;
+    cursor?: string | undefined;
+    timeZone?: string | undefined;
+}>;
+export declare const ListSegmentMembersInput: z.ZodObject<z.objectUtil.extendShape<{
+    subdomain: z.ZodString;
+    data: z.ZodOptional<z.ZodAny>;
+}, {
+    data: z.ZodObject<z.objectUtil.extendShape<{
+        contentType: z.ZodString;
+        node: z.ZodType<SegmentNode, z.ZodTypeDef, SegmentNode>;
+        ids: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+        timeZone: z.ZodOptional<z.ZodString>;
+    }, {
+        cursor: z.ZodOptional<z.ZodString>;
+        limit: z.ZodOptional<z.ZodNumber>;
+    }>, "strip", z.ZodTypeAny, {
+        contentType: string;
+        node: SegmentNode;
+        limit?: number | undefined;
+        ids?: string[] | undefined;
+        cursor?: string | undefined;
+        timeZone?: string | undefined;
+    }, {
+        contentType: string;
+        node: SegmentNode;
+        limit?: number | undefined;
+        ids?: string[] | undefined;
+        cursor?: string | undefined;
+        timeZone?: string | undefined;
+    }>;
+}>, "strip", z.ZodTypeAny, {
+    data: {
+        contentType: string;
+        node: SegmentNode;
+        limit?: number | undefined;
+        ids?: string[] | undefined;
+        cursor?: string | undefined;
+        timeZone?: string | undefined;
+    };
+    subdomain: string;
+}, {
+    data: {
+        contentType: string;
+        node: SegmentNode;
+        limit?: number | undefined;
+        ids?: string[] | undefined;
+        cursor?: string | undefined;
+        timeZone?: string | undefined;
+    };
+    subdomain: string;
+}>;
+export declare const CountSegmentMembersInput: z.ZodObject<z.objectUtil.extendShape<{
+    subdomain: z.ZodString;
+    data: z.ZodOptional<z.ZodAny>;
+}, {
+    data: z.ZodObject<{
+        contentType: z.ZodString;
+        node: z.ZodType<SegmentNode, z.ZodTypeDef, SegmentNode>;
+        ids: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+        timeZone: z.ZodOptional<z.ZodString>;
+    }, "strip", z.ZodTypeAny, {
+        contentType: string;
+        node: SegmentNode;
+        ids?: string[] | undefined;
+        timeZone?: string | undefined;
+    }, {
+        contentType: string;
+        node: SegmentNode;
+        ids?: string[] | undefined;
+        timeZone?: string | undefined;
+    }>;
+}>, "strip", z.ZodTypeAny, {
+    data: {
+        contentType: string;
+        node: SegmentNode;
+        ids?: string[] | undefined;
+        timeZone?: string | undefined;
+    };
+    subdomain: string;
+}, {
+    data: {
+        contentType: string;
+        node: SegmentNode;
+        ids?: string[] | undefined;
+        timeZone?: string | undefined;
+    };
+    subdomain: string;
+}>;
+declare const ApplyMembershipInputData: z.ZodObject<{
+    contentType: z.ZodString;
+    updates: z.ZodArray<z.ZodObject<{
+        segmentId: z.ZodString;
+        matched: z.ZodArray<z.ZodString, "many">;
+        notMatched: z.ZodArray<z.ZodString, "many">;
+    }, "strip", z.ZodTypeAny, {
+        segmentId: string;
+        matched: string[];
+        notMatched: string[];
+    }, {
+        segmentId: string;
+        matched: string[];
+        notMatched: string[];
+    }>, "many">;
+    forget: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+    countFor: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+    transitions: z.ZodOptional<z.ZodBoolean>;
+}, "strip", z.ZodTypeAny, {
+    contentType: string;
+    updates: {
+        segmentId: string;
+        matched: string[];
+        notMatched: string[];
+    }[];
+    forget?: string[] | undefined;
+    countFor?: string[] | undefined;
+    transitions?: boolean | undefined;
+}, {
+    contentType: string;
+    updates: {
+        segmentId: string;
+        matched: string[];
+        notMatched: string[];
+    }[];
+    forget?: string[] | undefined;
+    countFor?: string[] | undefined;
+    transitions?: boolean | undefined;
+}>;
+export declare const ApplyMembershipInput: z.ZodObject<z.objectUtil.extendShape<{
+    subdomain: z.ZodString;
+    data: z.ZodOptional<z.ZodAny>;
+}, {
+    data: z.ZodObject<{
+        contentType: z.ZodString;
+        updates: z.ZodArray<z.ZodObject<{
+            segmentId: z.ZodString;
+            matched: z.ZodArray<z.ZodString, "many">;
+            notMatched: z.ZodArray<z.ZodString, "many">;
+        }, "strip", z.ZodTypeAny, {
+            segmentId: string;
+            matched: string[];
+            notMatched: string[];
+        }, {
+            segmentId: string;
+            matched: string[];
+            notMatched: string[];
+        }>, "many">;
+        forget: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+        countFor: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+        transitions: z.ZodOptional<z.ZodBoolean>;
+    }, "strip", z.ZodTypeAny, {
+        contentType: string;
+        updates: {
+            segmentId: string;
+            matched: string[];
+            notMatched: string[];
+        }[];
+        forget?: string[] | undefined;
+        countFor?: string[] | undefined;
+        transitions?: boolean | undefined;
+    }, {
+        contentType: string;
+        updates: {
+            segmentId: string;
+            matched: string[];
+            notMatched: string[];
+        }[];
+        forget?: string[] | undefined;
+        countFor?: string[] | undefined;
+        transitions?: boolean | undefined;
+    }>;
+}>, "strip", z.ZodTypeAny, {
+    data: {
+        contentType: string;
+        updates: {
+            segmentId: string;
+            matched: string[];
+            notMatched: string[];
+        }[];
+        forget?: string[] | undefined;
+        countFor?: string[] | undefined;
+        transitions?: boolean | undefined;
+    };
+    subdomain: string;
+}, {
+    data: {
+        contentType: string;
+        updates: {
+            segmentId: string;
+            matched: string[];
+            notMatched: string[];
+        }[];
+        forget?: string[] | undefined;
+        countFor?: string[] | undefined;
+        transitions?: boolean | undefined;
+    };
+    subdomain: string;
+}>;
+export type TSegmentProducersInput = {
+    [TSegmentProducers.EVALUATE_FIELDS]: z.infer<typeof EvaluateFieldsInputData>;
+    [TSegmentProducers.LIST_MEMBERS]: z.infer<typeof ListSegmentMembersInputData>;
+    [TSegmentProducers.COUNT_MEMBERS]: z.infer<typeof SegmentMemberQueryInputData>;
+    [TSegmentProducers.APPLY_MEMBERSHIP]: z.infer<typeof ApplyMembershipInputData>;
+};
+export {};
+//# sourceMappingURL=zodSchemas.d.ts.map

package/dist/declarations/src/core-modules/segments/zodSchemas.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"zodSchemas.d.ts","sourceRoot":"../../../../../src/core-modules/segments","sources":["zodSchemas.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAExB,OAAO,EAAE,WAAW,EAAE,mBAAgB;AACtC,OAAO,EAAE,iBAAiB,EAAE,mBAAgB;AAE5C,eAAO,MAAM,iBAAiB,EAAE,CAAC,CAAC,OAAO,CAAC,WAAW,CAmCpD,CAAC;AAEF,eAAO,MAAM,gBAAgB;;;;;;;;;EAG3B,CAAC;AAEH,QAAA,MAAM,uBAAuB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EA4B3B,CAAC;AAEH,eAAO,MAAM,mBAAmB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAE9B,CAAC;AAEH,QAAA,MAAM,2BAA2B;;;;;;;;;;;;;;;EAK/B,CAAC;AAEH,QAAA,MAAM,2BAA2B;;;;;;;;;;;;;;;;;;;;;;EAG/B,CAAC;AAEH,eAAO,MAAM,uBAAuB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAElC,CAAC;AAEH,eAAO,MAAM,wBAAwB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAEnC,CAAC;AAEH,QAAA,MAAM,wBAAwB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAY5B,CAAC;AAEH,eAAO,MAAM,oBAAoB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAE/B,CAAC;AAEH,MAAM,MAAM,sBAAsB,GAAG;IACnC,CAAC,iBAAiB,CAAC,eAAe,CAAC,EAAE,CAAC,CAAC,KAAK,CAAC,OAAO,uBAAuB,CAAC,CAAC;IAC7E,CAAC,iBAAiB,CAAC,YAAY,CAAC,EAAE,CAAC,CAAC,KAAK,CAAC,OAAO,2BAA2B,CAAC,CAAC;IAC9E,CAAC,iBAAiB,CAAC,aAAa,CAAC,EAAE,CAAC,CAAC,KAAK,CACxC,OAAO,2BAA2B,CACnC,CAAC;IACF,CAAC,iBAAiB,CAAC,gBAAgB,CAAC,EAAE,CAAC,CAAC,KAAK,CAC3C,OAAO,wBAAwB,CAChC,CAAC;CACH,CAAC"}

package/dist/declarations/src/core-modules/segments/zonedTime.d.ts

@@ -0,0 +1,25 @@
+export type ZonedDate = {
+    year: number;
+    month: number;
+    day: number;
+};
+export declare const DEFAULT_SEGMENT_TIME_ZONE = "UTC";
+export declare const zonedDate: (instant: Date, timeZone: string) => ZonedDate;
+export declare const zonedDayStart: (date: ZonedDate, timeZone: string) => Date;
+export type ZonedPeriod = 'month' | 'quarter' | 'year';
+/**
+ * The calendar month, quarter or year holding `now` in the zone, as
+ * [start, next start): "this month" on 10/08 is 10/01 up to 11/01.
+ */
+export declare const zonedPeriodRange: (now: Date, timeZone: string, period: ZonedPeriod) => {
+    gte: Date;
+    lt: Date;
+};
+export declare const shiftZonedDays: (date: ZonedDate, days: number) => ZonedDate;
+export declare const isLeapYear: (year: number) => boolean;
+export declare const anniversaryRanges: (target: ZonedDate, timeZone: string) => {
+    gte: Date;
+    lt: Date;
+}[];
+export declare const isAnniversary: (instant: Date, target: ZonedDate, timeZone: string) => boolean;
+//# sourceMappingURL=zonedTime.d.ts.map

package/dist/declarations/src/core-modules/segments/zonedTime.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"zonedTime.d.ts","sourceRoot":"../../../../../src/core-modules/segments","sources":["zonedTime.ts"],"names":[],"mappings":"AAAA,MAAM,MAAM,SAAS,GAAG;IAAE,IAAI,EAAE,MAAM,CAAC;IAAC,KAAK,EAAE,MAAM,CAAC;IAAC,GAAG,EAAE,MAAM,CAAA;CAAE,CAAC;AAErE,eAAO,MAAM,yBAAyB,QAAQ,CAAC;AAkC/C,eAAO,MAAM,SAAS,GAAI,SAAS,IAAI,EAAE,UAAU,MAAM,KAAG,SAQ3D,CAAC;AAkBF,eAAO,MAAM,aAAa,GAAI,MAAM,SAAS,EAAE,UAAU,MAAM,KAAG,IAqBjE,CAAC;AAEF,MAAM,MAAM,WAAW,GAAG,OAAO,GAAG,SAAS,GAAG,MAAM,CAAC;AAQvD;;;GAGG;AACH,eAAO,MAAM,gBAAgB,GAC3B,KAAK,IAAI,EACT,UAAU,MAAM,EAChB,QAAQ,WAAW,KAClB;IAAE,GAAG,EAAE,IAAI,CAAC;IAAC,EAAE,EAAE,IAAI,CAAA;CAiBvB,CAAC;AAEF,eAAO,MAAM,cAAc,GAAI,MAAM,SAAS,EAAE,MAAM,MAAM,KAAG,SAU9D,CAAC;AAEF,eAAO,MAAM,UAAU,GAAI,MAAM,MAAM,KAAG,OACgB,CAAC;AAc3D,eAAO,MAAM,iBAAiB,GAC5B,QAAQ,SAAS,EACjB,UAAU,MAAM,KACf;IAAE,GAAG,EAAE,IAAI,CAAC;IAAC,EAAE,EAAE,IAAI,CAAA;CAAE,EA2BzB,CAAC;AAEF,eAAO,MAAM,aAAa,GACxB,SAAS,IAAI,EACb,QAAQ,SAAS,EACjB,UAAU,MAAM,KACf,OAcF,CAAC"}

package/dist/declarations/src/core-modules/templates/index.d.ts

@@ -0,0 +1,2 @@
+export * from "./utils.js";
+//# sourceMappingURL=index.d.ts.map

package/dist/declarations/src/core-modules/templates/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"../../../../../src/core-modules/templates","sources":["index.ts"],"names":[],"mappings":"AAAA,2BAAwB"}

package/dist/declarations/src/core-modules/templates/utils.d.ts

@@ -0,0 +1,11 @@
+import { Document } from 'mongoose';
+export declare class TemplateManager<T extends Document> {
+    private EXCLUDE_FIELDS;
+    private INCLUDE_FEILDS?;
+    constructor(EXCLUDE_FIELDS?: (keyof T)[], INCLUDE_FEILDS?: Record<string, unknown>);
+    generateIdentity(): string;
+    private generateHash;
+    getContent(documents: T[]): Record<string, T>;
+    setContent(content: Record<string, T>): T[];
+}
+//# sourceMappingURL=utils.d.ts.map

package/dist/declarations/src/core-modules/templates/utils.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"utils.d.ts","sourceRoot":"../../../../../src/core-modules/templates","sources":["utils.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,QAAQ,EAAY,MAAM,UAAU,CAAC;AAG9C,qBAAa,eAAe,CAAC,CAAC,SAAS,QAAQ;IAC7C,OAAO,CAAC,cAAc,CAAc;IACpC,OAAO,CAAC,cAAc,CAAC,CAA0B;gBAErC,cAAc,GAAE,CAAC,MAAM,CAAC,CAAC,EAAO,EAAE,cAAc,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC;IAK/E,gBAAgB,IAAI,MAAM;IAIjC,OAAO,CAAC,YAAY;IAQb,UAAU,CAAC,SAAS,EAAE,CAAC,EAAE,GAAG,MAAM,CAAC,MAAM,EAAE,CAAC,CAAC;IAkC7C,UAAU,CAAC,OAAO,EAAE,MAAM,CAAC,MAAM,EAAE,CAAC,CAAC;CA+B7C"}