@objectstack/spec 0.1.0 → 0.1.1

package/dist/data/mapping.zod.d.ts

@@ -0,0 +1,257 @@
+import { z } from 'zod';
+/**
+ * Transformation Logic
+ * Built-in helpers for converting data during import.
+ */
+export declare const TransformType: z.ZodEnum<["none", "constant", "lookup", "split", "join", "javascript", "map"]>;
+/**
+ * Field Mapping Item
+ */
+export declare const FieldMappingSchema: z.ZodObject<{
+    /** Source Column */
+    source: z.ZodUnion<[z.ZodString, z.ZodArray<z.ZodString, "many">]>;
+    /** Target Field */
+    target: z.ZodUnion<[z.ZodString, z.ZodArray<z.ZodString, "many">]>;
+    /** Transformation */
+    transform: z.ZodDefault<z.ZodEnum<["none", "constant", "lookup", "split", "join", "javascript", "map"]>>;
+    /** Configuration for transform */
+    params: z.ZodOptional<z.ZodObject<{
+        value: z.ZodOptional<z.ZodAny>;
+        object: z.ZodOptional<z.ZodString>;
+        fromField: z.ZodOptional<z.ZodString>;
+        toField: z.ZodOptional<z.ZodString>;
+        autoCreate: z.ZodOptional<z.ZodBoolean>;
+        valueMap: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodAny>>;
+        separator: z.ZodOptional<z.ZodString>;
+    }, "strip", z.ZodTypeAny, {
+        object?: string | undefined;
+        value?: any;
+        fromField?: string | undefined;
+        toField?: string | undefined;
+        autoCreate?: boolean | undefined;
+        valueMap?: Record<string, any> | undefined;
+        separator?: string | undefined;
+    }, {
+        object?: string | undefined;
+        value?: any;
+        fromField?: string | undefined;
+        toField?: string | undefined;
+        autoCreate?: boolean | undefined;
+        valueMap?: Record<string, any> | undefined;
+        separator?: string | undefined;
+    }>>;
+}, "strip", z.ZodTypeAny, {
+    source: string | string[];
+    target: string | string[];
+    transform: "lookup" | "join" | "map" | "none" | "constant" | "split" | "javascript";
+    params?: {
+        object?: string | undefined;
+        value?: any;
+        fromField?: string | undefined;
+        toField?: string | undefined;
+        autoCreate?: boolean | undefined;
+        valueMap?: Record<string, any> | undefined;
+        separator?: string | undefined;
+    } | undefined;
+}, {
+    source: string | string[];
+    target: string | string[];
+    params?: {
+        object?: string | undefined;
+        value?: any;
+        fromField?: string | undefined;
+        toField?: string | undefined;
+        autoCreate?: boolean | undefined;
+        valueMap?: Record<string, any> | undefined;
+        separator?: string | undefined;
+    } | undefined;
+    transform?: "lookup" | "join" | "map" | "none" | "constant" | "split" | "javascript" | undefined;
+}>;
+/**
+ * ETL Mapping Schema
+ * Definition for importing/exporting data defined in `integration-etl.mdx`.
+ */
+export declare const MappingSchema: z.ZodObject<{
+    /** Identity */
+    name: z.ZodString;
+    label: z.ZodOptional<z.ZodString>;
+    /** Scope */
+    sourceFormat: z.ZodDefault<z.ZodEnum<["csv", "json", "xml", "sql"]>>;
+    targetObject: z.ZodString;
+    /** Column Mappings */
+    fieldMapping: z.ZodArray<z.ZodObject<{
+        /** Source Column */
+        source: z.ZodUnion<[z.ZodString, z.ZodArray<z.ZodString, "many">]>;
+        /** Target Field */
+        target: z.ZodUnion<[z.ZodString, z.ZodArray<z.ZodString, "many">]>;
+        /** Transformation */
+        transform: z.ZodDefault<z.ZodEnum<["none", "constant", "lookup", "split", "join", "javascript", "map"]>>;
+        /** Configuration for transform */
+        params: z.ZodOptional<z.ZodObject<{
+            value: z.ZodOptional<z.ZodAny>;
+            object: z.ZodOptional<z.ZodString>;
+            fromField: z.ZodOptional<z.ZodString>;
+            toField: z.ZodOptional<z.ZodString>;
+            autoCreate: z.ZodOptional<z.ZodBoolean>;
+            valueMap: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodAny>>;
+            separator: z.ZodOptional<z.ZodString>;
+        }, "strip", z.ZodTypeAny, {
+            object?: string | undefined;
+            value?: any;
+            fromField?: string | undefined;
+            toField?: string | undefined;
+            autoCreate?: boolean | undefined;
+            valueMap?: Record<string, any> | undefined;
+            separator?: string | undefined;
+        }, {
+            object?: string | undefined;
+            value?: any;
+            fromField?: string | undefined;
+            toField?: string | undefined;
+            autoCreate?: boolean | undefined;
+            valueMap?: Record<string, any> | undefined;
+            separator?: string | undefined;
+        }>>;
+    }, "strip", z.ZodTypeAny, {
+        source: string | string[];
+        target: string | string[];
+        transform: "lookup" | "join" | "map" | "none" | "constant" | "split" | "javascript";
+        params?: {
+            object?: string | undefined;
+            value?: any;
+            fromField?: string | undefined;
+            toField?: string | undefined;
+            autoCreate?: boolean | undefined;
+            valueMap?: Record<string, any> | undefined;
+            separator?: string | undefined;
+        } | undefined;
+    }, {
+        source: string | string[];
+        target: string | string[];
+        params?: {
+            object?: string | undefined;
+            value?: any;
+            fromField?: string | undefined;
+            toField?: string | undefined;
+            autoCreate?: boolean | undefined;
+            valueMap?: Record<string, any> | undefined;
+            separator?: string | undefined;
+        } | undefined;
+        transform?: "lookup" | "join" | "map" | "none" | "constant" | "split" | "javascript" | undefined;
+    }>, "many">;
+    /** Upsert Logic */
+    mode: z.ZodDefault<z.ZodEnum<["insert", "update", "upsert"]>>;
+    upsertKey: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+    /** Extract Logic (For Export) */
+    extractQuery: z.ZodOptional<z.ZodObject<{
+        object: z.ZodString;
+        fields: z.ZodOptional<z.ZodArray<z.ZodType<any, z.ZodTypeDef, any>, "many">>;
+        filters: z.ZodOptional<z.ZodType<any, z.ZodTypeDef, any>>;
+        sort: z.ZodOptional<z.ZodArray<z.ZodObject<{
+            field: z.ZodString;
+            order: z.ZodDefault<z.ZodEnum<["asc", "desc"]>>;
+        }, "strip", z.ZodTypeAny, {
+            field: string;
+            order: "asc" | "desc";
+        }, {
+            field: string;
+            order?: "asc" | "desc" | undefined;
+        }>, "many">>;
+        top: z.ZodOptional<z.ZodNumber>;
+        skip: z.ZodOptional<z.ZodNumber>;
+    }, "strip", z.ZodTypeAny, {
+        object: string;
+        sort?: {
+            field: string;
+            order: "asc" | "desc";
+        }[] | undefined;
+        fields?: any[] | undefined;
+        filters?: any;
+        top?: number | undefined;
+        skip?: number | undefined;
+    }, {
+        object: string;
+        sort?: {
+            field: string;
+            order?: "asc" | "desc" | undefined;
+        }[] | undefined;
+        fields?: any[] | undefined;
+        filters?: any;
+        top?: number | undefined;
+        skip?: number | undefined;
+    }>>;
+    /** Error Handling */
+    errorPolicy: z.ZodDefault<z.ZodEnum<["skip", "abort", "retry"]>>;
+    batchSize: z.ZodDefault<z.ZodNumber>;
+}, "strip", z.ZodTypeAny, {
+    name: string;
+    mode: "insert" | "update" | "upsert";
+    sourceFormat: "json" | "csv" | "xml" | "sql";
+    targetObject: string;
+    fieldMapping: {
+        source: string | string[];
+        target: string | string[];
+        transform: "lookup" | "join" | "map" | "none" | "constant" | "split" | "javascript";
+        params?: {
+            object?: string | undefined;
+            value?: any;
+            fromField?: string | undefined;
+            toField?: string | undefined;
+            autoCreate?: boolean | undefined;
+            valueMap?: Record<string, any> | undefined;
+            separator?: string | undefined;
+        } | undefined;
+    }[];
+    errorPolicy: "skip" | "abort" | "retry";
+    batchSize: number;
+    label?: string | undefined;
+    upsertKey?: string[] | undefined;
+    extractQuery?: {
+        object: string;
+        sort?: {
+            field: string;
+            order: "asc" | "desc";
+        }[] | undefined;
+        fields?: any[] | undefined;
+        filters?: any;
+        top?: number | undefined;
+        skip?: number | undefined;
+    } | undefined;
+}, {
+    name: string;
+    targetObject: string;
+    fieldMapping: {
+        source: string | string[];
+        target: string | string[];
+        params?: {
+            object?: string | undefined;
+            value?: any;
+            fromField?: string | undefined;
+            toField?: string | undefined;
+            autoCreate?: boolean | undefined;
+            valueMap?: Record<string, any> | undefined;
+            separator?: string | undefined;
+        } | undefined;
+        transform?: "lookup" | "join" | "map" | "none" | "constant" | "split" | "javascript" | undefined;
+    }[];
+    label?: string | undefined;
+    mode?: "insert" | "update" | "upsert" | undefined;
+    sourceFormat?: "json" | "csv" | "xml" | "sql" | undefined;
+    upsertKey?: string[] | undefined;
+    extractQuery?: {
+        object: string;
+        sort?: {
+            field: string;
+            order?: "asc" | "desc" | undefined;
+        }[] | undefined;
+        fields?: any[] | undefined;
+        filters?: any;
+        top?: number | undefined;
+        skip?: number | undefined;
+    } | undefined;
+    errorPolicy?: "skip" | "abort" | "retry" | undefined;
+    batchSize?: number | undefined;
+}>;
+export type Mapping = z.infer<typeof MappingSchema>;
+export type FieldMapping = z.infer<typeof FieldMappingSchema>;
+//# sourceMappingURL=mapping.zod.d.ts.map

