@wildo-ai/saas-models 1.0.1

package/dist/esm/resources/resources.shared.schemas.d.ts

@@ -0,0 +1,1302 @@
+/**
+ * Operations Shared Schemas
+ *
+ * Reusable operation schemas for bulk actions and common operations
+ */
+import { z } from 'zod';
+import { CoreResourceOperation } from './resources.shared.core.definitions.js';
+import { ChildLifecycleMode, type ChildOperationsConfig_Parsed } from './child-operations.shared.schemas.js';
+import { SchemaInfer } from './utils/schema-type-inference.utils.js';
+export type { ResourceType } from './resources.shared.core.definitions.js';
+export declare enum ResourceOperationRiskLevel {
+    LOW = "low",
+    MEDIUM = "medium",
+    HIGH = "high",
+    CRITICAL = "critical"
+}
+/**
+ * Display mode for resource operation action bars — controls operation bar density.
+ * SUMMARY = compact row actions (icon-only, in list/table rows).
+ *
+ * Note: "summary" here is about *UI density*, not API data shape (see DataMode.SUMMARY)
+ * or FK rendering (see ForeignKeyDisplayMode.SUMMARY).
+ */
+export declare enum ResourceOperationDisplayMode {
+    /** In a list/table row — compact, icon-only, includes "View Details" */
+    SUMMARY = "summary",
+    /** In a full read/detail view — can show inline labels */
+    DETAIL = "detail"
+}
+export declare enum ResourcePrimaryScope {
+    USER_SELF = "user_self",
+    ORGANIZATIONS = "organizations",
+    APPLICATION = "applications",
+    ANONYMOUS = "anonymous"
+}
+/**
+ * W7.3a: Controls how anonymous resources are handled during transposition
+ * (when an anonymous user registers/logs in as an authenticated user).
+ */
+export declare enum ResourceTranspositionPolicy {
+    /** Simply reassign ownership (anonymousUserId → userId). No conflict check. Default. */
+    ADD = "ADD",
+    /** Delete the authenticated user's existing records of this type, then reassign anonymous ones. */
+    REPLACE = "REPLACE",
+    /** Delegate to a custom service hook (app-developer-defined merge logic). */
+    MERGE = "MERGE",
+    /** Skip transposition entirely — anonymous records are not carried over. */
+    DISCARD = "DISCARD"
+}
+import { CoreResourceType } from './resources.shared.core.definitions.js';
+/**
+ * Map from ResourcePrimaryScope to the CoreResourceType it represents.
+ * This is the foundation - other mappings derive from this.
+ */
+export declare const PRIMARY_SCOPE_TO_CORE_RESOURCE_TYPE: Record<ResourcePrimaryScope, CoreResourceType>;
+/**
+ * Map from ResourcePrimaryScope to its field identifier.
+ * Uses coreResourceShared_FieldIdentifier as the source of truth for field names.
+ */
+export declare const PRIMARY_SCOPE_TO_FIELD_IDENTIFIER: Record<ResourcePrimaryScope, string>;
+/**
+ * Primary scope field identifiers - auto-populated from execution context.
+ * These fields should be excluded from CREATE/UPDATE DTOs because they are
+ * automatically injected by the backend based on the authenticated user's context.
+ *
+ * Derived from PRIMARY_SCOPE_TO_FIELD_IDENTIFIER values.
+ */
+export declare const PRIMARY_SCOPE_FIELD_IDENTIFIERS: readonly string[];
+export type PrimaryScopeFieldIdentifier = (typeof PRIMARY_SCOPE_FIELD_IDENTIFIERS)[number];
+/**
+ * Map from field identifier to ResourcePrimaryScope.
+ * Built by inverting PRIMARY_SCOPE_TO_FIELD_IDENTIFIER.
+ */
+export declare const FIELD_IDENTIFIER_TO_PRIMARY_SCOPE: Record<string, ResourcePrimaryScope>;
+/**
+ * Map from ResourcePrimaryScope to the CoreResourceType(s) it represents.
+ * Returns as array for compatibility (though each scope maps to a single type).
+ */
+export declare const PRIMARY_SCOPE_TO_RESOURCE_TYPES: Record<ResourcePrimaryScope, CoreResourceType[]>;
+/**
+ * Get the field identifier for a primary scope.
+ */
+export declare function getPrimaryScopeFieldIdentifier(primaryScope: ResourcePrimaryScope): string;
+/**
+ * The 2 scopes that have billing polymorphic variants.
+ * APPLICATION scope is intentionally absent — it has no billing variants;
+ * scope-agnostic billing resources (Products, Prices, etc.) are not per-scope.
+ */
+export declare const BILLING_SCOPES: readonly ResourcePrimaryScope[];
+/**
+ * Per-scope billing resource types.
+ * Maps each billing scope to the set of polymorphic resource type variants
+ * that belong to it. Used to selectively exclude disabled scopes while
+ * keeping enabled scopes and scope-agnostic resources (Products, Prices, etc.).
+ */
+export declare const BILLING_SCOPE_RESOURCE_TYPES: Readonly<Partial<Record<ResourcePrimaryScope, ReadonlySet<CoreResourceType>>>>;
+/**
+ * Get the primary scope for a field identifier.
+ * Returns undefined if the field is not a primary scope field.
+ */
+export declare function getPrimaryScopeFromFieldIdentifier(fieldIdentifier: string): ResourcePrimaryScope | undefined;
+/**
+ * Check if a field identifier is a primary scope field.
+ */
+export declare function isPrimaryScopeFieldIdentifier(fieldIdentifier: string): fieldIdentifier is PrimaryScopeFieldIdentifier;
+export declare enum ResourceRelationshipCardinality {
+    ONE = "one",
+    ZERO_OR_ONE = "zero_or_one",
+    ONE_OR_MANY = "one_or_many",
+    MANY = "many"
+}
+/**
+ * Check if a cardinality represents a 1:1 relationship (single object).
+ * Both `ONE` (mandatory) and `ZERO_OR_ONE` (optional) are single-object cardinalities.
+ *
+ * Use this utility instead of checking `=== ONE` directly, to avoid
+ * the common bug of missing `ZERO_OR_ONE` (optional 1:1) handling.
+ *
+ * Determines:
+ * - DTO shape: single optional object (not array)
+ * - Nested field naming: singular (e.g., "profile" not "profiles")
+ * - Fetch strategy: READ (not LIST)
+ * - URL path: singular entity path
+ */
+export declare function isOneToOneCardinality(cardinality: ResourceRelationshipCardinality): boolean;
+/**
+ * Check if a cardinality represents a 1:N relationship (array/collection).
+ * Both `MANY` (zero or more) and `ONE_OR_MANY` (at least one) are array cardinalities.
+ *
+ * Use this utility instead of checking `=== MANY` directly, to avoid
+ * the common bug of missing `ONE_OR_MANY` (mandatory at-least-one) handling.
+ *
+ * Determines:
+ * - DTO shape: array of objects
+ * - Nested field naming: plural (e.g., "tasks" not "task")
+ * - Fetch strategy: LIST
+ * - URL path: collection path
+ */
+export declare function isArrayCardinality(cardinality: ResourceRelationshipCardinality): boolean;
+export declare enum ResourceOperationVariantType {
+    API_CALL = "api_call",
+    API_CALL_WITH_CALLBACK = "api_call_with_callback",
+    CRON_JOB = "cron_job",
+    BATCH_JOB = "batch_job",
+    INTERNAL_CALL = "internal_call",
+    REPOSITORY_ONLY = "repository_only"
+}
+export declare enum ResourceOperation_ServiceRuntimeMode {
+    INLINE = "inline",
+    INLINE_NOT_AWAITABLE = "inline_not_awaitable",
+    BACKGROUND_JOB = "background_job",
+    QUEUED = "queued",
+    QUEUED_NOT_AWAITABLE = "queued_not_awaitable",
+    NONE = "none"
+}
+export declare enum ResourceOperation_CustomServiceImplementationMode {
+    OVERRIDE_ALL = "override_all",
+    PREFIX_CORE_OPERARTIONS = "prefix_core_operations",
+    POSTFIX_CORE_OPERARTIONS = "postfix_core_operations",
+    REPLACE_CORE_OPERARTIONS = "between_core_operations",
+    AFTER_USER_NOTIFICATIONS = "after_user_notifications",
+    AT_THE_END = "at_the_end"
+}
+export declare enum ResourceParentResourceRequirement {
+    MANDATORY = "mandatory",
+    OPTIONAL = "optional"
+}
+export declare enum ResourceOperation_InputPolicy {
+    DEFAULT = "default",
+    CUSTOM = "custom"
+}
+export declare enum ResourceOperation_OutputPolicy {
+    DEFAULT = "default",
+    CUSTOM = "custom",
+    SUMMARY = "summary",
+    CONTEXT = "context"
+}
+export declare enum ResourceRelationshipAccessScopeStrategy {
+    REQUIRES_CONTEXT = "requires_context",
+    OPTIONAL_CONTEXT = "optional_context",
+    STANDALONE = "standalone"
+}
+/**
+ * High-level semantic kind of relationship.
+ *
+ * This is the primary shared meaning. Resolver/runtime layers may later derive
+ * engine-facing handling from it, but the declaration should start here rather
+ * than from low-level DTO or lifecycle toggles.
+ *
+ * Developer-facing interpretation:
+ *
+ * - `COMPOSITION`
+ *   The parent owns an aggregate boundary around the child. The relationship is
+ *   about parent-managed nested resources. Child lifecycle is typically
+ *   dependent on the parent, and nested create/update/delete is the natural UX.
+ *
+ * - `REFERENCE`
+ *   The current resource points to another independent resource. The default UX
+ *   is "select existing / clear / navigate". A future "quick create" shortcut
+ *   may exist, but it still means "create independent resource, then set the
+ *   reference" rather than aggregate-managed nested creation.
+ *
+ * - `ASSOCIATION`
+ *   The current resource is linked to peer resources through membership/link
+ *   semantics. The default UX is "link / unlink / replace peer set". A future
+ *   "quick create" shortcut may exist, but it still means "create independent
+ *   peer, then link it" rather than treating the peer as an owned child.
+ *
+ * Important rule:
+ * - "quick create" is a frontend workflow capability layered on top of a
+ *   relationship, not a fourth relationship nature.
+ */
+export declare enum RelationshipNature {
+    COMPOSITION = "composition",
+    REFERENCE = "reference",
+    ASSOCIATION = "association"
+}
+/**
+ * Parent-surface DTO model implied by relationship semantics.
+ *
+ * This tells the framework what kind of shape the parent-facing interaction
+ * should expose:
+ * - `NESTED_RESOURCE` → full nested child payloads
+ * - `REFERENCE_HANDLE` → handle/pointer semantics to an independent resource
+ * - `ASSOCIATION_HANDLE` → peer membership/link semantics
+ */
+export declare enum RelationshipDtoModel {
+    NESTED_RESOURCE = "nested_resource",
+    REFERENCE_HANDLE = "reference_handle",
+    ASSOCIATION_HANDLE = "association_handle"
+}
+/**
+ * Parent-driven mutation semantics for the relationship.
+ *
+ * Interpretation:
+ * - `AGGREGATE_MANAGED` → parent can orchestrate nested child CRUD
+ * - `REFERENCE_MANAGED` → parent mutates only the reference handle/pointer
+ * - `ASSOCIATION_MANAGED` → parent mutates membership/link state to peers
+ * - `NONE` → no parent-driven relationship-object mutation contract
+ */
+export declare enum RelationshipMutationModel {
+    AGGREGATE_MANAGED = "aggregate_managed",
+    REFERENCE_MANAGED = "reference_managed",
+    ASSOCIATION_MANAGED = "association_managed",
+    NONE = "none"
+}
+/**
+ * Lifecycle dependency semantics between the parent and the related element.
+ *
+ * This is about dependency, not frontend chrome:
+ * - `DEPENDENT` → child lifecycle follows parent ownership
+ * - `INDEPENDENT` → related resource lives independently
+ * - `LINK_ONLY` → only the relationship membership/link is owned here
+ */
+export declare enum RelationshipLifecycleModel {
+    DEPENDENT = "dependent",
+    INDEPENDENT = "independent",
+    LINK_ONLY = "link_only"
+}
+/**
+ * Shared read intent for the relationship.
+ *
+ * Important: this is NOT the same semantic plane as `DataMode`,
+ * `ContextPolicy_ObjectMode`, or `childOperations.nested.onRead`.
+ * It is the high-level engine-facing read intent that later resolver steps may
+ * project into those operational surfaces where the meaning is truly identical.
+ *
+ * Interpretation:
+ * - `EMBEDDED` → read as an owned nested child/children
+ * - `REFERENCE_ONLY` → read as a pointer/reference surface
+ * - `ASSOCIATION_EMBEDDED` → read as associated peers, while preserving peer
+ *   semantics rather than collapsing them into composition
+ */
+export declare enum RelationshipReadModel {
+    EMBEDDED = "embedded",
+    REFERENCE_ONLY = "reference_only",
+    ASSOCIATION_EMBEDDED = "association_embedded"
+}
+/**
+ * Explicit semantic read contract for a relationship.
+ *
+ * This answers the semantic question "how should this relationship read?" and
+ * intentionally stays separate from the low-level nested projection in
+ * `childOperations.nested.onRead`, which still carries payload-shaping details
+ * like `dataMode`, list behavior, limits, and sort order.
+ */
+export declare const RelationshipHandlingReadSettingsSchema: z.ZodObject<{
+    model: z.ZodEnum<typeof RelationshipReadModel>;
+}, z.core.$strip, core.$ZodObjectExtra>;
+export type RelationshipHandlingReadSettings = z.infer<typeof RelationshipHandlingReadSettingsSchema>;
+/**
+ * Narrow mutation refinements under the semantic handling contract.
+ *
+ * These are still low-level operational hints, not a replacement for
+ * `nature` or the top-level handling models.
+ */
+export declare const RelationshipHandlingMutationSettingsSchema: z.ZodObject<{
+    allowParentCreate: z.ZodOptional<z.ZodBoolean>;
+    allowParentUpdate: z.ZodOptional<z.ZodBoolean>;
+    allowParentDelete: z.ZodOptional<z.ZodBoolean>;
+    maxDepth: z.ZodOptional<z.ZodNumber>;
+}, z.core.$strip, core.$ZodObjectExtra>;
+export type RelationshipHandlingMutationSettings = z.infer<typeof RelationshipHandlingMutationSettingsSchema>;
+/**
+ * Narrow lifecycle refinements under the semantic handling contract.
+ */
+export declare const RelationshipHandlingLifecycleOnParentDeleteSettingsSchema: z.ZodObject<{
+    enabled: z.ZodOptional<z.ZodBoolean>;
+    mode: z.ZodOptional<z.ZodEnum<typeof ChildLifecycleMode>>;
+    maxDepth: z.ZodOptional<z.ZodNumber>;
+}, z.core.$strip, core.$ZodObjectExtra>;
+export type RelationshipHandlingLifecycleOnParentDeleteSettings = z.infer<typeof RelationshipHandlingLifecycleOnParentDeleteSettingsSchema>;
+export declare const RelationshipHandlingLifecycleSettingsSchema: z.ZodObject<{
+    onParentDelete: z.ZodOptional<z.ZodObject<{
+        enabled: z.ZodOptional<z.ZodBoolean>;
+        mode: z.ZodOptional<z.ZodEnum<typeof ChildLifecycleMode>>;
+        maxDepth: z.ZodOptional<z.ZodNumber>;
+    }, z.core.$strip, core.$ZodObjectExtra>>;
+}, z.core.$strip, core.$ZodObjectExtra>;
+export type RelationshipHandlingLifecycleSettings = z.infer<typeof RelationshipHandlingLifecycleSettingsSchema>;
+/**
+ * Explicit multi-target relationship actions.
+ *
+ * These actions are intentionally narrower than generic nested CRUD replay:
+ * - `SET` / `CLEAR` target reference relationships from the current resource as child
+ * - `CREATE` targets composition relationships from the current resource as parent
+ * - `LINK` / `UNLINK` target peer associations while keeping junction-row
+ *   persistence an internal implementation detail
+ * - `REPLACE` atomically expresses the desired peer set for association-backed
+ *   form controls without forcing the client to orchestrate unlink/link diffs
+ */
+export declare enum ResourceRelationshipBulkAction {
+    SET = "set",
+    CLEAR = "clear",
+    CREATE = "create",
+    LINK = "link",
+    UNLINK = "unlink",
+    REPLACE = "replace"
+}
+export declare const ResourceRelationshipBulkOperationIdentifierPrefix: {
+    readonly set: "bulk_set_";
+    readonly clear: "bulk_clear_";
+    readonly create: "bulk_create_";
+    readonly link: "bulk_link_";
+    readonly unlink: "bulk_unlink_";
+    readonly replace: "bulk_replace_";
+};
+export declare const ResourceRelationshipBulkSetActionRequestSchema: z.ZodObject<{
+    relationshipField: z.ZodString;
+    action: z.ZodLiteral<ResourceRelationshipBulkAction.SET>;
+    targetId: z.ZodString;
+}, z.core.$strip, core.$ZodObjectExtra>;
+export type ResourceRelationshipBulkSetActionRequest = z.infer<typeof ResourceRelationshipBulkSetActionRequestSchema>;
+export declare const ResourceRelationshipBulkClearActionRequestSchema: z.ZodObject<{
+    relationshipField: z.ZodString;
+    action: z.ZodLiteral<ResourceRelationshipBulkAction.CLEAR>;
+}, z.core.$strip, core.$ZodObjectExtra>;
+export type ResourceRelationshipBulkClearActionRequest = z.infer<typeof ResourceRelationshipBulkClearActionRequestSchema>;
+export declare const ResourceRelationshipBulkCreateActionRequestSchema: z.ZodObject<{
+    relationshipField: z.ZodString;
+    action: z.ZodLiteral<ResourceRelationshipBulkAction.CREATE>;
+    data: z.ZodRecord<z.ZodString, z.ZodAny>;
+}, z.core.$strip, core.$ZodObjectExtra>;
+export type ResourceRelationshipBulkCreateActionRequest = z.infer<typeof ResourceRelationshipBulkCreateActionRequestSchema>;
+export declare const ResourceRelationshipBulkLinkActionRequestSchema: z.ZodObject<{
+    relationshipField: z.ZodString;
+    action: z.ZodLiteral<ResourceRelationshipBulkAction.LINK>;
+    peerIds: z.ZodArray<z.ZodString>;
+}, z.core.$strip, core.$ZodObjectExtra>;
+export type ResourceRelationshipBulkLinkActionRequest = z.infer<typeof ResourceRelationshipBulkLinkActionRequestSchema>;
+export declare const ResourceRelationshipBulkUnlinkActionRequestSchema: z.ZodObject<{
+    relationshipField: z.ZodString;
+    action: z.ZodLiteral<ResourceRelationshipBulkAction.UNLINK>;
+    peerIds: z.ZodArray<z.ZodString>;
+}, z.core.$strip, core.$ZodObjectExtra>;
+export type ResourceRelationshipBulkUnlinkActionRequest = z.infer<typeof ResourceRelationshipBulkUnlinkActionRequestSchema>;
+export declare const ResourceRelationshipBulkReplaceActionRequestSchema: z.ZodObject<{
+    relationshipField: z.ZodString;
+    action: z.ZodLiteral<ResourceRelationshipBulkAction.REPLACE>;
+    peerIds: z.ZodArray<z.ZodString>;
+}, z.core.$strip, core.$ZodObjectExtra>;
+export type ResourceRelationshipBulkReplaceActionRequest = z.infer<typeof ResourceRelationshipBulkReplaceActionRequestSchema>;
+export declare const ResourceRelationshipBulkActionRequestSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
+    relationshipField: z.ZodString;
+    action: z.ZodLiteral<ResourceRelationshipBulkAction.SET>;
+    targetId: z.ZodString;
+}, z.core.$strip, core.$ZodObjectExtra>, z.ZodObject<{
+    relationshipField: z.ZodString;
+    action: z.ZodLiteral<ResourceRelationshipBulkAction.CLEAR>;
+}, z.core.$strip, core.$ZodObjectExtra>, z.ZodObject<{
+    relationshipField: z.ZodString;
+    action: z.ZodLiteral<ResourceRelationshipBulkAction.CREATE>;
+    data: z.ZodRecord<z.ZodString, z.ZodAny>;
+}, z.core.$strip, core.$ZodObjectExtra>, z.ZodObject<{
+    relationshipField: z.ZodString;
+    action: z.ZodLiteral<ResourceRelationshipBulkAction.LINK>;
+    peerIds: z.ZodArray<z.ZodString>;
+}, z.core.$strip, core.$ZodObjectExtra>, z.ZodObject<{
+    relationshipField: z.ZodString;
+    action: z.ZodLiteral<ResourceRelationshipBulkAction.UNLINK>;
+    peerIds: z.ZodArray<z.ZodString>;
+}, z.core.$strip, core.$ZodObjectExtra>, z.ZodObject<{
+    relationshipField: z.ZodString;
+    action: z.ZodLiteral<ResourceRelationshipBulkAction.REPLACE>;
+    peerIds: z.ZodArray<z.ZodString>;
+}, z.core.$strip, core.$ZodObjectExtra>], "action">;
+export type ResourceRelationshipBulkActionRequest = z.infer<typeof ResourceRelationshipBulkActionRequestSchema>;
+/**
+ * Public request selector for explicit bulk relationship operations.
+ *
+ * Unlike the legacy bulk DTO base, this selector intentionally supports either:
+ * - `_ids` for UI-driven selection over a finite checked list
+ * - `filter` for backend/automation-driven targeting over a query
+ *
+ * The exposed operation surface stays one-selector / one-action / one-payload.
+ */
+export declare const ResourceRelationshipBulkOperationSelectorSchema: z.ZodUnion<readonly [z.ZodObject<{
+    _ids: z.ZodArray<z.ZodString>;
+    filter: z.ZodOptional<z.ZodUndefined>;
+}, z.core.$strip, core.$ZodObjectExtra>, z.ZodObject<{
+    filter: z.ZodRecord<z.ZodString, z.ZodAny>;
+    _ids: z.ZodOptional<z.ZodUndefined>;
+}, z.core.$strip, core.$ZodObjectExtra>]>;
+export type ResourceRelationshipBulkOperationSelector = z.infer<typeof ResourceRelationshipBulkOperationSelectorSchema>;
+export declare const ResourceRelationshipBulkSetOperationRequestSchema: z.ZodIntersection<z.ZodUnion<readonly [z.ZodObject<{
+    _ids: z.ZodArray<z.ZodString>;
+    filter: z.ZodOptional<z.ZodUndefined>;
+}, z.core.$strip, core.$ZodObjectExtra>, z.ZodObject<{
+    filter: z.ZodRecord<z.ZodString, z.ZodAny>;
+    _ids: z.ZodOptional<z.ZodUndefined>;
+}, z.core.$strip, core.$ZodObjectExtra>]>, z.ZodObject<{
+    targetId: z.ZodString;
+}, z.core.$strip, core.$ZodObjectExtra>>;
+export type ResourceRelationshipBulkSetOperationRequest = z.infer<typeof ResourceRelationshipBulkSetOperationRequestSchema>;
+export declare const ResourceRelationshipBulkClearOperationRequestSchema: z.ZodUnion<readonly [z.ZodObject<{
+    _ids: z.ZodArray<z.ZodString>;
+    filter: z.ZodOptional<z.ZodUndefined>;
+}, z.core.$strip, core.$ZodObjectExtra>, z.ZodObject<{
+    filter: z.ZodRecord<z.ZodString, z.ZodAny>;
+    _ids: z.ZodOptional<z.ZodUndefined>;
+}, z.core.$strip, core.$ZodObjectExtra>]>;
+export type ResourceRelationshipBulkClearOperationRequest = z.infer<typeof ResourceRelationshipBulkClearOperationRequestSchema>;
+export declare const ResourceRelationshipBulkCreateOperationRequestSchema: z.ZodIntersection<z.ZodUnion<readonly [z.ZodObject<{
+    _ids: z.ZodArray<z.ZodString>;
+    filter: z.ZodOptional<z.ZodUndefined>;
+}, z.core.$strip, core.$ZodObjectExtra>, z.ZodObject<{
+    filter: z.ZodRecord<z.ZodString, z.ZodAny>;
+    _ids: z.ZodOptional<z.ZodUndefined>;
+}, z.core.$strip, core.$ZodObjectExtra>]>, z.ZodObject<{
+    data: z.ZodRecord<z.ZodString, z.ZodAny>;
+}, z.core.$strip, core.$ZodObjectExtra>>;
+export type ResourceRelationshipBulkCreateOperationRequest = z.infer<typeof ResourceRelationshipBulkCreateOperationRequestSchema>;
+export declare const ResourceRelationshipBulkLinkOperationRequestSchema: z.ZodIntersection<z.ZodUnion<readonly [z.ZodObject<{
+    _ids: z.ZodArray<z.ZodString>;
+    filter: z.ZodOptional<z.ZodUndefined>;
+}, z.core.$strip, core.$ZodObjectExtra>, z.ZodObject<{
+    filter: z.ZodRecord<z.ZodString, z.ZodAny>;
+    _ids: z.ZodOptional<z.ZodUndefined>;
+}, z.core.$strip, core.$ZodObjectExtra>]>, z.ZodObject<{
+    peerIds: z.ZodArray<z.ZodString>;
+}, z.core.$strip, core.$ZodObjectExtra>>;
+export type ResourceRelationshipBulkLinkOperationRequest = z.infer<typeof ResourceRelationshipBulkLinkOperationRequestSchema>;
+export declare const ResourceRelationshipBulkUnlinkOperationRequestSchema: z.ZodIntersection<z.ZodUnion<readonly [z.ZodObject<{
+    _ids: z.ZodArray<z.ZodString>;
+    filter: z.ZodOptional<z.ZodUndefined>;
+}, z.core.$strip, core.$ZodObjectExtra>, z.ZodObject<{
+    filter: z.ZodRecord<z.ZodString, z.ZodAny>;
+    _ids: z.ZodOptional<z.ZodUndefined>;
+}, z.core.$strip, core.$ZodObjectExtra>]>, z.ZodObject<{
+    peerIds: z.ZodArray<z.ZodString>;
+}, z.core.$strip, core.$ZodObjectExtra>>;
+export type ResourceRelationshipBulkUnlinkOperationRequest = z.infer<typeof ResourceRelationshipBulkUnlinkOperationRequestSchema>;
+export declare const ResourceRelationshipBulkReplaceOperationRequestSchema: z.ZodIntersection<z.ZodUnion<readonly [z.ZodObject<{
+    _ids: z.ZodArray<z.ZodString>;
+    filter: z.ZodOptional<z.ZodUndefined>;
+}, z.core.$strip, core.$ZodObjectExtra>, z.ZodObject<{
+    filter: z.ZodRecord<z.ZodString, z.ZodAny>;
+    _ids: z.ZodOptional<z.ZodUndefined>;
+}, z.core.$strip, core.$ZodObjectExtra>]>, z.ZodObject<{
+    peerIds: z.ZodArray<z.ZodString>;
+}, z.core.$strip, core.$ZodObjectExtra>>;
+export type ResourceRelationshipBulkReplaceOperationRequest = z.infer<typeof ResourceRelationshipBulkReplaceOperationRequestSchema>;
+export declare const ResourceRelationshipBulkActionResultSchema: z.ZodObject<{
+    relationshipField: z.ZodString;
+    action: z.ZodEnum<typeof ResourceRelationshipBulkAction>;
+    matchedTargetIds: z.ZodArray<z.ZodString>;
+    affectedCount: z.ZodNumber;
+    results: z.ZodArray<z.ZodAny>;
+}, z.core.$strip, core.$ZodObjectExtra>;
+export type ResourceRelationshipBulkActionResult = z.infer<typeof ResourceRelationshipBulkActionResultSchema>;
+/**
+ * Fully resolved relationship handling contract.
+ *
+ * This describes the engine-facing semantic handling after `nature` has been
+ * resolved. The `read` block is the semantic source of truth, while
+ * `childOperations.nested.onRead` remains the low-level operational projection
+ * for payload shaping.
+ */
+export declare const RelationshipHandlingContractSchema: z.ZodObject<{
+    dtoModelMode: z.ZodEnum<typeof RelationshipDtoModel>;
+    mutationModelMode: z.ZodEnum<typeof RelationshipMutationModel>;
+    lifecycleModelMode: z.ZodEnum<typeof RelationshipLifecycleModel>;
+    readModelMode: z.ZodEnum<typeof RelationshipReadModel>;
+    read: z.ZodObject<{
+        model: z.ZodEnum<typeof RelationshipReadModel>;
+    }, z.core.$strip, core.$ZodObjectExtra>;
+    mutation: z.ZodOptional<z.ZodObject<{
+        allowParentCreate: z.ZodOptional<z.ZodBoolean>;
+        allowParentUpdate: z.ZodOptional<z.ZodBoolean>;
+        allowParentDelete: z.ZodOptional<z.ZodBoolean>;
+        maxDepth: z.ZodOptional<z.ZodNumber>;
+    }, z.core.$strip, core.$ZodObjectExtra>>;
+    lifecycle: z.ZodOptional<z.ZodObject<{
+        onParentDelete: z.ZodOptional<z.ZodObject<{
+            enabled: z.ZodOptional<z.ZodBoolean>;
+            mode: z.ZodOptional<z.ZodEnum<typeof ChildLifecycleMode>>;
+            maxDepth: z.ZodOptional<z.ZodNumber>;
+        }, z.core.$strip, core.$ZodObjectExtra>>;
+    }, z.core.$strip, core.$ZodObjectExtra>>;
+}, z.core.$strip, core.$ZodObjectExtra>;
+export type RelationshipHandlingContract = z.infer<typeof RelationshipHandlingContractSchema>;
+export declare const ResourceRelationshipBaseSchema: z.ZodObject<{
+    resourceType1: z.ZodUnion<readonly [z.ZodEnum<typeof CoreResourceType>, z.ZodString]>;
+    resourceType2: z.ZodUnion<readonly [z.ZodEnum<typeof CoreResourceType>, z.ZodString]>;
+}, z.core.$strip, core.$ZodObjectExtra>;
+export type ResourceRelationshipBase = z.infer<typeof ResourceRelationshipBaseSchema>;
+export declare const ResourceRelationshipSchema: z.ZodObject<{
+    cardinality1: z.ZodEnum<typeof ResourceRelationshipCardinality>;
+    cardinality2: z.ZodEnum<typeof ResourceRelationshipCardinality>;
+    resourceType1: z.ZodUnion<readonly [z.ZodEnum<typeof CoreResourceType>, z.ZodString]>;
+    resourceType2: z.ZodUnion<readonly [z.ZodEnum<typeof CoreResourceType>, z.ZodString]>;
+    accessScopeStrategy: z.ZodDefault<z.ZodEnum<typeof ResourceRelationshipAccessScopeStrategy>>;
+    parentResourceRequirement: z.ZodDefault<z.ZodEnum<typeof ResourceParentResourceRequirement>>;
+    jointResourceType: z.ZodOptional<z.ZodUnion<readonly [z.ZodEnum<typeof CoreResourceType>, z.ZodString]>>;
+    isPrimaryScope: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
+    primaryScope: z.ZodOptional<z.ZodEnum<typeof ResourcePrimaryScope>>;
+    allowCycle: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
+    isDisabled: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
+    contextPolicy: z.ZodOptional<z.ZodObject<{
+        enabled: z.ZodOptional<z.ZodBoolean>;
+        depth: z.ZodOptional<z.ZodNumber>;
+        objectMode: z.ZodOptional<z.ZodEnum<typeof import("./context-policy.shared.schemas.js").ContextPolicy_ObjectMode>>;
+        accessRightsMode: z.ZodOptional<z.ZodEnum<typeof import("./context-policy.shared.schemas.js").ContextPolicy_AccessRightsMode>>;
+        operationOverrides: z.ZodOptional<z.ZodRecord<z.ZodEnum<typeof CoreResourceOperation> & z.core.$partial, z.ZodObject<{
+            enabled: z.ZodOptional<z.ZodBoolean>;
+            depth: z.ZodOptional<z.ZodNumber>;
+            objectMode: z.ZodOptional<z.ZodEnum<typeof import("./context-policy.shared.schemas.js").ContextPolicy_ObjectMode>>;
+            accessRightsMode: z.ZodOptional<z.ZodEnum<typeof import("./context-policy.shared.schemas.js").ContextPolicy_AccessRightsMode>>;
+        }, z.core.$strip, core.$ZodObjectExtra>>>;
+    }, z.core.$strip, core.$ZodObjectExtra>>;
+    nature: z.ZodEnum<typeof RelationshipNature>;
+    read: z.ZodOptional<z.ZodObject<{
+        model: z.ZodEnum<typeof RelationshipReadModel>;
+    }, z.core.$strip, core.$ZodObjectExtra>>;
+    childOperations: z.ZodOptional<z.ZodObject<{
+        lifecycle: z.ZodOptional<z.ZodObject<{
+            onParentDelete: z.ZodOptional<z.ZodObject<{
+                enabled: z.ZodDefault<z.ZodBoolean>;
+                mode: z.ZodDefault<z.ZodEnum<typeof ChildLifecycleMode>>;
+                maxDepth: z.ZodDefault<z.ZodNumber>;
+            }, z.core.$strip, core.$ZodObjectExtra>>;
+        }, z.core.$strip, core.$ZodObjectExtra>>;
+        nested: z.ZodOptional<z.ZodObject<{
+            onRead: z.ZodOptional<z.ZodObject<{
+                dataMode: z.ZodEnum<typeof import("./resources-config.shared.schemas.js").DataMode>;
+                enabledOnList: z.ZodDefault<z.ZodBoolean>;
+                listDataMode: z.ZodDefault<z.ZodEnum<typeof import("./resources-config.shared.schemas.js").DataMode>>;
+                maxItems: z.ZodOptional<z.ZodNumber>;
+                sortBy: z.ZodOptional<z.ZodString>;
+                maxDepth: z.ZodDefault<z.ZodNumber>;
+            }, z.core.$strip, core.$ZodObjectExtra>>;
+            onUpdate: z.ZodOptional<z.ZodObject<{
+                allowCreate: z.ZodDefault<z.ZodBoolean>;
+                allowUpdate: z.ZodDefault<z.ZodBoolean>;
+                allowDelete: z.ZodDefault<z.ZodBoolean>;
+                maxDepth: z.ZodDefault<z.ZodNumber>;
+            }, z.core.$strip, core.$ZodObjectExtra>>;
+            onCreate: z.ZodOptional<z.ZodObject<{
+                allowCreate: z.ZodDefault<z.ZodBoolean>;
+                allowUpdate: z.ZodDefault<z.ZodBoolean>;
+                allowDelete: z.ZodDefault<z.ZodBoolean>;
+                maxDepth: z.ZodDefault<z.ZodNumber>;
+            }, z.core.$strip, core.$ZodObjectExtra>>;
+        }, z.core.$strip, core.$ZodObjectExtra>>;
+    }, z.core.$strip, core.$ZodObjectExtra>>;
+    discriminator: z.ZodOptional<z.ZodObject<{
+        discriminatorField: z.ZodString;
+        values: z.ZodArray<z.ZodString>;
+    }, z.core.$strip, core.$ZodObjectExtra>>;
+    display: z.ZodOptional<z.ZodObject<{
+        inParentView: z.ZodOptional<z.ZodObject<{
+            orderIndex: z.ZodOptional<z.ZodNumber>;
+            inlineLimit: z.ZodOptional<z.ZodNumber>;
+            showViewAllLink: z.ZodOptional<z.ZodBoolean>;
+            contentSectionConfig: z.ZodOptional<z.ZodUnion<readonly [z.ZodDiscriminatedUnion<[z.ZodObject<{
+                showSingleSectionNav: z.ZodOptional<z.ZodBoolean>;
+                hideWhenEmpty: z.ZodOptional<z.ZodBoolean>;
+                fallbackMode: z.ZodOptional<z.ZodEnum<{
+                    collapsible: import("@wildo-ai/zod-decorators").SectionMode.COLLAPSIBLE;
+                    inline: import("@wildo-ai/zod-decorators").SectionMode.INLINE;
+                    grid: import("@wildo-ai/zod-decorators").SectionMode.GRID;
+                    columns: import("@wildo-ai/zod-decorators").SectionMode.COLUMNS;
+                    tabs: import("@wildo-ai/zod-decorators").SectionMode.TABS;
+                    vertical_tabs: import("@wildo-ai/zod-decorators").SectionMode.VERTICAL_TABS;
+                    pills: import("@wildo-ai/zod-decorators").SectionMode.PILLS;
+                    accordion: import("@wildo-ai/zod-decorators").SectionMode.ACCORDION;
+                    expandable: import("@wildo-ai/zod-decorators").SectionMode.EXPANDABLE;
+                    stepper: import("@wildo-ai/zod-decorators").SectionMode.STEPPER;
+                    timeline: import("@wildo-ai/zod-decorators").SectionMode.TIMELINE;
+                }>>;
+                emptyStateMessage: z.ZodOptional<z.ZodString>;
+                ariaLabel: z.ZodOptional<z.ZodString>;
+                ariaLabelledBy: z.ZodOptional<z.ZodString>;
+                mode: z.ZodLiteral<import("@wildo-ai/zod-decorators").SectionMode.COLLAPSIBLE>;
+                triggerLabel: z.ZodOptional<z.ZodObject<{
+                    open: z.ZodString;
+                    closed: z.ZodString;
+                }, z.core.$strip, core.$ZodObjectExtra>>;
+            }, z.core.$strict, core.$ZodObjectExtra>, z.ZodObject<{
+                showSingleSectionNav: z.ZodOptional<z.ZodBoolean>;
+                hideWhenEmpty: z.ZodOptional<z.ZodBoolean>;
+                fallbackMode: z.ZodOptional<z.ZodEnum<{
+                    collapsible: import("@wildo-ai/zod-decorators").SectionMode.COLLAPSIBLE;
+                    inline: import("@wildo-ai/zod-decorators").SectionMode.INLINE;
+                    grid: import("@wildo-ai/zod-decorators").SectionMode.GRID;
+                    columns: import("@wildo-ai/zod-decorators").SectionMode.COLUMNS;
+                    tabs: import("@wildo-ai/zod-decorators").SectionMode.TABS;
+                    vertical_tabs: import("@wildo-ai/zod-decorators").SectionMode.VERTICAL_TABS;
+                    pills: import("@wildo-ai/zod-decorators").SectionMode.PILLS;
+                    accordion: import("@wildo-ai/zod-decorators").SectionMode.ACCORDION;
+                    expandable: import("@wildo-ai/zod-decorators").SectionMode.EXPANDABLE;
+                    stepper: import("@wildo-ai/zod-decorators").SectionMode.STEPPER;
+                    timeline: import("@wildo-ai/zod-decorators").SectionMode.TIMELINE;
+                }>>;
+                emptyStateMessage: z.ZodOptional<z.ZodString>;
+                ariaLabel: z.ZodOptional<z.ZodString>;
+                ariaLabelledBy: z.ZodOptional<z.ZodString>;
+                mode: z.ZodLiteral<import("@wildo-ai/zod-decorators").SectionMode.INLINE>;
+                gap: z.ZodOptional<z.ZodEnum<{
+                    sm: "sm";
+                    md: "md";
+                    lg: "lg";
+                }>>;
+            }, z.core.$strict, core.$ZodObjectExtra>, z.ZodObject<{
+                showSingleSectionNav: z.ZodOptional<z.ZodBoolean>;
+                hideWhenEmpty: z.ZodOptional<z.ZodBoolean>;
+                fallbackMode: z.ZodOptional<z.ZodEnum<{
+                    collapsible: import("@wildo-ai/zod-decorators").SectionMode.COLLAPSIBLE;
+                    inline: import("@wildo-ai/zod-decorators").SectionMode.INLINE;
+                    grid: import("@wildo-ai/zod-decorators").SectionMode.GRID;
+                    columns: import("@wildo-ai/zod-decorators").SectionMode.COLUMNS;
+                    tabs: import("@wildo-ai/zod-decorators").SectionMode.TABS;
+                    vertical_tabs: import("@wildo-ai/zod-decorators").SectionMode.VERTICAL_TABS;
+                    pills: import("@wildo-ai/zod-decorators").SectionMode.PILLS;
+                    accordion: import("@wildo-ai/zod-decorators").SectionMode.ACCORDION;
+                    expandable: import("@wildo-ai/zod-decorators").SectionMode.EXPANDABLE;
+                    stepper: import("@wildo-ai/zod-decorators").SectionMode.STEPPER;
+                    timeline: import("@wildo-ai/zod-decorators").SectionMode.TIMELINE;
+                }>>;
+                emptyStateMessage: z.ZodOptional<z.ZodString>;
+                ariaLabel: z.ZodOptional<z.ZodString>;
+                ariaLabelledBy: z.ZodOptional<z.ZodString>;
+                mode: z.ZodLiteral<import("@wildo-ai/zod-decorators").SectionMode.GRID>;
+                columnCount: z.ZodOptional<z.ZodUnion<readonly [z.ZodNumber, z.ZodLiteral<"auto">]>>;
+                gap: z.ZodOptional<z.ZodEnum<{
+                    sm: "sm";
+                    md: "md";
+                    lg: "lg";
+                }>>;
+                minColumnWidth: z.ZodOptional<z.ZodString>;
+            }, z.core.$strict, core.$ZodObjectExtra>, z.ZodObject<{
+                showSingleSectionNav: z.ZodOptional<z.ZodBoolean>;
+                hideWhenEmpty: z.ZodOptional<z.ZodBoolean>;
+                fallbackMode: z.ZodOptional<z.ZodEnum<{
+                    collapsible: import("@wildo-ai/zod-decorators").SectionMode.COLLAPSIBLE;
+                    inline: import("@wildo-ai/zod-decorators").SectionMode.INLINE;
+                    grid: import("@wildo-ai/zod-decorators").SectionMode.GRID;
+                    columns: import("@wildo-ai/zod-decorators").SectionMode.COLUMNS;
+                    tabs: import("@wildo-ai/zod-decorators").SectionMode.TABS;
+                    vertical_tabs: import("@wildo-ai/zod-decorators").SectionMode.VERTICAL_TABS;
+                    pills: import("@wildo-ai/zod-decorators").SectionMode.PILLS;
+                    accordion: import("@wildo-ai/zod-decorators").SectionMode.ACCORDION;
+                    expandable: import("@wildo-ai/zod-decorators").SectionMode.EXPANDABLE;
+                    stepper: import("@wildo-ai/zod-decorators").SectionMode.STEPPER;
+                    timeline: import("@wildo-ai/zod-decorators").SectionMode.TIMELINE;
+                }>>;
+                emptyStateMessage: z.ZodOptional<z.ZodString>;
+                ariaLabel: z.ZodOptional<z.ZodString>;
+                ariaLabelledBy: z.ZodOptional<z.ZodString>;
+                mode: z.ZodLiteral<import("@wildo-ai/zod-decorators").SectionMode.COLUMNS>;
+                columnCount: z.ZodOptional<z.ZodUnion<readonly [z.ZodNumber, z.ZodLiteral<"auto">]>>;
+                gap: z.ZodOptional<z.ZodEnum<{
+                    sm: "sm";
+                    md: "md";
+                    lg: "lg";
+                }>>;
+            }, z.core.$strict, core.$ZodObjectExtra>, z.ZodObject<{
+                showSingleSectionNav: z.ZodOptional<z.ZodBoolean>;
+                hideWhenEmpty: z.ZodOptional<z.ZodBoolean>;
+                fallbackMode: z.ZodOptional<z.ZodEnum<{
+                    collapsible: import("@wildo-ai/zod-decorators").SectionMode.COLLAPSIBLE;
+                    inline: import("@wildo-ai/zod-decorators").SectionMode.INLINE;
+                    grid: import("@wildo-ai/zod-decorators").SectionMode.GRID;
+                    columns: import("@wildo-ai/zod-decorators").SectionMode.COLUMNS;
+                    tabs: import("@wildo-ai/zod-decorators").SectionMode.TABS;
+                    vertical_tabs: import("@wildo-ai/zod-decorators").SectionMode.VERTICAL_TABS;
+                    pills: import("@wildo-ai/zod-decorators").SectionMode.PILLS;
+                    accordion: import("@wildo-ai/zod-decorators").SectionMode.ACCORDION;
+                    expandable: import("@wildo-ai/zod-decorators").SectionMode.EXPANDABLE;
+                    stepper: import("@wildo-ai/zod-decorators").SectionMode.STEPPER;
+                    timeline: import("@wildo-ai/zod-decorators").SectionMode.TIMELINE;
+                }>>;
+                emptyStateMessage: z.ZodOptional<z.ZodString>;
+                ariaLabel: z.ZodOptional<z.ZodString>;
+                ariaLabelledBy: z.ZodOptional<z.ZodString>;
+                mode: z.ZodLiteral<import("@wildo-ai/zod-decorators").SectionMode.TABS>;
+                allowNone: z.ZodOptional<z.ZodBoolean>;
+            }, z.core.$strict, core.$ZodObjectExtra>, z.ZodObject<{
+                showSingleSectionNav: z.ZodOptional<z.ZodBoolean>;
+                hideWhenEmpty: z.ZodOptional<z.ZodBoolean>;
+                fallbackMode: z.ZodOptional<z.ZodEnum<{
+                    collapsible: import("@wildo-ai/zod-decorators").SectionMode.COLLAPSIBLE;
+                    inline: import("@wildo-ai/zod-decorators").SectionMode.INLINE;
+                    grid: import("@wildo-ai/zod-decorators").SectionMode.GRID;
+                    columns: import("@wildo-ai/zod-decorators").SectionMode.COLUMNS;
+                    tabs: import("@wildo-ai/zod-decorators").SectionMode.TABS;
+                    vertical_tabs: import("@wildo-ai/zod-decorators").SectionMode.VERTICAL_TABS;
+                    pills: import("@wildo-ai/zod-decorators").SectionMode.PILLS;
+                    accordion: import("@wildo-ai/zod-decorators").SectionMode.ACCORDION;
+                    expandable: import("@wildo-ai/zod-decorators").SectionMode.EXPANDABLE;
+                    stepper: import("@wildo-ai/zod-decorators").SectionMode.STEPPER;
+                    timeline: import("@wildo-ai/zod-decorators").SectionMode.TIMELINE;
+                }>>;
+                emptyStateMessage: z.ZodOptional<z.ZodString>;
+                ariaLabel: z.ZodOptional<z.ZodString>;
+                ariaLabelledBy: z.ZodOptional<z.ZodString>;
+                mode: z.ZodLiteral<import("@wildo-ai/zod-decorators").SectionMode.VERTICAL_TABS>;
+                allowNone: z.ZodOptional<z.ZodBoolean>;
+                navWidth: z.ZodOptional<z.ZodString>;
+            }, z.core.$strict, core.$ZodObjectExtra>, z.ZodObject<{
+                showSingleSectionNav: z.ZodOptional<z.ZodBoolean>;
+                hideWhenEmpty: z.ZodOptional<z.ZodBoolean>;
+                fallbackMode: z.ZodOptional<z.ZodEnum<{
+                    collapsible: import("@wildo-ai/zod-decorators").SectionMode.COLLAPSIBLE;
+                    inline: import("@wildo-ai/zod-decorators").SectionMode.INLINE;
+                    grid: import("@wildo-ai/zod-decorators").SectionMode.GRID;
+                    columns: import("@wildo-ai/zod-decorators").SectionMode.COLUMNS;
+                    tabs: import("@wildo-ai/zod-decorators").SectionMode.TABS;
+                    vertical_tabs: import("@wildo-ai/zod-decorators").SectionMode.VERTICAL_TABS;
+                    pills: import("@wildo-ai/zod-decorators").SectionMode.PILLS;
+                    accordion: import("@wildo-ai/zod-decorators").SectionMode.ACCORDION;
+                    expandable: import("@wildo-ai/zod-decorators").SectionMode.EXPANDABLE;
+                    stepper: import("@wildo-ai/zod-decorators").SectionMode.STEPPER;
+                    timeline: import("@wildo-ai/zod-decorators").SectionMode.TIMELINE;
+                }>>;
+                emptyStateMessage: z.ZodOptional<z.ZodString>;
+                ariaLabel: z.ZodOptional<z.ZodString>;
+                ariaLabelledBy: z.ZodOptional<z.ZodString>;
+                mode: z.ZodLiteral<import("@wildo-ai/zod-decorators").SectionMode.PILLS>;
+                allowNone: z.ZodOptional<z.ZodBoolean>;
+            }, z.core.$strict, core.$ZodObjectExtra>, z.ZodObject<{
+                showSingleSectionNav: z.ZodOptional<z.ZodBoolean>;
+                hideWhenEmpty: z.ZodOptional<z.ZodBoolean>;
+                fallbackMode: z.ZodOptional<z.ZodEnum<{
+                    collapsible: import("@wildo-ai/zod-decorators").SectionMode.COLLAPSIBLE;
+                    inline: import("@wildo-ai/zod-decorators").SectionMode.INLINE;
+                    grid: import("@wildo-ai/zod-decorators").SectionMode.GRID;
+                    columns: import("@wildo-ai/zod-decorators").SectionMode.COLUMNS;
+                    tabs: import("@wildo-ai/zod-decorators").SectionMode.TABS;
+                    vertical_tabs: import("@wildo-ai/zod-decorators").SectionMode.VERTICAL_TABS;
+                    pills: import("@wildo-ai/zod-decorators").SectionMode.PILLS;
+                    accordion: import("@wildo-ai/zod-decorators").SectionMode.ACCORDION;
+                    expandable: import("@wildo-ai/zod-decorators").SectionMode.EXPANDABLE;
+                    stepper: import("@wildo-ai/zod-decorators").SectionMode.STEPPER;
+                    timeline: import("@wildo-ai/zod-decorators").SectionMode.TIMELINE;
+                }>>;
+                emptyStateMessage: z.ZodOptional<z.ZodString>;
+                ariaLabel: z.ZodOptional<z.ZodString>;
+                ariaLabelledBy: z.ZodOptional<z.ZodString>;
+                mode: z.ZodLiteral<import("@wildo-ai/zod-decorators").SectionMode.ACCORDION>;
+                allowMultiple: z.ZodOptional<z.ZodBoolean>;
+            }, z.core.$strict, core.$ZodObjectExtra>, z.ZodObject<{
+                showSingleSectionNav: z.ZodOptional<z.ZodBoolean>;
+                hideWhenEmpty: z.ZodOptional<z.ZodBoolean>;
+                fallbackMode: z.ZodOptional<z.ZodEnum<{
+                    collapsible: import("@wildo-ai/zod-decorators").SectionMode.COLLAPSIBLE;
+                    inline: import("@wildo-ai/zod-decorators").SectionMode.INLINE;
+                    grid: import("@wildo-ai/zod-decorators").SectionMode.GRID;
+                    columns: import("@wildo-ai/zod-decorators").SectionMode.COLUMNS;
+                    tabs: import("@wildo-ai/zod-decorators").SectionMode.TABS;
+                    vertical_tabs: import("@wildo-ai/zod-decorators").SectionMode.VERTICAL_TABS;
+                    pills: import("@wildo-ai/zod-decorators").SectionMode.PILLS;
+                    accordion: import("@wildo-ai/zod-decorators").SectionMode.ACCORDION;
+                    expandable: import("@wildo-ai/zod-decorators").SectionMode.EXPANDABLE;
+                    stepper: import("@wildo-ai/zod-decorators").SectionMode.STEPPER;
+                    timeline: import("@wildo-ai/zod-decorators").SectionMode.TIMELINE;
+                }>>;
+                emptyStateMessage: z.ZodOptional<z.ZodString>;
+                ariaLabel: z.ZodOptional<z.ZodString>;
+                ariaLabelledBy: z.ZodOptional<z.ZodString>;
+                mode: z.ZodLiteral<import("@wildo-ai/zod-decorators").SectionMode.EXPANDABLE>;
+                initialVisibleCount: z.ZodOptional<z.ZodNumber>;
+                showMoreLabel: z.ZodOptional<z.ZodString>;
+                showLessLabel: z.ZodOptional<z.ZodString>;
+            }, z.core.$strict, core.$ZodObjectExtra>, z.ZodObject<{
+                showSingleSectionNav: z.ZodOptional<z.ZodBoolean>;
+                hideWhenEmpty: z.ZodOptional<z.ZodBoolean>;
+                fallbackMode: z.ZodOptional<z.ZodEnum<{
+                    collapsible: import("@wildo-ai/zod-decorators").SectionMode.COLLAPSIBLE;
+                    inline: import("@wildo-ai/zod-decorators").SectionMode.INLINE;
+                    grid: import("@wildo-ai/zod-decorators").SectionMode.GRID;
+                    columns: import("@wildo-ai/zod-decorators").SectionMode.COLUMNS;
+                    tabs: import("@wildo-ai/zod-decorators").SectionMode.TABS;
+                    vertical_tabs: import("@wildo-ai/zod-decorators").SectionMode.VERTICAL_TABS;
+                    pills: import("@wildo-ai/zod-decorators").SectionMode.PILLS;
+                    accordion: import("@wildo-ai/zod-decorators").SectionMode.ACCORDION;
+                    expandable: import("@wildo-ai/zod-decorators").SectionMode.EXPANDABLE;
+                    stepper: import("@wildo-ai/zod-decorators").SectionMode.STEPPER;
+                    timeline: import("@wildo-ai/zod-decorators").SectionMode.TIMELINE;
+                }>>;
+                emptyStateMessage: z.ZodOptional<z.ZodString>;
+                ariaLabel: z.ZodOptional<z.ZodString>;
+                ariaLabelledBy: z.ZodOptional<z.ZodString>;
+                mode: z.ZodLiteral<import("@wildo-ai/zod-decorators").SectionMode.STEPPER>;
+                allowSkip: z.ZodOptional<z.ZodBoolean>;
+                showProgress: z.ZodOptional<z.ZodBoolean>;
+                orientation: z.ZodOptional<z.ZodEnum<typeof import("@wildo-ai/zod-decorators").DisplayDirection>>;
+                nextLabel: z.ZodOptional<z.ZodString>;
+                previousLabel: z.ZodOptional<z.ZodString>;
+                completeLabel: z.ZodOptional<z.ZodString>;
+            }, z.core.$strict, core.$ZodObjectExtra>, z.ZodObject<{
+                showSingleSectionNav: z.ZodOptional<z.ZodBoolean>;
+                hideWhenEmpty: z.ZodOptional<z.ZodBoolean>;
+                fallbackMode: z.ZodOptional<z.ZodEnum<{
+                    collapsible: import("@wildo-ai/zod-decorators").SectionMode.COLLAPSIBLE;
+                    inline: import("@wildo-ai/zod-decorators").SectionMode.INLINE;
+                    grid: import("@wildo-ai/zod-decorators").SectionMode.GRID;
+                    columns: import("@wildo-ai/zod-decorators").SectionMode.COLUMNS;
+                    tabs: import("@wildo-ai/zod-decorators").SectionMode.TABS;
+                    vertical_tabs: import("@wildo-ai/zod-decorators").SectionMode.VERTICAL_TABS;
+                    pills: import("@wildo-ai/zod-decorators").SectionMode.PILLS;
+                    accordion: import("@wildo-ai/zod-decorators").SectionMode.ACCORDION;
+                    expandable: import("@wildo-ai/zod-decorators").SectionMode.EXPANDABLE;
+                    stepper: import("@wildo-ai/zod-decorators").SectionMode.STEPPER;
+                    timeline: import("@wildo-ai/zod-decorators").SectionMode.TIMELINE;
+                }>>;
+                emptyStateMessage: z.ZodOptional<z.ZodString>;
+                ariaLabel: z.ZodOptional<z.ZodString>;
+                ariaLabelledBy: z.ZodOptional<z.ZodString>;
+                mode: z.ZodLiteral<import("@wildo-ai/zod-decorators").SectionMode.TIMELINE>;
+            }, z.core.$strict, core.$ZodObjectExtra>], "mode">, z.ZodRecord<z.ZodEnum<typeof import("@wildo-ai/zod-decorators").ViewportBreakpoint> & z.core.$partial, z.ZodDiscriminatedUnion<[z.ZodObject<{
+                showSingleSectionNav: z.ZodOptional<z.ZodBoolean>;
+                hideWhenEmpty: z.ZodOptional<z.ZodBoolean>;
+                fallbackMode: z.ZodOptional<z.ZodEnum<{
+                    collapsible: import("@wildo-ai/zod-decorators").SectionMode.COLLAPSIBLE;
+                    inline: import("@wildo-ai/zod-decorators").SectionMode.INLINE;
+                    grid: import("@wildo-ai/zod-decorators").SectionMode.GRID;
+                    columns: import("@wildo-ai/zod-decorators").SectionMode.COLUMNS;
+                    tabs: import("@wildo-ai/zod-decorators").SectionMode.TABS;
+                    vertical_tabs: import("@wildo-ai/zod-decorators").SectionMode.VERTICAL_TABS;
+                    pills: import("@wildo-ai/zod-decorators").SectionMode.PILLS;
+                    accordion: import("@wildo-ai/zod-decorators").SectionMode.ACCORDION;
+                    expandable: import("@wildo-ai/zod-decorators").SectionMode.EXPANDABLE;
+                    stepper: import("@wildo-ai/zod-decorators").SectionMode.STEPPER;
+                    timeline: import("@wildo-ai/zod-decorators").SectionMode.TIMELINE;
+                }>>;
+                emptyStateMessage: z.ZodOptional<z.ZodString>;
+                ariaLabel: z.ZodOptional<z.ZodString>;
+                ariaLabelledBy: z.ZodOptional<z.ZodString>;
+                mode: z.ZodLiteral<import("@wildo-ai/zod-decorators").SectionMode.COLLAPSIBLE>;
+                triggerLabel: z.ZodOptional<z.ZodObject<{
+                    open: z.ZodString;
+                    closed: z.ZodString;
+                }, z.core.$strip, core.$ZodObjectExtra>>;
+            }, z.core.$strict, core.$ZodObjectExtra>, z.ZodObject<{
+                showSingleSectionNav: z.ZodOptional<z.ZodBoolean>;
+                hideWhenEmpty: z.ZodOptional<z.ZodBoolean>;
+                fallbackMode: z.ZodOptional<z.ZodEnum<{
+                    collapsible: import("@wildo-ai/zod-decorators").SectionMode.COLLAPSIBLE;
+                    inline: import("@wildo-ai/zod-decorators").SectionMode.INLINE;
+                    grid: import("@wildo-ai/zod-decorators").SectionMode.GRID;
+                    columns: import("@wildo-ai/zod-decorators").SectionMode.COLUMNS;
+                    tabs: import("@wildo-ai/zod-decorators").SectionMode.TABS;
+                    vertical_tabs: import("@wildo-ai/zod-decorators").SectionMode.VERTICAL_TABS;
+                    pills: import("@wildo-ai/zod-decorators").SectionMode.PILLS;
+                    accordion: import("@wildo-ai/zod-decorators").SectionMode.ACCORDION;
+                    expandable: import("@wildo-ai/zod-decorators").SectionMode.EXPANDABLE;
+                    stepper: import("@wildo-ai/zod-decorators").SectionMode.STEPPER;
+                    timeline: import("@wildo-ai/zod-decorators").SectionMode.TIMELINE;
+                }>>;
+                emptyStateMessage: z.ZodOptional<z.ZodString>;
+                ariaLabel: z.ZodOptional<z.ZodString>;
+                ariaLabelledBy: z.ZodOptional<z.ZodString>;
+                mode: z.ZodLiteral<import("@wildo-ai/zod-decorators").SectionMode.INLINE>;
+                gap: z.ZodOptional<z.ZodEnum<{
+                    sm: "sm";
+                    md: "md";
+                    lg: "lg";
+                }>>;
+            }, z.core.$strict, core.$ZodObjectExtra>, z.ZodObject<{
+                showSingleSectionNav: z.ZodOptional<z.ZodBoolean>;
+                hideWhenEmpty: z.ZodOptional<z.ZodBoolean>;
+                fallbackMode: z.ZodOptional<z.ZodEnum<{
+                    collapsible: import("@wildo-ai/zod-decorators").SectionMode.COLLAPSIBLE;
+                    inline: import("@wildo-ai/zod-decorators").SectionMode.INLINE;
+                    grid: import("@wildo-ai/zod-decorators").SectionMode.GRID;
+                    columns: import("@wildo-ai/zod-decorators").SectionMode.COLUMNS;
+                    tabs: import("@wildo-ai/zod-decorators").SectionMode.TABS;
+                    vertical_tabs: import("@wildo-ai/zod-decorators").SectionMode.VERTICAL_TABS;
+                    pills: import("@wildo-ai/zod-decorators").SectionMode.PILLS;
+                    accordion: import("@wildo-ai/zod-decorators").SectionMode.ACCORDION;
+                    expandable: import("@wildo-ai/zod-decorators").SectionMode.EXPANDABLE;
+                    stepper: import("@wildo-ai/zod-decorators").SectionMode.STEPPER;
+                    timeline: import("@wildo-ai/zod-decorators").SectionMode.TIMELINE;
+                }>>;
+                emptyStateMessage: z.ZodOptional<z.ZodString>;
+                ariaLabel: z.ZodOptional<z.ZodString>;
+                ariaLabelledBy: z.ZodOptional<z.ZodString>;
+                mode: z.ZodLiteral<import("@wildo-ai/zod-decorators").SectionMode.GRID>;
+                columnCount: z.ZodOptional<z.ZodUnion<readonly [z.ZodNumber, z.ZodLiteral<"auto">]>>;
+                gap: z.ZodOptional<z.ZodEnum<{
+                    sm: "sm";
+                    md: "md";
+                    lg: "lg";
+                }>>;
+                minColumnWidth: z.ZodOptional<z.ZodString>;
+            }, z.core.$strict, core.$ZodObjectExtra>, z.ZodObject<{
+                showSingleSectionNav: z.ZodOptional<z.ZodBoolean>;
+                hideWhenEmpty: z.ZodOptional<z.ZodBoolean>;
+                fallbackMode: z.ZodOptional<z.ZodEnum<{
+                    collapsible: import("@wildo-ai/zod-decorators").SectionMode.COLLAPSIBLE;
+                    inline: import("@wildo-ai/zod-decorators").SectionMode.INLINE;
+                    grid: import("@wildo-ai/zod-decorators").SectionMode.GRID;
+                    columns: import("@wildo-ai/zod-decorators").SectionMode.COLUMNS;
+                    tabs: import("@wildo-ai/zod-decorators").SectionMode.TABS;
+                    vertical_tabs: import("@wildo-ai/zod-decorators").SectionMode.VERTICAL_TABS;
+                    pills: import("@wildo-ai/zod-decorators").SectionMode.PILLS;
+                    accordion: import("@wildo-ai/zod-decorators").SectionMode.ACCORDION;
+                    expandable: import("@wildo-ai/zod-decorators").SectionMode.EXPANDABLE;
+                    stepper: import("@wildo-ai/zod-decorators").SectionMode.STEPPER;
+                    timeline: import("@wildo-ai/zod-decorators").SectionMode.TIMELINE;
+                }>>;
+                emptyStateMessage: z.ZodOptional<z.ZodString>;
+                ariaLabel: z.ZodOptional<z.ZodString>;
+                ariaLabelledBy: z.ZodOptional<z.ZodString>;
+                mode: z.ZodLiteral<import("@wildo-ai/zod-decorators").SectionMode.COLUMNS>;
+                columnCount: z.ZodOptional<z.ZodUnion<readonly [z.ZodNumber, z.ZodLiteral<"auto">]>>;
+                gap: z.ZodOptional<z.ZodEnum<{
+                    sm: "sm";
+                    md: "md";
+                    lg: "lg";
+                }>>;
+            }, z.core.$strict, core.$ZodObjectExtra>, z.ZodObject<{
+                showSingleSectionNav: z.ZodOptional<z.ZodBoolean>;
+                hideWhenEmpty: z.ZodOptional<z.ZodBoolean>;
+                fallbackMode: z.ZodOptional<z.ZodEnum<{
+                    collapsible: import("@wildo-ai/zod-decorators").SectionMode.COLLAPSIBLE;
+                    inline: import("@wildo-ai/zod-decorators").SectionMode.INLINE;
+                    grid: import("@wildo-ai/zod-decorators").SectionMode.GRID;
+                    columns: import("@wildo-ai/zod-decorators").SectionMode.COLUMNS;
+                    tabs: import("@wildo-ai/zod-decorators").SectionMode.TABS;
+                    vertical_tabs: import("@wildo-ai/zod-decorators").SectionMode.VERTICAL_TABS;
+                    pills: import("@wildo-ai/zod-decorators").SectionMode.PILLS;
+                    accordion: import("@wildo-ai/zod-decorators").SectionMode.ACCORDION;
+                    expandable: import("@wildo-ai/zod-decorators").SectionMode.EXPANDABLE;
+                    stepper: import("@wildo-ai/zod-decorators").SectionMode.STEPPER;
+                    timeline: import("@wildo-ai/zod-decorators").SectionMode.TIMELINE;
+                }>>;
+                emptyStateMessage: z.ZodOptional<z.ZodString>;
+                ariaLabel: z.ZodOptional<z.ZodString>;
+                ariaLabelledBy: z.ZodOptional<z.ZodString>;
+                mode: z.ZodLiteral<import("@wildo-ai/zod-decorators").SectionMode.TABS>;
+                allowNone: z.ZodOptional<z.ZodBoolean>;
+            }, z.core.$strict, core.$ZodObjectExtra>, z.ZodObject<{
+                showSingleSectionNav: z.ZodOptional<z.ZodBoolean>;
+                hideWhenEmpty: z.ZodOptional<z.ZodBoolean>;
+                fallbackMode: z.ZodOptional<z.ZodEnum<{
+                    collapsible: import("@wildo-ai/zod-decorators").SectionMode.COLLAPSIBLE;
+                    inline: import("@wildo-ai/zod-decorators").SectionMode.INLINE;
+                    grid: import("@wildo-ai/zod-decorators").SectionMode.GRID;
+                    columns: import("@wildo-ai/zod-decorators").SectionMode.COLUMNS;
+                    tabs: import("@wildo-ai/zod-decorators").SectionMode.TABS;
+                    vertical_tabs: import("@wildo-ai/zod-decorators").SectionMode.VERTICAL_TABS;
+                    pills: import("@wildo-ai/zod-decorators").SectionMode.PILLS;
+                    accordion: import("@wildo-ai/zod-decorators").SectionMode.ACCORDION;
+                    expandable: import("@wildo-ai/zod-decorators").SectionMode.EXPANDABLE;
+                    stepper: import("@wildo-ai/zod-decorators").SectionMode.STEPPER;
+                    timeline: import("@wildo-ai/zod-decorators").SectionMode.TIMELINE;
+                }>>;
+                emptyStateMessage: z.ZodOptional<z.ZodString>;
+                ariaLabel: z.ZodOptional<z.ZodString>;
+                ariaLabelledBy: z.ZodOptional<z.ZodString>;
+                mode: z.ZodLiteral<import("@wildo-ai/zod-decorators").SectionMode.VERTICAL_TABS>;
+                allowNone: z.ZodOptional<z.ZodBoolean>;
+                navWidth: z.ZodOptional<z.ZodString>;
+            }, z.core.$strict, core.$ZodObjectExtra>, z.ZodObject<{
+                showSingleSectionNav: z.ZodOptional<z.ZodBoolean>;
+                hideWhenEmpty: z.ZodOptional<z.ZodBoolean>;
+                fallbackMode: z.ZodOptional<z.ZodEnum<{
+                    collapsible: import("@wildo-ai/zod-decorators").SectionMode.COLLAPSIBLE;
+                    inline: import("@wildo-ai/zod-decorators").SectionMode.INLINE;
+                    grid: import("@wildo-ai/zod-decorators").SectionMode.GRID;
+                    columns: import("@wildo-ai/zod-decorators").SectionMode.COLUMNS;
+                    tabs: import("@wildo-ai/zod-decorators").SectionMode.TABS;
+                    vertical_tabs: import("@wildo-ai/zod-decorators").SectionMode.VERTICAL_TABS;
+                    pills: import("@wildo-ai/zod-decorators").SectionMode.PILLS;
+                    accordion: import("@wildo-ai/zod-decorators").SectionMode.ACCORDION;
+                    expandable: import("@wildo-ai/zod-decorators").SectionMode.EXPANDABLE;
+                    stepper: import("@wildo-ai/zod-decorators").SectionMode.STEPPER;
+                    timeline: import("@wildo-ai/zod-decorators").SectionMode.TIMELINE;
+                }>>;
+                emptyStateMessage: z.ZodOptional<z.ZodString>;
+                ariaLabel: z.ZodOptional<z.ZodString>;
+                ariaLabelledBy: z.ZodOptional<z.ZodString>;
+                mode: z.ZodLiteral<import("@wildo-ai/zod-decorators").SectionMode.PILLS>;
+                allowNone: z.ZodOptional<z.ZodBoolean>;
+            }, z.core.$strict, core.$ZodObjectExtra>, z.ZodObject<{
+                showSingleSectionNav: z.ZodOptional<z.ZodBoolean>;
+                hideWhenEmpty: z.ZodOptional<z.ZodBoolean>;
+                fallbackMode: z.ZodOptional<z.ZodEnum<{
+                    collapsible: import("@wildo-ai/zod-decorators").SectionMode.COLLAPSIBLE;
+                    inline: import("@wildo-ai/zod-decorators").SectionMode.INLINE;
+                    grid: import("@wildo-ai/zod-decorators").SectionMode.GRID;
+                    columns: import("@wildo-ai/zod-decorators").SectionMode.COLUMNS;
+                    tabs: import("@wildo-ai/zod-decorators").SectionMode.TABS;
+                    vertical_tabs: import("@wildo-ai/zod-decorators").SectionMode.VERTICAL_TABS;
+                    pills: import("@wildo-ai/zod-decorators").SectionMode.PILLS;
+                    accordion: import("@wildo-ai/zod-decorators").SectionMode.ACCORDION;
+                    expandable: import("@wildo-ai/zod-decorators").SectionMode.EXPANDABLE;
+                    stepper: import("@wildo-ai/zod-decorators").SectionMode.STEPPER;
+                    timeline: import("@wildo-ai/zod-decorators").SectionMode.TIMELINE;
+                }>>;
+                emptyStateMessage: z.ZodOptional<z.ZodString>;
+                ariaLabel: z.ZodOptional<z.ZodString>;
+                ariaLabelledBy: z.ZodOptional<z.ZodString>;
+                mode: z.ZodLiteral<import("@wildo-ai/zod-decorators").SectionMode.ACCORDION>;
+                allowMultiple: z.ZodOptional<z.ZodBoolean>;
+            }, z.core.$strict, core.$ZodObjectExtra>, z.ZodObject<{
+                showSingleSectionNav: z.ZodOptional<z.ZodBoolean>;
+                hideWhenEmpty: z.ZodOptional<z.ZodBoolean>;
+                fallbackMode: z.ZodOptional<z.ZodEnum<{
+                    collapsible: import("@wildo-ai/zod-decorators").SectionMode.COLLAPSIBLE;
+                    inline: import("@wildo-ai/zod-decorators").SectionMode.INLINE;
+                    grid: import("@wildo-ai/zod-decorators").SectionMode.GRID;
+                    columns: import("@wildo-ai/zod-decorators").SectionMode.COLUMNS;
+                    tabs: import("@wildo-ai/zod-decorators").SectionMode.TABS;
+                    vertical_tabs: import("@wildo-ai/zod-decorators").SectionMode.VERTICAL_TABS;
+                    pills: import("@wildo-ai/zod-decorators").SectionMode.PILLS;
+                    accordion: import("@wildo-ai/zod-decorators").SectionMode.ACCORDION;
+                    expandable: import("@wildo-ai/zod-decorators").SectionMode.EXPANDABLE;
+                    stepper: import("@wildo-ai/zod-decorators").SectionMode.STEPPER;
+                    timeline: import("@wildo-ai/zod-decorators").SectionMode.TIMELINE;
+                }>>;
+                emptyStateMessage: z.ZodOptional<z.ZodString>;
+                ariaLabel: z.ZodOptional<z.ZodString>;
+                ariaLabelledBy: z.ZodOptional<z.ZodString>;
+                mode: z.ZodLiteral<import("@wildo-ai/zod-decorators").SectionMode.EXPANDABLE>;
+                initialVisibleCount: z.ZodOptional<z.ZodNumber>;
+                showMoreLabel: z.ZodOptional<z.ZodString>;
+                showLessLabel: z.ZodOptional<z.ZodString>;
+            }, z.core.$strict, core.$ZodObjectExtra>, z.ZodObject<{
+                showSingleSectionNav: z.ZodOptional<z.ZodBoolean>;
+                hideWhenEmpty: z.ZodOptional<z.ZodBoolean>;
+                fallbackMode: z.ZodOptional<z.ZodEnum<{
+                    collapsible: import("@wildo-ai/zod-decorators").SectionMode.COLLAPSIBLE;
+                    inline: import("@wildo-ai/zod-decorators").SectionMode.INLINE;
+                    grid: import("@wildo-ai/zod-decorators").SectionMode.GRID;
+                    columns: import("@wildo-ai/zod-decorators").SectionMode.COLUMNS;
+                    tabs: import("@wildo-ai/zod-decorators").SectionMode.TABS;
+                    vertical_tabs: import("@wildo-ai/zod-decorators").SectionMode.VERTICAL_TABS;
+                    pills: import("@wildo-ai/zod-decorators").SectionMode.PILLS;
+                    accordion: import("@wildo-ai/zod-decorators").SectionMode.ACCORDION;
+                    expandable: import("@wildo-ai/zod-decorators").SectionMode.EXPANDABLE;
+                    stepper: import("@wildo-ai/zod-decorators").SectionMode.STEPPER;
+                    timeline: import("@wildo-ai/zod-decorators").SectionMode.TIMELINE;
+                }>>;
+                emptyStateMessage: z.ZodOptional<z.ZodString>;
+                ariaLabel: z.ZodOptional<z.ZodString>;
+                ariaLabelledBy: z.ZodOptional<z.ZodString>;
+                mode: z.ZodLiteral<import("@wildo-ai/zod-decorators").SectionMode.STEPPER>;
+                allowSkip: z.ZodOptional<z.ZodBoolean>;
+                showProgress: z.ZodOptional<z.ZodBoolean>;
+                orientation: z.ZodOptional<z.ZodEnum<typeof import("@wildo-ai/zod-decorators").DisplayDirection>>;
+                nextLabel: z.ZodOptional<z.ZodString>;
+                previousLabel: z.ZodOptional<z.ZodString>;
+                completeLabel: z.ZodOptional<z.ZodString>;
+            }, z.core.$strict, core.$ZodObjectExtra>, z.ZodObject<{
+                showSingleSectionNav: z.ZodOptional<z.ZodBoolean>;
+                hideWhenEmpty: z.ZodOptional<z.ZodBoolean>;
+                fallbackMode: z.ZodOptional<z.ZodEnum<{
+                    collapsible: import("@wildo-ai/zod-decorators").SectionMode.COLLAPSIBLE;
+                    inline: import("@wildo-ai/zod-decorators").SectionMode.INLINE;
+                    grid: import("@wildo-ai/zod-decorators").SectionMode.GRID;
+                    columns: import("@wildo-ai/zod-decorators").SectionMode.COLUMNS;
+                    tabs: import("@wildo-ai/zod-decorators").SectionMode.TABS;
+                    vertical_tabs: import("@wildo-ai/zod-decorators").SectionMode.VERTICAL_TABS;
+                    pills: import("@wildo-ai/zod-decorators").SectionMode.PILLS;
+                    accordion: import("@wildo-ai/zod-decorators").SectionMode.ACCORDION;
+                    expandable: import("@wildo-ai/zod-decorators").SectionMode.EXPANDABLE;
+                    stepper: import("@wildo-ai/zod-decorators").SectionMode.STEPPER;
+                    timeline: import("@wildo-ai/zod-decorators").SectionMode.TIMELINE;
+                }>>;
+                emptyStateMessage: z.ZodOptional<z.ZodString>;
+                ariaLabel: z.ZodOptional<z.ZodString>;
+                ariaLabelledBy: z.ZodOptional<z.ZodString>;
+                mode: z.ZodLiteral<import("@wildo-ai/zod-decorators").SectionMode.TIMELINE>;
+            }, z.core.$strict, core.$ZodObjectExtra>], "mode">>]>>;
+            hidden: z.ZodOptional<z.ZodBoolean>;
+        }, z.core.$strict, core.$ZodObjectExtra>>;
+        inParentNavigation: z.ZodOptional<z.ZodObject<{
+            transition: z.ZodOptional<z.ZodUnion<readonly [z.ZodUnion<readonly [z.ZodEnum<typeof import("../index.js").NavigationTransition>, z.ZodObject<{
+                transition: z.ZodEnum<typeof import("../index.js").NavigationTransition>;
+                persistent: z.ZodOptional<z.ZodBoolean>;
+                ephemeral: z.ZodOptional<z.ZodBoolean>;
+            }, z.core.$strip, core.$ZodObjectExtra>]>, z.ZodRecord<z.ZodEnum<typeof import("@wildo-ai/zod-decorators").ViewportBreakpoint> & z.core.$partial, z.ZodUnion<readonly [z.ZodEnum<typeof import("../index.js").NavigationTransition>, z.ZodObject<{
+                transition: z.ZodEnum<typeof import("../index.js").NavigationTransition>;
+                persistent: z.ZodOptional<z.ZodBoolean>;
+                ephemeral: z.ZodOptional<z.ZodBoolean>;
+            }, z.core.$strip, core.$ZodObjectExtra>]>>]>>;
+            maxDepth: z.ZodOptional<z.ZodNumber>;
+            direction: z.ZodOptional<z.ZodEnum<typeof import("./resources.shared.core.definitions.js").CascadeDirection>>;
+            ancestorOperation: z.ZodOptional<z.ZodEnum<typeof CoreResourceOperation>>;
+        }, z.core.$strict, core.$ZodObjectExtra>>;
+        inChildView: z.ZodOptional<z.ZodObject<{
+            showParentLink: z.ZodOptional<z.ZodBoolean>;
+            parentDisplay: z.ZodOptional<z.ZodEnum<typeof import("./relationship-display.shared.schemas.js").ParentDisplay>>;
+        }, z.core.$strict, core.$ZodObjectExtra>>;
+        interaction: z.ZodOptional<z.ZodObject<{
+            allowQuickCreate: z.ZodOptional<z.ZodBoolean>;
+        }, z.core.$strict, core.$ZodObjectExtra>>;
+    }, z.core.$strict, core.$ZodObjectExtra>>;
+    foreignKeyField: z.ZodOptional<z.ZodString>;
+}, z.core.$strip, core.$ZodObjectExtra>;
+/**
+ * Function-based condition for conditional relationships.
+ * Evaluated at runtime with the PARENT resource data.
+ * Return `true` to include the relationship, `false` to exclude it.
+ *
+ * Unlike the static `discriminator` (which is a simple field+values match),
+ * this allows arbitrary logic: cross-field checks, computed conditions, etc.
+ *
+ * When both `discriminator` and `condition` are present on a relationship,
+ * they are combined with AND semantics — the relationship is active only when
+ * both pass.
+ *
+ * Error handling is selected by the runtime caller through
+ * `Resources_SharedUtils.isRelationshipActiveForParent()`:
+ * - Backend callers propagate condition errors normally.
+ * - Frontend callers may fail safe and exclude the relationship.
+ *
+ * @param parentResource - The parent resource's data object.
+ * @returns `true` to include the relationship, `false` to exclude it.
+ */
+export type ResourceRelationshipConditionFn = (parentResource: Record<string, any>) => boolean;
+export type ResolvedRelationshipNatureCalculationMode = 'explicit';
+export type ResolvedRelationshipReadCalculationMode = 'explicit' | 'legacy_nested_read_fallback' | 'default_reference_only';
+/**
+ * Internal relationship contract built once from the developer-authored
+ * declaration and then reused by runtime consumers.
+ */
+export interface ResolvedRelationshipSemantics {
+    nature: RelationshipNature;
+    natureCalculationMode: ResolvedRelationshipNatureCalculationMode;
+    /**
+     * Documents whether the semantic read intent came from explicit authored
+     * `read`, from the legacy `childOperations.nested.onRead` compatibility seam,
+     * or from the default non-embedded fallback when neither is authored.
+     */
+    readCalculationMode: ResolvedRelationshipReadCalculationMode;
+    handling: RelationshipHandlingContract;
+    childOperations?: ChildOperationsConfig_Parsed;
+}
+/**
+ * Developer-authored relationship declaration.
+ *
+ * The `condition` function cannot be represented in a Zod schema (functions aren't
+ * serializable), so we extend via a TypeScript intersection type. This means:
+ * - The Zod schema (`ResourceRelationshipSchema`) defines all serializable fields,
+ *   including the static `discriminator` object.
+ * - This intersection adds the optional `condition` function on top.
+ * - The `createResourcesRelationship()` factory accepts both and returns this type.
+ * - `nature` + optional `read` form the authored semantic surface; the
+ *   framework compiles that into `resolvedSemantics.handling`.
+ *
+ * ## Conditional Relationship Architecture
+ *
+ * Relationships may optionally carry two kinds of runtime filters:
+ *
+ * 1. **`discriminator`** (static) — A simple field+values match on the parent resource.
+ *    Defined as `{ discriminatorField: string, values: string[] }`.
+ *    Example: "this relationship only applies when `recurringType === 'RECURRING'`".
+ *
+ * 2. **`condition`** (dynamic) — An arbitrary function evaluated with the parent
+ *    resource data. Use for cross-field logic, computed conditions, etc.
+ *
+ * Both are evaluated against the PARENT resource, never the child. When both are
+ * present, they use AND semantics (both must pass for the relationship to be active).
+ *
+ * ## Where Conditions Are Evaluated at Runtime
+ *
+ * | Layer                         | Evaluates discriminator/condition? | Against which resource? |
+ * |-------------------------------|------------------------------------|-------------------------|
+ * | **Factory** (startup)         | No — stores them inline            | N/A                     |
+ * | **DTO Builder** (startup)     | No — generates DTOs for ALL rels   | N/A                     |
+ * | **URL Builder** (startup)     | No — synthetic parents clear them  | N/A                     |
+ * | **ResourceContext** (backend) | Yes, via shared activation helper  | parentResource          |
+ * | **ServicesRegistryHandler**   | Yes, via shared activation helper  | parentResult/state      |
+ * | **ContainerNested** (frontend)| Yes, via shared activation helper  | parentData              |
+ *
+ * The key design insight is that conditions are a RUNTIME concern. At startup
+ * (factory/DTO/URL), all relationships are processed unconditionally — conditions
+ * are evaluated only when actual parent data is available.
+ */
+export type ResourceRelationshipDeclaration = z.infer<typeof ResourceRelationshipSchema> & {
+    condition?: ResourceRelationshipConditionFn;
+};
+/**
+ * Internal runtime relationship shape.
+ *
+ * This mirrors the resource-configuration pattern: app developers author the
+ * declaration shape, and the factory compiles/stores the internal semantics
+ * once so runtime consumers reuse the resolved form instead of rebuilding it.
+ */
+export type ResourceRelationship = ResourceRelationshipDeclaration & {
+    resolvedSemantics: ResolvedRelationshipSemantics;
+};
+/**
+ * Default response patterns for resource operations based on best practices
+ */
+export declare const DefaultDeleteResponseSchema: z.ZodObject<{
+    id: z.ZodString;
+    deletedAt: z.ZodOptional<z.ZodDate>;
+}, z.core.$strip, core.$ZodObjectExtra>;
+export type DefaultDeleteResponse = z.infer<typeof DefaultDeleteResponseSchema>;
+export declare const DefaultBulkDeleteResponseSchema: z.ZodObject<{
+    deletedIds: z.ZodArray<z.ZodString>;
+    deletedCount: z.ZodNumber;
+    deletedAt: z.ZodOptional<z.ZodDate>;
+}, z.core.$strip, core.$ZodObjectExtra>;
+export type DefaultBulkDeleteResponse = z.infer<typeof DefaultBulkDeleteResponseSchema>;
+export declare const DefaultUpdateManyResponseSchema: z.ZodObject<{
+    updatedCount: z.ZodNumber;
+    updatedIds: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    updatedAt: z.ZodOptional<z.ZodDate>;
+}, z.core.$strip, core.$ZodObjectExtra>;
+export type DefaultUpdateManyResponse = z.infer<typeof DefaultUpdateManyResponseSchema>;
+export declare const DefaultCountResponseSchema: z.ZodObject<{
+    count: z.ZodNumber;
+}, z.core.$strip, core.$ZodObjectExtra>;
+export type DefaultCountResponse = z.infer<typeof DefaultCountResponseSchema>;
+export interface DefaultCreateManyResponse<T> {
+    items: T[];
+    createdCount: number;
+    createdAt?: Date;
+}
+export declare const DefaultCreateManyResponseSchema: <T extends z.ZodTypeAny>(itemSchema: T) => z.ZodType<DefaultCreateManyResponse<SchemaInfer<T>>>;
+/**
+ * Generic success envelope for explicit custom action-style operations.
+ *
+ * This schema is intentionally transport-oriented. It can be attached through
+ * explicit `customResponseDto` / `responseDto` config when a custom operation
+ * returns a generic success envelope instead of a resource DTO.
+ */
+export declare const DefaultActionResponseSchema: z.ZodObject<{
+    success: z.ZodBoolean;
+    message: z.ZodOptional<z.ZodString>;
+    executedAt: z.ZodDate;
+    result: z.ZodOptional<z.ZodAny>;
+}, z.core.$strip, core.$ZodObjectExtra>;
+export type DefaultActionResponse = z.infer<typeof DefaultActionResponseSchema>;
+/**
+ * Fields that are always discarded from create/update payloads at runtime.
+ * These are auto-generated or system-managed fields.
+ *
+ * Note: _id is also handled by the isPrimaryKey decorator at the schema level,
+ * but is kept here as a runtime safety net for backward compatibility.
+ */
+export declare const createOrUpdateMandatoryDiscardFields: readonly string[];
+export declare function getDefaultResponseSchemaForOperation<T extends z.ZodTypeAny>(operation: string, mainSchema: T): z.ZodTypeAny;
+export declare function operationShouldHaveRequestDto(operation: string): boolean;
+/**
+ * Database-agnostic Resource ID utilities
+ *
+ * Supports both MongoDB ObjectId (24-char hex) and PostgreSQL UUID formats.
+ * Used across the entire stack for ID validation and format detection.
+ *
+ * @see DATABASE_AGNOSTIC_REPOSITORY_ANALYSIS.md Section 28
+ */
+/**
+ * Abstract resource ID type - string that can be either ObjectId or UUID format
+ */
+export type ResourceId = string;
+/**
+ * Supported ID format types
+ */
+export declare enum ResourceIdFormat {
+    /** MongoDB ObjectId - 24 character hexadecimal string */
+    OBJECT_ID = "OBJECT_ID",
+    /** PostgreSQL UUID - 36 character UUID with dashes */
+    UUID = "UUID"
+}
+//# sourceMappingURL=resources.shared.schemas.d.ts.map