@wildo-ai/saas-models 1.0.1

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

@@ -0,0 +1,767 @@
+/**
+ * Operations Shared Schemas
+ *
+ * Reusable operation schemas for bulk actions and common operations
+ */
+import { z } from 'zod';
+import { EnumLikeType, EnumValues, PrimitiveZodType } from '@wildo-ai/zod-decorators';
+import { HttpMethod } from '../requests/http-requests.shared.js';
+import { Roles } from '../security/authorizations/roles.shared.schemas.js';
+import { TokenAuthenticationConfig, TokenGenerationConfig, TokenRevocationConfig } from '../security/authentications/consumable-token.shared.schemas.js';
+import { ResourceOperation_ServiceRuntimeMode, ResourceOperationVariantType, ResourceOperationRiskLevel, ResourcePrimaryScope, ResourceTranspositionPolicy, ResourceOperation_CustomServiceImplementationMode, ResourceRelationship, ResourceRelationshipAccessScopeStrategy } from './resources.shared.schemas.js';
+import { NotificationBadgeIdentifier, NotificationBadgeOperation } from '../notifications/notification-badges.schemas.js';
+import { M2MNotificationDefinition, UserNotificationDefinition } from '../notifications/notifications.shared.schemas.js';
+import { NotificationBadgeDefinition } from '../notifications/notification-badges.schemas.js';
+import { CoreResourceOperation, ResourceFieldIdentifier, ResourceType } from './resources.shared.core.definitions.js';
+import { LimitCountingConfig } from '../features/feature-definition.shared.schemas.js';
+import { MainSchemaInfer, SchemaArrayInfer } from './utils/schema-type-inference.utils.js';
+export declare const Resouces_PaginationResponseMetadataSchema: z.ZodObject<{
+    page: z.ZodDefault<z.ZodNumber>;
+    limit: z.ZodDefault<z.ZodNumber>;
+    total: z.ZodNumber;
+    totalPages: z.ZodNumber;
+}, z.core.$strip, core.$ZodObjectExtra>;
+export declare const Resouces_PaginationRequestSchema: z.ZodObject<{
+    page: z.ZodDefault<z.ZodNumber>;
+    limit: z.ZodDefault<z.ZodNumber>;
+}, z.core.$strip, core.$ZodObjectExtra>;
+export type ResourcePaginatedResponseResultSchema<T extends z.ZodTypeAny> = {
+    data: SchemaArrayInfer<T>;
+    pagination: z.infer<typeof Resouces_PaginationResponseMetadataSchema>;
+};
+export type Resources_PaginationMetadata = z.infer<typeof Resouces_PaginationResponseMetadataSchema>;
+export type Resources_PaginationRequest = z.infer<typeof Resouces_PaginationRequestSchema>;
+export type Resources_PaginatedResult<T> = {
+    data: T[];
+    pagination: Resources_PaginationMetadata;
+};
+/**
+ * Data mode for read/list operations — controls API data shape.
+ * SUMMARY = backend returns only `isSummaryField()` fields and populates `isSummaryField({ populate: true })` FKs.
+ *
+ * Note: "summary" here is about *data shape*, not FK rendering (see ForeignKeyDisplayMode.SUMMARY)
+ * or operation bar density (see ResourceOperationDisplayMode.SUMMARY).
+ * Values are lowercase strings matching URL/serialization format directly.
+ */
+export declare enum DataMode {
+    /** All stored fields, no population */
+    RAW = "raw",
+    /** isSummaryField fields only, populate isSummaryField({ populate: true }) FKs */
+    SUMMARY = "summary",
+    /** All fields, populate based on contextPolicy */
+    CONTEXT = "context"
+}
+/**
+ * Persistence adapter type for database selection.
+ *
+ * Determines which database backend is used for a resource:
+ * - `mongodb`: MongoDB with Mongoose ORM
+ * - `postgresql`: PostgreSQL (SQL adapter)
+ *
+ * If not specified at resource level, uses `appConfig.database.defaultAdapter`.
+ *
+ */
+export type PersistenceAdapterType = 'mongodb' | 'postgresql';
+/**
+ * Default persistence adapter when not specified
+ */
+export declare const DEFAULT_PERSISTENCE_ADAPTER: PersistenceAdapterType;
+/**
+ * Variant key constants for operation variants.
+ * Values are identical to DataMode.SUMMARY and DataMode.CONTEXT.
+ * Kept as a standalone constant for use in factory/controller code that
+ * deals with variant keys independently of DataMode.
+ */
+export declare const OPERATION_VARIANT_KEY: {
+    readonly SUMMARY: "summary";
+    readonly CONTEXT: "context";
+};
+/**
+ * Convert DataMode to corresponding variant key.
+ * RAW mode has no variant (returns undefined).
+ * For SUMMARY/CONTEXT, the variant key equals the DataMode value directly.
+ */
+export declare function dataModeToVariantKey(dataMode: DataMode): string | undefined;
+/**
+ * Options for read operations.
+ */
+export interface ReadOperationOptions {
+    /**
+     * Data mode controlling fields and population.
+     * @default DataMode.RAW
+     */
+    dataMode?: DataMode;
+}
+/**
+ * Options for list operations.
+ */
+export interface ListOperationOptions {
+    /**
+     * Data mode controlling fields and population.
+     * @default DataMode.RAW
+     */
+    dataMode?: DataMode;
+    /**
+     * Whether to wrap in pagination container.
+     * @default false for internal, should be true for API responses
+     */
+    paginated?: boolean;
+    /**
+     * Pagination parameters (required if paginated: true).
+     */
+    pagination?: Resources_PaginationRequest;
+}
+/**
+ * Configuration for auto-generated operation variants.
+ * Controls which READ/LIST variants (summary, context) are auto-generated.
+ */
+export type ResourceConfiguration_AutoVariants = {
+    read?: {
+        /** Enable READ.context variant. @default true */
+        enableContext?: boolean;
+        /** Enable READ.summary variant. @default true */
+        enableSummary?: boolean;
+    };
+    list?: {
+        /** Enable LIST.context variant. @default true */
+        enableContext?: boolean;
+        /** Enable LIST.summary variant. @default true */
+        enableSummary?: boolean;
+    };
+};
+export declare enum SortOrder {
+    ASC = "asc",
+    DESC = "desc"
+}
+export declare const Resouces_Filter_DateRangeSchema: z.ZodObject<{
+    startDate: z.ZodOptional<z.ZodDate>;
+    endDate: z.ZodOptional<z.ZodDate>;
+}, z.core.$strip, core.$ZodObjectExtra>;
+export declare const Resouces_Filter_BaseSchema: z.ZodObject<{
+    searchRequest: z.ZodOptional<z.ZodString>;
+    createdAt: z.ZodOptional<z.ZodObject<{
+        startDate: z.ZodOptional<z.ZodDate>;
+        endDate: z.ZodOptional<z.ZodDate>;
+    }, z.core.$strip, core.$ZodObjectExtra>>;
+    updatedAt: z.ZodOptional<z.ZodObject<{
+        startDate: z.ZodOptional<z.ZodDate>;
+        endDate: z.ZodOptional<z.ZodDate>;
+    }, z.core.$strip, core.$ZodObjectExtra>>;
+}, z.core.$strip, core.$ZodObjectExtra>;
+export declare const Resouces_FilterRequestSchema: z.ZodObject<{
+    searchRequest: z.ZodOptional<z.ZodString>;
+    createdAt: z.ZodOptional<z.ZodObject<{
+        startDate: z.ZodOptional<z.ZodDate>;
+        endDate: z.ZodOptional<z.ZodDate>;
+    }, z.core.$strip, core.$ZodObjectExtra>>;
+    updatedAt: z.ZodOptional<z.ZodObject<{
+        startDate: z.ZodOptional<z.ZodDate>;
+        endDate: z.ZodOptional<z.ZodDate>;
+    }, z.core.$strip, core.$ZodObjectExtra>>;
+}, z.core.$catchall<z.ZodOptional<z.ZodAny>>, core.$ZodObjectExtra>;
+export declare const Resouces_SortingFieldSchema: z.ZodObject<{
+    field: z.ZodString;
+    order: z.ZodDefault<z.ZodEnum<typeof SortOrder>>;
+    priority: z.ZodDefault<z.ZodNumber>;
+}, z.core.$strip, core.$ZodObjectExtra>;
+export declare const Resouces_SortingRequestSchema: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodOptional<z.ZodObject<{
+    field: z.ZodString;
+    order: z.ZodDefault<z.ZodEnum<typeof SortOrder>>;
+    priority: z.ZodDefault<z.ZodNumber>;
+}, z.core.$strip, core.$ZodObjectExtra>>>>;
+export declare const Resouces_SearchQueryRequestSchema: z.ZodObject<{
+    pagination: z.ZodOptional<z.ZodObject<{
+        page: z.ZodDefault<z.ZodNumber>;
+        limit: z.ZodDefault<z.ZodNumber>;
+    }, z.core.$strip, core.$ZodObjectExtra>>;
+    sorting: z.ZodOptional<z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodOptional<z.ZodObject<{
+        field: z.ZodString;
+        order: z.ZodDefault<z.ZodEnum<typeof SortOrder>>;
+        priority: z.ZodDefault<z.ZodNumber>;
+    }, z.core.$strip, core.$ZodObjectExtra>>>>>;
+    filters: z.ZodOptional<z.ZodObject<{
+        searchRequest: z.ZodOptional<z.ZodString>;
+        createdAt: z.ZodOptional<z.ZodObject<{
+            startDate: z.ZodOptional<z.ZodDate>;
+            endDate: z.ZodOptional<z.ZodDate>;
+        }, z.core.$strip, core.$ZodObjectExtra>>;
+        updatedAt: z.ZodOptional<z.ZodObject<{
+            startDate: z.ZodOptional<z.ZodDate>;
+            endDate: z.ZodOptional<z.ZodDate>;
+        }, z.core.$strip, core.$ZodObjectExtra>>;
+    }, z.core.$catchall<z.ZodOptional<z.ZodAny>>, core.$ZodObjectExtra>>;
+}, z.core.$strip, core.$ZodObjectExtra>;
+export type ResourceSearchQueryRequestResult<TFilterFields extends Record<string, PrimitiveZodType | ((filterRef: PrimitiveZodType) => string)> | undefined, TSortFields extends readonly string[] | undefined> = z.ZodObject<{
+    pagination: z.ZodOptional<typeof Resouces_PaginationRequestSchema>;
+    sorting: z.ZodOptional<typeof Resouces_SortingRequestSchema>;
+    filters: z.ZodOptional<typeof Resouces_Filter_BaseSchema>;
+}>;
+export type Ressources_RequestSortPriority<T extends EnumLikeType> = {
+    [K in keyof T as T[K]]: number;
+};
+type UserNotificationDefinitionWithoutPrimaryScopeAndIdentifier = Omit<UserNotificationDefinition, 'primaryScope' | 'identifier'>;
+type M2MNotificationDefinitionWithoutIdentifier = Omit<M2MNotificationDefinition, 'identifier'>;
+export type CollectionView_SearchOptions = {
+    caseSensitive?: boolean;
+    fullMatchOnly?: boolean;
+};
+/**
+ * Shared collection-view fields for operations that render a collection of items (LIST, SEARCH).
+ * These fields are integrated directly into the variant builder type — not nested.
+ * The factory flattens them onto the final operation object.
+ */
+export type CollectionViewFields_Shared = {
+    pageSize?: number;
+    displayMode?: 'list' | 'table' | 'cards';
+    filterFields?: Record<string, PrimitiveZodType | ((filterRef: PrimitiveZodType) => string)>;
+    sortFields?: readonly string[];
+};
+/** LIST-specific collection-view fields (LIST and custom ops with resourceOperationLike: LIST) */
+export type CollectionViewFields_List = CollectionViewFields_Shared & {
+    searchEnabled?: boolean;
+    filtersEnabled?: boolean;
+};
+/** SEARCH-specific collection-view fields (SEARCH and custom ops with resourceOperationLike: SEARCH) */
+export type CollectionViewFields_Search = CollectionViewFields_Shared & {
+    isSearchable?: boolean;
+    searchableFields?: string[];
+    searchableOptions?: CollectionView_SearchOptions;
+    maxPaginatedResultPerPageLimit?: number;
+};
+export declare const Resouces_BulkOperationBaseSchema: z.ZodObject<{
+    _ids: z.ZodArray<z.ZodString>;
+}, z.core.$strip, core.$ZodObjectExtra>;
+export type ResourceConfiguration_OperationVariant_CustomImplementation_FunctionParameters<TMainSchema extends z.ZodTypeAny = z.ZodAny> = {
+    inputDto: MainSchemaInfer<TMainSchema>;
+    currentObject: MainSchemaInfer<TMainSchema>;
+    objectContext: any;
+    initiatorUserContext?: any;
+    initiatorIds?: {
+        userId?: string;
+        organizationId?: string;
+        applicationId?: string;
+    };
+};
+/**
+ * Metadata for functions that can optionally require context.
+ * Similar to virtual fields, these flags indicate whether objectContext/initiatorUserContext
+ * should be populated when calling the function.
+ */
+export type ResourceConfiguration_FunctionContextNeeds = {
+    needsObjectContext?: boolean;
+    needsUserContext?: boolean;
+};
+/**
+ * Limit check entry: references a LIMIT-type feature and specifies the increment.
+ * The gate uses the feature definition's `counting` config to measure current usage.
+ */
+export type RequiredFeaturesLimitCheck = {
+    /** Feature identifier (must reference a LIMIT-type feature) */
+    featureId: string;
+    /**
+     * How many units this operation would add.
+     * When omitted: auto-inferred from operation type:
+     *   - CREATE → 1
+     *   - CREATE_MANY → validatedData.length
+     *   - All others → 0
+     */
+    increment?: number;
+    /**
+     * Override counting config from feature definition (rare).
+     * Use when this specific operation needs different counting than the default.
+     */
+    countingOverride?: LimitCountingConfig;
+};
+/**
+ * Full required features configuration for an operation variant.
+ */
+export type RequiredFeaturesFullConfig = {
+    /** Boolean feature identifiers that gate this operation (presence check) */
+    features?: string[];
+    /** Combination mode for boolean features: OR = any enables (default), AND = all required */
+    mode?: 'OR' | 'AND';
+    /** Limit checks to perform before this operation */
+    limitChecks?: RequiredFeaturesLimitCheck[];
+};
+/**
+ * Required features config: accepts either shorthand (string[]) or full config.
+ * Shorthand is auto-normalized by the factory to { features: [...], mode: 'OR' }.
+ */
+export type RequiredFeaturesConfig = string[] | RequiredFeaturesFullConfig;
+/**
+ * Normalized required features (always the full form, after factory processing).
+ */
+export type RequiredFeaturesNormalized = RequiredFeaturesFullConfig;
+/**
+ * Wrapper type for functions that can optionally require context.
+ * Stores both the function and metadata about its context needs.
+ */
+export type ResourceConfiguration_FunctionWithContextNeeds<TFunction extends (...args: any[]) => any> = TFunction & ResourceConfiguration_FunctionContextNeeds;
+type ResourceConfiguration_OperationVariant_Base<TMainSchema extends z.ZodTypeAny = z.ZodAny> = {
+    variantType: ResourceOperationVariantType;
+    resourceOperationLike?: CoreResourceOperation;
+    /**
+     * Feature gating for this operation variant.
+     * Shorthand: `string[]` auto-normalized by factory to `{ features: [...], mode: 'OR' }`.
+     * Full form: `{ features, mode?, limitChecks? }`.
+     */
+    requiredFeatures?: RequiredFeaturesConfig;
+    isDefault?: boolean;
+    variantKey?: string;
+    riskLevel: ResourceOperationRiskLevel;
+    roles: Roles[];
+    requestDto?: z.ZodSchema<any>;
+    /**
+     * RepositoryDto for repository projection.
+     * Excludes virtual fields and populated placeholders.
+     * Calculated at factory execution time.
+     */
+    repositoryDto?: z.ZodSchema<any>;
+    customServiceImplementationModes?: ResourceOperation_CustomServiceImplementationMode[];
+    /**
+     * Function to modify input before core operation.
+     * Can optionally specify needsObjectContext/needsUserContext flags:
+     * basicPrefixOperation.needsObjectContext = true
+     * basicPrefixOperation.needsUserContext = true
+     */
+    basicPrefixOperation?: ResourceConfiguration_FunctionWithContextNeeds<(params: ResourceConfiguration_OperationVariant_CustomImplementation_FunctionParameters<TMainSchema>) => MainSchemaInfer<TMainSchema>>;
+};
+type ResourceConfiguration_OperationVariant_ApiCall_BuilderParameters<TMainSchema extends z.ZodTypeAny = z.ZodAny> = ResourceConfiguration_OperationVariant_Base<TMainSchema> & {
+    variantType: ResourceOperationVariantType.API_CALL;
+    isDefault?: boolean;
+    haveBulkOperation?: boolean;
+    isApiKeyAccessDisabled?: boolean;
+    /** Declares which consumable token types this operation accepts for authentication */
+    tokenAuthentication?: TokenAuthenticationConfig;
+    /** Declarative token generation config — creates a token as side-effect after successful operation */
+    tokenGeneration?: TokenGenerationConfig;
+    /** Declarative token revocation config — revokes tokens before the core operation (e.g., on DELETE) */
+    tokenRevocation?: TokenRevocationConfig;
+    customResponseDto?: z.ZodSchema<any>;
+    /**
+     * Function to determine if operation variant is enabled.
+     * Available in both frontend and backend.
+     * Can optionally specify needsObjectContext/needsUserContext flags:
+     * enabledCondition.needsObjectContext = true
+     * enabledCondition.needsUserContext = true
+     */
+    enabledCondition?: ResourceConfiguration_FunctionWithContextNeeds<(params: ResourceConfiguration_OperationVariant_CustomImplementation_FunctionParameters<TMainSchema>) => boolean>;
+};
+type ResourceConfiguration_OperationVariant_ApiCallWithCallback_BuilderParameters<TMainSchema extends z.ZodTypeAny = z.ZodAny> = ResourceConfiguration_OperationVariant_Base<TMainSchema> & {
+    variantType: ResourceOperationVariantType.API_CALL_WITH_CALLBACK;
+    isDefault?: boolean;
+    haveBulkOperation?: boolean;
+    isApiKeyAccessDisabled?: boolean;
+    /** Declares which consumable token types this operation accepts for authentication */
+    tokenAuthentication?: TokenAuthenticationConfig;
+    /** Declarative token generation config — creates a token as side-effect after successful operation */
+    tokenGeneration?: TokenGenerationConfig;
+    /** Declarative token revocation config — revokes tokens before the core operation (e.g., on DELETE) */
+    tokenRevocation?: TokenRevocationConfig;
+    customResponseDto?: z.ZodSchema<any>;
+    /**
+     * Function to determine if operation variant is enabled.
+     * Available in both frontend and backend.
+     * Can optionally specify needsObjectContext/needsUserContext flags:
+     * enabledCondition.needsObjectContext = true
+     * enabledCondition.needsUserContext = true
+     */
+    enabledCondition?: ResourceConfiguration_FunctionWithContextNeeds<(params: ResourceConfiguration_OperationVariant_CustomImplementation_FunctionParameters<TMainSchema>) => boolean>;
+    callbackUrl?: string;
+    callbackTimeout?: number;
+    callbackRetryAttempts?: number;
+};
+type ResourceConfiguration_OperationVariant_CronJob_BuilderParameters = ResourceConfiguration_OperationVariant_Base & {
+    variantType: ResourceOperationVariantType.CRON_JOB;
+    cronExpression: string;
+};
+type ResourceConfiguration_OperationVariant_BatchJob_BuilderParameters = ResourceConfiguration_OperationVariant_Base & {
+    variantType: ResourceOperationVariantType.BATCH_JOB;
+};
+type ResourceConfiguration_OperationVariant_InternalCall_BuilderParameters = ResourceConfiguration_OperationVariant_Base & {
+    variantType: ResourceOperationVariantType.INTERNAL_CALL;
+};
+type ResourceConfiguration_OperationVariant_RepositoryOnly_BuilderParameters = ResourceConfiguration_OperationVariant_Base & {
+    variantType: ResourceOperationVariantType.REPOSITORY_ONLY;
+};
+/**
+ * Base operation configuration type.
+ * NOTE: TDatabaseSchema has been removed. Backend-only fields are now marked with
+ * the isBackendOnly decorator in mainSchema and are stripped at the service layer.
+ */
+export type ResourceConfiguration_Operation_Base<TCustomOperationEnum extends EnumLikeType | undefined, TCoreOperationEnum extends Partial<CoreResourceOperation> | undefined, TMainSchema extends z.ZodTypeAny = z.ZodAny> = ResourceConfiguration_OperationVariant_Base<TMainSchema> & {
+    isDisabled: boolean;
+    mainSchema: TMainSchema;
+    resourcePrimaryScope: ResourcePrimaryScope;
+    resourceIdentifier: ResourceType;
+    resourceFieldIdentifier: ResourceFieldIdentifier;
+    resourceRelationships: ResourceConfiguration_ResourceRelationships;
+    isSystemResource: boolean;
+    operationIdentifier: TCustomOperationEnum | TCoreOperationEnum;
+    isOperationDefault: boolean;
+    serviceRuntimeMode: ResourceOperation_ServiceRuntimeMode;
+    requestDto?: z.ZodSchema<any>;
+    responseDto?: z.ZodSchema<any>;
+    /** Set by factory when `customResponseDto` was explicitly provided in variant params.
+     * Allows the DTO builder to skip heuristic comparison and always preserve the custom schema. */
+    hasCustomResponseDto?: boolean;
+    /**
+     * SummaryDto contains only fields marked with isSummaryField decorator.
+     * Used for LIST operations in SUMMARY mode.
+     * Calculated at factory execution time.
+     */
+    summaryDto?: z.ZodSchema<any>;
+    /**
+     * ContextDto includes relationship placeholders for context-dependent operations.
+     * Used for operations in CONTEXT mode.
+     * Calculated at factory execution time.
+     */
+    contextDto?: z.ZodSchema<any>;
+    /**
+     * InternalDto includes backend-only fields (isBackendOnly decorator).
+     * Used for backend-to-backend communication (queues, internal calls).
+     * Calculated at factory execution time.
+     */
+    internalDto?: z.ZodSchema<any>;
+    /**
+     * RepositoryDto for repository projection.
+     * Excludes virtual fields and populated placeholders.
+     * Calculated at factory execution time.
+     */
+    repositoryDto?: z.ZodSchema<any>;
+    notificationBadgeOperations: {
+        identifier: NotificationBadgeIdentifier;
+        operation: NotificationBadgeOperation;
+    }[];
+    userNotifications: UserNotificationDefinition[];
+    m2mNotifications: M2MNotificationDefinitionWithoutIdentifier[];
+};
+/**
+ * Base operation type - explicitly extracted for better type checking performance.
+ * TypeScript can cache this more efficiently when it's a named type alias.
+ * This helps reduce memory usage during compilation when processing union types.
+ */
+export type ResourceConfiguration_Operation_BaseType<TCustomOperationEnum extends EnumLikeType | undefined, TCoreOperationEnum extends Partial<CoreResourceOperation> | undefined, TMainSchema extends z.ZodTypeAny = z.ZodAny> = ResourceConfiguration_Operation_Base<TCustomOperationEnum, TCoreOperationEnum, TMainSchema>;
+export type ResourceConfiguration_Operation_CronJob<TCustomOperationEnum extends EnumLikeType | undefined, TCoreOperationEnum extends Partial<CoreResourceOperation> | undefined, TMainSchema extends z.ZodTypeAny = z.ZodAny> = ResourceConfiguration_Operation_Base<TCustomOperationEnum, TCoreOperationEnum, TMainSchema> & {
+    variantType: ResourceOperationVariantType.CRON_JOB;
+    cronExpression: string;
+};
+export type ResourceConfiguration_Operation_BatchJob<TCustomOperationEnum extends EnumLikeType | undefined, TCoreOperationEnum extends Partial<CoreResourceOperation> | undefined, TMainSchema extends z.ZodTypeAny = z.ZodAny> = ResourceConfiguration_Operation_Base<TCustomOperationEnum, TCoreOperationEnum, TMainSchema> & {
+    variantType: ResourceOperationVariantType.BATCH_JOB;
+};
+export type ResourceConfiguration_Operation_InternalCall<TCustomOperationEnum extends EnumLikeType | undefined, TCoreOperationEnum extends Partial<CoreResourceOperation> | undefined, TMainSchema extends z.ZodTypeAny = z.ZodAny> = ResourceConfiguration_Operation_Base<TCustomOperationEnum, TCoreOperationEnum, TMainSchema> & {
+    variantType: ResourceOperationVariantType.INTERNAL_CALL;
+};
+export type ResourceConfiguration_Operation_RepositoryOnly<TCustomOperationEnum extends EnumLikeType | undefined, TCoreOperationEnum extends Partial<CoreResourceOperation> | undefined, TMainSchema extends z.ZodTypeAny = z.ZodAny> = ResourceConfiguration_Operation_Base<TCustomOperationEnum, TCoreOperationEnum, TMainSchema> & {
+    variantType: ResourceOperationVariantType.REPOSITORY_ONLY;
+};
+export type ResourceConfiguration_Operation_UrlParameterInfo = {
+    fieldIdentifier: string;
+    resourceType: ResourceType;
+    /**
+     * The FK relationship field if this parameter comes from a FK relationship.
+     * e.g., 'assignedToUserId' for /assigned-to-users/{userId}/...
+     * undefined for default parent relationships.
+     */
+    relationshipField?: string;
+};
+export type ResourceConfiguration_Operation_UrlInitiatorInfo = {
+    url: string;
+    urlCallback?: string;
+    parameters: ResourceConfiguration_Operation_UrlParameterInfo[];
+};
+export type ResourceConfiguration_Operation_ApiCall<TCustomOperationEnum extends EnumLikeType | undefined, TCoreOperationEnum extends Partial<CoreResourceOperation> | undefined, TMainSchema extends z.ZodTypeAny = z.ZodAny> = ResourceConfiguration_Operation_Base<TCustomOperationEnum, TCoreOperationEnum, TMainSchema> & {
+    variantType: ResourceOperationVariantType.API_CALL;
+    httpVerb: HttpMethod;
+    isApiKeyAccessDisabled: boolean;
+    isBulkOperation: boolean;
+    initiatorInfos?: ResourceConfiguration_Operation_UrlInitiatorInfo[];
+    tokenAuthentication?: TokenAuthenticationConfig;
+    tokenGeneration?: TokenGenerationConfig;
+    tokenRevocation?: TokenRevocationConfig;
+    /**
+     * Function to determine if operation variant is enabled.
+     * Available in both frontend and backend.
+     * Can optionally specify needsObjectContext/needsUserContext flags:
+     * enabledCondition.needsObjectContext = true
+     * enabledCondition.needsUserContext = true
+     */
+    enabledCondition?: ResourceConfiguration_FunctionWithContextNeeds<(params: ResourceConfiguration_OperationVariant_CustomImplementation_FunctionParameters<TMainSchema>) => boolean>;
+};
+export type ResourceConfiguration_Operation_ApiCallWithCallback<TCustomOperationEnum extends EnumLikeType | undefined, TCoreOperationEnum extends Partial<CoreResourceOperation> | undefined, TMainSchema extends z.ZodTypeAny = z.ZodAny> = ResourceConfiguration_Operation_Base<TCustomOperationEnum, TCoreOperationEnum, TMainSchema> & {
+    variantType: ResourceOperationVariantType.API_CALL_WITH_CALLBACK;
+    httpVerb: HttpMethod;
+    isApiKeyAccessDisabled: boolean;
+    isBulkOperation: boolean;
+    initiatorInfos?: ResourceConfiguration_Operation_UrlInitiatorInfo[];
+    tokenAuthentication?: TokenAuthenticationConfig;
+    tokenGeneration?: TokenGenerationConfig;
+    tokenRevocation?: TokenRevocationConfig;
+    /**
+     * Function to determine if operation variant is enabled.
+     * Available in both frontend and backend.
+     * Can optionally specify needsObjectContext/needsUserContext flags:
+     * enabledCondition.needsObjectContext = true
+     * enabledCondition.needsUserContext = true
+     */
+    enabledCondition?: ResourceConfiguration_FunctionWithContextNeeds<(params: ResourceConfiguration_OperationVariant_CustomImplementation_FunctionParameters<TMainSchema>) => boolean>;
+    callbackUrl?: string;
+    callbackTimeout: number;
+    callbackRetryAttempts: number;
+};
+export type ResourceConfiguration_OperationVariant_BuilderParameters<TMainSchema extends z.ZodTypeAny = z.ZodAny> = ResourceConfiguration_OperationVariant_ApiCall_BuilderParameters<TMainSchema> | ResourceConfiguration_OperationVariant_ApiCallWithCallback_BuilderParameters<TMainSchema> | ResourceConfiguration_OperationVariant_CronJob_BuilderParameters | ResourceConfiguration_OperationVariant_BatchJob_BuilderParameters | ResourceConfiguration_OperationVariant_InternalCall_BuilderParameters | ResourceConfiguration_OperationVariant_RepositoryOnly_BuilderParameters;
+/**
+ * Variant builder type that distributes operation-specific fields based on the operation key.
+ *
+ * Collection-view fields are intersected with the **full** variant union — not restricted to
+ * API_CALL. The variant type ("how is this triggered?") and collection-view fields ("how does
+ * this operation query/present a collection?") are orthogonal concerns. A REPOSITORY_ONLY LIST
+ * still lists things and may need pageSize, filterFields, sortFields for internal queries.
+ *
+ * Only collection-style operations get operation-specific frontend/query
+ * metadata here. Action-style behavior for custom operations is modeled
+ * explicitly through custom operation identifiers plus variant/runtime config,
+ * not through a special core operation.
+ */
+export type OperationVariant_ForKey<K, TMainSchema extends z.ZodTypeAny = z.ZodAny> = K extends CoreResourceOperation.LIST ? ResourceConfiguration_OperationVariant_BuilderParameters<TMainSchema> & CollectionViewFields_List : K extends CoreResourceOperation.SEARCH ? ResourceConfiguration_OperationVariant_BuilderParameters<TMainSchema> & CollectionViewFields_Search : ResourceConfiguration_OperationVariant_BuilderParameters<TMainSchema>;
+/**
+ * Operation config with variant type narrowed by operation key.
+ * Distributes at the operation-config level; collection-view fields live on the variant.
+ */
+export type OperationConfig_ForKey<K, TMainSchema extends z.ZodTypeAny = z.ZodAny> = {
+    variants: OperationVariant_ForKey<K, TMainSchema>[];
+    serviceRuntimeMode?: ResourceOperation_ServiceRuntimeMode;
+    parentResourceAccessScopeStrategyOverrides?: {
+        resourceType: ResourceType;
+        accessScopeStrategy: ResourceRelationshipAccessScopeStrategy;
+    }[];
+    userNotifications?: UserNotificationDefinitionWithoutPrimaryScopeAndIdentifier[];
+    notificationBadgeOperations?: {
+        identifier: NotificationBadgeIdentifier;
+        operation: NotificationBadgeOperation;
+    }[];
+    m2mNotifications?: M2MNotificationDefinitionWithoutIdentifier[];
+};
+export type ResourceConfiguration_Operation<TCustomOperationEnum extends EnumLikeType | undefined, TCoreOperationEnum extends Partial<CoreResourceOperation> | undefined, TMainSchema extends z.ZodTypeAny = z.ZodAny> = ResourceConfiguration_Operation_ApiCall<TCustomOperationEnum, TCoreOperationEnum, TMainSchema> | ResourceConfiguration_Operation_ApiCallWithCallback<TCustomOperationEnum, TCoreOperationEnum, TMainSchema> | ResourceConfiguration_Operation_CronJob<TCustomOperationEnum, TCoreOperationEnum, TMainSchema> | ResourceConfiguration_Operation_BatchJob<TCustomOperationEnum, TCoreOperationEnum, TMainSchema> | ResourceConfiguration_Operation_InternalCall<TCustomOperationEnum, TCoreOperationEnum, TMainSchema> | ResourceConfiguration_Operation_RepositoryOnly<TCustomOperationEnum, TCoreOperationEnum, TMainSchema>;
+export type ResourceConfiguration_OperationPath<TCustomOperationEnum extends EnumLikeType | undefined, TCoreOperationEnum extends Partial<CoreResourceOperation> | undefined> = {
+    resourceIdentifier: ResourceType;
+    operationIdentifier: TCustomOperationEnum | TCoreOperationEnum;
+    variantType: ResourceOperationVariantType;
+    isOperationDefault?: boolean;
+    isBulkOperation?: boolean;
+    variantKey?: string;
+};
+export type ResourceConfiguration_OperationRepositoryPath = {
+    resourceIdentifier: ResourceType;
+    operationIdentifier: CoreResourceOperation;
+    /**
+     * Actual configured operation identifier when a custom operation is routed
+     * through repository logic using `resourceOperationLike`.
+     *
+     * This preserves action identity for repository lookups so multiple custom
+     * operations that share the same effective core behavior do not collide.
+     */
+    operationRef?: string;
+    isBulkOperation?: boolean;
+};
+/**
+ * Helper type for individual inherited schema configuration.
+ * NOTE: databaseSchema has been removed. Backend-only fields are now marked with
+ * the isBackendOnly decorator in the schema and are stripped at the service layer.
+ */
+export type ResourceConfiguration_InheritanceItemSchemaDefinition<TDiscriminationEnum extends EnumLikeType, TMainSchema extends z.ZodTypeAny, TInheritedSchema extends TMainSchema = TMainSchema> = {
+    discriminatorFieldValue: string;
+    schema: TInheritedSchema;
+    inheritenceSchemaDefinition?: ResourceConfiguration_InheritanceSchemaDefinition<EnumLikeType, TInheritedSchema>;
+};
+export type ResourceConfiguration_InheritanceSchemaDefinition<TDiscriminationEnum extends EnumLikeType, TMainSchema extends z.ZodTypeAny> = {
+    discriminatorField: string;
+    withoutInheritanceDiscriminatorFieldValues?: string[];
+    inheritedSchemas: ResourceConfiguration_InheritanceItemSchemaDefinition<TDiscriminationEnum, TMainSchema>[];
+};
+export type ResourceConfiguration_Operation_BuilderParameters<TMainSchema extends z.ZodTypeAny = z.ZodAny> = {
+    variants: ResourceConfiguration_OperationVariant_BuilderParameters<TMainSchema>[];
+    serviceRuntimeMode?: ResourceOperation_ServiceRuntimeMode;
+    parentResourceAccessScopeStrategyOverrides?: {
+        resourceType: ResourceType;
+        accessScopeStrategy: ResourceRelationshipAccessScopeStrategy;
+    }[];
+    userNotifications?: UserNotificationDefinitionWithoutPrimaryScopeAndIdentifier[];
+    notificationBadgeOperations?: {
+        identifier: NotificationBadgeIdentifier;
+        operation: NotificationBadgeOperation;
+    }[];
+    m2mNotifications?: M2MNotificationDefinitionWithoutIdentifier[];
+};
+export type ValidOperationKeys<TCustomOperationEnum extends EnumLikeType | undefined, TCoreOperationEnum extends Partial<CoreResourceOperation> | undefined> = (TCustomOperationEnum extends EnumLikeType ? EnumValues<TCustomOperationEnum> : never) | (TCoreOperationEnum extends Partial<CoreResourceOperation> ? TCoreOperationEnum : never);
+/**
+ * Builder parameters for creating a resource configuration.
+ * NOTE: databaseSchema has been removed. Backend-only fields are now marked with
+ * the isBackendOnly decorator in mainSchema and are stripped at the service layer.
+ */
+export type ResourceConfiguration_BuilderParameters<TCustomOperationEnum extends EnumLikeType | undefined, TCoreOperationEnum extends Partial<CoreResourceOperation> | undefined, TMainSchema extends z.ZodTypeAny> = {
+    isDisabled?: boolean;
+    mainSchema: TMainSchema;
+    resourceIdentifier: ResourceType;
+    resourceFieldIdentifier: ResourceFieldIdentifier;
+    resourceRelationships: ResourceRelationship[];
+    inheritenceSchemaDefinition?: ResourceConfiguration_InheritanceSchemaDefinition<EnumLikeType, TMainSchema>;
+    /**
+     * Persistence adapter (database type) for this resource.
+     * - `mongodb`: MongoDB with Mongoose ORM (default)
+     * - `postgresql`: PostgreSQL (SQL adapter)
+     *
+     * If not specified, uses `appConfig.database.defaultAdapter`.
+     *
+     * @see DATABASE_AGNOSTIC_REPOSITORY_ANALYSIS.md Section 18.3
+     */
+    persistenceAdapter?: PersistenceAdapterType;
+    isSystemResource?: boolean;
+    coreOperations: TCoreOperationEnum[];
+    customOperation?: TCustomOperationEnum;
+    operationsConfiguration: {
+        [K in ValidOperationKeys<TCustomOperationEnum, TCoreOperationEnum>]: OperationConfig_ForKey<K, TMainSchema>;
+    };
+    /**
+     * Configuration for auto-generated operation variants.
+     * Controls which READ/LIST variants (summary, context) are auto-generated.
+     * All variants are enabled by default.
+     */
+    autoVariants?: ResourceConfiguration_AutoVariants;
+    /**
+     * W7.3a: Marks this resource as accessible to anonymous sessions.
+     * When true, the factory auto-generates dual URL paths (USER_SELF + ANONYMOUS)
+     * and a STANDALONE relationship to ANONYMOUS_USERS.
+     * The resource MUST have a nullable `userId` field.
+     */
+    isAnonymizable?: boolean;
+    /**
+     * W7.3a: Controls how anonymous resources are handled during transposition.
+     * Only meaningful when isAnonymizable is true.
+     * Defaults to ADD (simple ownership reassignment).
+     */
+    transpositionPolicy?: ResourceTranspositionPolicy;
+};
+/**
+ * Categorized resource relationships produced by `transformResourceRelationships()`.
+ *
+ * All relationships — including conditional ones (those with `discriminator` or `condition`) —
+ * are stored flat in these three buckets. There is no separate `inheritanceSchemaRelationships`
+ * bucket; that structure was removed because it was populated but never consumed at runtime,
+ * making the conditional relationship system non-functional.
+ *
+ * The flat design means:
+ * - **Factory/startup**: All relationships are categorized structurally (by resourceType
+ *   and cardinality), regardless of whether they have conditions.
+ * - **Runtime**: Consumers (ResourceContext, ServicesRegistryHandler, ContainerNested)
+ *   evaluate `discriminator`/`condition` inline when actual parent data is available.
+ *
+ * M:N relationships are decomposed into synthetic 1:N relationships and placed into the
+ * appropriate bucket. Synthetic relationships for entity→junction carry the original
+ * `discriminator` and `condition` from the M:N declaration.
+ *
+ * @see ResourceRelationship — for the full type including optional `condition` function.
+ * @see transformResourceRelationships — in resources-config.shared.factory.ts for categorization logic.
+ */
+export type ResourceConfiguration_ResourceRelationships = {
+    parentRelationships: ResourceRelationship[];
+    childRelationships: ResourceRelationship[];
+    selfRelationships: ResourceRelationship[];
+};
+/**
+ * Returns all relationships where this resource acts as a child (has a parent).
+ * Merges `childRelationships` with `selfRelationships` — self-refs are both
+ * parent and child of themselves, so they must be included when iterating
+ * "what children does this resource have?"
+ */
+export declare function getChildDirectionRelationships(rels: ResourceConfiguration_ResourceRelationships): ResourceRelationship[];
+/**
+ * Returns all relationships where this resource acts as a parent (provides context).
+ * Merges `parentRelationships` with `selfRelationships` — self-refs need to be
+ * treated as parents when resolving FK fields, scope requirements, and URL paths.
+ */
+export declare function getParentDirectionRelationships(rels: ResourceConfiguration_ResourceRelationships): ResourceRelationship[];
+/**
+ * Full resource configuration type.
+ * NOTE: databaseSchema has been removed. Backend-only fields are now marked with
+ * the isBackendOnly decorator in mainSchema and are stripped at the service layer.
+ */
+export type ResourceConfiguration<TCustomOperationEnum extends EnumLikeType | undefined, TCoreOperationEnum extends Partial<CoreResourceOperation> | undefined, TMainSchema extends z.ZodTypeAny> = {
+    isDisabled: boolean;
+    resourcePrimaryScope: ResourcePrimaryScope;
+    resourceIdentifier: ResourceType;
+    resourceFieldIdentifier: ResourceFieldIdentifier;
+    coreOperations: TCoreOperationEnum[];
+    customOperation?: TCustomOperationEnum;
+    mainSchema: TMainSchema;
+    resourceRelationships: ResourceConfiguration_ResourceRelationships;
+    inheritenceSchemaDefinition?: ResourceConfiguration_InheritanceSchemaDefinition<EnumLikeType, TMainSchema>;
+    /**
+     * Persistence adapter (database type) for this resource.
+     * - `mongodb`: MongoDB with Mongoose ORM
+     * - `postgresql`: PostgreSQL (SQL adapter)
+     *
+     * Resolved at runtime from:
+     * 1. This field (if specified)
+     * 2. `appConfig.database.defaultAdapter` (fallback)
+     */
+    persistenceAdapter?: PersistenceAdapterType;
+    isSystemResource: boolean;
+    /**
+     * W7.3a: Marks this resource as accessible to anonymous sessions.
+     * When true, the engine generates dual URL paths and a STANDALONE relationship to ANONYMOUS_USERS.
+     */
+    isAnonymizable: boolean;
+    /**
+     * W7.3a: Transposition policy for anonymous→authenticated ownership transfer.
+     * Only meaningful when isAnonymizable is true. Defaults to ADD.
+     */
+    transpositionPolicy: ResourceTranspositionPolicy;
+    operations: ResourceConfiguration_Operation<TCustomOperationEnum, TCoreOperationEnum, TMainSchema>[];
+};
+export type ResourceConfiguration_InitializationFactory<TCustomOperationEnum extends EnumLikeType | undefined, TCoreOperationEnum extends Partial<CoreResourceOperation> | undefined, TMainSchema extends z.ZodTypeAny> = (resourcesRelationships: ResourceRelationship[]) => ResourceConfiguration<TCustomOperationEnum, TCoreOperationEnum, TMainSchema>;
+export type ResourceConfiguration_InitializationFactoryMap<TResourceType extends ResourceType | undefined = undefined> = TResourceType extends undefined ? undefined : [TResourceType] extends [undefined] ? undefined : TResourceType extends ResourceType ? {
+    [key in TResourceType]: ResourceConfiguration_InitializationFactory<any, any, any>;
+} : {
+    [key: string]: ResourceConfiguration_InitializationFactory<any, any, any>;
+};
+export type AnyResourceConfiguration = ResourceConfiguration<any, // TCustomOperationEnum - allow any custom operations
+any, // TCoreOperationEnum - allow any subset of core operations
+any>;
+export type ResourcesRegistry = {
+    notificationBadgeDefinitions: NotificationBadgeDefinition[];
+    additionalUserNotificationDefinitions: UserNotificationDefinition[];
+    resourceRelationships: ResourceRelationship[];
+    resourceConfigurations: {
+        [key: ResourceType]: AnyResourceConfiguration;
+    };
+    /**
+     * Map of ResourceType to its standard field identifier (e.g., USERS -> userId).
+     * Used for FK field resolution without string manipulation.
+     */
+    allResourceFieldIdentifiers: Record<ResourceType, string>;
+    /**
+     * Reverse map of field identifier to ResourceType (e.g., userId -> USERS).
+     * Used for quick lookup of resource type from a FK field name.
+     */
+    fieldIdentifierToResourceType: Record<string, ResourceType>;
+};
+export type ResourceRegistry_InitializerParameters<TResourceType extends ResourceType | undefined = undefined> = [
+    TResourceType
+] extends [undefined] ? {
+    resourceRelationships: ResourceRelationship[];
+    resourceConfigurationsFactoryMap: ResourceConfiguration_InitializationFactoryMap<undefined>;
+    resourceFieldIdentifiers: undefined;
+} : TResourceType extends ResourceType ? {
+    resourceRelationships: ResourceRelationship[];
+    resourceConfigurationsFactoryMap: ResourceConfiguration_InitializationFactoryMap<TResourceType>;
+    resourceFieldIdentifiers: {
+        [key in TResourceType]: string;
+    };
+} : {
+    resourceRelationships: ResourceRelationship[];
+    resourceConfigurationsFactoryMap: ResourceConfiguration_InitializationFactoryMap<ResourceType>;
+    resourceFieldIdentifiers: {} | undefined;
+};
+export {};
+//# sourceMappingURL=resources-config.shared.schemas.d.ts.map