openxiangda-devkit-core 2.0.0-alpha.100

package/dist/compiler/config.d.ts

@@ -0,0 +1,857 @@
+import { type AppApiOperationDeclaration, type AppEventSubscriptionPlatformAccessDeclaration, type AppAuthorizationTransitionDeclaration, type AppBackendSecretDeclaration, type AppCapabilityDeclaration, type AppDataPolicyDeclaration, type AppDataPolicyExpressionDeclaration, type AppDataPolicyRuleDeclaration, type AppFrontendRouteDeclaration, type AppFrontendRouteAccess, type AppRouteManifestDevicePolicyV3, type AnonymousPublicAccessContractV2, type ApplicationAuthenticationDeclarationV2, type AppAdminNavigationDeclaration, type AppAdminNavigationGroupDeclaration, type AppAdminNavigationItemDeclaration, type AppWorkflowLaunchDeclaration, type AppWorkflowDetailRouteCodeDeclaration, type AppPerspectiveDeclaration, type AppRoleDeclaration, type AppRoleMembershipSourceDeclaration, type AppRelationshipGrantSourceDeclaration, type AppScopeDimensionDeclaration, type AppScopeSourceDeclaration, type NativeWorkflowEditableParameterDeclaration, type DataFieldDefinition, type DataFieldPolicy, type DataFieldSurfaceWidget, type DataResourceSurface, type DataResource, type Diagnostic, type ApplicationEventSchemaDeclaration, type DateTrigger, type EventSubscription, type TimerSubscription, type WorkflowBinding, type WorkflowDefinition } from 'openxiangda-contracts';
+export type EventSubscriptionDeclaration = Pick<EventSubscription, 'code' | 'eventTypes'> & {
+    description?: string;
+    filter?: EventSubscription['filter'];
+    payload?: Partial<EventSubscription['payload']>;
+    platformAccess?: AppEventSubscriptionPlatformAccessDeclaration;
+    delivery?: Partial<EventSubscription['delivery']>;
+};
+export type TimerSubscriptionDeclaration = Pick<TimerSubscription, 'code' | 'eventType' | 'cronExpression' | 'timezone' | 'payload'> & {
+    misfirePolicy?: TimerSubscription['misfirePolicy'];
+};
+export type DateTriggerDeclaration = Pick<DateTrigger, 'code' | 'resourceCode' | 'field' | 'offset' | 'eventType' | 'payload'>;
+export interface WorkflowDefinitionDeclaration {
+    version: number;
+    definition: WorkflowDefinition;
+    launch?: AppWorkflowLaunchDeclaration;
+    detailRouteCode?: AppWorkflowDetailRouteCodeDeclaration;
+}
+export interface WorkflowBindingDeclaration {
+    version: number;
+    binding: WorkflowBinding;
+}
+export interface WorkflowActivationDeclaration {
+    workflowCode: string;
+    definitionVersion: number;
+    bindingVersion: number;
+    acceptedCommandDeactivationPolicy: WorkflowDefinition['acceptedCommandDeactivationPolicy'];
+}
+export interface WorkflowAssigneeProviderDeclaration {
+    code: string;
+    endpointPath: string;
+    timeoutMs?: number;
+    status?: 'active' | 'paused';
+}
+export type BackendSecretDeclaration = AppBackendSecretDeclaration;
+export type AuthzRoleDeclaration = AppRoleDeclaration;
+export type AuthzScopeDimensionDeclaration = AppScopeDimensionDeclaration;
+export type AuthzScopeSourceDeclaration = AppScopeSourceDeclaration;
+export type AuthzRoleMembershipSourceDeclaration = AppRoleMembershipSourceDeclaration;
+export type AuthzRelationshipGrantSourceDeclaration = AppRelationshipGrantSourceDeclaration;
+export type AuthzDataPolicyRuleDeclaration = AppDataPolicyRuleDeclaration;
+export type AuthzDataPolicyDeclaration = AppDataPolicyDeclaration;
+export type AppDataFieldAccessDeclaration = {
+    read?: string[] | false;
+    create?: string[] | false;
+    update?: string[] | false;
+    mask?: DataFieldPolicy['mask'];
+};
+/**
+ * One source field owns storage, validation, presentation and field access.
+ * The compiler projects it into the strict platform schema and UI Surface.
+ */
+export interface AppDataFieldDeclaration {
+    code: string;
+    type: DataFieldDefinition['type'];
+    label: string;
+    required?: boolean;
+    indexed?: boolean;
+    options?: DataFieldDefinition['options'];
+    source?: DataFieldDefinition['source'];
+    maxLength?: DataFieldDefinition['maxLength'];
+    precision?: DataFieldDefinition['precision'];
+    scale?: DataFieldDefinition['scale'];
+    min?: DataFieldDefinition['min'];
+    max?: DataFieldDefinition['max'];
+    rangeBoundary?: NonNullable<DataFieldDefinition['rangeBoundary']>;
+    timePrecision?: DataFieldDefinition['timePrecision'];
+    file?: DataFieldDefinition['file'];
+    serial?: DataFieldDefinition['serial'];
+    subtable?: DataFieldDefinition['subtable'];
+    widget?: DataFieldSurfaceWidget;
+    section?: string;
+    system?: boolean;
+    list?: boolean;
+    filter?: boolean;
+    searchable?: boolean;
+    sortable?: boolean;
+    access?: AppDataFieldAccessDeclaration;
+}
+export interface AppDataResourceDeclaration {
+    code: string;
+    name: string;
+    mutationOwner?: 'native' | 'action' | 'readonly' | 'workflow';
+    generated?: {
+        list?: boolean;
+        detail?: boolean;
+        create?: boolean;
+        update?: boolean;
+        delete?: boolean;
+    };
+    fields: AppDataFieldDeclaration[];
+    invariants?: DataResource['invariants'];
+    list?: {
+        defaultPageSize?: number;
+        defaultSort?: {
+            field: string;
+            order?: 'asc' | 'desc';
+        };
+    };
+    form?: {
+        layout?: 'flat' | 'sections';
+    };
+    detail?: {
+        layout?: 'flat' | 'sections';
+    };
+    mobile?: DataResourceSurface['mobile'];
+    dataPolicyCode?: string | null;
+}
+export interface OpenXiangdaAppDeclaration {
+    schemaVersion: 3;
+    app: OpenXiangdaAppConfig['app'];
+    frontend: OpenXiangdaAppConfig['frontend'];
+    backend: OpenXiangdaAppConfig['backend'];
+    platform: OpenXiangdaAppConfig['platform'];
+    perspectives?: AppPerspectiveDeclaration[];
+    data?: {
+        resources: AppDataResourceDeclaration[];
+    };
+    authz?: NonNullable<OpenXiangdaAppConfig['authz']>;
+    events?: NonNullable<OpenXiangdaAppConfig['events']>;
+    workflows?: NonNullable<OpenXiangdaAppConfig['workflows']>;
+}
+export interface OpenXiangdaAppConfig {
+    schemaVersion: 3;
+    app: {
+        code: string;
+        name: string;
+    };
+    frontend: {
+        root: string;
+        routes?: AppFrontendRouteDeclaration[];
+        devicePolicy?: AppRouteManifestDevicePolicyV3;
+        user?: {
+            applicationTodoCenter?: boolean;
+        };
+        admin?: {
+            access?: AppFrontendRouteAccess;
+            navigation: AppAdminNavigationDeclaration;
+        };
+        authentication?: ApplicationAuthenticationDeclarationV2;
+        publicAccess?: AnonymousPublicAccessContractV2;
+    };
+    backend: {
+        root: string;
+        runtime: 'node';
+        framework: 'nestjs';
+        /** Omit for pure CRUD applications; set true for an intentional backend. */
+        enabled?: boolean;
+        isolation?: 'shared' | 'dedicated';
+        resourceProfile?: 'light' | 'standard';
+        secrets?: BackendSecretDeclaration[];
+        operations?: AppApiOperationDeclaration[];
+    };
+    platform: {
+        root: string;
+    };
+    perspectives?: AppPerspectiveDeclaration[];
+    data?: {
+        resources: DataResource[];
+    };
+    authz?: {
+        /** Package role granted by the platform to every authenticated user on first access. */
+        authenticatedUserRoleCode?: string;
+        capabilities: AppCapabilityDeclaration[];
+        roles: AuthzRoleDeclaration[];
+        scopeDimensions?: AuthzScopeDimensionDeclaration[];
+        scopeSources?: AuthzScopeSourceDeclaration[];
+        roleMembershipSources?: AuthzRoleMembershipSourceDeclaration[];
+        relationshipGrantSources?: AuthzRelationshipGrantSourceDeclaration[];
+        dataPolicies?: AuthzDataPolicyDeclaration[];
+        authorizationTransitions?: AppAuthorizationTransitionDeclaration[];
+    };
+    events?: {
+        schemas?: ApplicationEventSchemaDeclaration[];
+        subscriptions: EventSubscriptionDeclaration[];
+        timers?: TimerSubscriptionDeclaration[];
+        dateTriggers?: DateTriggerDeclaration[];
+    };
+    workflows?: {
+        definitions: WorkflowDefinitionDeclaration[];
+        bindings: WorkflowBindingDeclaration[];
+        /** Complete desired activation set; removing an item deactivates it on deploy. */
+        activations: WorkflowActivationDeclaration[];
+        providers?: WorkflowAssigneeProviderDeclaration[];
+        editableParameters?: NativeWorkflowEditableParameterDeclaration[];
+    };
+}
+type AdminNavigationItemOptions = Omit<AppAdminNavigationItemDeclaration, 'page'>;
+type AdminNavigationGroupOptions = Pick<AppAdminNavigationGroupDeclaration, 'icon' | 'order'>;
+/** Explicitly owns the complete admin menu; the compiler never appends pages. */
+export declare function defineAdminNavigation<const Groups extends AppAdminNavigationDeclaration>(groups: Groups): Groups;
+export declare function adminNavigationGroup(code: string, label: string, items: readonly AppAdminNavigationItemDeclaration[], options?: AdminNavigationGroupOptions): AppAdminNavigationGroupDeclaration;
+export declare function adminResourcePage(resourceCode: string, options?: AdminNavigationItemOptions): AppAdminNavigationItemDeclaration;
+export declare function adminOperationPage(routeCode: string, options?: AdminNavigationItemOptions): AppAdminNavigationItemDeclaration;
+/**
+ * Produces a deterministic one-time authoring suggestion for tooling. The
+ * compiler never calls this function and never mutates a saved declaration.
+ */
+export declare function suggestAdminNavigation(config: OpenXiangdaAppConfig): AppAdminNavigationDeclaration;
+export interface AdminNavigationSuggestionSource {
+    module: 'openxiangda/config';
+    imports: readonly string[];
+    proposal: AppAdminNavigationDeclaration;
+    expression: string;
+    groupCount: number;
+    itemCount: number;
+}
+/**
+ * Renders the deterministic proposal as a typed expression that an AI author
+ * can copy once into frontend.admin.navigation and then edit normally.
+ */
+export declare function renderAdminNavigationSuggestion(config: OpenXiangdaAppConfig): AdminNavigationSuggestionSource;
+export declare const openXiangdaAppConfigSchema: {
+    readonly $id: "openxiangda.app-config/v3";
+    readonly type: "object";
+    readonly additionalProperties: false;
+    readonly required: readonly ["schemaVersion", "app", "frontend", "backend", "platform"];
+    readonly properties: {
+        readonly schemaVersion: {
+            readonly const: 3;
+        };
+        readonly app: {
+            readonly type: "object";
+            readonly additionalProperties: false;
+            readonly required: readonly ["code", "name"];
+            readonly properties: {
+                readonly code: {
+                    readonly type: "string";
+                    readonly pattern: "^[a-z][a-z0-9]*(?:-[a-z0-9]+)*$";
+                    readonly minLength: 2;
+                    readonly maxLength: 128;
+                };
+                readonly name: {
+                    readonly type: "string";
+                    readonly minLength: 1;
+                    readonly maxLength: 255;
+                };
+            };
+        };
+        readonly frontend: {
+            readonly type: "object";
+            readonly additionalProperties: false;
+            readonly required: readonly ["root"];
+            readonly properties: {
+                readonly root: {
+                    readonly type: "string";
+                    readonly minLength: 1;
+                };
+                readonly routes: {
+                    readonly type: "array";
+                    readonly maxItems: 500;
+                    readonly items: {
+                        readonly type: "object";
+                    };
+                };
+                readonly admin: {
+                    readonly type: "object";
+                };
+                readonly authentication: {
+                    readonly type: "object";
+                };
+                readonly publicAccess: {
+                    readonly type: "object";
+                };
+                readonly devicePolicy: {
+                    readonly type: "object";
+                    readonly additionalProperties: false;
+                    readonly required: readonly ["kind", "mobileMaxWidthPx", "desktopMinWidthPx"];
+                    readonly properties: {
+                        readonly kind: {
+                            readonly const: "viewport-family";
+                        };
+                        readonly mobileMaxWidthPx: {
+                            readonly type: "integer";
+                            readonly minimum: 320;
+                            readonly maximum: 1600;
+                        };
+                        readonly desktopMinWidthPx: {
+                            readonly type: "integer";
+                            readonly minimum: 320;
+                            readonly maximum: 1600;
+                        };
+                    };
+                };
+            };
+        };
+        readonly backend: {
+            readonly type: "object";
+            readonly additionalProperties: false;
+            readonly required: readonly ["root", "runtime", "framework"];
+            readonly properties: {
+                readonly root: {
+                    readonly type: "string";
+                    readonly minLength: 1;
+                };
+                readonly runtime: {
+                    readonly const: "node";
+                };
+                readonly framework: {
+                    readonly const: "nestjs";
+                };
+                readonly enabled: {
+                    readonly type: "boolean";
+                };
+                readonly isolation: {
+                    readonly enum: readonly ["shared", "dedicated"];
+                };
+                readonly resourceProfile: {
+                    readonly enum: readonly ["light", "standard"];
+                };
+                readonly secrets: {
+                    readonly type: "array";
+                    readonly maxItems: 100;
+                    readonly items: {
+                        readonly type: "object";
+                        readonly additionalProperties: false;
+                        readonly required: readonly ["name", "env"];
+                        readonly properties: {
+                            readonly name: {
+                                readonly type: "string";
+                                readonly pattern: "^[a-z][a-z0-9]*(?:[-_][a-z0-9]+)*$";
+                                readonly maxLength: 128;
+                            };
+                            readonly env: {
+                                readonly type: "string";
+                                readonly pattern: "^[A-Z][A-Z0-9_]*$";
+                                readonly maxLength: 128;
+                            };
+                            readonly description: {
+                                readonly type: "string";
+                                readonly maxLength: 2000;
+                            };
+                            readonly required: {
+                                readonly type: "boolean";
+                            };
+                        };
+                    };
+                };
+                readonly operations: {
+                    readonly type: "array";
+                    readonly maxItems: 500;
+                    readonly items: {
+                        readonly type: "object";
+                    };
+                };
+            };
+        };
+        readonly platform: {
+            readonly type: "object";
+            readonly additionalProperties: false;
+            readonly required: readonly ["root"];
+            readonly properties: {
+                readonly root: {
+                    readonly type: "string";
+                    readonly minLength: 1;
+                };
+            };
+        };
+        readonly perspectives: {
+            readonly type: "array";
+            readonly maxItems: 100;
+            readonly items: {
+                readonly type: "object";
+                readonly additionalProperties: false;
+                readonly required: readonly ["code", "name", "roleCodes"];
+                readonly properties: {
+                    readonly code: {
+                        readonly type: "string";
+                        readonly pattern: "^[a-z][a-z0-9]*(?:[-_][a-z0-9]+)*$";
+                        readonly maxLength: 128;
+                    };
+                    readonly name: {
+                        readonly type: "string";
+                        readonly minLength: 1;
+                        readonly maxLength: 255;
+                    };
+                    readonly description: {
+                        readonly type: "string";
+                        readonly maxLength: 2000;
+                    };
+                    readonly roleCodes: {
+                        readonly type: "array";
+                        readonly minItems: 1;
+                        readonly maxItems: 20;
+                        readonly uniqueItems: true;
+                        readonly items: {
+                            readonly type: "string";
+                        };
+                    };
+                    readonly default: {
+                        readonly type: "boolean";
+                    };
+                };
+            };
+        };
+        readonly data: {
+            readonly type: "object";
+            readonly additionalProperties: false;
+            readonly required: readonly ["resources"];
+            readonly properties: {
+                readonly resources: {
+                    readonly type: "array";
+                    readonly maxItems: 100;
+                    readonly items: {
+                        readonly type: "object";
+                    };
+                };
+            };
+        };
+        readonly authz: {
+            readonly type: "object";
+            readonly additionalProperties: false;
+            readonly required: readonly ["capabilities", "roles"];
+            readonly properties: {
+                readonly authenticatedUserRoleCode: {
+                    readonly type: "string";
+                    readonly pattern: "^[a-z][a-z0-9]*(?:[-_][a-z0-9]+)*$";
+                    readonly maxLength: 128;
+                };
+                readonly capabilities: {
+                    readonly type: "array";
+                    readonly maxItems: 2000;
+                    readonly items: {
+                        readonly type: "object";
+                    };
+                };
+                readonly roles: {
+                    readonly type: "array";
+                    readonly maxItems: 100;
+                    readonly items: {
+                        readonly type: "object";
+                    };
+                };
+                readonly scopeDimensions: {
+                    readonly type: "array";
+                    readonly maxItems: 100;
+                    readonly items: {
+                        readonly type: "object";
+                        readonly additionalProperties: false;
+                        readonly required: readonly ["code", "name"];
+                        readonly properties: {
+                            readonly code: {
+                                readonly type: "string";
+                            };
+                            readonly name: {
+                                readonly type: "string";
+                            };
+                            readonly resourceCode: {
+                                readonly type: "string";
+                            };
+                            readonly valueType: {
+                                readonly enum: readonly ["string", "uuid"];
+                            };
+                            readonly hierarchyMode: {
+                                readonly enum: readonly ["flat", "self_parent"];
+                            };
+                            readonly valueSource: {
+                                readonly type: "object";
+                                readonly additionalProperties: false;
+                                readonly required: readonly ["kind", "resourceCode", "labelField"];
+                                readonly properties: {
+                                    readonly kind: {
+                                        readonly const: "native_resource";
+                                    };
+                                    readonly resourceCode: {
+                                        readonly type: "string";
+                                    };
+                                    readonly labelField: {
+                                        readonly type: "string";
+                                    };
+                                    readonly enabledField: {
+                                        readonly type: "string";
+                                    };
+                                };
+                            };
+                        };
+                    };
+                };
+                readonly scopeSources: {
+                    readonly type: "array";
+                    readonly maxItems: 100;
+                    readonly items: {
+                        readonly type: "object";
+                    };
+                };
+                readonly roleMembershipSources: {
+                    readonly type: "array";
+                    readonly maxItems: 100;
+                    readonly items: {
+                        readonly type: "object";
+                        readonly additionalProperties: false;
+                        readonly required: readonly ["code", "name", "resourceCode", "userIdField", "roleCode", "failureMode"];
+                        readonly properties: {
+                            readonly enabledField: {
+                                readonly type: "string";
+                                readonly pattern: "^[A-Za-z_][A-Za-z0-9_]{0,127}$";
+                            };
+                            readonly effectiveFromField: {
+                                readonly type: "string";
+                                readonly pattern: "^[A-Za-z_][A-Za-z0-9_]{0,127}$";
+                            };
+                            readonly effectiveToField: {
+                                readonly type: "string";
+                                readonly pattern: "^[A-Za-z_][A-Za-z0-9_]{0,127}$";
+                            };
+                            readonly failureMode: {
+                                readonly const: "strict";
+                            };
+                            readonly code: {
+                                readonly type: "string";
+                                readonly pattern: "^[a-z][a-z0-9]*(?:[-_.][a-z0-9]+)*$";
+                                readonly maxLength: 100;
+                            };
+                            readonly name: {
+                                readonly type: "string";
+                                readonly minLength: 1;
+                                readonly maxLength: 255;
+                            };
+                            readonly resourceCode: {
+                                readonly type: "string";
+                            };
+                            readonly userIdField: {
+                                readonly type: "string";
+                                readonly pattern: "^[A-Za-z_][A-Za-z0-9_]{0,127}(?:\\.(?:value|snapshot\\.[A-Za-z_][A-Za-z0-9_]{0,127}))?$";
+                            };
+                            readonly roleCode: {
+                                readonly type: "string";
+                            };
+                        };
+                    };
+                };
+                readonly relationshipGrantSources: {
+                    readonly type: "array";
+                    readonly maxItems: 100;
+                    readonly items: {
+                        readonly type: "object";
+                        readonly additionalProperties: false;
+                        readonly required: readonly ["code", "name", "resourceCode", "subject", "relationCode", "targetResourceCode", "resourceIdField", "operations", "failureMode"];
+                        readonly properties: {
+                            readonly enabledField: {
+                                readonly type: "string";
+                                readonly pattern: "^[A-Za-z_][A-Za-z0-9_]{0,127}$";
+                            };
+                            readonly effectiveFromField: {
+                                readonly type: "string";
+                                readonly pattern: "^[A-Za-z_][A-Za-z0-9_]{0,127}$";
+                            };
+                            readonly effectiveToField: {
+                                readonly type: "string";
+                                readonly pattern: "^[A-Za-z_][A-Za-z0-9_]{0,127}$";
+                            };
+                            readonly failureMode: {
+                                readonly const: "strict";
+                            };
+                            readonly code: {
+                                readonly type: "string";
+                                readonly pattern: "^[a-z][a-z0-9]*(?:[-_.][a-z0-9]+)*$";
+                                readonly maxLength: 100;
+                            };
+                            readonly name: {
+                                readonly type: "string";
+                                readonly minLength: 1;
+                                readonly maxLength: 255;
+                            };
+                            readonly resourceCode: {
+                                readonly type: "string";
+                            };
+                            readonly subject: {
+                                readonly oneOf: readonly [{
+                                    readonly type: "object";
+                                    readonly additionalProperties: false;
+                                    readonly required: readonly ["type", "userIdField"];
+                                    readonly properties: {
+                                        readonly type: {
+                                            readonly const: "user";
+                                        };
+                                        readonly userIdField: {
+                                            readonly type: "string";
+                                            readonly pattern: "^[A-Za-z_][A-Za-z0-9_]{0,127}(?:\\.(?:value|snapshot\\.[A-Za-z_][A-Za-z0-9_]{0,127}))?$";
+                                        };
+                                    };
+                                }, {
+                                    readonly type: "object";
+                                    readonly additionalProperties: false;
+                                    readonly required: readonly ["type", "userIdField", "roleCode"];
+                                    readonly properties: {
+                                        readonly type: {
+                                            readonly const: "role_membership";
+                                        };
+                                        readonly userIdField: {
+                                            readonly type: "string";
+                                            readonly pattern: "^[A-Za-z_][A-Za-z0-9_]{0,127}(?:\\.(?:value|snapshot\\.[A-Za-z_][A-Za-z0-9_]{0,127}))?$";
+                                        };
+                                        readonly roleCode: {
+                                            readonly type: "string";
+                                        };
+                                    };
+                                }];
+                            };
+                            readonly relationCode: {
+                                readonly type: "string";
+                                readonly minLength: 1;
+                                readonly maxLength: 128;
+                            };
+                            readonly targetResourceCode: {
+                                readonly type: "string";
+                            };
+                            readonly resourceIdField: {
+                                readonly type: "string";
+                                readonly pattern: "^[A-Za-z_][A-Za-z0-9_]{0,127}(?:\\.(?:value|snapshot\\.[A-Za-z_][A-Za-z0-9_]{0,127}))?$";
+                            };
+                            readonly operations: {
+                                readonly type: "array";
+                                readonly minItems: 1;
+                                readonly maxItems: 20;
+                                readonly uniqueItems: true;
+                                readonly items: {
+                                    readonly type: "string";
+                                    readonly minLength: 1;
+                                    readonly maxLength: 64;
+                                    readonly pattern: "^[A-Za-z0-9][A-Za-z0-9:._*-]{0,63}$";
+                                };
+                            };
+                        };
+                    };
+                };
+                readonly dataPolicies: {
+                    readonly type: "array";
+                    readonly maxItems: 100;
+                    readonly items: {
+                        readonly type: "object";
+                    };
+                };
+                readonly authorizationTransitions: {
+                    readonly type: "array";
+                    readonly maxItems: 100;
+                    readonly items: {
+                        readonly type: "object";
+                        readonly additionalProperties: false;
+                        readonly required: readonly ["fromAuthzDigest", "reason"];
+                        readonly properties: {
+                            readonly fromAuthzDigest: {
+                                readonly type: "string";
+                                readonly pattern: "^[0-9a-f]{64}$";
+                            };
+                            readonly removeRoleCodes: {
+                                readonly type: "array";
+                                readonly maxItems: 2000;
+                                readonly uniqueItems: true;
+                                readonly items: {
+                                    readonly type: "string";
+                                    readonly pattern: "^[a-z][a-z0-9]*(?:[-_.][a-z0-9]+)*$";
+                                    readonly maxLength: 128;
+                                };
+                            };
+                            readonly removeCapabilityCodes: {
+                                readonly type: "array";
+                                readonly maxItems: 2000;
+                                readonly uniqueItems: true;
+                                readonly items: {
+                                    readonly type: "string";
+                                    readonly pattern: "^[A-Za-z*][A-Za-z0-9:._*-]{0,254}$";
+                                    readonly maxLength: 255;
+                                };
+                            };
+                            readonly reason: {
+                                readonly type: "string";
+                                readonly minLength: 1;
+                                readonly maxLength: 2000;
+                                readonly pattern: "\\S";
+                            };
+                        };
+                    };
+                };
+            };
+        };
+        readonly events: {
+            readonly type: "object";
+            readonly additionalProperties: false;
+            readonly required: readonly ["subscriptions"];
+            readonly properties: {
+                readonly schemas: {
+                    readonly type: "array";
+                    readonly maxItems: 100;
+                    readonly items: {
+                        readonly type: "object";
+                    };
+                };
+                readonly subscriptions: {
+                    readonly type: "array";
+                    readonly maxItems: 100;
+                    readonly items: {
+                        readonly type: "object";
+                    };
+                };
+                readonly timers: {
+                    readonly type: "array";
+                    readonly maxItems: 100;
+                    readonly items: {
+                        readonly type: "object";
+                    };
+                };
+                readonly dateTriggers: {
+                    readonly type: "array";
+                    readonly maxItems: 100;
+                    readonly items: {
+                        readonly type: "object";
+                    };
+                };
+            };
+        };
+        readonly workflows: {
+            readonly type: "object";
+            readonly additionalProperties: false;
+            readonly required: readonly ["definitions", "bindings", "activations"];
+            readonly properties: {
+                readonly definitions: {
+                    readonly type: "array";
+                    readonly maxItems: 100;
+                    readonly items: {
+                        readonly type: "object";
+                    };
+                };
+                readonly bindings: {
+                    readonly type: "array";
+                    readonly maxItems: 100;
+                    readonly items: {
+                        readonly type: "object";
+                    };
+                };
+                readonly activations: {
+                    readonly type: "array";
+                    readonly maxItems: 100;
+                    readonly items: {
+                        readonly type: "object";
+                    };
+                };
+                readonly providers: {
+                    readonly type: "array";
+                    readonly maxItems: 100;
+                    readonly items: {
+                        readonly type: "object";
+                        readonly additionalProperties: false;
+                        readonly required: readonly ["code", "endpointPath"];
+                        readonly properties: {
+                            readonly code: {
+                                readonly type: "string";
+                                readonly pattern: "^[a-z][a-z0-9]*(?:[-_][a-z0-9]+)*$";
+                            };
+                            readonly endpointPath: {
+                                readonly type: "string";
+                                readonly pattern: "^/[A-Za-z0-9/_-]+$";
+                            };
+                            readonly timeoutMs: {
+                                readonly type: "integer";
+                                readonly minimum: 100;
+                                readonly maximum: 10000;
+                            };
+                        };
+                    };
+                };
+                readonly editableParameters: {
+                    readonly type: "array";
+                    readonly maxItems: 100;
+                    readonly items: {
+                        readonly type: "object";
+                    };
+                };
+            };
+        };
+    };
+};
+/**
+ * A backend is opt-in for a resource-only application. Explicit backend
+ * declarations (operations, secrets, events or workflows) still imply it.
+ */
+export declare function backendRuntimeRequired(config: OpenXiangdaAppConfig): boolean;
+export declare function validateAppConfig(value: unknown): Diagnostic[];
+export declare class AppConfigValidationError extends Error {
+    readonly diagnostics: Diagnostic[];
+    readonly code = "OPENXIANGDA_APP_CONFIG_INVALID";
+    constructor(diagnostics: Diagnostic[]);
+}
+export declare function resourceCapabilityCodes(appCode: string, resourceCode: string): {
+    readonly read: `${string}:read`;
+    readonly create: `${string}:create`;
+    readonly update: `${string}:update`;
+    readonly delete: `${string}:delete`;
+};
+export declare function currentUserDataPolicy(input: {
+    code: string;
+    name: string;
+    resourceCode: string;
+    field: string;
+    roleCodes: string[];
+    unrestrictedRoleCodes?: string[];
+}): AppDataPolicyDeclaration;
+export declare const dataPolicyExpression: {
+    readonly allOf: (...values: AppDataPolicyExpressionDeclaration[]) => AppDataPolicyExpressionDeclaration;
+    readonly anyOf: (...values: AppDataPolicyExpressionDeclaration[]) => AppDataPolicyExpressionDeclaration;
+    readonly constant: (input: {
+        field: string;
+        operator: "eq" | "not_eq" | "in" | "not_in";
+        value: string | string[];
+        roleCodes?: string[];
+    }) => AppDataPolicyRuleDeclaration;
+    readonly null: (input: {
+        field: string;
+        operator: "is_null" | "is_not_null";
+        roleCodes?: string[];
+    }) => AppDataPolicyRuleDeclaration;
+    readonly databaseNow: (input: {
+        field: string;
+        operator: "lt" | "lte" | "gt" | "gte";
+        roleCodes?: string[];
+    }) => AppDataPolicyRuleDeclaration;
+    readonly currentUser: (input: {
+        field: string;
+        roleCodes?: string[];
+    }) => AppDataPolicyRuleDeclaration;
+    readonly dimension: (input: {
+        dimensionCode: string;
+        field: string;
+        roleCodes?: string[];
+        operation?: string;
+        valuePath?: string;
+        emptyMatchesAll?: boolean;
+    }) => AppDataPolicyRuleDeclaration;
+    readonly relation: (input: {
+        relationCode: string;
+        resourceCode: string;
+        field: string;
+        roleCodes?: string[];
+        operation?: string;
+        valuePath?: string;
+    }) => AppDataPolicyRuleDeclaration;
+};
+export declare function resourceReadPolicy(input: {
+    code: string;
+    name: string;
+    resourceCode: string;
+    expression: AppDataPolicyExpressionDeclaration;
+    unrestrictedRoleCodes?: string[];
+} & ({
+    matchMode: 'AND' | 'OR';
+    rules: AppDataPolicyRuleDeclaration[];
+    writeBoundary?: never;
+} | {
+    matchMode?: never;
+    rules?: never;
+    writeBoundary: 'capability_only';
+})): AppDataPolicyDeclaration;
+export declare function materializeDataResource(appCode: string, declaration: AppDataResourceDeclaration): DataResource;
+export declare function validateAppDeclaration(value: unknown): Diagnostic[];
+export declare function defineOpenXiangdaApp(declaration: OpenXiangdaAppDeclaration): OpenXiangdaAppConfig;
+export {};
+//# sourceMappingURL=config.d.ts.map