@cargo-ai/api 1.0.1

package/build/src/store/segmentation.d.ts

@@ -0,0 +1,566 @@
+import type { SegmentationTypes } from "cargo-domain-types";
+import type { JsonSchema } from "cargo-utils";
+import { z } from "zod/v4";
+import type { StateCreator } from "zustand";
+import type { BackendToFrontend, DateToString } from "../types.js";
+export declare namespace Segmentation {
+    type FilterConditionKind = BackendToFrontend<SegmentationTypes.FilterConditionKind>;
+    type FilterConditionString = BackendToFrontend<SegmentationTypes.FilterConditionString>;
+    type FilterConditionNumber = BackendToFrontend<SegmentationTypes.FilterConditionNumber>;
+    type FilterConditionObjectProperty = BackendToFrontend<SegmentationTypes.FilterConditionObjectProperty>;
+    type FilterConditionObject = BackendToFrontend<SegmentationTypes.FilterConditionObject>;
+    type FilterConditionArray = BackendToFrontend<SegmentationTypes.FilterConditionArray>;
+    type FilterConditionAny = BackendToFrontend<SegmentationTypes.FilterConditionAny>;
+    type FilterConditionDate = BackendToFrontend<SegmentationTypes.FilterConditionDate>;
+    type FilterConditionBoolean = BackendToFrontend<SegmentationTypes.FilterConditionBoolean>;
+    type FilterCondition = BackendToFrontend<SegmentationTypes.FilterCondition>;
+    type FilterConjonction = BackendToFrontend<SegmentationTypes.FilterConjonction>;
+    type FilterGroup = BackendToFrontend<SegmentationTypes.FilterGroup>;
+    type Filter = BackendToFrontend<SegmentationTypes.Filter>;
+    type Sort = BackendToFrontend<SegmentationTypes.Sort>;
+    type Segment = BackendToFrontend<SegmentationTypes.Segment>;
+    type SegmentMetric = BackendToFrontend<SegmentationTypes.SegmentMetric>;
+    type Change = BackendToFrontend<SegmentationTypes.Change>;
+    type ChangeKind = BackendToFrontend<SegmentationTypes.ChangeKind>;
+    type Column = BackendToFrontend<SegmentationTypes.Column>;
+    const filterJsonSchema: JsonSchema;
+    const sortJsonSchema: JsonSchema;
+    namespace Api {
+        type CreateSegmentPayload = DateToString<{
+            name: string;
+            modelUuid: string;
+            filter: Filter;
+            sort?: Sort;
+            limit?: number;
+            trackingColumnSlugs?: string[];
+        }>;
+        type CreateSegmentResult = {
+            segment: Segment;
+        };
+        const zodCreateSegmentErrorReason: z.ZodEnum<{
+            invalidFilter: "invalidFilter";
+        }>;
+        const zodArchiveSegmentErrorReason: z.ZodEnum<{
+            segmentNotFound: "segmentNotFound";
+            segmentLinkedToWorkflow: "segmentLinkedToWorkflow";
+        }>;
+        type DownloadSegmentPayload = DateToString<{
+            filter: Filter;
+            sort?: Sort;
+            limit?: number;
+            modelUuid: string;
+        }>;
+        type DownloadSegmentResult = {
+            urls: string[];
+        };
+        const zodDownloadSegmentErrorReason: z.ZodEnum<{
+            invalidFilter: "invalidFilter";
+            failedToDownloadRecordsFromClient: "failedToDownloadRecordsFromClient";
+        }>;
+        type FetchSegmentPayload = DateToString<{
+            modelUuid: string;
+            filter: Filter;
+            sort?: Sort;
+            limit?: number;
+            fetchingLimit?: number;
+            fetchingOffset?: number;
+            enrich?: boolean;
+            sync?: boolean;
+        }>;
+        type FetchSegmentResult = {
+            records: Record<string, any>[];
+            count: number;
+            columns: Column[];
+        };
+        const zodFetchSegmentErrorReason: z.ZodEnum<{
+            invalidFilter: "invalidFilter";
+        }>;
+        type GetSegmentResult = {
+            segment: Segment;
+        };
+        type GetMetricsResult = {
+            segmentMetrics: SegmentMetric[];
+        };
+        type AllSegmentsResult = {
+            segments: Segment[];
+        };
+        type UpdateSegmentPayload = DateToString<{
+            uuid: string;
+            name?: string;
+            filter?: Filter;
+            sort?: Sort | null;
+            limit?: number | null;
+            trackingColumnSlugs?: string[] | null;
+        }>;
+        type UpdateSegmentResult = {
+            segment: Segment;
+        };
+        const zodUpdateSegmentErrorReason: z.ZodEnum<{
+            invalidFilter: "invalidFilter";
+            segmentNotFound: "segmentNotFound";
+            segmentLinkedToWorkflow: "segmentLinkedToWorkflow";
+        }>;
+        const zodRemoveSegmentErrorReason: z.ZodEnum<{
+            segmentNotFound: "segmentNotFound";
+            segmentLinkedToWorkflow: "segmentLinkedToWorkflow";
+            segmentAlreadyRemoved: "segmentAlreadyRemoved";
+        }>;
+        const zodUnarchiveSegmentErrorReason: z.ZodEnum<{
+            segmentNotFound: "segmentNotFound";
+        }>;
+        type CreateChangePayload = DateToString<{
+            segmentUuid: string;
+        }>;
+        type CreateChangeResult = {
+            change: Change;
+        };
+        const zodCreateChangeErrorReason: z.ZodEnum<{
+            segmentNotFound: "segmentNotFound";
+            changeAlreadyRunning: "changeAlreadyRunning";
+        }>;
+        type DownloadChangePayload = DateToString<{
+            uuid: string;
+            kinds: ChangeKind[];
+        }>;
+        type DownloadChangeResult = {
+            urls: string[];
+        };
+        const zodDownloadChangeErrorReason: z.ZodEnum<{
+            segmentNotFound: "segmentNotFound";
+            failedToDownloadRecordsFromClient: "failedToDownloadRecordsFromClient";
+            changeNotFound: "changeNotFound";
+        }>;
+        type FetchChangePayload = DateToString<{
+            uuid: string;
+            kinds: ChangeKind[];
+            limit?: number;
+            offset?: number;
+        }>;
+        type FetchChangeResult = {
+            records: Record<string, any>[];
+            count: number;
+            columns: Column[];
+        };
+        const zodFetchChangeErrorReason: z.ZodEnum<{
+            segmentNotFound: "segmentNotFound";
+            changeNotFound: "changeNotFound";
+        }>;
+        type ListChangesPayload = DateToString<{
+            segmentUuid?: string;
+            notEmpty?: boolean;
+            hasRecords?: ChangeKind;
+            limit?: number;
+            offset?: number;
+        }>;
+        type ListChangesResult = {
+            changes: Change[];
+        };
+        type GetChangeResult = {
+            change: Change;
+        };
+        type FetchRecordPayload = DateToString<{
+            modelUuid: string;
+            ids: string[];
+            resetCache?: boolean;
+        }>;
+        type FetchRecordResult = {
+            records: Record<string, any>[];
+        };
+        const zodFetchRecordErrorReason: z.ZodEnum<{
+            invalidFilter: "invalidFilter";
+        }>;
+    }
+    const segmentKeys: {
+        all: (workspaceUuid: string) => readonly ["segments", string];
+        get: (workspaceUuid: string, uuid: string) => readonly ["segments", string, string];
+        fetch: (workspaceUuid: string, payload: Api.FetchSegmentPayload) => readonly ["segments", string, "fetch", {
+            modelUuid: string;
+            filter: {
+                conjonction: import("cargo-domain-types").SystemOfRecordIntegrationTypes.FilterConjonction;
+                groups: {
+                    conjonction: import("cargo-domain-types").SystemOfRecordIntegrationTypes.FilterConjonction;
+                    conditions: ({
+                        kind: "string";
+                        relatedModelUuid?: string | undefined;
+                        columnSlug: string;
+                        operator: "endsWith" | "startsWith" | "is" | "isNot" | "contains" | "doesNotContain";
+                        values: string | string[];
+                    } | {
+                        kind: "string";
+                        relatedModelUuid?: string | undefined;
+                        columnSlug: string;
+                        operator: "isNull" | "isNotNull" | "isEmpty" | "isNotEmpty";
+                    } | {
+                        kind: "number";
+                        relatedModelUuid?: string | undefined;
+                        columnSlug: string;
+                        operator: "is" | "isNot" | "greaterThan" | "lowerThan";
+                        value: number;
+                    } | {
+                        kind: "number";
+                        relatedModelUuid?: string | undefined;
+                        columnSlug: string;
+                        operator: "between";
+                        firstValue: number;
+                        lastValue: number;
+                    } | {
+                        kind: "number";
+                        relatedModelUuid?: string | undefined;
+                        columnSlug: string;
+                        operator: "isNull" | "isNotNull";
+                    } | {
+                        kind: "objectProperty";
+                        relatedModelUuid?: string | undefined;
+                        columnSlug: string;
+                        propertyName: string;
+                        operator: "endsWith" | "startsWith" | "is" | "isNot" | "contains" | "doesNotContain" | "greaterThan" | "lowerThan";
+                        value: string;
+                    } | {
+                        kind: "objectProperty";
+                        relatedModelUuid?: string | undefined;
+                        columnSlug: string;
+                        propertyName: string;
+                        operator: "isNull" | "isNotNull";
+                    } | {
+                        kind: "objectProperty";
+                        relatedModelUuid?: string | undefined;
+                        columnSlug: string;
+                        propertyName: string;
+                        operator: "between";
+                        value: string;
+                        otherValue: string;
+                    } | {
+                        kind: "object";
+                        relatedModelUuid?: string | undefined;
+                        columnSlug: string;
+                        operator: "isNull";
+                    } | {
+                        kind: "object";
+                        relatedModelUuid?: string | undefined;
+                        columnSlug: string;
+                        operator: "isNotNull";
+                    } | {
+                        kind: "object";
+                        relatedModelUuid?: string | undefined;
+                        columnSlug: string;
+                        operator: "matchConditions";
+                        conjonction: import("cargo-domain-types").SystemOfRecordIntegrationTypes.FilterConjonction;
+                        propertyConditions: ({
+                            kind: "objectProperty";
+                            relatedModelUuid?: string | undefined;
+                            columnSlug: string;
+                            propertyName: string;
+                            operator: "endsWith" | "startsWith" | "is" | "isNot" | "contains" | "doesNotContain" | "greaterThan" | "lowerThan";
+                            value: string;
+                        } | {
+                            kind: "objectProperty";
+                            relatedModelUuid?: string | undefined;
+                            columnSlug: string;
+                            propertyName: string;
+                            operator: "isNull" | "isNotNull";
+                        } | {
+                            kind: "objectProperty";
+                            relatedModelUuid?: string | undefined;
+                            columnSlug: string;
+                            propertyName: string;
+                            operator: "between";
+                            value: string;
+                            otherValue: string;
+                        })[];
+                    } | {
+                        kind: "array";
+                        relatedModelUuid?: string | undefined;
+                        columnSlug: string;
+                        operator: "isNull";
+                    } | {
+                        kind: "array";
+                        relatedModelUuid?: string | undefined;
+                        columnSlug: string;
+                        operator: "isNotNull";
+                    } | {
+                        kind: "array";
+                        relatedModelUuid?: string | undefined;
+                        columnSlug: string;
+                        operator: "matchConditions";
+                        conjonction: import("cargo-domain-types").SystemOfRecordIntegrationTypes.FilterConjonction;
+                        propertyConditions: ({
+                            kind: "objectProperty";
+                            relatedModelUuid?: string | undefined;
+                            columnSlug: string;
+                            propertyName: string;
+                            operator: "endsWith" | "startsWith" | "is" | "isNot" | "contains" | "doesNotContain" | "greaterThan" | "lowerThan";
+                            value: string;
+                        } | {
+                            kind: "objectProperty";
+                            relatedModelUuid?: string | undefined;
+                            columnSlug: string;
+                            propertyName: string;
+                            operator: "isNull" | "isNotNull";
+                        } | {
+                            kind: "objectProperty";
+                            relatedModelUuid?: string | undefined;
+                            columnSlug: string;
+                            propertyName: string;
+                            operator: "between";
+                            value: string;
+                            otherValue: string;
+                        })[];
+                    } | {
+                        kind: "any";
+                        relatedModelUuid?: string | undefined;
+                        columnSlug: string;
+                        operator: "isNull" | "isNotNull";
+                    } | {
+                        kind: "date";
+                        relatedModelUuid?: string | undefined;
+                        columnSlug: string;
+                        operator: "is" | "isNot" | "greaterThan" | "lowerThan";
+                        value: string;
+                    } | {
+                        kind: "date";
+                        relatedModelUuid?: string | undefined;
+                        columnSlug: string;
+                        operator: "between";
+                        firstValue: string;
+                        lastValue: string;
+                    } | {
+                        kind: "date";
+                        relatedModelUuid?: string | undefined;
+                        columnSlug: string;
+                        operator: "isNull" | "isNotNull";
+                    } | {
+                        relatedModelUuid?: string | undefined;
+                        kind: "boolean";
+                        columnSlug: string;
+                        operator: "isNull" | "isNotNull" | "isTrue" | "isFalse";
+                    } | {
+                        kind: "sql";
+                        name: string;
+                        clause: string;
+                    } | {
+                        kind: "vector";
+                        relatedModelUuid?: string | undefined;
+                        columnSlug: string;
+                        operator: "isNull" | "isNotNull";
+                    } | {
+                        kind: "occurrence";
+                        relatedModelUuid: string;
+                        frequency: {
+                            operator: "not";
+                        } | {
+                            operator: "moreThan" | "lessThan" | "exactly";
+                            value: number;
+                        };
+                        period: {
+                            operator: "moreThan" | "lessThan" | "exactly";
+                            value: number;
+                            unit: "day";
+                        };
+                        conjonction: import("cargo-domain-types").SystemOfRecordIntegrationTypes.FilterConjonction;
+                        conditions: ({
+                            kind: "string";
+                            relatedModelUuid?: string | undefined;
+                            columnSlug: string;
+                            operator: "endsWith" | "startsWith" | "is" | "isNot" | "contains" | "doesNotContain";
+                            values: string | string[];
+                        } | {
+                            kind: "string";
+                            relatedModelUuid?: string | undefined;
+                            columnSlug: string;
+                            operator: "isNull" | "isNotNull" | "isEmpty" | "isNotEmpty";
+                        } | {
+                            kind: "number";
+                            relatedModelUuid?: string | undefined;
+                            columnSlug: string;
+                            operator: "is" | "isNot" | "greaterThan" | "lowerThan";
+                            value: number;
+                        } | {
+                            kind: "number";
+                            relatedModelUuid?: string | undefined;
+                            columnSlug: string;
+                            operator: "between";
+                            firstValue: number;
+                            lastValue: number;
+                        } | {
+                            kind: "number";
+                            relatedModelUuid?: string | undefined;
+                            columnSlug: string;
+                            operator: "isNull" | "isNotNull";
+                        } | {
+                            kind: "object";
+                            relatedModelUuid?: string | undefined;
+                            columnSlug: string;
+                            operator: "isNull";
+                        } | {
+                            kind: "object";
+                            relatedModelUuid?: string | undefined;
+                            columnSlug: string;
+                            operator: "isNotNull";
+                        } | {
+                            kind: "object";
+                            relatedModelUuid?: string | undefined;
+                            columnSlug: string;
+                            operator: "matchConditions";
+                            conjonction: import("cargo-domain-types").SystemOfRecordIntegrationTypes.FilterConjonction;
+                            propertyConditions: ({
+                                kind: "objectProperty";
+                                relatedModelUuid?: string | undefined;
+                                columnSlug: string;
+                                propertyName: string;
+                                operator: "endsWith" | "startsWith" | "is" | "isNot" | "contains" | "doesNotContain" | "greaterThan" | "lowerThan";
+                                value: string;
+                            } | {
+                                kind: "objectProperty";
+                                relatedModelUuid?: string | undefined;
+                                columnSlug: string;
+                                propertyName: string;
+                                operator: "isNull" | "isNotNull";
+                            } | {
+                                kind: "objectProperty";
+                                relatedModelUuid?: string | undefined;
+                                columnSlug: string;
+                                propertyName: string;
+                                operator: "between";
+                                value: string;
+                                otherValue: string;
+                            })[];
+                        } | {
+                            kind: "array";
+                            relatedModelUuid?: string | undefined;
+                            columnSlug: string;
+                            operator: "isNull";
+                        } | {
+                            kind: "array";
+                            relatedModelUuid?: string | undefined;
+                            columnSlug: string;
+                            operator: "isNotNull";
+                        } | {
+                            kind: "array";
+                            relatedModelUuid?: string | undefined;
+                            columnSlug: string;
+                            operator: "matchConditions";
+                            conjonction: import("cargo-domain-types").SystemOfRecordIntegrationTypes.FilterConjonction;
+                            propertyConditions: ({
+                                kind: "objectProperty";
+                                relatedModelUuid?: string | undefined;
+                                columnSlug: string;
+                                propertyName: string;
+                                operator: "endsWith" | "startsWith" | "is" | "isNot" | "contains" | "doesNotContain" | "greaterThan" | "lowerThan";
+                                value: string;
+                            } | {
+                                kind: "objectProperty";
+                                relatedModelUuid?: string | undefined;
+                                columnSlug: string;
+                                propertyName: string;
+                                operator: "isNull" | "isNotNull";
+                            } | {
+                                kind: "objectProperty";
+                                relatedModelUuid?: string | undefined;
+                                columnSlug: string;
+                                propertyName: string;
+                                operator: "between";
+                                value: string;
+                                otherValue: string;
+                            })[];
+                        } | {
+                            kind: "any";
+                            relatedModelUuid?: string | undefined;
+                            columnSlug: string;
+                            operator: "isNull" | "isNotNull";
+                        } | {
+                            kind: "date";
+                            relatedModelUuid?: string | undefined;
+                            columnSlug: string;
+                            operator: "is" | "isNot" | "greaterThan" | "lowerThan";
+                            value: string;
+                        } | {
+                            kind: "date";
+                            relatedModelUuid?: string | undefined;
+                            columnSlug: string;
+                            operator: "between";
+                            firstValue: string;
+                            lastValue: string;
+                        } | {
+                            kind: "date";
+                            relatedModelUuid?: string | undefined;
+                            columnSlug: string;
+                            operator: "isNull" | "isNotNull";
+                        } | {
+                            relatedModelUuid?: string | undefined;
+                            kind: "boolean";
+                            columnSlug: string;
+                            operator: "isNull" | "isNotNull" | "isTrue" | "isFalse";
+                        } | {
+                            kind: "vector";
+                            relatedModelUuid?: string | undefined;
+                            columnSlug: string;
+                            operator: "isNull" | "isNotNull";
+                        })[];
+                    } | {
+                        kind: "enrollment";
+                        workflowUuid: string;
+                        activityKind: import("cargo-domain-types").SystemOfRecordIntegrationTypes.FilterConditionEnrollmentActivityKind;
+                        nodeSlug?: string | undefined;
+                        frequency: {
+                            operator: "not";
+                        } | {
+                            operator: "moreThan" | "lessThan" | "exactly";
+                            value: number;
+                        };
+                        period: {
+                            operator: "moreThan" | "lessThan" | "exactly";
+                            value: number;
+                            unit: "day";
+                        };
+                    } | {
+                        kind: "segment";
+                        segmentUuid: string;
+                        operator: "in" | "notIn";
+                    })[];
+                }[];
+            };
+            sort?: {
+                columnSlug: string;
+                kind: "desc" | "asc";
+            }[] | undefined;
+            limit?: number | undefined;
+            fetchingLimit?: number | undefined;
+            fetchingOffset?: number | undefined;
+            enrich?: boolean | undefined;
+            sync?: boolean | undefined;
+        }];
+    };
+    const changeKeys: {
+        all: (workspaceUuid: string) => readonly ["changes", string];
+        list: (workspaceUuid: string, payload: Api.ListChangesPayload) => readonly ["changes", string, "list", {
+            segmentUuid?: string | undefined;
+            notEmpty?: boolean | undefined;
+            hasRecords?: ChangeKind | undefined;
+            limit?: number | undefined;
+            offset?: number | undefined;
+        }];
+        get: (workspaceUuid: string, uuid: string) => readonly ["changes", string, string];
+        fetch: (workspaceUuid: string, payload: Api.FetchChangePayload) => readonly ["changes", string, "fetch", {
+            uuid: string;
+            kinds: ChangeKind[];
+            limit?: number | undefined;
+            offset?: number | undefined;
+        }];
+    };
+    const recordKeys: {
+        all: (workspaceUuid: string) => readonly ["records", string];
+        fetch: (workspaceUuid: string, payload: Api.FetchRecordPayload) => readonly ["records", string, "fetch", {
+            modelUuid: string;
+            ids: string[];
+            resetCache?: boolean | undefined;
+        }];
+    };
+}
+export interface SegmentationSlice {
+    segments: Segmentation.Segment[];
+    setSegments: (segments: Segmentation.Segment[]) => void;
+}
+export declare const createSegmentationSlice: StateCreator<SegmentationSlice, [
+], [
+], SegmentationSlice>;
+//# sourceMappingURL=segmentation.d.ts.map