package/dist/data/mapping.zod.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"mapping.zod.d.ts","sourceRoot":"","sources":["../../src/data/mapping.zod.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAGxB;;;GAGG;AACH,eAAO,MAAM,aAAa,iFAQxB,CAAC;AAEH;;GAEG;AACH,eAAO,MAAM,kBAAkB;IAC7B,oBAAoB;;IAGpB,mBAAmB;;IAGnB,qBAAqB;;IAGrB,kCAAkC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAiBlC,CAAC;AAEH;;;GAGG;AACH,eAAO,MAAM,aAAa;IACxB,eAAe;;;IAIf,YAAY;;;IAIZ,sBAAsB;;QAzCtB,oBAAoB;;QAGpB,mBAAmB;;QAGnB,qBAAqB;;QAGrB,kCAAkC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;IAmClC,mBAAmB;;;IAInB,iCAAiC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;IAGjC,qBAAqB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAGrB,CAAC;AAEH,MAAM,MAAM,OAAO,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,aAAa,CAAC,CAAC;AACpD,MAAM,MAAM,YAAY,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,kBAAkB,CAAC,CAAC"}

package/dist/data/mapping.zod.js

@@ -0,0 +1,65 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MappingSchema = exports.FieldMappingSchema = exports.TransformType = void 0;
+const zod_1 = require("zod");
+const query_zod_1 = require("./query.zod");
+/**
+ * Transformation Logic
+ * Built-in helpers for converting data during import.
+ */
+exports.TransformType = zod_1.z.enum([
+    'none', // Direct copy
+    'constant', // Use a hardcoded value
+    'lookup', // Resolve FK (Name -> ID)
+    'split', // "John Doe" -> ["John", "Doe"]
+    'join', // ["John", "Doe"] -> "John Doe"
+    'javascript', // Custom script (Review security!)
+    'map' // Value mapping (e.g. "Active" -> "active")
+]);
+/**
+ * Field Mapping Item
+ */
+exports.FieldMappingSchema = zod_1.z.object({
+    /** Source Column */
+    source: zod_1.z.union([zod_1.z.string(), zod_1.z.array(zod_1.z.string())]).describe('Source column header(s)'),
+    /** Target Field */
+    target: zod_1.z.union([zod_1.z.string(), zod_1.z.array(zod_1.z.string())]).describe('Target object field(s)'),
+    /** Transformation */
+    transform: exports.TransformType.default('none'),
+    /** Configuration for transform */
+    params: zod_1.z.object({
+        // Constant
+        value: zod_1.z.any().optional(),
+        // Lookup
+        object: zod_1.z.string().optional(), // Lookup Object
+        fromField: zod_1.z.string().optional(), // Match on (e.g. "name")
+        toField: zod_1.z.string().optional(), // Value to take (e.g. "_id")
+        autoCreate: zod_1.z.boolean().optional(), // Create if missing
+        // Map
+        valueMap: zod_1.z.record(zod_1.z.any()).optional(), // { "Open": "draft" }
+        // Split/Join
+        separator: zod_1.z.string().optional()
+    }).optional()
+});
+/**
+ * ETL Mapping Schema
+ * Definition for importing/exporting data defined in `integration-etl.mdx`.
+ */
+exports.MappingSchema = zod_1.z.object({
+    /** Identity */
+    name: zod_1.z.string().regex(/^[a-z_][a-z0-9_]*$/),
+    label: zod_1.z.string().optional(),
+    /** Scope */
+    sourceFormat: zod_1.z.enum(['csv', 'json', 'xml', 'sql']).default('csv'),
+    targetObject: zod_1.z.string().describe('Target Object Name'),
+    /** Column Mappings */
+    fieldMapping: zod_1.z.array(exports.FieldMappingSchema),
+    /** Upsert Logic */
+    mode: zod_1.z.enum(['insert', 'update', 'upsert']).default('insert'),
+    upsertKey: zod_1.z.array(zod_1.z.string()).optional().describe('Fields to match for upsert (e.g. email)'),
+    /** Extract Logic (For Export) */
+    extractQuery: query_zod_1.QuerySchema.optional().describe('Query to run for export only'),
+    /** Error Handling */
+    errorPolicy: zod_1.z.enum(['skip', 'abort', 'retry']).default('skip'),
+    batchSize: zod_1.z.number().default(1000)
+});

