@stndrds/schema 0.1.0-alpha.14

package/dist/index.d.ts

@@ -0,0 +1,1222 @@
+import { A as Attribute, S as StatusAttribute, a as SelectAttribute, M as MultiselectAttribute, P as Phone, C as Currency, L as Location, T as TextAttribute, b as TextAreaAttribute, N as NumberAttribute, c as CheckboxAttribute, D as DateAttribute, d as PhoneAttribute, e as CurrencyAttribute, O as Option, f as LocationAttribute, g as TimestampAttribute, F as FileAttribute, U as UserAttribute, h as SingleRelationAttribute, R as RelationOnDelete, i as MultiRelationAttribute, j as RelationTarget, k as RatingAttribute, l as ObjectDefinition, m as Field, n as AttributeGroupField, G as Group, V as ViewDefinition, o as Tab } from './runtime-yMql0npY.js';
+export { bS as AddAttributeInput, aa as AdvancedFilterState, bA as AttributeChange, r as AttributeGroup, p as AttributeType, bJ as AttributesRepository, B as BaseAttribute, Y as CheckboxFilterOperator, at as CompletionStatus, bR as CreateCustomObjectInput, cm as CreateDBAttribute, ci as CreateDBObject, cw as CreateDBView, K as CreateFile, cp as CreateObjectRecord, ay as CreateUserProfile, c2 as CreateViewInput, a3 as CurrencyFilterValue, aD as CustomTab, cl as DBAttribute, ch as DBObject, cv as DBView, cd as DEFAULT_LABEL_FALLBACK, bz as DatabaseAdapter, Z as DateFilterOperator, t as DateFormat, u as DateValue, x as DocumentFace, w as DocumentType, y as DocumentTypeConfig, J as File, cu as FileListOptions, bO as FileService, z as FileVerificationConfig, I as FileVisibility, bL as FilesRepository, a7 as FilterCombinator, a9 as FilterGroup, a1 as FilterOperator, a6 as FilterRule, a8 as FilterState, a5 as FilterValue, aB as FormTab, cb as FullSyncOptions, ca as FullSyncResult, ap as GeocodingAdapter, am as GeocodingAutocompleteParams, ao as GeocodingParams, bP as GeocodingService, al as GeocodingSuggestion, b$ as GetRelationOptionsParams, cs as GlobalSearchOptions, ct as GlobalSearchResultItem, bQ as GlobalSearchService, bB as HookContext, bC as HookDefinition, bD as HookHandler, bG as HookRegistry, bE as HookType, cq as ListOptions, v as LocationGranularity, $ as MultiselectFilterOperator, aj as NO_VALUE_OPERATORS, ai as NoValueOperator, aq as NoopGeocodingAdapter, bF as NoopHookRegistry, X as NumberFilterOperator, s as NumberUnit, ah as OPERATORS_BY_TYPE, as as ObjectAttribute, au as ObjectRecord, bM as ObjectRecordsRepository, bU as ObjectSchemaService, bI as ObjectsRepository, cz as OperationResult, a4 as PhoneFilterValue, ag as QueryState, bW as RecordService, bV as RecordServiceOptions, E as RelationAttribute, a0 as RelationFilterOperator, bZ as RelationOption, b_ as RelationOptionsResponse, c0 as RelationService, bY as RelationValidationError, bX as RelationValidationResult, a2 as RelativeDateValue, an as ReverseGeocodingParams, cr as SearchOptions, _ as SelectFilterOperator, ae as SortDirection, af as SortRule, q as StatusGroup, H as StorageProvider, c6 as SyncOptions, c5 as SyncResult, aA as TabType, aC as TableTab, aI as TenantId, W as TextFilterOperator, ar as Timestamps, cn as UpdateDBAttribute, cj as UpdateDBObject, cx as UpdateDBView, Q as UpdateFile, bT as UpdateObjectInput, az as UpdateUserProfile, c3 as UpdateViewInput, co as UpsertDBAttribute, ck as UpsertDBObject, cy as UpsertDBView, ax as UserProfile, c1 as UserProfileService, bK as UserProfilesRepository, av as UserRole, aw as UserStatus, aH as Uuid, bp as ValidationResult, c4 as ViewService, cB as ViewSyncOptions, cA as ViewSyncResult, bN as ViewsRepository, b1 as attributeConfigSchemas, aQ as checkboxConfigSchema, by as computeRecordStatus, bn as createAttributeValidator, b8 as createCheckboxValidator, bb as createCurrencyValidator, b9 as createDateValidator, bt as createDraftValidator, bh as createFileValidator, bf as createLocationValidator, bH as createMockAdapter, bk as createMultiRelationValidator, be as createMultiselectValidator, b7 as createNumberValidator, bo as createObjectValidator, ba as createPhoneValidator, bm as createRatingValidator, bl as createRelationValidator, bd as createSelectValidator, bj as createSingleRelationValidator, bc as createStatusValidator, b6 as createTextValidator, bg as createTimestampValidator, bi as createUserValidator, aT as currencyConfigSchema, aR as dateConfigSchema, cg as extractAttributeNames, aZ as fileConfigSchema, aJ as generateId, aK as generatePrefixedId, b2 as getAttributeConfigSchema, bw as getMissingRequiredAttributes, c9 as getSyncPreview, cE as getViewSyncPreview, ab as isAdvancedFilterState, aG as isCustomTab, aE as isFormTab, cf as isLabelExpression, ak as isNoValueOperator, bx as isRecordComplete, aF as isTableTab, aV as locationConfigSchema, aY as multiselectConfigSchema, aP as numberConfigSchema, b4 as parseAttributeConfig, aS as phoneConfigSchema, b0 as ratingConfigSchema, aL as registry, a$ as relationConfigSchema, ce as renderLabelExpression, b5 as safeParseAttributeConfig, aX as selectConfigSchema, aU as statusConfigSchema, cc as syncAll, c7 as syncNativeObjects, cC as syncNativeViews, aN as textConfigSchema, aO as textareaConfigSchema, aW as timestampConfigSchema, ac as toAdvancedFilterState, ad as toSimpleFilterState, a_ as userConfigSchema, bq as validateAttribute, b3 as validateAttributeConfig, bu as validateDraft, bv as validateDraftOrThrow, br as validateObject, bs as validateObjectOrThrow, c8 as verifyNativeObjectsSync, cD as verifyNativeViewsSync, aM as viewRegistry } from './runtime-yMql0npY.js';
+import { IconName, CountryIso3, CurrencyCode, MimeType } from '@stndrds/constants';
+import 'zod';
+
+/**
+ * Common configuration for all builders (Objects & Attributes)
+ */
+interface BuilderConfig {
+    /**
+     * Technical name (snake_case, kebab-case, camelCase)
+     * Used as identifier in database and API
+     */
+    name: string;
+    /**
+     * Human-readable label
+     * Used in UI
+     */
+    label: string;
+}
+
+/**
+ * Lookup table for primitive attribute types
+ * Maps attribute type name to its runtime value type
+ */
+type AttributeValueMap = {
+    text: string;
+    textarea: string;
+    number: number;
+    checkbox: boolean;
+    date: string;
+    phone: Phone;
+    currency: Currency;
+    location: Location;
+    timestamp: number;
+    file: string;
+    user: string;
+    relation: string;
+    rating: number;
+};
+/**
+ * Infer status value from options (union of option values)
+ */
+type InferStatusValue<A extends StatusAttribute> = A["options"] extends readonly {
+    value: infer V;
+}[] ? V : string;
+/**
+ * Infer select value from options (union of option values)
+ */
+type InferSelectValue<A extends SelectAttribute> = A["options"] extends readonly {
+    value: infer V;
+}[] ? V : string;
+/**
+ * Infer multiselect value from options (array of option values)
+ */
+type InferMultiselectValue<A extends MultiselectAttribute> = A["options"] extends readonly {
+    value: infer V;
+}[] ? V[] : string[];
+/**
+ * Maps an Attribute type to its runtime value type
+ * Uses a flat lookup table + 3 special cases for option-based attributes
+ * This avoids deep conditional nesting that causes TS2589 on large objects
+ */
+type InferAttributeValue<A extends Attribute> = A extends StatusAttribute ? InferStatusValue<A> : A extends SelectAttribute ? InferSelectValue<A> : A extends MultiselectAttribute ? InferMultiselectValue<A> : A["type"] extends keyof AttributeValueMap ? AttributeValueMap[A["type"]] : unknown;
+/**
+ * Schema definition type for type-safe object definitions
+ * Maps attribute names to their builder types
+ */
+type AttributeSchema = Record<string, Attribute>;
+/**
+ * Infer record type from an attribute schema
+ * Creates a typed object with all attribute values
+ */
+type InferRecordFromSchema<TSchema extends AttributeSchema> = {
+    [K in keyof TSchema]: InferAttributeValue<TSchema[K]>;
+};
+/**
+ * Make required attributes required and optional ones optional
+ */
+type InferRecordWithRequirements<TSchema extends AttributeSchema> = {
+    [K in RequiredAttributeKeys<TSchema>]: InferAttributeValue<TSchema[K]>;
+} & {
+    [K in OptionalAttributeKeys<TSchema>]?: InferAttributeValue<TSchema[K]>;
+};
+/**
+ * Extract keys of required attributes
+ */
+type RequiredAttributeKeys<TSchema extends AttributeSchema> = {
+    [K in keyof TSchema]: TSchema[K]["required"] extends true ? K : never;
+}[keyof TSchema];
+/**
+ * Extract keys of optional attributes
+ */
+type OptionalAttributeKeys<TSchema extends AttributeSchema> = {
+    [K in keyof TSchema]: TSchema[K]["required"] extends true ? never : K;
+}[keyof TSchema];
+/**
+ * Type-safe attribute entry for builder accumulation
+ * Preserves the attribute name as a literal type
+ */
+type TypedAttribute<TName extends string = string, TAttr extends Attribute = Attribute> = TAttr & {
+    readonly name: TName;
+};
+/**
+ * Accumulated attributes map (built via chained .attribute() calls)
+ */
+type AttributeMap = Record<string, Attribute>;
+/**
+ * Add an attribute to an existing map
+ */
+type AddAttribute$1<TMap extends AttributeMap, TName extends string, TAttr extends Attribute> = TMap & {
+    [K in TName]: TAttr;
+};
+/**
+ * Infer record type from accumulated attribute map
+ */
+type InferRecord<TMap extends AttributeMap> = InferRecordWithRequirements<TMap>;
+/**
+ * Infer input type for creating a record (all required + partial optional)
+ */
+type InferRecordInput<TMap extends AttributeMap> = InferRecordWithRequirements<TMap>;
+/**
+ * Infer update type (all fields optional)
+ */
+type InferRecordUpdate<TMap extends AttributeMap> = Partial<InferRecordFromSchema<TMap>>;
+/**
+ * Base type for custom attribute values added via UI
+ * Supports all possible attribute value types
+ */
+type CustomAttributeValue = Attribute["defaultValue"] | undefined;
+/**
+ * Adds support for custom attributes (added via UI) to a record type
+ * Preserves autocompletion for known attributes while allowing additional properties
+ */
+type WithCustomAttributes<T> = T & {
+    [key: string]: CustomAttributeValue;
+};
+/**
+ * Extract the record type from an ObjectBuilder instance
+ * Includes support for custom attributes added via UI
+ *
+ * @example
+ * ```typescript
+ * const PRODUCT = object({ name: "products", label: "Product" })
+ *   .attribute(text({ name: "name", label: "Name" }).required())
+ *   .attribute(number({ name: "price", label: "Price" }));
+ *
+ * type ProductRecord = ExtractRecord<typeof PRODUCT>;
+ * // → { name: string; price?: number } & { [key: string]: CustomAttributeValue }
+ *
+ * const product: ProductRecord = {
+ *   name: "Nike Air Max",
+ *   price: 129.99,
+ *   customField: "added via UI",  // ✅ Allowed
+ * };
+ * ```
+ */
+type ExtractRecord<TBuilder> = TBuilder extends {
+    _types: {
+        record: infer R;
+    };
+} ? WithCustomAttributes<R> : never;
+/**
+ * Extract the record type without custom attributes (strict mode)
+ * Use this when you only want the defined attributes
+ */
+type ExtractRecordStrict<TBuilder> = TBuilder extends {
+    _types: {
+        record: infer R;
+    };
+} ? R : never;
+/**
+ * Extract the input type from an ObjectBuilder instance
+ * Includes support for custom attributes
+ */
+type ExtractRecordInput<TBuilder> = TBuilder extends {
+    _types: {
+        input: infer R;
+    };
+} ? WithCustomAttributes<R> : never;
+/**
+ * Extract the input type without custom attributes (strict mode)
+ */
+type ExtractRecordInputStrict<TBuilder> = TBuilder extends {
+    _types: {
+        input: infer R;
+    };
+} ? R : never;
+/**
+ * Extract the update type from an ObjectBuilder instance
+ * Includes support for custom attributes
+ */
+type ExtractRecordUpdate<TBuilder> = TBuilder extends {
+    _types: {
+        update: infer R;
+    };
+} ? WithCustomAttributes<R> : never;
+/**
+ * Extract the update type without custom attributes (strict mode)
+ */
+type ExtractRecordUpdateStrict<TBuilder> = TBuilder extends {
+    _types: {
+        update: infer R;
+    };
+} ? R : never;
+/**
+ * Extract the attribute map from an ObjectBuilder instance
+ */
+type ExtractAttributes<TBuilder> = TBuilder extends {
+    _types: {
+        attributes: infer A;
+    };
+} ? A : never;
+
+/**
+ * Error codes for schema exceptions
+ */
+declare const SchemaErrorCode: {
+    readonly UNKNOWN: "SCHEMA_UNKNOWN_ERROR";
+    readonly OBJECT_NOT_FOUND: "SCHEMA_OBJECT_NOT_FOUND";
+    readonly ATTRIBUTE_NOT_FOUND: "SCHEMA_ATTRIBUTE_NOT_FOUND";
+    readonly RECORD_NOT_FOUND: "SCHEMA_RECORD_NOT_FOUND";
+    readonly USER_PROFILE_NOT_FOUND: "SCHEMA_USER_PROFILE_NOT_FOUND";
+    readonly FILE_NOT_FOUND: "SCHEMA_FILE_NOT_FOUND";
+    readonly VALIDATION_FAILED: "SCHEMA_VALIDATION_FAILED";
+    readonly INVALID_ATTRIBUTE_NAME: "SCHEMA_INVALID_ATTRIBUTE_NAME";
+    readonly INVALID_OBJECT_NAME: "SCHEMA_INVALID_OBJECT_NAME";
+    readonly PROTECTED_OBJECT: "SCHEMA_PROTECTED_OBJECT";
+    readonly PROTECTED_ATTRIBUTE: "SCHEMA_PROTECTED_ATTRIBUTE";
+    readonly SYNC_FAILED: "SCHEMA_SYNC_FAILED";
+    readonly NOT_SYSTEM_OBJECT: "SCHEMA_NOT_SYSTEM_OBJECT";
+    readonly DUPLICATE_OBJECT: "SCHEMA_DUPLICATE_OBJECT";
+    readonly DUPLICATE_ATTRIBUTE: "SCHEMA_DUPLICATE_ATTRIBUTE";
+};
+type SchemaErrorCode = (typeof SchemaErrorCode)[keyof typeof SchemaErrorCode];
+/**
+ * Base error class for all schema-related errors
+ */
+declare class SchemaError extends Error {
+    readonly code: SchemaErrorCode;
+    readonly details?: Record<string, unknown>;
+    constructor(message: string, code?: SchemaErrorCode, details?: Record<string, unknown>);
+    toJSON(): {
+        name: string;
+        code: SchemaErrorCode;
+        message: string;
+        details: Record<string, unknown> | undefined;
+    };
+}
+/**
+ * Base class for "not found" errors
+ */
+declare class NotFoundError extends SchemaError {
+    readonly resourceType: string;
+    readonly resourceId: string;
+    constructor(resourceType: string, resourceId: string, code?: SchemaErrorCode);
+}
+/**
+ * Object not found error
+ */
+declare class ObjectNotFoundError extends NotFoundError {
+    constructor(objectId: string);
+}
+/**
+ * Attribute not found error
+ */
+declare class AttributeNotFoundError extends NotFoundError {
+    constructor(attributeId: string);
+}
+/**
+ * Record not found error
+ */
+declare class RecordNotFoundError extends NotFoundError {
+    constructor(recordId: string);
+}
+/**
+ * User profile not found error
+ */
+declare class UserProfileNotFoundError extends NotFoundError {
+    constructor(identifier: string);
+}
+/**
+ * File not found error
+ */
+declare class FileNotFoundError extends NotFoundError {
+    constructor(fileId: string);
+}
+/**
+ * Validation error with field-level details
+ */
+interface ValidationErrorDetail {
+    path: string[];
+    message: string;
+    code?: string;
+}
+/**
+ * Validation error thrown when data fails schema validation
+ */
+declare class ValidationError extends SchemaError {
+    readonly errors: ValidationErrorDetail[];
+    constructor(message: string, errors: ValidationErrorDetail[]);
+    /**
+     * Create a validation error from Zod-style errors
+     */
+    static fromZodErrors(errors: Array<{
+        path: (string | number)[];
+        message: string;
+    }>): ValidationError;
+}
+/**
+ * Error thrown when attempting to modify a protected (system) resource
+ */
+declare class ProtectedResourceError extends SchemaError {
+    readonly resourceType: "object" | "attribute";
+    readonly resourceName: string;
+    readonly operation: "delete" | "modify";
+    constructor(resourceType: "object" | "attribute", resourceName: string, operation: "delete" | "modify");
+}
+/**
+ * Error thrown during native object synchronization
+ */
+declare class SyncError extends SchemaError {
+    readonly objectName: string;
+    readonly cause?: Error;
+    constructor(objectName: string, message: string, cause?: Error);
+}
+/**
+ * Error thrown when trying to sync a non-system object as native
+ */
+declare class NotSystemObjectError extends SchemaError {
+    readonly objectName: string;
+    constructor(objectName: string);
+}
+/**
+ * Error thrown when attempting to create a duplicate resource
+ */
+declare class DuplicateError extends SchemaError {
+    readonly resourceType: "object" | "attribute";
+    readonly resourceName: string;
+    constructor(resourceType: "object" | "attribute", resourceName: string);
+}
+/**
+ * Check if an error is a SchemaError
+ */
+declare function isSchemaError(error: unknown): error is SchemaError;
+/**
+ * Check if an error is a NotFoundError
+ */
+declare function isNotFoundError(error: unknown): error is NotFoundError;
+/**
+ * Check if an error is a ValidationError
+ */
+declare function isValidationError(error: unknown): error is ValidationError;
+/**
+ * Check if an error is a ProtectedResourceError
+ */
+declare function isProtectedResourceError(error: unknown): error is ProtectedResourceError;
+
+/**
+ * Builder config with literal name type preservation
+ */
+interface TypedBuilderConfig<TName extends string> extends BuilderConfig {
+    name: TName;
+}
+/**
+ * Base attribute builder
+ * Type tracking is done via the `_types` phantom property
+ */
+declare abstract class BaseAttributeBuilder<TAttr extends Attribute> {
+    protected attr: Partial<TAttr>;
+    constructor(type: TAttr["type"], name: string, label: string);
+    protected setRequired(value: boolean): void;
+    system(): this;
+    disabled(): this;
+    hidden(): this;
+    placeholder(value: string): this;
+    description(value: string): this;
+    icon(value: IconName): this;
+    order(value: number): this;
+    defaultValue(value: TAttr["defaultValue"]): this;
+    metadata(value: Record<string, unknown>): this;
+    build(): TAttr;
+}
+declare class TextAttributeBuilder<TName extends string, TRequired extends boolean = false> extends BaseAttributeBuilder<TextAttribute> {
+    /**
+     * Phantom type for inference
+     */
+    readonly _types: {
+        name: TName;
+        attribute: TextAttribute;
+        required: TRequired;
+    };
+    constructor(name: TName, label: string);
+    minLength(value: number): this;
+    maxLength(value: number): this;
+    pattern(value: string): this;
+    required(): TextAttributeBuilder<TName, true>;
+    optional(): TextAttributeBuilder<TName, false>;
+    /**
+     * Set email validation pattern
+     */
+    email(): this;
+    /**
+     * Set URL validation pattern
+     */
+    url(): this;
+    /**
+     * Set slug validation pattern
+     */
+    slug(): this;
+}
+declare function text<TName extends string>(config: TypedBuilderConfig<TName>): TextAttributeBuilder<TName, false>;
+declare class TextAreaAttributeBuilder<TName extends string, TRequired extends boolean = false> extends BaseAttributeBuilder<TextAreaAttribute> {
+    /**
+     * Phantom type for inference
+     */
+    readonly _types: {
+        name: TName;
+        attribute: TextAreaAttribute;
+        required: TRequired;
+    };
+    constructor(name: TName, label: string);
+    required(): TextAreaAttributeBuilder<TName, true>;
+    optional(): TextAreaAttributeBuilder<TName, false>;
+}
+declare function textarea<TName extends string>(config: TypedBuilderConfig<TName>): TextAreaAttributeBuilder<TName, false>;
+declare class NumberAttributeBuilder<TName extends string, TRequired extends boolean = false> extends BaseAttributeBuilder<NumberAttribute> {
+    readonly _types: {
+        name: TName;
+        attribute: NumberAttribute;
+        required: TRequired;
+    };
+    constructor(name: TName, label: string);
+    min(value: number): this;
+    max(value: number): this;
+    integer(): this;
+    decimal(decimals?: number): this;
+    percentage(): this;
+    required(): NumberAttributeBuilder<TName, true>;
+    optional(): NumberAttributeBuilder<TName, false>;
+}
+declare function number<TName extends string>(config: TypedBuilderConfig<TName>): NumberAttributeBuilder<TName, false>;
+declare class CheckboxAttributeBuilder<TName extends string, TRequired extends boolean = false> extends BaseAttributeBuilder<CheckboxAttribute> {
+    readonly _types: {
+        name: TName;
+        attribute: CheckboxAttribute;
+        required: TRequired;
+    };
+    constructor(name: TName, label: string);
+    required(): CheckboxAttributeBuilder<TName, true>;
+    optional(): CheckboxAttributeBuilder<TName, false>;
+}
+declare function checkbox<TName extends string>(config: TypedBuilderConfig<TName>): CheckboxAttributeBuilder<TName, false>;
+declare class DateAttributeBuilder<TName extends string, TRequired extends boolean = false> extends BaseAttributeBuilder<DateAttribute> {
+    readonly _types: {
+        name: TName;
+        attribute: DateAttribute;
+        required: TRequired;
+    };
+    constructor(name: TName, label: string);
+    format(value: DateAttribute["dateFormat"]): this;
+    minDate(value: DateAttribute["minDate"]): this;
+    maxDate(value: DateAttribute["maxDate"]): this;
+    required(): DateAttributeBuilder<TName, true>;
+    optional(): DateAttributeBuilder<TName, false>;
+}
+declare function date<TName extends string>(config: TypedBuilderConfig<TName>): DateAttributeBuilder<TName, false>;
+declare class PhoneAttributeBuilder<TName extends string, TRequired extends boolean = false> extends BaseAttributeBuilder<PhoneAttribute> {
+    readonly _types: {
+        name: TName;
+        attribute: PhoneAttribute;
+        required: TRequired;
+    };
+    constructor(name: TName, label: string);
+    defaultCountry(value: CountryIso3): this;
+    required(): PhoneAttributeBuilder<TName, true>;
+    optional(): PhoneAttributeBuilder<TName, false>;
+}
+declare function phone<TName extends string>(config: TypedBuilderConfig<TName>): PhoneAttributeBuilder<TName, false>;
+declare class CurrencyAttributeBuilder<TName extends string, TRequired extends boolean = false> extends BaseAttributeBuilder<CurrencyAttribute> {
+    readonly _types: {
+        name: TName;
+        attribute: CurrencyAttribute;
+        required: TRequired;
+    };
+    constructor(name: TName, label: string);
+    defaultCurrency(value: CurrencyCode): this;
+    allowedCurrencies(value: CurrencyCode[]): this;
+    required(): CurrencyAttributeBuilder<TName, true>;
+    optional(): CurrencyAttributeBuilder<TName, false>;
+}
+declare function currency<TName extends string>(config: TypedBuilderConfig<TName>): CurrencyAttributeBuilder<TName, false>;
+declare class StatusAttributeBuilder<TName extends string, TOptions extends readonly Option[] = Option[], TRequired extends boolean = false> extends BaseAttributeBuilder<StatusAttribute> {
+    readonly _types: {
+        name: TName;
+        attribute: StatusAttribute & {
+            options: TOptions;
+        };
+        required: TRequired;
+    };
+    constructor(name: TName, label: string);
+    /**
+     * Set all options at once (preserves literal types for values)
+     */
+    options<const T extends readonly Option[]>(value: T): StatusAttributeBuilder<TName, T, TRequired>;
+    option(config: Option): this;
+    required(): StatusAttributeBuilder<TName, TOptions, true>;
+    optional(): StatusAttributeBuilder<TName, TOptions, false>;
+}
+declare function status<TName extends string>(config: TypedBuilderConfig<TName>): StatusAttributeBuilder<TName, Option[], false>;
+declare class SelectAttributeBuilder<TName extends string, TOptions extends readonly Option[] = Option[], TRequired extends boolean = false> extends BaseAttributeBuilder<SelectAttribute> {
+    readonly _types: {
+        name: TName;
+        attribute: SelectAttribute & {
+            options: TOptions;
+        };
+        required: TRequired;
+    };
+    constructor(name: TName, label: string);
+    /**
+     * Set all options at once (preserves literal types for values)
+     */
+    options<const T extends readonly Option[]>(value: T): SelectAttributeBuilder<TName, T, TRequired>;
+    option(config: Option): this;
+    required(): SelectAttributeBuilder<TName, TOptions, true>;
+    optional(): SelectAttributeBuilder<TName, TOptions, false>;
+}
+declare function select<TName extends string>(config: TypedBuilderConfig<TName>): SelectAttributeBuilder<TName, Option[], false>;
+declare class MultiselectAttributeBuilder<TName extends string, TOptions extends readonly Option[] = Option[], TRequired extends boolean = false> extends BaseAttributeBuilder<MultiselectAttribute> {
+    readonly _types: {
+        name: TName;
+        attribute: MultiselectAttribute & {
+            options: TOptions;
+        };
+        required: TRequired;
+    };
+    constructor(name: TName, label: string);
+    /**
+     * Set all options at once (preserves literal types for values)
+     */
+    options<const T extends readonly Option[]>(value: T): MultiselectAttributeBuilder<TName, T, TRequired>;
+    option(config: Option): this;
+    required(): MultiselectAttributeBuilder<TName, TOptions, true>;
+    optional(): MultiselectAttributeBuilder<TName, TOptions, false>;
+}
+declare function multiselect<TName extends string>(config: TypedBuilderConfig<TName>): MultiselectAttributeBuilder<TName, Option[], false>;
+declare class LocationAttributeBuilder<TName extends string, TRequired extends boolean = false> extends BaseAttributeBuilder<LocationAttribute> {
+    readonly _types: {
+        name: TName;
+        attribute: LocationAttribute;
+        required: TRequired;
+    };
+    constructor(name: TName, label: string);
+    granularity(value: LocationAttribute["granularity"]): this;
+    enableAutocomplete(): this;
+    enableMap(): this;
+    defaultCountry(value: CountryIso3): this;
+    allowedCountries(value: CountryIso3[]): this;
+    displayFormat(value: LocationAttribute["displayFormat"]): this;
+    required(): LocationAttributeBuilder<TName, true>;
+    optional(): LocationAttributeBuilder<TName, false>;
+}
+declare function location<TName extends string>(config: TypedBuilderConfig<TName>): LocationAttributeBuilder<TName, false>;
+declare class TimestampAttributeBuilder<TName extends string, TRequired extends boolean = false> extends BaseAttributeBuilder<TimestampAttribute> {
+    readonly _types: {
+        name: TName;
+        attribute: TimestampAttribute;
+        required: TRequired;
+    };
+    constructor(name: TName, label: string);
+    autoUpdate(): this;
+    required(): TimestampAttributeBuilder<TName, true>;
+    optional(): TimestampAttributeBuilder<TName, false>;
+}
+declare function timestamp<TName extends string>(config: TypedBuilderConfig<TName>): TimestampAttributeBuilder<TName, false>;
+declare class FileAttributeBuilder<TName extends string, TRequired extends boolean = false> extends BaseAttributeBuilder<FileAttribute> {
+    readonly _types: {
+        name: TName;
+        attribute: FileAttribute;
+        required: TRequired;
+    };
+    constructor(name: TName, label: string);
+    maxFiles(value: number): this;
+    maxSize(bytes: number): this;
+    allowedTypes(types: MimeType[] | readonly MimeType[]): this;
+    verification(config: FileAttribute["verification"]): this;
+    required(): FileAttributeBuilder<TName, true>;
+    optional(): FileAttributeBuilder<TName, false>;
+}
+declare function file<TName extends string>(config: TypedBuilderConfig<TName>): FileAttributeBuilder<TName, false>;
+declare class UserAttributeBuilder<TName extends string, TRequired extends boolean = false> extends BaseAttributeBuilder<UserAttribute> {
+    readonly _types: {
+        name: TName;
+        attribute: UserAttribute;
+        required: TRequired;
+    };
+    constructor(name: TName, label: string);
+    allowedRoles(roles: string[]): this;
+    required(): UserAttributeBuilder<TName, true>;
+    optional(): UserAttributeBuilder<TName, false>;
+}
+declare function user<TName extends string>(config: TypedBuilderConfig<TName>): UserAttributeBuilder<TName, false>;
+/**
+ * Options for adding a relation target
+ */
+interface RelationTargetOptions {
+    /** Display template using mustache syntax, e.g., "{name}" or "{firstName} {lastName}" */
+    displayTemplate?: string;
+    /** Filter to restrict available records */
+    filter?: Record<string, unknown>;
+}
+/**
+ * Internal options for creating a relation builder from existing data
+ */
+interface RelationBuilderInitOptions {
+    targets?: RelationTarget[];
+    onDelete?: RelationOnDelete;
+    isRequired?: boolean;
+}
+/**
+ * Builder for single relation attributes (cardinality: "one")
+ */
+declare class SingleRelationAttributeBuilder<TName extends string, TRequired extends boolean = false> extends BaseAttributeBuilder<SingleRelationAttribute> {
+    readonly _types: {
+        name: TName;
+        attribute: SingleRelationAttribute;
+        required: TRequired;
+    };
+    constructor(name: TName, label: string);
+    /**
+     * Add a target object that can be linked
+     * @param objectName - Name of the object (e.g., "companies")
+     * @param options - Display template and filter options
+     */
+    to(objectName: string, options?: RelationTargetOptions): this;
+    /**
+     * Set the deletion strategy when target record is deleted
+     * @param strategy - "restrict" (default), "cascade", or "set_null"
+     */
+    onDelete(strategy: RelationOnDelete): this;
+    /**
+     * Convert to a multi-relation (cardinality: "many")
+     */
+    many(): MultiRelationAttributeBuilder<TName, TRequired>;
+    required(): SingleRelationAttributeBuilder<TName, true>;
+    optional(): SingleRelationAttributeBuilder<TName, false>;
+}
+/**
+ * Builder for multi relation attributes (cardinality: "many")
+ */
+declare class MultiRelationAttributeBuilder<TName extends string, TRequired extends boolean = false> extends BaseAttributeBuilder<MultiRelationAttribute> {
+    readonly _types: {
+        name: TName;
+        attribute: MultiRelationAttribute;
+        required: TRequired;
+    };
+    constructor(name: TName, label: string, initOptions?: RelationBuilderInitOptions);
+    /**
+     * Add a target object that can be linked
+     * @param objectName - Name of the object (e.g., "companies")
+     * @param options - Display template and filter options
+     */
+    to(objectName: string, options?: RelationTargetOptions): this;
+    /**
+     * Set the deletion strategy when target record is deleted
+     * @param strategy - "restrict" (default), "cascade", or "set_null"
+     */
+    onDelete(strategy: RelationOnDelete): this;
+    /**
+     * Set minimum number of relations required
+     */
+    minItems(count: number): this;
+    /**
+     * Set maximum number of relations allowed
+     */
+    maxItems(count: number): this;
+    required(): MultiRelationAttributeBuilder<TName, true>;
+    optional(): MultiRelationAttributeBuilder<TName, false>;
+}
+/**
+ * Create a relation attribute builder
+ *
+ * @example Single relation (default)
+ * ```typescript
+ * relation({ name: "company", label: "Company" })
+ *   .to("companies")
+ *   .required()
+ * ```
+ *
+ * @example Multi relation
+ * ```typescript
+ * relation({ name: "contacts", label: "Contacts" })
+ *   .to("contacts", { displayTemplate: "{firstName} {lastName}" })
+ *   .many()
+ *   .maxItems(5)
+ * ```
+ *
+ * @example Polymorphic relation
+ * ```typescript
+ * relation({ name: "linked", label: "Linked Items" })
+ *   .to("companies")
+ *   .to("contacts")
+ *   .many()
+ *   .onDelete("cascade")
+ * ```
+ */
+declare function relation<TName extends string>(config: TypedBuilderConfig<TName>): SingleRelationAttributeBuilder<TName, false>;
+declare class RatingAttributeBuilder<TName extends string, TRequired extends boolean = false> extends BaseAttributeBuilder<RatingAttribute> {
+    readonly _types: {
+        name: TName;
+        attribute: RatingAttribute;
+        required: TRequired;
+    };
+    constructor(name: TName, label: string);
+    max(value: number): this;
+    iconType(value: RatingAttribute["iconType"]): this;
+    required(): RatingAttributeBuilder<TName, true>;
+    optional(): RatingAttributeBuilder<TName, false>;
+}
+declare function rating<TName extends string>(config: TypedBuilderConfig<TName>): RatingAttributeBuilder<TName, false>;
+/**
+ * Union of all attribute builder types
+ */
+type AnyAttributeBuilder = TextAttributeBuilder<string, boolean> | TextAreaAttributeBuilder<string, boolean> | NumberAttributeBuilder<string, boolean> | CheckboxAttributeBuilder<string, boolean> | DateAttributeBuilder<string, boolean> | PhoneAttributeBuilder<string, boolean> | CurrencyAttributeBuilder<string, boolean> | StatusAttributeBuilder<string, readonly Option[], boolean> | SelectAttributeBuilder<string, readonly Option[], boolean> | MultiselectAttributeBuilder<string, readonly Option[], boolean> | LocationAttributeBuilder<string, boolean> | TimestampAttributeBuilder<string, boolean> | FileAttributeBuilder<string, boolean> | UserAttributeBuilder<string, boolean> | SingleRelationAttributeBuilder<string, boolean> | MultiRelationAttributeBuilder<string, boolean> | RatingAttributeBuilder<string, boolean>;
+/**
+ * Extract the attribute name from a builder
+ */
+type ExtractAttributeName<T> = T extends {
+    _types: {
+        name: infer N;
+    };
+} ? N : never;
+/**
+ * Extract the required flag from a builder
+ */
+type ExtractAttributeRequired<T> = T extends {
+    _types: {
+        required: infer R;
+    };
+} ? R : false;
+
+/**
+ * Extract attribute info from a builder instance
+ */
+type ExtractBuilderInfo<T> = T extends {
+    _types: {
+        name: infer N;
+        attribute: infer A;
+        required: infer R;
+    };
+} ? {
+    name: N;
+    attribute: A;
+    required: R;
+} : T extends Attribute ? {
+    name: T["name"];
+    attribute: T;
+    required: T["required"];
+} : never;
+/**
+ * Flatten and simplify an intersection type for better IDE display
+ */
+type Flatten<T> = T extends object ? {
+    [K in keyof T]: T[K];
+} : T;
+/**
+ * Add a required attribute to the record type
+ */
+type WithRequiredAttr<TRecord extends Record<string, unknown>, TName extends string, TValue> = Flatten<Omit<TRecord, TName> & {
+    [K in TName]: TValue;
+}>;
+/**
+ * Add an optional attribute to the record type
+ */
+type WithOptionalAttr<TRecord extends Record<string, unknown>, TName extends string, TValue> = Flatten<Omit<TRecord, TName> & {
+    [K in TName]?: TValue;
+}>;
+/**
+ * Add an attribute to the accumulated record type
+ */
+type AddAttribute<TRecord extends Record<string, unknown>, TName extends string, TAttr extends Attribute, TRequired extends boolean> = TRequired extends true ? WithRequiredAttr<TRecord, TName, InferAttributeValue<TAttr>> : WithOptionalAttr<TRecord, TName, InferAttributeValue<TAttr>>;
+/**
+ * Fluent builder for creating ObjectDefinition with full type inference
+ *
+ * The generic parameter TRecord accumulates attribute types as you chain
+ * .attribute() calls, enabling full autocompletion on the inferred record type.
+ *
+ * IMPORTANT: Every object MUST define a `labelExpression` to specify how records
+ * are displayed. Use `.labelExpression("{{ name }}")` to define the display template.
+ *
+ * @example
+ * ```typescript
+ * import { object, text, number, status } from "@stndrds/schema";
+ * import type { ExtractRecord } from "@stndrds/schema";
+ *
+ * const PRODUCT = object({ name: "products", label: "Product" })
+ *   .system()
+ *   .attribute(text({ name: "name", label: "Name" }).required()) // This becomes the title
+ *   .attribute(number({ name: "price", label: "Price" }).decimal(2))
+ *   .attribute(
+ *     status({ name: "status", label: "Status" })
+ *       .options([
+ *         { id: "active", label: "Active", value: "active", color: "green" },
+ *         { id: "draft", label: "Draft", value: "draft", color: "yellow" }
+ *       ])
+ *       .required()
+ *   );
+ *
+ * // Full autocompletion! ✨
+ * type ProductRecord = ExtractRecord<typeof PRODUCT>;
+ * // → { name: string; price?: number; status: string }
+ * ```
+ */
+declare class ObjectBuilder<TRecord extends Record<string, unknown> = {}> {
+    private obj;
+    private _labelExpression?;
+    private _pluralLabel?;
+    /**
+     * Phantom type property for type extraction
+     * Never used at runtime, only for TypeScript inference
+     */
+    readonly _types: {
+        record: TRecord;
+        input: TRecord;
+        update: {
+            [K in keyof TRecord]?: TRecord[K];
+        };
+    };
+    constructor(config: BuilderConfig);
+    /**
+     * Set object description
+     */
+    description(value: string): this;
+    /**
+     * Set the plural form of the label (e.g., "Products" for "Product")
+     * Used in UI when displaying collections
+     */
+    pluralLabel(value: string): this;
+    /**
+     * Set object icon
+     */
+    icon(value: IconName): this;
+    /**
+     * Mark as system/native object (defined in code, protected)
+     * System objects cannot be deleted/modified by clients
+     */
+    system(): this;
+    /**
+     * Add an attribute to the object with type accumulation
+     *
+     * The return type accumulates the attribute's name and value type
+     * into the TRecord generic, enabling full inference.
+     *
+     * @param attr - Attribute definition or builder (auto-builds if builder)
+     */
+    attribute<TBuilder extends {
+        _types: unknown;
+    } | Attribute, TInfo extends ExtractBuilderInfo<TBuilder> = ExtractBuilderInfo<TBuilder>, TName extends string = TInfo["name"] extends string ? TInfo["name"] : string, TAttr extends Attribute = TInfo["attribute"] extends Attribute ? TInfo["attribute"] : Attribute, TRequired extends boolean = TInfo["required"] extends true ? true : false>(attr: TBuilder): ObjectBuilder<AddAttribute<TRecord, TName, TAttr, TRequired>>;
+    /**
+     * Add multiple attributes at once
+     * Note: For full type inference, prefer chaining .attribute() calls
+     */
+    attributes(attrs: Array<Attribute | {
+        build: () => Attribute;
+    }>): this;
+    /**
+     * Set metadata
+     */
+    metadata(value: Record<string, unknown>): this;
+    /**
+     * Set the label expression template for displaying records
+     * This is REQUIRED for every object.
+     *
+     * Supports variable interpolation with `{{ attribute }}` syntax
+     * and pipes for formatting: `{{ name | UPPER }}`, `{{ name | capitalize }}`
+     *
+     * Available pipes: UPPER, LOWER, capitalize, trim
+     *
+     * @param template - The label expression template
+     *
+     * @example
+     * ```typescript
+     * object({ name: "contacts", label: "Contact" })
+     *   .labelExpression("{{ firstName }} {{ lastName }}")
+     *   .attribute(text({ name: "firstName", label: "First Name" }).required())
+     *   .attribute(text({ name: "lastName", label: "Last Name" }).required())
+     * ```
+     */
+    labelExpression(template: string): this;
+    /**
+     * Build the final ObjectDefinition
+     * @throws Error if required fields are missing or invalid
+     */
+    build(): ObjectDefinition;
+    /**
+     * Validate object name format
+     * Must be kebab-case (slug format), max 63 characters
+     * @internal
+     */
+    private validateName;
+}
+/**
+ * Create a new object builder with type inference
+ *
+ * @example
+ * ```typescript
+ * import { object, text, number } from "@stndrds/schema";
+ * import type { ExtractRecord } from "@stndrds/schema";
+ *
+ * // Define object with fluent API
+ * const PRODUCT = object({ name: "products", label: "Product" })
+ *   .system()
+ *   .attribute(text({ name: "name", label: "Name" }).required())
+ *   .attribute(number({ name: "price", label: "Price" }));
+ *
+ * // Extract the inferred record type
+ * type ProductRecord = ExtractRecord<typeof PRODUCT>;
+ * // → { name: string; price?: number }
+ *
+ * // Full autocompletion when creating records! ✨
+ * const product: ProductRecord = {
+ *   name: "Nike Air Max",  // required
+ *   price: 129.99          // optional
+ * };
+ * ```
+ */
+declare function object(config: BuilderConfig): ObjectBuilder<{}>;
+
+/**
+ * Builder for creating form groups
+ *
+ * @example
+ * ```typescript
+ * group("identity", "Identity")
+ *   .field("name", { span: 8 })
+ *   .field("status", { span: 4 })
+ *   .fields("description", "website")
+ *   .collapsible()
+ * ```
+ */
+declare class GroupBuilder {
+    private data;
+    constructor(id: string, label: string);
+    /**
+     * Set group description
+     */
+    description(value: string): this;
+    /**
+     * Make group collapsible
+     * @param collapsed - Initial collapsed state (default: false)
+     */
+    collapsible(collapsed?: boolean): this;
+    /**
+     * Set display order
+     */
+    order(value: number): this;
+    /**
+     * Add multiple fields with default options
+     * @example .fields("name", "email", "phone")
+     */
+    fields(...names: string[]): this;
+    /**
+     * Add a single field with options
+     * @example .field("name", { span: 8, readOnly: true })
+     */
+    field(attribute: string, options?: Omit<Field, "attribute" | "attributeGroup">): this;
+    /**
+     * Add an inline attribute group (composite field with dropdown)
+     * Groups multiple attributes into a single field
+     * @example .attributeGroup({ id: "address", label: "Address", attributes: ["street", "city", "postal_code"], displayTemplate: "{street}, {city}" })
+     */
+    attributeGroup(config: AttributeGroupField, options?: Omit<Field, "attribute" | "attributeGroup">): this;
+    /**
+     * Build the group definition
+     */
+    build(): Group;
+}
+/**
+ * Base tab configuration shared across tab types
+ */
+interface BaseTabConfig {
+    id: string;
+    name: string;
+    label: string;
+    icon?: IconName;
+    order?: number;
+    system?: boolean;
+}
+/**
+ * Builder for configuring table tabs
+ */
+declare class TableTabConfig {
+    private view;
+    private tabData;
+    /** @internal */
+    constructor(view: ViewBuilder, base: BaseTabConfig, relation: string);
+    /**
+     * Set columns to display
+     * @example .columns("firstName", "lastName", "email")
+     */
+    columns(...names: string[]): this;
+    /**
+     * Allow creating new records
+     */
+    create(): this;
+    /**
+     * Allow inline editing
+     */
+    edit(): this;
+    /**
+     * Allow deleting records
+     */
+    delete(): this;
+    /**
+     * Enable all CRUD operations (create, edit, delete)
+     */
+    crud(): this;
+    /**
+     * Set default filters
+     */
+    filters(value: Record<string, unknown>): this;
+    /**
+     * Set default sort
+     * @example .sort("lastName") or .sort("createdAt", "desc")
+     */
+    sort(field: string, order?: "asc" | "desc"): this;
+    /**
+     * Continue building with a new tab
+     */
+    tab(name: string, label: string): TabBuilder;
+    /**
+     * Finish this tab and return to ViewBuilder
+     */
+    done(): ViewBuilder;
+    /**
+     * Build the final view definition
+     */
+    build(): ViewDefinition;
+    private finalize;
+}
+/**
+ * Builder for configuring custom tabs
+ */
+declare class CustomTabConfig {
+    private view;
+    private tabData;
+    /** @internal */
+    constructor(view: ViewBuilder, base: BaseTabConfig, component: string);
+    /**
+     * Set props to pass to the component
+     */
+    props(value: Record<string, unknown>): this;
+    /**
+     * Continue building with a new tab
+     */
+    tab(name: string, label: string): TabBuilder;
+    /**
+     * Finish this tab and return to ViewBuilder
+     */
+    done(): ViewBuilder;
+    /**
+     * Build the final view definition
+     */
+    build(): ViewDefinition;
+}
+/**
+ * Builder for creating tabs with type discrimination
+ *
+ * @example
+ * ```typescript
+ * .tab("general", "Info").form(group(...))
+ * .tab("contacts", "Contacts").table("contacts").columns("name", "email")
+ * .tab("analytics", "Stats").custom("AnalyticsWidget")
+ * ```
+ */
+declare class TabBuilder {
+    private view;
+    private base;
+    /** @internal */
+    constructor(view: ViewBuilder, name: string, label: string);
+    /**
+     * Set tab icon
+     */
+    icon(value: IconName): this;
+    /**
+     * Set display order
+     */
+    order(value: number): this;
+    /**
+     * Mark as system tab (protected)
+     */
+    system(): this;
+    /**
+     * Create a form tab with groups
+     * @example .form(group("info", "Info").fields("name", "email"))
+     */
+    form(...groups: (GroupBuilder | Group)[]): ViewBuilder;
+    /**
+     * Create a table tab for a relation
+     * @example .table("contacts").columns("name", "email").crud()
+     */
+    table(relation: string): TableTabConfig;
+    /**
+     * Create a custom tab with a component
+     * @example .custom("AnalyticsWidget").props({ period: "12m" })
+     */
+    custom(component: string): CustomTabConfig;
+}
+/**
+ * Builder for creating view definitions
+ *
+ * @example
+ * ```typescript
+ * const COMPANY_VIEW = view("detail", "Company Detail")
+ *   .for("companies")
+ *   .default()
+ *   .system()
+ *   .icon("building")
+ *
+ *   .tab("general", "Info").icon("info")
+ *     .form(
+ *       group("identity", "Identity").fields("name", "status"),
+ *       group("address", "Address").fields("location").collapsible()
+ *     )
+ *
+ *   .tab("contacts", "Contacts").icon("users")
+ *     .table("contacts")
+ *     .columns("firstName", "lastName", "email")
+ *     .crud()
+ *
+ *   .tab("analytics", "Stats").icon("bar-chart")
+ *     .custom("CompanyAnalytics")
+ *     .props({ period: "12m" })
+ *
+ *   .build();
+ * ```
+ */
+declare class ViewBuilder {
+    private data;
+    private validated;
+    constructor(name: string, label: string);
+    /**
+     * Set view description
+     */
+    description(value: string): this;
+    /**
+     * Set view icon
+     */
+    icon(value: IconName): this;
+    /**
+     * Associate view with an object
+     * @param objectName - Object name (kebab-case)
+     */
+    for(objectName: string): this;
+    /**
+     * Mark as default view for the object
+     */
+    default(): this;
+    /**
+     * Mark as system view (protected, defined by developer)
+     */
+    system(): this;
+    /**
+     * Set metadata
+     */
+    metadata(value: Record<string, unknown>): this;
+    /**
+     * Start building a new tab
+     */
+    tab(name: string, label: string): TabBuilder;
+    /**
+     * Add a pre-built tab
+     */
+    addTab(tab: Tab): this;
+    /**
+     * @internal Used by TabBuilder to add tabs
+     */
+    _addTab(tab: Tab): this;
+    /**
+     * Build the final view definition
+     */
+    build(): ViewDefinition;
+    /**
+     * Validate view name format (kebab-case)
+     */
+    private validateName;
+}
+/**
+ * Create a new view builder
+ *
+ * @param name - View name (kebab-case)
+ * @param label - Display label
+ *
+ * @example
+ * ```typescript
+ * const COMPANY_VIEW = view("detail", "Company Detail")
+ *   .for("companies")
+ *   .default()
+ *   .system()
+ *   .tab("general", "Info")
+ *     .form(group("main", "Main").fields("name", "status"))
+ *   .build();
+ * ```
+ */
+declare function view(name: string, label: string): ViewBuilder;
+/**
+ * Create a new group builder
+ *
+ * @param id - Group identifier
+ * @param label - Display label
+ *
+ * @example
+ * ```typescript
+ * group("identity", "Identity")
+ *   .field("name", { span: 8 })
+ *   .field("status", { span: 4 })
+ *   .collapsible()
+ * ```
+ */
+declare function group(id: string, label: string): GroupBuilder;
+
+export { type AddAttribute$1 as AddAttribute, type AnyAttributeBuilder, Attribute, AttributeGroupField, type AttributeMap, AttributeNotFoundError, type AttributeSchema, type BuilderConfig, CheckboxAttribute, Currency, CurrencyAttribute, type CustomAttributeValue, CustomTabConfig, DateAttribute, DuplicateError, type ExtractAttributeName, type ExtractAttributeRequired, type ExtractAttributes, type ExtractRecord, type ExtractRecordInput, type ExtractRecordInputStrict, type ExtractRecordStrict, type ExtractRecordUpdate, type ExtractRecordUpdateStrict, Field, FileAttribute, FileNotFoundError, Group, GroupBuilder, type InferAttributeValue, type InferRecord, type InferRecordFromSchema, type InferRecordInput, type InferRecordUpdate, type InferRecordWithRequirements, Location, LocationAttribute, MultiRelationAttribute, MultiselectAttribute, NotFoundError, NotSystemObjectError, NumberAttribute, ObjectBuilder, ObjectDefinition, ObjectNotFoundError, Option, Phone, PhoneAttribute, ProtectedResourceError, RatingAttribute, RecordNotFoundError, RelationOnDelete, RelationTarget, SchemaError, SchemaErrorCode, SelectAttribute, SingleRelationAttribute, StatusAttribute, SyncError, Tab, TabBuilder, TableTabConfig, TextAreaAttribute, TextAttribute, TimestampAttribute, type TypedAttribute, type TypedBuilderConfig, UserAttribute, UserProfileNotFoundError, ValidationError, type ValidationErrorDetail, ViewBuilder, ViewDefinition, type WithCustomAttributes, checkbox, currency, date, file, group, isNotFoundError, isProtectedResourceError, isSchemaError, isValidationError, location, multiselect, number, object, phone, rating, relation, select, status, text, textarea, timestamp, user, view };