package/build/src/store/segmentation.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"segmentation.d.ts","sourceRoot":"","sources":["../../../src/store/segmentation.ts"],"names":[],"mappings":"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"}

package/build/src/store/segmentation.js

@@ -0,0 +1,103 @@
+/* eslint-disable @typescript-eslint/no-explicit-any */
+import { z } from "zod/v4";
+// eslint-disable-next-line @typescript-eslint/no-namespace
+export var Segmentation;
+(function (Segmentation) {
+    Segmentation.filterJsonSchema = {
+        type: "object",
+        properties: {
+            conjonction: {
+                type: "string",
+                enum: ["or", "and"],
+                default: "or",
+            },
+            groups: {
+                type: "array",
+                items: {
+                    type: "object",
+                    additionalProperties: true,
+                },
+                default: [],
+            },
+        },
+    };
+    Segmentation.sortJsonSchema = {
+        type: "array",
+        items: {
+            type: "object",
+            properties: {
+                columnSlug: {
+                    type: "string",
+                },
+                kind: {
+                    type: "string",
+                    enum: ["desc", "asc"],
+                },
+            },
+            required: ["columnSlug", "kind"],
+        },
+    };
+    // eslint-disable-next-line @typescript-eslint/no-namespace
+    let Api;
+    (function (Api) {
+        Api.zodCreateSegmentErrorReason = z.enum(["invalidFilter"]);
+        Api.zodArchiveSegmentErrorReason = z.enum([
+            "segmentNotFound",
+            "segmentLinkedToWorkflow",
+        ]);
+        Api.zodDownloadSegmentErrorReason = z.enum([
+            "invalidFilter",
+            "failedToDownloadRecordsFromClient",
+        ]);
+        Api.zodFetchSegmentErrorReason = z.enum(["invalidFilter"]);
+        Api.zodUpdateSegmentErrorReason = z.enum([
+            "segmentNotFound",
+            "segmentLinkedToWorkflow",
+            "invalidFilter",
+        ]);
+        Api.zodRemoveSegmentErrorReason = z.enum([
+            "segmentNotFound",
+            "segmentLinkedToWorkflow",
+            "segmentAlreadyRemoved",
+        ]);
+        Api.zodUnarchiveSegmentErrorReason = z.enum(["segmentNotFound"]);
+        Api.zodCreateChangeErrorReason = z.enum([
+            "segmentNotFound",
+            "changeAlreadyRunning",
+        ]);
+        Api.zodDownloadChangeErrorReason = z.enum([
+            "changeNotFound",
+            "segmentNotFound",
+            "failedToDownloadRecordsFromClient",
+        ]);
+        Api.zodFetchChangeErrorReason = z.enum([
+            "changeNotFound",
+            "segmentNotFound",
+        ]);
+        Api.zodFetchRecordErrorReason = z.enum(["invalidFilter"]);
+    })(Api = Segmentation.Api || (Segmentation.Api = {}));
+    Segmentation.segmentKeys = {
+        all: (workspaceUuid) => ["segments", workspaceUuid],
+        get: (workspaceUuid, uuid) => [...Segmentation.segmentKeys.all(workspaceUuid), uuid],
+        fetch: (workspaceUuid, payload) => [...Segmentation.segmentKeys.all(workspaceUuid), "fetch", payload],
+    };
+    Segmentation.changeKeys = {
+        all: (workspaceUuid) => ["changes", workspaceUuid],
+        list: (workspaceUuid, payload) => [...Segmentation.changeKeys.all(workspaceUuid), "list", payload],
+        get: (workspaceUuid, uuid) => [...Segmentation.changeKeys.all(workspaceUuid), uuid],
+        fetch: (workspaceUuid, payload) => [...Segmentation.changeKeys.all(workspaceUuid), "fetch", payload],
+    };
+    Segmentation.recordKeys = {
+        all: (workspaceUuid) => ["records", workspaceUuid],
+        fetch: (workspaceUuid, payload) => [...Segmentation.recordKeys.all(workspaceUuid), "fetch", payload],
+    };
+})(Segmentation || (Segmentation = {}));
+export const createSegmentationSlice = (set) => ({
+    segments: [],
+    setSegments: (segments) => {
+        set((state) => ({
+            ...state,
+            segments,
+        }));
+    },
+});