package/dist/data/object.zod.d.ts

@@ -0,0 +1,364 @@
+import { z } from 'zod';
+/**
+ * Capability Flags
+ * Defines what system features are enabled for this object.
+ */
+export declare const ObjectCapabilities: z.ZodObject<{
+    /** Enable history tracking (Audit Trail) */
+    trackHistory: z.ZodDefault<z.ZodBoolean>;
+    /** Enable global search indexing */
+    searchable: z.ZodDefault<z.ZodBoolean>;
+    /** Enable REST/GraphQL API access */
+    apiEnabled: z.ZodDefault<z.ZodBoolean>;
+    /** Enable attachments/files */
+    files: z.ZodDefault<z.ZodBoolean>;
+    /** Enable discussions/chatter */
+    feedEnabled: z.ZodDefault<z.ZodBoolean>;
+    /** Enable Recycle Bin mechanics */
+    trash: z.ZodDefault<z.ZodBoolean>;
+}, "strip", z.ZodTypeAny, {
+    trackHistory: boolean;
+    searchable: boolean;
+    apiEnabled: boolean;
+    files: boolean;
+    feedEnabled: boolean;
+    trash: boolean;
+}, {
+    trackHistory?: boolean | undefined;
+    searchable?: boolean | undefined;
+    apiEnabled?: boolean | undefined;
+    files?: boolean | undefined;
+    feedEnabled?: boolean | undefined;
+    trash?: boolean | undefined;
+}>;
+/**
+ * Schema for database indexes.
+ */
+export declare const IndexSchema: z.ZodObject<{
+    name: z.ZodOptional<z.ZodString>;
+    fields: z.ZodArray<z.ZodString, "many">;
+    unique: z.ZodOptional<z.ZodBoolean>;
+}, "strip", z.ZodTypeAny, {
+    fields: string[];
+    name?: string | undefined;
+    unique?: boolean | undefined;
+}, {
+    fields: string[];
+    name?: string | undefined;
+    unique?: boolean | undefined;
+}>;
+/**
+ * Object Schema - Enterprise Data Model
+ */
+export declare const ObjectSchema: z.ZodObject<{
+    /** Identify */
+    name: z.ZodString;
+    label: z.ZodOptional<z.ZodString>;
+    pluralLabel: z.ZodOptional<z.ZodString>;
+    description: z.ZodOptional<z.ZodString>;
+    icon: z.ZodOptional<z.ZodString>;
+    /** Storage Config */
+    datasource: z.ZodDefault<z.ZodString>;
+    tableName: z.ZodOptional<z.ZodString>;
+    isSystem: z.ZodDefault<z.ZodBoolean>;
+    /** Fields Definition */
+    fields: z.ZodRecord<z.ZodString, z.ZodObject<{
+        name: z.ZodString;
+        label: z.ZodString;
+        type: z.ZodEnum<["text", "textarea", "email", "url", "phone", "password", "markdown", "html", "number", "currency", "percent", "date", "datetime", "time", "boolean", "select", "multiselect", "lookup", "master_detail", "image", "file", "avatar", "formula", "summary", "autonumber"]>;
+        description: z.ZodOptional<z.ZodString>;
+        required: z.ZodDefault<z.ZodBoolean>;
+        multiple: z.ZodDefault<z.ZodBoolean>;
+        unique: z.ZodDefault<z.ZodBoolean>;
+        defaultValue: z.ZodOptional<z.ZodAny>;
+        maxLength: z.ZodOptional<z.ZodNumber>;
+        minLength: z.ZodOptional<z.ZodNumber>;
+        precision: z.ZodOptional<z.ZodNumber>;
+        scale: z.ZodOptional<z.ZodNumber>;
+        min: z.ZodOptional<z.ZodNumber>;
+        max: z.ZodOptional<z.ZodNumber>;
+        options: z.ZodOptional<z.ZodArray<z.ZodObject<{
+            label: z.ZodString;
+            value: z.ZodString;
+            color: z.ZodOptional<z.ZodString>;
+            default: z.ZodOptional<z.ZodBoolean>;
+        }, "strip", z.ZodTypeAny, {
+            value: string;
+            label: string;
+            color?: string | undefined;
+            default?: boolean | undefined;
+        }, {
+            value: string;
+            label: string;
+            color?: string | undefined;
+            default?: boolean | undefined;
+        }>, "many">>;
+        reference: z.ZodOptional<z.ZodString>;
+        referenceFilters: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+        writeRequiresMasterRead: z.ZodOptional<z.ZodBoolean>;
+        deleteBehavior: z.ZodDefault<z.ZodOptional<z.ZodEnum<["set_null", "cascade", "restrict"]>>>;
+        expression: z.ZodOptional<z.ZodString>;
+        formula: z.ZodOptional<z.ZodString>;
+        summaryOperations: z.ZodOptional<z.ZodObject<{
+            object: z.ZodString;
+            field: z.ZodString;
+            function: z.ZodEnum<["count", "sum", "min", "max", "avg"]>;
+        }, "strip", z.ZodTypeAny, {
+            object: string;
+            function: "min" | "max" | "count" | "sum" | "avg";
+            field: string;
+        }, {
+            object: string;
+            function: "min" | "max" | "count" | "sum" | "avg";
+            field: string;
+        }>>;
+        hidden: z.ZodDefault<z.ZodBoolean>;
+        readonly: z.ZodDefault<z.ZodBoolean>;
+        encryption: z.ZodDefault<z.ZodBoolean>;
+        index: z.ZodDefault<z.ZodBoolean>;
+        externalId: z.ZodDefault<z.ZodBoolean>;
+    }, "strip", z.ZodTypeAny, {
+        type: "number" | "boolean" | "text" | "textarea" | "email" | "url" | "phone" | "password" | "markdown" | "html" | "currency" | "percent" | "date" | "datetime" | "time" | "select" | "multiselect" | "lookup" | "master_detail" | "image" | "file" | "avatar" | "formula" | "summary" | "autonumber";
+        label: string;
+        name: string;
+        required: boolean;
+        multiple: boolean;
+        unique: boolean;
+        deleteBehavior: "set_null" | "cascade" | "restrict";
+        hidden: boolean;
+        readonly: boolean;
+        encryption: boolean;
+        index: boolean;
+        externalId: boolean;
+        formula?: string | undefined;
+        options?: {
+            value: string;
+            label: string;
+            color?: string | undefined;
+            default?: boolean | undefined;
+        }[] | undefined;
+        description?: string | undefined;
+        defaultValue?: any;
+        maxLength?: number | undefined;
+        minLength?: number | undefined;
+        precision?: number | undefined;
+        scale?: number | undefined;
+        min?: number | undefined;
+        max?: number | undefined;
+        reference?: string | undefined;
+        referenceFilters?: string[] | undefined;
+        writeRequiresMasterRead?: boolean | undefined;
+        expression?: string | undefined;
+        summaryOperations?: {
+            object: string;
+            function: "min" | "max" | "count" | "sum" | "avg";
+            field: string;
+        } | undefined;
+    }, {
+        type: "number" | "boolean" | "text" | "textarea" | "email" | "url" | "phone" | "password" | "markdown" | "html" | "currency" | "percent" | "date" | "datetime" | "time" | "select" | "multiselect" | "lookup" | "master_detail" | "image" | "file" | "avatar" | "formula" | "summary" | "autonumber";
+        label: string;
+        name: string;
+        formula?: string | undefined;
+        options?: {
+            value: string;
+            label: string;
+            color?: string | undefined;
+            default?: boolean | undefined;
+        }[] | undefined;
+        description?: string | undefined;
+        required?: boolean | undefined;
+        multiple?: boolean | undefined;
+        unique?: boolean | undefined;
+        defaultValue?: any;
+        maxLength?: number | undefined;
+        minLength?: number | undefined;
+        precision?: number | undefined;
+        scale?: number | undefined;
+        min?: number | undefined;
+        max?: number | undefined;
+        reference?: string | undefined;
+        referenceFilters?: string[] | undefined;
+        writeRequiresMasterRead?: boolean | undefined;
+        deleteBehavior?: "set_null" | "cascade" | "restrict" | undefined;
+        expression?: string | undefined;
+        summaryOperations?: {
+            object: string;
+            function: "min" | "max" | "count" | "sum" | "avg";
+            field: string;
+        } | undefined;
+        hidden?: boolean | undefined;
+        readonly?: boolean | undefined;
+        encryption?: boolean | undefined;
+        index?: boolean | undefined;
+        externalId?: boolean | undefined;
+    }>>;
+    /** Indexes */
+    indexes: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        name: z.ZodOptional<z.ZodString>;
+        fields: z.ZodArray<z.ZodString, "many">;
+        unique: z.ZodOptional<z.ZodBoolean>;
+    }, "strip", z.ZodTypeAny, {
+        fields: string[];
+        name?: string | undefined;
+        unique?: boolean | undefined;
+    }, {
+        fields: string[];
+        name?: string | undefined;
+        unique?: boolean | undefined;
+    }>, "many">>;
+    /** Key Fields */
+    nameField: z.ZodOptional<z.ZodString>;
+    /** Features & Capabilities */
+    enable: z.ZodOptional<z.ZodObject<{
+        /** Enable history tracking (Audit Trail) */
+        trackHistory: z.ZodDefault<z.ZodBoolean>;
+        /** Enable global search indexing */
+        searchable: z.ZodDefault<z.ZodBoolean>;
+        /** Enable REST/GraphQL API access */
+        apiEnabled: z.ZodDefault<z.ZodBoolean>;
+        /** Enable attachments/files */
+        files: z.ZodDefault<z.ZodBoolean>;
+        /** Enable discussions/chatter */
+        feedEnabled: z.ZodDefault<z.ZodBoolean>;
+        /** Enable Recycle Bin mechanics */
+        trash: z.ZodDefault<z.ZodBoolean>;
+    }, "strip", z.ZodTypeAny, {
+        trackHistory: boolean;
+        searchable: boolean;
+        apiEnabled: boolean;
+        files: boolean;
+        feedEnabled: boolean;
+        trash: boolean;
+    }, {
+        trackHistory?: boolean | undefined;
+        searchable?: boolean | undefined;
+        apiEnabled?: boolean | undefined;
+        files?: boolean | undefined;
+        feedEnabled?: boolean | undefined;
+        trash?: boolean | undefined;
+    }>>;
+}, "strip", z.ZodTypeAny, {
+    name: string;
+    fields: Record<string, {
+        type: "number" | "boolean" | "text" | "textarea" | "email" | "url" | "phone" | "password" | "markdown" | "html" | "currency" | "percent" | "date" | "datetime" | "time" | "select" | "multiselect" | "lookup" | "master_detail" | "image" | "file" | "avatar" | "formula" | "summary" | "autonumber";
+        label: string;
+        name: string;
+        required: boolean;
+        multiple: boolean;
+        unique: boolean;
+        deleteBehavior: "set_null" | "cascade" | "restrict";
+        hidden: boolean;
+        readonly: boolean;
+        encryption: boolean;
+        index: boolean;
+        externalId: boolean;
+        formula?: string | undefined;
+        options?: {
+            value: string;
+            label: string;
+            color?: string | undefined;
+            default?: boolean | undefined;
+        }[] | undefined;
+        description?: string | undefined;
+        defaultValue?: any;
+        maxLength?: number | undefined;
+        minLength?: number | undefined;
+        precision?: number | undefined;
+        scale?: number | undefined;
+        min?: number | undefined;
+        max?: number | undefined;
+        reference?: string | undefined;
+        referenceFilters?: string[] | undefined;
+        writeRequiresMasterRead?: boolean | undefined;
+        expression?: string | undefined;
+        summaryOperations?: {
+            object: string;
+            function: "min" | "max" | "count" | "sum" | "avg";
+            field: string;
+        } | undefined;
+    }>;
+    datasource: string;
+    isSystem: boolean;
+    label?: string | undefined;
+    description?: string | undefined;
+    pluralLabel?: string | undefined;
+    icon?: string | undefined;
+    tableName?: string | undefined;
+    indexes?: {
+        fields: string[];
+        name?: string | undefined;
+        unique?: boolean | undefined;
+    }[] | undefined;
+    nameField?: string | undefined;
+    enable?: {
+        trackHistory: boolean;
+        searchable: boolean;
+        apiEnabled: boolean;
+        files: boolean;
+        feedEnabled: boolean;
+        trash: boolean;
+    } | undefined;
+}, {
+    name: string;
+    fields: Record<string, {
+        type: "number" | "boolean" | "text" | "textarea" | "email" | "url" | "phone" | "password" | "markdown" | "html" | "currency" | "percent" | "date" | "datetime" | "time" | "select" | "multiselect" | "lookup" | "master_detail" | "image" | "file" | "avatar" | "formula" | "summary" | "autonumber";
+        label: string;
+        name: string;
+        formula?: string | undefined;
+        options?: {
+            value: string;
+            label: string;
+            color?: string | undefined;
+            default?: boolean | undefined;
+        }[] | undefined;
+        description?: string | undefined;
+        required?: boolean | undefined;
+        multiple?: boolean | undefined;
+        unique?: boolean | undefined;
+        defaultValue?: any;
+        maxLength?: number | undefined;
+        minLength?: number | undefined;
+        precision?: number | undefined;
+        scale?: number | undefined;
+        min?: number | undefined;
+        max?: number | undefined;
+        reference?: string | undefined;
+        referenceFilters?: string[] | undefined;
+        writeRequiresMasterRead?: boolean | undefined;
+        deleteBehavior?: "set_null" | "cascade" | "restrict" | undefined;
+        expression?: string | undefined;
+        summaryOperations?: {
+            object: string;
+            function: "min" | "max" | "count" | "sum" | "avg";
+            field: string;
+        } | undefined;
+        hidden?: boolean | undefined;
+        readonly?: boolean | undefined;
+        encryption?: boolean | undefined;
+        index?: boolean | undefined;
+        externalId?: boolean | undefined;
+    }>;
+    label?: string | undefined;
+    description?: string | undefined;
+    pluralLabel?: string | undefined;
+    icon?: string | undefined;
+    datasource?: string | undefined;
+    tableName?: string | undefined;
+    isSystem?: boolean | undefined;
+    indexes?: {
+        fields: string[];
+        name?: string | undefined;
+        unique?: boolean | undefined;
+    }[] | undefined;
+    nameField?: string | undefined;
+    enable?: {
+        trackHistory?: boolean | undefined;
+        searchable?: boolean | undefined;
+        apiEnabled?: boolean | undefined;
+        files?: boolean | undefined;
+        feedEnabled?: boolean | undefined;
+        trash?: boolean | undefined;
+    } | undefined;
+}>;
+export type ServiceObject = z.infer<typeof ObjectSchema>;
+//# sourceMappingURL=object.zod.d.ts.map