openxiangda-contracts 2.0.0-alpha.12

package/dist/schemas.js

@@ -0,0 +1,2216 @@
+import { OPENXIANGDA_CONTRACT_VERSION, SCHEMA_VERSIONS } from "./types.js";
+const digest = { type: "string", pattern: "^[0-9a-f]{64}$" };
+const dateTime = { type: "string", format: "date-time" };
+const nonEmptyString = { type: "string", minLength: 1 };
+export const diagnosticSchema = {
+    $id: SCHEMA_VERSIONS.diagnostic,
+    type: "object",
+    additionalProperties: false,
+    required: ["schemaVersion", "code", "severity", "message", "retryable"],
+    properties: {
+        schemaVersion: { const: SCHEMA_VERSIONS.diagnostic },
+        code: nonEmptyString,
+        severity: { enum: ["info", "warning", "error"] },
+        message: nonEmptyString,
+        path: { type: "string" },
+        source: { type: "string" },
+        retryable: { type: "boolean" },
+        remediation: { type: "string" },
+        details: { type: "object" },
+    },
+};
+export const workspaceContextSchema = {
+    $id: SCHEMA_VERSIONS.workspaceContext,
+    type: "object",
+    additionalProperties: false,
+    required: [
+        "schemaVersion",
+        "workspace",
+        "roots",
+        "toolchain",
+        "environments",
+        "changedDomains",
+    ],
+    properties: {
+        schemaVersion: { const: SCHEMA_VERSIONS.workspaceContext },
+        workspace: {
+            type: "object",
+            additionalProperties: false,
+            required: ["appCode", "root"],
+            properties: {
+                appCode: nonEmptyString,
+                name: { type: "string" },
+                root: nonEmptyString,
+                repository: { type: "string" },
+                revision: { type: "string" },
+                dirty: { type: "boolean" },
+            },
+        },
+        roots: {
+            type: "object",
+            additionalProperties: false,
+            required: ["frontend", "backend", "platform"],
+            properties: {
+                frontend: nonEmptyString,
+                backend: nonEmptyString,
+                platform: nonEmptyString,
+            },
+        },
+        toolchain: {
+            type: "object",
+            additionalProperties: false,
+            required: ["version", "contractVersion", "nodeVersion", "packageManager"],
+            properties: {
+                version: nonEmptyString,
+                contractVersion: { const: OPENXIANGDA_CONTRACT_VERSION },
+                nodeVersion: nonEmptyString,
+                packageManager: nonEmptyString,
+            },
+        },
+        environments: {
+            type: "array",
+            items: {
+                type: "object",
+                additionalProperties: false,
+                required: ["name", "kind"],
+                properties: {
+                    id: { type: "string" },
+                    name: nonEmptyString,
+                    kind: {
+                        enum: ["development", "preproduction", "production"],
+                    },
+                },
+            },
+        },
+        changedDomains: {
+            type: "array",
+            uniqueItems: true,
+            items: {
+                enum: [
+                    "frontend",
+                    "backend",
+                    "data",
+                    "authz",
+                    "events",
+                    "workflow",
+                    "config",
+                ],
+            },
+        },
+    },
+};
+export const applicationSchema = {
+    $id: SCHEMA_VERSIONS.application,
+    type: "object",
+    additionalProperties: false,
+    required: ["schemaVersion", "created", "application", "bootstrapAdminRole"],
+    properties: {
+        schemaVersion: { const: SCHEMA_VERSIONS.application },
+        created: { type: "boolean" },
+        application: {
+            type: "object",
+            additionalProperties: false,
+            required: ["id", "appCode", "name", "runtimeMode"],
+            properties: {
+                id: nonEmptyString,
+                appCode: nonEmptyString,
+                name: nonEmptyString,
+                description: { type: ["string", "null"] },
+                runtimeMode: { const: "react-spa" },
+                createdAt: { anyOf: [dateTime, { type: "null" }] },
+                updatedAt: { anyOf: [dateTime, { type: "null" }] },
+            },
+        },
+        bootstrapAdminRole: {
+            type: "object",
+            additionalProperties: false,
+            required: ["code"],
+            properties: { code: nonEmptyString },
+        },
+    },
+};
+export const principalSchema = {
+    $id: SCHEMA_VERSIONS.principal,
+    type: "object",
+    additionalProperties: false,
+    required: [
+        "schemaVersion",
+        "tenantId",
+        "appCode",
+        "environmentId",
+        "principalType",
+        "subjectId",
+        "authzVersion",
+        "isAppSuperAdmin",
+    ],
+    properties: {
+        schemaVersion: { const: SCHEMA_VERSIONS.principal },
+        tenantId: nonEmptyString,
+        appCode: nonEmptyString,
+        environmentId: nonEmptyString,
+        principalType: { enum: ["user", "service", "public"] },
+        subjectId: nonEmptyString,
+        userId: { type: "string" },
+        loginSessionId: { type: "string" },
+        roleSessionId: { type: "string" },
+        activeRoleAssignmentId: { type: "string" },
+        activeRoleCode: { type: "string" },
+        clientRecordId: { type: "string" },
+        clientId: { type: "string" },
+        credentialVersion: { type: "integer", minimum: 1 },
+        environmentKey: { type: "string" },
+        scopes: { type: "array", items: nonEmptyString },
+        rateLimitPerMinute: { type: "integer", minimum: 1 },
+        tokenId: { type: "string" },
+        authzVersion: { type: "integer", minimum: 0 },
+        isAppSuperAdmin: { type: "boolean" },
+    },
+};
+export const roleSessionSchema = {
+    $id: SCHEMA_VERSIONS.roleSession,
+    type: "object",
+    additionalProperties: false,
+    required: [
+        "schemaVersion",
+        "id",
+        "loginSessionId",
+        "tenantId",
+        "appCode",
+        "userId",
+        "activeRoleAssignmentId",
+        "activeRoleCode",
+        "authzVersion",
+        "issuedAt",
+        "expiresAt",
+        "lastUsedAt",
+    ],
+    properties: {
+        schemaVersion: { const: SCHEMA_VERSIONS.roleSession },
+        id: nonEmptyString,
+        loginSessionId: nonEmptyString,
+        tenantId: nonEmptyString,
+        appCode: nonEmptyString,
+        userId: nonEmptyString,
+        activeRoleAssignmentId: nonEmptyString,
+        activeRoleCode: nonEmptyString,
+        authzVersion: { type: "integer", minimum: 0 },
+        issuedAt: dateTime,
+        expiresAt: dateTime,
+        lastUsedAt: dateTime,
+    },
+};
+export const roleAssignmentSchema = {
+    $id: SCHEMA_VERSIONS.roleAssignment,
+    type: "object",
+    additionalProperties: false,
+    required: [
+        "schemaVersion",
+        "id",
+        "tenantId",
+        "appCode",
+        "userId",
+        "role",
+        "status",
+        "revision",
+        "scopeGrants",
+        "createdAt",
+        "updatedAt",
+    ],
+    properties: {
+        schemaVersion: { const: SCHEMA_VERSIONS.roleAssignment },
+        id: nonEmptyString,
+        tenantId: nonEmptyString,
+        appCode: nonEmptyString,
+        userId: nonEmptyString,
+        role: {
+            type: "object",
+            additionalProperties: false,
+            required: ["id", "code", "name", "isAppSuperAdmin"],
+            properties: {
+                id: nonEmptyString,
+                code: nonEmptyString,
+                name: nonEmptyString,
+                isAppSuperAdmin: { type: "boolean" },
+            },
+        },
+        status: { enum: ["active", "revoked", "expired"] },
+        revision: { type: "integer", minimum: 1 },
+        scopeGrants: {
+            type: "array",
+            items: {
+                type: "object",
+                additionalProperties: false,
+                required: ["dimensionCode", "values", "operations"],
+                properties: {
+                    dimensionCode: nonEmptyString,
+                    values: {
+                        type: "array",
+                        uniqueItems: true,
+                        minItems: 1,
+                        items: nonEmptyString,
+                    },
+                    operations: {
+                        type: "array",
+                        uniqueItems: true,
+                        minItems: 1,
+                        items: nonEmptyString,
+                    },
+                },
+            },
+        },
+        validFrom: { anyOf: [dateTime, { type: "null" }] },
+        validTo: { anyOf: [dateTime, { type: "null" }] },
+        createdAt: dateTime,
+        updatedAt: dateTime,
+    },
+};
+export const relationshipGrantSchema = {
+    $id: SCHEMA_VERSIONS.relationshipGrant,
+    type: "object",
+    additionalProperties: false,
+    required: [
+        "schemaVersion",
+        "id",
+        "tenantId",
+        "appCode",
+        "relationCode",
+        "subjectType",
+        "subjectKey",
+        "resourceCode",
+        "resourceId",
+        "operations",
+        "sourceCode",
+        "status",
+        "revision",
+        "createdAt",
+        "updatedAt",
+    ],
+    properties: {
+        schemaVersion: { const: SCHEMA_VERSIONS.relationshipGrant },
+        id: nonEmptyString,
+        tenantId: nonEmptyString,
+        appCode: nonEmptyString,
+        relationCode: nonEmptyString,
+        subjectType: { enum: ["user", "role_assignment"] },
+        subjectKey: nonEmptyString,
+        resourceCode: nonEmptyString,
+        resourceId: nonEmptyString,
+        operations: {
+            type: "array",
+            minItems: 1,
+            uniqueItems: true,
+            items: nonEmptyString,
+        },
+        sourceCode: nonEmptyString,
+        status: { enum: ["active", "revoked", "expired"] },
+        revision: { type: "integer", minimum: 1 },
+        validFrom: { anyOf: [dateTime, { type: "null" }] },
+        validTo: { anyOf: [dateTime, { type: "null" }] },
+        createdAt: dateTime,
+        updatedAt: dateTime,
+    },
+};
+export const authorizationDecisionSchema = {
+    $id: SCHEMA_VERSIONS.authorizationDecision,
+    type: "object",
+    additionalProperties: false,
+    required: [
+        "schemaVersion",
+        "explainId",
+        "allowed",
+        "principal",
+        "roleSession",
+        "decisions",
+    ],
+    properties: {
+        schemaVersion: { const: SCHEMA_VERSIONS.authorizationDecision },
+        explainId: nonEmptyString,
+        allowed: { type: "boolean" },
+        principal: { $ref: SCHEMA_VERSIONS.principal },
+        roleSession: { $ref: SCHEMA_VERSIONS.roleSession },
+        decisions: {
+            type: "array",
+            minItems: 1,
+            items: {
+                type: "object",
+                required: ["layer", "allowed"],
+                properties: {
+                    layer: {
+                        enum: ["app_super_admin", "rbac", "data_policy", "field_policy"],
+                    },
+                    allowed: { type: "boolean" },
+                    reason: { type: "string" },
+                    detail: { type: "object" },
+                },
+            },
+        },
+    },
+};
+const authorizationExplainRequestSchema = {
+    type: "object",
+    additionalProperties: false,
+    required: ["key", "capability"],
+    properties: {
+        key: { type: "string", minLength: 1, maxLength: 128 },
+        capability: { type: "string", minLength: 1, maxLength: 255 },
+        dataPolicyCode: { type: "string", minLength: 1, maxLength: 128 },
+        operation: { type: "string", minLength: 1, maxLength: 64 },
+        data: { type: "object" },
+    },
+};
+export const authorizationBatchRequestSchema = {
+    $id: SCHEMA_VERSIONS.authorizationBatchRequest,
+    type: "object",
+    additionalProperties: false,
+    required: ["schemaVersion", "requests"],
+    properties: {
+        schemaVersion: { const: SCHEMA_VERSIONS.authorizationBatchRequest },
+        requests: {
+            type: "array",
+            minItems: 1,
+            maxItems: 200,
+            items: authorizationExplainRequestSchema,
+        },
+    },
+};
+export const authorizationBatchResultSchema = {
+    $id: SCHEMA_VERSIONS.authorizationBatchResult,
+    type: "object",
+    additionalProperties: false,
+    required: ["schemaVersion", "principal", "roleSession", "items"],
+    properties: {
+        schemaVersion: { const: SCHEMA_VERSIONS.authorizationBatchResult },
+        principal: { $ref: SCHEMA_VERSIONS.principal },
+        roleSession: { $ref: SCHEMA_VERSIONS.roleSession },
+        items: {
+            type: "array",
+            minItems: 1,
+            maxItems: 200,
+            items: {
+                type: "object",
+                additionalProperties: false,
+                required: ["key", "decision"],
+                properties: {
+                    key: authorizationExplainRequestSchema.properties.key,
+                    decision: { $ref: SCHEMA_VERSIONS.authorizationDecision },
+                },
+            },
+        },
+    },
+};
+const directoryKindSchema = { enum: ["department", "user"] };
+const directoryEntrySchema = {
+    type: "object",
+    additionalProperties: false,
+    required: ["kind", "id", "label"],
+    properties: {
+        kind: directoryKindSchema,
+        id: nonEmptyString,
+        label: nonEmptyString,
+        description: { type: "string" },
+        path: {
+            type: "array",
+            items: {
+                type: "object",
+                additionalProperties: false,
+                required: ["id", "label"],
+                properties: { id: nonEmptyString, label: nonEmptyString },
+            },
+        },
+    },
+};
+export const directoryResolveRequestSchema = {
+    $id: SCHEMA_VERSIONS.directoryResolveRequest,
+    type: "object",
+    additionalProperties: false,
+    required: ["schemaVersion", "kind", "ids"],
+    properties: {
+        schemaVersion: { const: SCHEMA_VERSIONS.directoryResolveRequest },
+        kind: directoryKindSchema,
+        ids: {
+            type: "array",
+            minItems: 1,
+            maxItems: 50,
+            uniqueItems: true,
+            items: nonEmptyString,
+        },
+    },
+};
+export const directorySearchResultSchema = {
+    $id: SCHEMA_VERSIONS.directorySearchResult,
+    type: "object",
+    additionalProperties: false,
+    required: ["schemaVersion", "kind", "items", "total"],
+    properties: {
+        schemaVersion: { const: SCHEMA_VERSIONS.directorySearchResult },
+        kind: directoryKindSchema,
+        items: {
+            type: "array",
+            maxItems: 50,
+            items: directoryEntrySchema,
+        },
+        total: { type: "integer", minimum: 0 },
+    },
+};
+export const dataRefSchema = {
+    $id: SCHEMA_VERSIONS.dataRef,
+    type: "object",
+    additionalProperties: false,
+    required: ["schemaVersion", "appCode", "resource", "recordId", "revision"],
+    properties: {
+        schemaVersion: { const: SCHEMA_VERSIONS.dataRef },
+        appCode: nonEmptyString,
+        resource: nonEmptyString,
+        recordId: nonEmptyString,
+        revision: { type: "integer", minimum: 0 },
+        environmentId: { type: "string" },
+    },
+};
+const dataFieldCode = {
+    type: "string",
+    pattern: "^[A-Za-z][A-Za-z0-9_]{0,62}$",
+};
+const dataResourceCode = {
+    type: "string",
+    pattern: "^[A-Za-z][A-Za-z0-9_]{0,63}$",
+};
+const dataCapabilities = {
+    type: "object",
+    additionalProperties: false,
+    required: ["read", "create", "update", "delete"],
+    properties: {
+        read: nonEmptyString,
+        create: nonEmptyString,
+        update: nonEmptyString,
+        delete: nonEmptyString,
+    },
+};
+export const dataResourceSchema = {
+    $id: SCHEMA_VERSIONS.dataResource,
+    type: "object",
+    additionalProperties: false,
+    required: [
+        "schemaVersion",
+        "appCode",
+        "code",
+        "name",
+        "schema",
+        "capabilities",
+        "fieldPolicies",
+    ],
+    properties: {
+        schemaVersion: { const: SCHEMA_VERSIONS.dataResource },
+        id: { type: "string" },
+        tenantId: { type: "string" },
+        appCode: nonEmptyString,
+        code: dataResourceCode,
+        name: nonEmptyString,
+        schema: {
+            type: "object",
+            additionalProperties: false,
+            required: ["fields"],
+            properties: {
+                fields: {
+                    type: "array",
+                    minItems: 1,
+                    maxItems: 100,
+                    items: {
+                        type: "object",
+                        additionalProperties: false,
+                        required: ["code", "type"],
+                        properties: {
+                            code: dataFieldCode,
+                            type: {
+                                enum: [
+                                    "string",
+                                    "text",
+                                    "integer",
+                                    "decimal",
+                                    "boolean",
+                                    "date",
+                                    "datetime",
+                                    "uuid",
+                                    "json",
+                                    "file",
+                                ],
+                            },
+                            nullable: { type: "boolean" },
+                            indexed: { type: "boolean" },
+                            file: {
+                                type: "object",
+                                additionalProperties: false,
+                                properties: {
+                                    multiple: { type: "boolean" },
+                                    maxCount: { type: "integer", minimum: 1, maximum: 20 },
+                                    maxSizeMb: { type: "integer", minimum: 1, maximum: 1024 },
+                                    accept: {
+                                        type: "array",
+                                        uniqueItems: true,
+                                        maxItems: 50,
+                                        items: nonEmptyString,
+                                    },
+                                },
+                            },
+                        },
+                    },
+                },
+            },
+        },
+        capabilities: dataCapabilities,
+        dataPolicyCode: {
+            anyOf: [dataResourceCode, { type: "null" }],
+        },
+        fieldPolicies: {
+            type: "object",
+            additionalProperties: {
+                type: "object",
+                additionalProperties: false,
+                properties: {
+                    read: {
+                        type: "array",
+                        uniqueItems: true,
+                        maxItems: 20,
+                        items: nonEmptyString,
+                    },
+                    write: {
+                        type: "array",
+                        uniqueItems: true,
+                        maxItems: 20,
+                        items: nonEmptyString,
+                    },
+                    mask: { enum: ["omit", "null"] },
+                },
+            },
+        },
+        status: { enum: ["active", "retired"] },
+        revision: { type: "integer", minimum: 1 },
+        createdAt: dateTime,
+        updatedAt: dateTime,
+    },
+};
+const dataQueryFilter = {
+    type: "object",
+    additionalProperties: false,
+    required: ["field", "operator", "value"],
+    properties: {
+        field: dataFieldCode,
+        operator: {
+            enum: [
+                "eq",
+                "neq",
+                "gt",
+                "gte",
+                "lt",
+                "lte",
+                "like",
+                "ilike",
+                "in",
+                "is",
+                "cs",
+                "cd",
+                "ov",
+            ],
+        },
+        value: {},
+    },
+};
+export const dataQuerySchema = {
+    $id: SCHEMA_VERSIONS.dataQuery,
+    type: "object",
+    additionalProperties: false,
+    required: ["schemaVersion"],
+    properties: {
+        schemaVersion: { const: SCHEMA_VERSIONS.dataQuery },
+        select: {
+            type: "array",
+            uniqueItems: true,
+            maxItems: 100,
+            items: dataFieldCode,
+        },
+        filters: {
+            type: "array",
+            maxItems: 50,
+            items: dataQueryFilter,
+        },
+        order: {
+            type: "array",
+            maxItems: 10,
+            items: {
+                type: "object",
+                additionalProperties: false,
+                required: ["field"],
+                properties: {
+                    field: dataFieldCode,
+                    direction: { enum: ["asc", "desc"] },
+                    nulls: { enum: ["first", "last"] },
+                },
+            },
+        },
+        limit: { type: "integer", minimum: 1, maximum: 1000 },
+        offset: { type: "integer", minimum: 0, maximum: 1000000 },
+    },
+};
+export const dataPageSchema = {
+    $id: SCHEMA_VERSIONS.dataPage,
+    type: "object",
+    additionalProperties: false,
+    required: [
+        "schemaVersion",
+        "resourceCode",
+        "items",
+        "total",
+        "limit",
+        "offset",
+    ],
+    properties: {
+        schemaVersion: { const: SCHEMA_VERSIONS.dataPage },
+        resourceCode: dataResourceCode,
+        items: { type: "array", items: { type: "object" } },
+        total: { type: "integer", minimum: 0 },
+        limit: { type: "integer", minimum: 1, maximum: 1000 },
+        offset: { type: "integer", minimum: 0 },
+    },
+};
+export const dataRecordSchema = {
+    $id: SCHEMA_VERSIONS.dataRecord,
+    type: "object",
+    additionalProperties: false,
+    required: ["schemaVersion", "resourceCode", "data"],
+    properties: {
+        schemaVersion: { const: SCHEMA_VERSIONS.dataRecord },
+        resourceCode: dataResourceCode,
+        data: { type: "object" },
+    },
+};
+const dataAggregateAlias = {
+    type: "string",
+    pattern: "^[A-Za-z][A-Za-z0-9_]{0,62}$",
+};
+export const dataAggregateQuerySchema = {
+    $id: SCHEMA_VERSIONS.dataAggregateQuery,
+    type: "object",
+    additionalProperties: false,
+    required: ["schemaVersion", "measures"],
+    properties: {
+        schemaVersion: { const: SCHEMA_VERSIONS.dataAggregateQuery },
+        dimensions: {
+            type: "array",
+            maxItems: 3,
+            items: {
+                type: "object",
+                additionalProperties: false,
+                required: ["field", "as"],
+                properties: {
+                    field: dataFieldCode,
+                    as: dataAggregateAlias,
+                    bucket: { enum: ["day", "week", "month", "quarter", "year"] },
+                },
+            },
+        },
+        measures: {
+            type: "array",
+            minItems: 1,
+            maxItems: 8,
+            items: {
+                type: "object",
+                additionalProperties: false,
+                required: ["type", "as"],
+                properties: {
+                    type: { enum: ["count", "countDistinct", "sum", "avg", "min", "max"] },
+                    field: dataFieldCode,
+                    as: dataAggregateAlias,
+                },
+            },
+        },
+        filters: dataQuerySchema.properties.filters,
+        order: {
+            type: "array",
+            maxItems: 10,
+            items: {
+                type: "object",
+                additionalProperties: false,
+                required: ["field"],
+                properties: {
+                    field: dataAggregateAlias,
+                    direction: { enum: ["asc", "desc"] },
+                    nulls: { enum: ["first", "last"] },
+                },
+            },
+        },
+        limit: { type: "integer", minimum: 1, maximum: 100 },
+        offset: { type: "integer", minimum: 0, maximum: 1000000 },
+    },
+};
+export const dataAggregatePageSchema = {
+    $id: SCHEMA_VERSIONS.dataAggregatePage,
+    type: "object",
+    additionalProperties: false,
+    required: ["schemaVersion", "resourceCode", "items", "total", "limit", "offset"],
+    properties: {
+        schemaVersion: { const: SCHEMA_VERSIONS.dataAggregatePage },
+        resourceCode: dataResourceCode,
+        items: { type: "array", items: { type: "object" } },
+        total: { type: "integer", minimum: 0 },
+        limit: { type: "integer", minimum: 1, maximum: 100 },
+        offset: { type: "integer", minimum: 0 },
+    },
+};
+export const dataAuditPageSchema = {
+    $id: SCHEMA_VERSIONS.dataAuditPage,
+    type: "object",
+    additionalProperties: false,
+    required: ["schemaVersion", "resourceCode", "recordId", "items", "total", "limit", "offset"],
+    properties: {
+        schemaVersion: { const: SCHEMA_VERSIONS.dataAuditPage },
+        resourceCode: dataResourceCode,
+        recordId: nonEmptyString,
+        items: { type: "array", items: { type: "object" } },
+        total: { type: "integer", minimum: 0 },
+        limit: { type: "integer", minimum: 1, maximum: 100 },
+        offset: { type: "integer", minimum: 0 },
+    },
+};
+export const dataFileRefSchema = {
+    $id: SCHEMA_VERSIONS.dataFileRef,
+    type: "object",
+    additionalProperties: false,
+    required: ["schemaVersion", "id", "name", "size", "contentType"],
+    properties: {
+        schemaVersion: { const: SCHEMA_VERSIONS.dataFileRef },
+        id: nonEmptyString,
+        name: nonEmptyString,
+        size: { type: "integer", minimum: 0 },
+        contentType: { type: "string" },
+    },
+};
+export const dataFileUploadPlanSchema = {
+    $id: SCHEMA_VERSIONS.dataFileUploadPlan,
+    type: "object",
+    additionalProperties: false,
+    required: ["schemaVersion", "resourceCode", "fieldCode", "file", "uploadMethod", "uploadUrl", "headers", "expiresAt"],
+    properties: {
+        schemaVersion: { const: SCHEMA_VERSIONS.dataFileUploadPlan },
+        resourceCode: dataResourceCode,
+        fieldCode: dataFieldCode,
+        file: { $ref: SCHEMA_VERSIONS.dataFileRef },
+        uploadMethod: { const: "PUT" },
+        uploadUrl: nonEmptyString,
+        headers: { type: "object", additionalProperties: { type: "string" } },
+        expiresAt: dateTime,
+    },
+};
+const dataTransactionOperation = {
+    oneOf: [
+        {
+            type: "object",
+            additionalProperties: false,
+            required: ["operation", "resourceCode", "data"],
+            properties: {
+                operation: { const: "create" },
+                resourceCode: dataResourceCode,
+                data: { type: "object" },
+            },
+        },
+        {
+            type: "object",
+            additionalProperties: false,
+            required: ["operation", "resourceCode", "id", "expectedRevision", "data"],
+            properties: {
+                operation: { const: "update" },
+                resourceCode: dataResourceCode,
+                id: nonEmptyString,
+                expectedRevision: { type: "integer", minimum: 1 },
+                data: { type: "object" },
+            },
+        },
+        {
+            type: "object",
+            additionalProperties: false,
+            required: ["operation", "resourceCode", "id", "expectedRevision"],
+            properties: {
+                operation: { const: "delete" },
+                resourceCode: dataResourceCode,
+                id: nonEmptyString,
+                expectedRevision: { type: "integer", minimum: 1 },
+            },
+        },
+    ],
+};
+export const dataTransactionRequestSchema = {
+    $id: SCHEMA_VERSIONS.dataTransactionRequest,
+    type: "object",
+    additionalProperties: false,
+    required: ["schemaVersion", "idempotencyKey", "operations"],
+    properties: {
+        schemaVersion: { const: SCHEMA_VERSIONS.dataTransactionRequest },
+        idempotencyKey: nonEmptyString,
+        operations: {
+            type: "array",
+            minItems: 1,
+            maxItems: 100,
+            items: dataTransactionOperation,
+        },
+    },
+};
+export const dataTransactionResultSchema = {
+    $id: SCHEMA_VERSIONS.dataTransactionResult,
+    type: "object",
+    additionalProperties: false,
+    required: ["schemaVersion", "idempotencyKey", "replayed", "items"],
+    properties: {
+        schemaVersion: { const: SCHEMA_VERSIONS.dataTransactionResult },
+        idempotencyKey: nonEmptyString,
+        replayed: { type: "boolean" },
+        items: {
+            type: "array",
+            maxItems: 100,
+            items: {
+                type: "object",
+                additionalProperties: false,
+                required: ["index", "resourceCode", "operation", "id", "revision"],
+                properties: {
+                    index: { type: "integer", minimum: 0 },
+                    resourceCode: dataResourceCode,
+                    operation: { enum: ["create", "update", "delete"] },
+                    id: nonEmptyString,
+                    revision: { type: "integer", minimum: 1 },
+                },
+            },
+        },
+    },
+};
+export const appPackageSchema = {
+    $id: SCHEMA_VERSIONS.appPackage,
+    type: "object",
+    additionalProperties: false,
+    required: [
+        "schemaVersion",
+        "appCode",
+        "version",
+        "createdAt",
+        "source",
+        "toolchain",
+        "artifacts",
+        "manifests",
+        "compatibility",
+    ],
+    properties: {
+        schemaVersion: { const: SCHEMA_VERSIONS.appPackage },
+        appCode: nonEmptyString,
+        version: nonEmptyString,
+        createdAt: dateTime,
+        source: {
+            type: "object",
+            additionalProperties: false,
+            required: ["repository", "commit", "dirty"],
+            properties: {
+                repository: nonEmptyString,
+                commit: nonEmptyString,
+                dirty: { type: "boolean" },
+            },
+        },
+        toolchain: {
+            type: "object",
+            additionalProperties: false,
+            required: ["version", "contractVersion"],
+            properties: {
+                version: nonEmptyString,
+                contractVersion: { const: OPENXIANGDA_CONTRACT_VERSION },
+            },
+        },
+        artifacts: {
+            type: "array",
+            items: {
+                type: "object",
+                additionalProperties: false,
+                required: ["kind", "digest", "mediaType"],
+                properties: {
+                    kind: {
+                        enum: ["frontend", "backend", "config", "contracts"],
+                    },
+                    digest,
+                    mediaType: nonEmptyString,
+                    size: { type: "integer", minimum: 0 },
+                    entrypoint: { type: "string" },
+                    metadata: { type: "object" },
+                },
+            },
+        },
+        manifests: {
+            type: "object",
+            additionalProperties: false,
+            properties: {
+                frontend: digest,
+                backend: digest,
+                config: digest,
+                dataContract: digest,
+            },
+        },
+        compatibility: {
+            type: "object",
+            additionalProperties: false,
+            required: ["minimumPlatformVersion", "requiredCapabilities"],
+            properties: {
+                minimumPlatformVersion: nonEmptyString,
+                requiredCapabilities: {
+                    type: "array",
+                    uniqueItems: true,
+                    items: nonEmptyString,
+                },
+            },
+        },
+        metadata: { type: "object" },
+    },
+};
+const componentRevisions = {
+    type: "object",
+    additionalProperties: false,
+    required: ["frontend", "backend", "config", "dataContract"],
+    properties: {
+        frontend: { type: ["string", "null"] },
+        backend: { type: ["string", "null"] },
+        config: { type: ["string", "null"] },
+        dataContract: { type: ["string", "null"] },
+    },
+};
+export const appVersionSchema = {
+    $id: SCHEMA_VERSIONS.appVersion,
+    type: "object",
+    additionalProperties: false,
+    required: [
+        "schemaVersion",
+        "id",
+        "appCode",
+        "version",
+        "packageDigest",
+        "source",
+        "toolchain",
+        "revisions",
+        "metadata",
+        "createdBy",
+        "createdAt",
+    ],
+    properties: {
+        schemaVersion: { const: SCHEMA_VERSIONS.appVersion },
+        id: nonEmptyString,
+        appCode: nonEmptyString,
+        version: nonEmptyString,
+        packageDigest: digest,
+        source: appPackageSchema.properties.source,
+        toolchain: appPackageSchema.properties.toolchain,
+        revisions: componentRevisions,
+        metadata: { type: "object" },
+        createdBy: nonEmptyString,
+        createdAt: dateTime,
+    },
+};
+export const environmentHeadSchema = {
+    $id: SCHEMA_VERSIONS.environmentHead,
+    type: "object",
+    additionalProperties: false,
+    required: [
+        "schemaVersion",
+        "id",
+        "appCode",
+        "environmentKey",
+        "environmentId",
+        "environmentKind",
+        "activeAppVersionId",
+        "revisions",
+        "revision",
+        "activatedByDeploymentId",
+        "activatedBy",
+        "activatedAt",
+        "updatedAt",
+    ],
+    properties: {
+        schemaVersion: { const: SCHEMA_VERSIONS.environmentHead },
+        id: nonEmptyString,
+        appCode: nonEmptyString,
+        environmentKey: nonEmptyString,
+        environmentId: { type: ["string", "null"] },
+        environmentKind: {
+            enum: ["development", "preproduction", "production"],
+        },
+        activeAppVersionId: nonEmptyString,
+        revisions: componentRevisions,
+        revision: { type: "integer", minimum: 1 },
+        activatedByDeploymentId: nonEmptyString,
+        activatedBy: nonEmptyString,
+        activatedAt: dateTime,
+        updatedAt: dateTime,
+        activeAppVersion: {
+            anyOf: [appVersionSchema, { type: "null" }],
+        },
+    },
+};
+const deploymentStatus = {
+    enum: [
+        "queued",
+        "preparing",
+        "deploying",
+        "activating",
+        "verifying",
+        "succeeded",
+        "failed",
+        "cancelled",
+    ],
+};
+export const deploymentRunSchema = {
+    $id: SCHEMA_VERSIONS.deploymentRun,
+    type: "object",
+    additionalProperties: false,
+    required: [
+        "schemaVersion",
+        "id",
+        "appCode",
+        "environment",
+        "kind",
+        "packageDigest",
+        "idempotencyKey",
+        "status",
+        "stage",
+        "attempt",
+        "progress",
+        "checkpoints",
+        "result",
+        "requestedBy",
+        "createdAt",
+        "updatedAt",
+    ],
+    properties: {
+        schemaVersion: { const: SCHEMA_VERSIONS.deploymentRun },
+        id: nonEmptyString,
+        appCode: nonEmptyString,
+        environment: {
+            type: "object",
+            additionalProperties: false,
+            properties: {
+                id: { type: "string" },
+                kind: {
+                    enum: ["development", "preproduction", "production"],
+                },
+            },
+        },
+        kind: { enum: ["deploy", "promotion", "rollback"] },
+        packageDigest: digest,
+        idempotencyKey: nonEmptyString,
+        status: deploymentStatus,
+        stage: nonEmptyString,
+        attempt: { type: "integer", minimum: 1 },
+        progress: { type: "object" },
+        checkpoints: {
+            type: "array",
+            items: {
+                type: "object",
+                additionalProperties: false,
+                required: ["stage", "status", "at", "attempt"],
+                properties: {
+                    stage: nonEmptyString,
+                    status: deploymentStatus,
+                    at: dateTime,
+                    attempt: { type: "integer", minimum: 1 },
+                    component: { type: "string" },
+                    result: { type: "object" },
+                },
+            },
+        },
+        failure: {
+            type: "object",
+            additionalProperties: false,
+            required: ["code", "message", "retryable"],
+            properties: {
+                code: nonEmptyString,
+                message: nonEmptyString,
+                retryable: { type: "boolean" },
+                stage: { type: "string" },
+                component: { type: "string" },
+                details: { type: "object" },
+            },
+        },
+        result: { type: "object" },
+        requestedBy: nonEmptyString,
+        startedAt: dateTime,
+        finishedAt: dateTime,
+        createdAt: dateTime,
+        updatedAt: dateTime,
+    },
+};
+export const platformCapabilitiesSchema = {
+    $id: SCHEMA_VERSIONS.platformCapabilities,
+    type: "object",
+    additionalProperties: false,
+    required: [
+        "schemaVersion",
+        "apiVersion",
+        "contractVersion",
+        "platformVersion",
+        "features",
+        "deployment",
+    ],
+    properties: {
+        schemaVersion: { const: SCHEMA_VERSIONS.platformCapabilities },
+        apiVersion: { const: "v2" },
+        contractVersion: { const: OPENXIANGDA_CONTRACT_VERSION },
+        platformVersion: nonEmptyString,
+        features: {
+            type: "object",
+            additionalProperties: {
+                type: "object",
+                additionalProperties: false,
+                required: ["version", "status"],
+                properties: {
+                    version: nonEmptyString,
+                    status: { enum: ["available", "preview", "planned"] },
+                },
+            },
+        },
+        deployment: {
+            type: "object",
+            additionalProperties: false,
+            required: ["executionOwner", "durableRuns", "clientCanCheckpoint"],
+            properties: {
+                executionOwner: { const: "platform" },
+                durableRuns: { const: true },
+                clientCanCheckpoint: { const: false },
+            },
+        },
+        oauth2: {
+            type: "object",
+            additionalProperties: false,
+            required: [
+                "tokenEndpoint",
+                "grantTypes",
+                "clientAuthenticationMethods",
+                "accessTokenTtlSeconds",
+                "supportedScopes",
+                "environmentBoundClients",
+                "dualSecretRotation",
+                "defaultRotationGracePeriodSeconds",
+                "clientRateLimit",
+                "auditEvents",
+            ],
+            properties: {
+                tokenEndpoint: nonEmptyString,
+                grantTypes: {
+                    type: "array",
+                    items: { const: "client_credentials" },
+                },
+                clientAuthenticationMethods: {
+                    type: "array",
+                    items: { const: "client_secret_basic" },
+                },
+                accessTokenTtlSeconds: { type: "integer", minimum: 1 },
+                supportedScopes: { type: "array", items: nonEmptyString },
+                environmentBoundClients: { type: "boolean" },
+                dualSecretRotation: { type: "boolean" },
+                defaultRotationGracePeriodSeconds: { type: "integer", minimum: 0 },
+                clientRateLimit: { type: "boolean" },
+                auditEvents: { type: "boolean" },
+            },
+        },
+    },
+};
+export const cloudEventSchema = {
+    $id: SCHEMA_VERSIONS.cloudEvent,
+    type: "object",
+    additionalProperties: false,
+    required: [
+        "specversion",
+        "id",
+        "source",
+        "type",
+        "time",
+        "datacontenttype",
+        "data",
+        "tenantid",
+        "appcode",
+        "environment",
+        "schemaversion",
+    ],
+    properties: {
+        specversion: { const: "1.0" },
+        id: nonEmptyString,
+        source: nonEmptyString,
+        type: {
+            type: "string",
+            pattern: "^[A-Za-z0-9]+(?:[._-][A-Za-z0-9]+)+$",
+        },
+        subject: { type: "string" },
+        time: dateTime,
+        datacontenttype: { const: "application/json" },
+        dataschema: { type: "string" },
+        data: { type: "object" },
+        tenantid: nonEmptyString,
+        appcode: nonEmptyString,
+        environment: nonEmptyString,
+        traceid: { type: "string" },
+        schemaversion: nonEmptyString,
+    },
+};
+export const eventSubscriptionSchema = {
+    $id: SCHEMA_VERSIONS.eventSubscription,
+    type: "object",
+    additionalProperties: false,
+    required: [
+        "schemaVersion",
+        "id",
+        "appCode",
+        "code",
+        "description",
+        "eventTypes",
+        "subjectFilters",
+        "environmentKey",
+        "endpointPath",
+        "delivery",
+        "status",
+        "revision",
+        "createdAt",
+        "updatedAt",
+    ],
+    properties: {
+        schemaVersion: { const: SCHEMA_VERSIONS.eventSubscription },
+        id: nonEmptyString,
+        appCode: nonEmptyString,
+        code: { type: "string", pattern: "^[a-z][a-z0-9-]*$" },
+        description: { type: ["string", "null"] },
+        eventTypes: {
+            type: "array",
+            minItems: 1,
+            maxItems: 100,
+            uniqueItems: true,
+            items: nonEmptyString,
+        },
+        subjectFilters: {
+            type: "object",
+            additionalProperties: false,
+            properties: {
+                equals: { type: "string" },
+                prefix: { type: "string" },
+                suffix: { type: "string" },
+                contains: {
+                    anyOf: [
+                        { type: "string" },
+                        { type: "array", maxItems: 20, items: { type: "string" } },
+                    ],
+                },
+            },
+        },
+        environmentKey: nonEmptyString,
+        endpointPath: { type: "string", pattern: "^/(?!/)(?!.*\\.\\.).+" },
+        delivery: {
+            type: "object",
+            additionalProperties: false,
+            required: [
+                "timeoutMs",
+                "maxAttempts",
+                "initialBackoffMs",
+                "maxBackoffMs",
+            ],
+            properties: {
+                timeoutMs: { type: "integer", minimum: 100, maximum: 60000 },
+                maxAttempts: { type: "integer", minimum: 1, maximum: 32 },
+                initialBackoffMs: {
+                    type: "integer",
+                    minimum: 100,
+                    maximum: 300000,
+                },
+                maxBackoffMs: {
+                    type: "integer",
+                    minimum: 100,
+                    maximum: 3600000,
+                },
+            },
+        },
+        status: { enum: ["active", "paused"] },
+        revision: { type: "integer", minimum: 1 },
+        signingSecret: { type: "string" },
+        signingSecretVersion: { type: "integer", minimum: 1 },
+        signingSecretReturnedOnce: { type: "boolean" },
+        createdAt: dateTime,
+        updatedAt: dateTime,
+    },
+};
+export const eventDeliverySchema = {
+    $id: SCHEMA_VERSIONS.eventDelivery,
+    type: "object",
+    additionalProperties: false,
+    required: [
+        "schemaVersion",
+        "id",
+        "eventId",
+        "eventType",
+        "subject",
+        "subscriptionId",
+        "subscriptionCode",
+        "status",
+        "attempt",
+        "nextAttemptAt",
+        "deliveredAt",
+        "responseStatus",
+        "responseBodyPreview",
+        "lastError",
+        "replayOfDeliveryId",
+        "createdAt",
+        "updatedAt",
+    ],
+    properties: {
+        schemaVersion: { const: SCHEMA_VERSIONS.eventDelivery },
+        id: nonEmptyString,
+        eventId: nonEmptyString,
+        eventType: nonEmptyString,
+        subject: { type: ["string", "null"] },
+        subscriptionId: nonEmptyString,
+        subscriptionCode: nonEmptyString,
+        status: {
+            enum: [
+                "pending",
+                "delivering",
+                "retry_wait",
+                "succeeded",
+                "dead_lettered",
+            ],
+        },
+        attempt: { type: "integer", minimum: 0 },
+        nextAttemptAt: { anyOf: [dateTime, { type: "null" }] },
+        deliveredAt: { anyOf: [dateTime, { type: "null" }] },
+        responseStatus: { type: ["integer", "null"] },
+        responseBodyPreview: { type: ["string", "null"] },
+        lastError: { type: ["string", "null"] },
+        replayOfDeliveryId: { type: ["string", "null"] },
+        correlation: {
+            type: "object",
+            additionalProperties: false,
+            required: [
+                "eventId",
+                "requestId",
+                "traceId",
+                "environmentKey",
+                "eventOccurredAt",
+                "outboxStatus",
+                "outboxAttempts",
+                "outboxError",
+            ],
+            properties: {
+                eventId: nonEmptyString,
+                requestId: { type: ["string", "null"] },
+                traceId: { type: ["string", "null"] },
+                environmentKey: nonEmptyString,
+                eventOccurredAt: { anyOf: [dateTime, { type: "null" }] },
+                outboxStatus: { type: ["string", "null"] },
+                outboxAttempts: { type: "integer", minimum: 0 },
+                outboxError: { type: ["string", "null"] },
+            },
+        },
+        createdAt: dateTime,
+        updatedAt: dateTime,
+    },
+};
+export const eventReceiptCommandSchema = {
+    $id: SCHEMA_VERSIONS.eventReceiptCommand,
+    type: "object",
+    additionalProperties: false,
+    required: [
+        "schemaVersion",
+        "action",
+        "tenantId",
+        "appCode",
+        "environmentKey",
+        "subscriptionCode",
+        "eventId",
+        "deliveryId",
+    ],
+    properties: {
+        schemaVersion: { const: SCHEMA_VERSIONS.eventReceiptCommand },
+        action: { enum: ["claim", "complete", "release"] },
+        tenantId: nonEmptyString,
+        appCode: nonEmptyString,
+        environmentKey: nonEmptyString,
+        subscriptionCode: {
+            type: "string",
+            pattern: "^[a-z][a-z0-9]*(?:[-_][a-z0-9]+)*$",
+        },
+        eventId: nonEmptyString,
+        deliveryId: {
+            type: "string",
+            format: "uuid",
+        },
+        claimToken: {
+            type: "string",
+            format: "uuid",
+        },
+    },
+};
+export const eventReceiptResultSchema = {
+    $id: SCHEMA_VERSIONS.eventReceiptResult,
+    type: "object",
+    additionalProperties: false,
+    required: [
+        "schemaVersion",
+        "outcome",
+        "eventId",
+        "deliveryId",
+        "status",
+        "claimToken",
+        "attempts",
+        "leaseExpiresAt",
+        "completedAt",
+    ],
+    properties: {
+        schemaVersion: { const: SCHEMA_VERSIONS.eventReceiptResult },
+        outcome: { enum: ["claimed", "duplicate", "completed", "released"] },
+        eventId: nonEmptyString,
+        deliveryId: {
+            type: "string",
+            format: "uuid",
+        },
+        status: { enum: ["processing", "succeeded", "released"] },
+        claimToken: { type: ["string", "null"], format: "uuid" },
+        attempts: { type: "integer", minimum: 1 },
+        leaseExpiresAt: dateTime,
+        completedAt: { anyOf: [dateTime, { type: "null" }] },
+    },
+};
+export const applicationSecretSchema = {
+    $id: SCHEMA_VERSIONS.applicationSecret,
+    type: "object",
+    additionalProperties: true,
+    required: [
+        "schemaVersion",
+        "id",
+        "appCode",
+        "environmentKey",
+        "name",
+        "description",
+        "status",
+        "revision",
+        "hasValue",
+        "expiresAt",
+        "createdAt",
+        "updatedAt",
+    ],
+    properties: {
+        schemaVersion: { const: SCHEMA_VERSIONS.applicationSecret },
+        id: nonEmptyString,
+        appCode: nonEmptyString,
+        environmentKey: nonEmptyString,
+        name: { type: "string", pattern: "^[a-z][a-z0-9]*([-_][a-z0-9]+)*$" },
+        description: { type: ["string", "null"] },
+        status: { enum: ["active", "disabled", "deleted"] },
+        revision: { type: "integer", minimum: 1 },
+        hasValue: { type: "boolean" },
+        expiresAt: { anyOf: [dateTime, { type: "null" }] },
+        createdAt: dateTime,
+        updatedAt: dateTime,
+    },
+};
+export const timerSubscriptionSchema = {
+    $id: SCHEMA_VERSIONS.timerSubscription,
+    type: "object",
+    additionalProperties: false,
+    required: [
+        "schemaVersion",
+        "id",
+        "appCode",
+        "code",
+        "eventType",
+        "cronExpression",
+        "timezone",
+        "payload",
+        "environmentKey",
+        "status",
+        "revision",
+        "nextDueAt",
+        "lastFiredAt",
+        "createdAt",
+        "updatedAt",
+    ],
+    properties: {
+        schemaVersion: { const: SCHEMA_VERSIONS.timerSubscription },
+        id: nonEmptyString,
+        appCode: nonEmptyString,
+        code: { type: "string", pattern: "^[a-z][a-z0-9-]*$" },
+        eventType: nonEmptyString,
+        cronExpression: nonEmptyString,
+        timezone: nonEmptyString,
+        payload: { type: "object" },
+        environmentKey: nonEmptyString,
+        status: { enum: ["active", "paused"] },
+        revision: { type: "integer", minimum: 1 },
+        nextDueAt: { anyOf: [dateTime, { type: "null" }] },
+        lastFiredAt: { anyOf: [dateTime, { type: "null" }] },
+        createdAt: dateTime,
+        updatedAt: dateTime,
+    },
+};
+const workflowExpressionSchema = {
+    type: "object",
+    required: ["op"],
+    properties: {
+        op: {
+            enum: [
+                "literal",
+                "path",
+                "eq",
+                "neq",
+                "gt",
+                "gte",
+                "lt",
+                "lte",
+                "in",
+                "contains",
+                "and",
+                "or",
+                "not",
+                "exists",
+            ],
+        },
+        value: {},
+        path: { type: "string", pattern: "^[A-Za-z][A-Za-z0-9_.]{0,254}$" },
+        left: { type: "object" },
+        right: { type: "object" },
+        values: { type: "array", minItems: 1, items: { type: "object" } },
+    },
+};
+const workflowNodeSchema = {
+    oneOf: [
+        {
+            type: "object",
+            additionalProperties: false,
+            required: [
+                "id",
+                "kind",
+                "title",
+                "binding",
+                "mode",
+                "onApprove",
+                "onReject",
+            ],
+            properties: {
+                id: nonEmptyString,
+                kind: { const: "approval" },
+                title: nonEmptyString,
+                binding: nonEmptyString,
+                mode: { enum: ["single", "any", "all", "sequence"] },
+                onApprove: nonEmptyString,
+                onReject: nonEmptyString,
+                allowedOperations: {
+                    type: "array",
+                    uniqueItems: true,
+                    items: {
+                        enum: [
+                            "approve",
+                            "reject",
+                            "return",
+                            "transfer",
+                            "delegate",
+                            "add_assignee",
+                            "resubmit",
+                            "admin_reassign",
+                            "admin_override",
+                        ],
+                    },
+                },
+                returnTargets: {
+                    type: "array",
+                    uniqueItems: true,
+                    items: nonEmptyString,
+                },
+                fieldPolicy: {
+                    type: "object",
+                    additionalProperties: false,
+                    properties: {
+                        default: {
+                            enum: ["hidden", "readonly", "edit", "edit_required"],
+                        },
+                        fields: {
+                            type: "object",
+                            additionalProperties: {
+                                enum: ["hidden", "readonly", "edit", "edit_required"],
+                            },
+                        },
+                    },
+                },
+            },
+        },
+        {
+            type: "object",
+            additionalProperties: false,
+            required: ["id", "kind", "branches", "otherwise"],
+            properties: {
+                id: nonEmptyString,
+                kind: { const: "condition" },
+                title: { type: "string" },
+                branches: {
+                    type: "array",
+                    minItems: 1,
+                    items: {
+                        type: "object",
+                        additionalProperties: false,
+                        required: ["when", "target"],
+                        properties: {
+                            when: workflowExpressionSchema,
+                            target: nonEmptyString,
+                            label: { type: "string" },
+                        },
+                    },
+                },
+                otherwise: nonEmptyString,
+            },
+        },
+        {
+            type: "object",
+            additionalProperties: false,
+            required: ["id", "kind", "title", "outcome"],
+            properties: {
+                id: nonEmptyString,
+                kind: { const: "end" },
+                title: nonEmptyString,
+                outcome: nonEmptyString,
+            },
+        },
+    ],
+};
+export const workflowDefinitionSchema = {
+    $id: SCHEMA_VERSIONS.workflowDefinition,
+    type: "object",
+    additionalProperties: false,
+    required: [
+        "schemaVersion",
+        "code",
+        "title",
+        "startAt",
+        "inputSchema",
+        "nodes",
+    ],
+    properties: {
+        schemaVersion: { const: SCHEMA_VERSIONS.workflowDefinition },
+        code: { type: "string", pattern: "^[A-Za-z][A-Za-z0-9_-]{0,127}$" },
+        title: nonEmptyString,
+        startAt: nonEmptyString,
+        inputSchema: { type: "object" },
+        organizationContext: {
+            type: "object",
+            additionalProperties: false,
+            properties: {
+                department: {
+                    type: "object",
+                    additionalProperties: false,
+                    required: ["source"],
+                    properties: {
+                        source: {
+                            enum: [
+                                "none",
+                                "user_primary_department",
+                                "choose_if_multiple",
+                                "always_choose",
+                                "fixed",
+                                "from_input",
+                                "from_role_scope",
+                            ],
+                        },
+                        required: { type: "boolean" },
+                        value: { type: "string" },
+                        path: { type: "string" },
+                        dimension: { type: "string" },
+                    },
+                },
+            },
+        },
+        nodes: {
+            type: "object",
+            minProperties: 1,
+            maxProperties: 200,
+            additionalProperties: workflowNodeSchema,
+        },
+    },
+};
+export const workflowBindingSchema = {
+    $id: SCHEMA_VERSIONS.workflowBinding,
+    type: "object",
+    additionalProperties: false,
+    required: ["schemaVersion", "workflowCode", "bindings"],
+    properties: {
+        schemaVersion: { const: SCHEMA_VERSIONS.workflowBinding },
+        workflowCode: nonEmptyString,
+        bindings: {
+            type: "object",
+            maxProperties: 200,
+            additionalProperties: {
+                type: "object",
+                additionalProperties: false,
+                required: ["provider"],
+                properties: {
+                    provider: {
+                        enum: [
+                            "fixed_users",
+                            "initiator",
+                            "input_users",
+                            "form_field_users",
+                            "department_supervisor",
+                            "app_role",
+                            "app_role_in_scope",
+                            "business_relation",
+                            "previous_node_actor",
+                            "initiator_select",
+                            "application_provider",
+                        ],
+                    },
+                    users: { type: "array", uniqueItems: true, items: nonEmptyString },
+                    inputPath: { type: "string" },
+                    departmentIdFrom: { type: "string" },
+                    level: { type: "integer", minimum: 1, maximum: 20 },
+                    fallbackToAncestorSupervisor: { type: "boolean" },
+                    roleCode: { type: "string" },
+                    scope: {
+                        type: "object",
+                        additionalProperties: false,
+                        required: ["dimension"],
+                        properties: {
+                            dimension: nonEmptyString,
+                            valueFrom: { type: "string" },
+                            value: { type: "string" },
+                        },
+                    },
+                    relationCode: { type: "string" },
+                    resourceCode: { type: "string" },
+                    resourceIdFrom: { type: "string" },
+                    providerCode: { type: "string" },
+                    min: { type: "integer", minimum: 1 },
+                    max: { type: "integer", minimum: 1 },
+                },
+            },
+        },
+    },
+};
+export const workflowPreparationSchema = {
+    $id: SCHEMA_VERSIONS.workflowPreparation,
+    type: "object",
+    additionalProperties: false,
+    required: [
+        "schemaVersion",
+        "preparationId",
+        "status",
+        "requirements",
+        "preparationToken",
+        "preview",
+        "expiresAt",
+        "definitionVersion",
+        "bindingVersion",
+        "inputHash",
+    ],
+    properties: {
+        schemaVersion: { const: SCHEMA_VERSIONS.workflowPreparation },
+        preparationId: nonEmptyString,
+        status: { enum: ["needs_input", "ready"] },
+        requirements: {
+            type: "array",
+            items: {
+                type: "object",
+                required: ["id", "kind", "title"],
+                properties: {
+                    id: nonEmptyString,
+                    kind: nonEmptyString,
+                    title: nonEmptyString,
+                    required: { type: "boolean" },
+                    min: { type: "integer", minimum: 1 },
+                    max: { type: "integer", minimum: 1 },
+                    candidates: { type: "array", items: { type: "object" } },
+                    inputSchema: { type: "object" },
+                    uiSchema: { type: "object" },
+                },
+            },
+        },
+        preparationToken: { type: ["string", "null"] },
+        preview: { type: "object" },
+        expiresAt: dateTime,
+        definitionVersion: { type: "integer", minimum: 1 },
+        bindingVersion: { type: "integer", minimum: 1 },
+        inputHash: digest,
+    },
+};
+export const workflowInstanceSchema = {
+    $id: SCHEMA_VERSIONS.workflowInstance,
+    type: "object",
+    required: [
+        "engineVersion",
+        "id",
+        "appCode",
+        "workflowCode",
+        "status",
+        "version",
+    ],
+    properties: {
+        schemaVersion: { const: SCHEMA_VERSIONS.workflowInstance },
+        engineVersion: { const: "2.0" },
+        id: nonEmptyString,
+        appCode: nonEmptyString,
+        environmentKey: nonEmptyString,
+        workflowCode: nonEmptyString,
+        status: {
+            enum: [
+                "running",
+                "returned",
+                "approved",
+                "rejected",
+                "withdrawn",
+                "terminated",
+                "error",
+            ],
+        },
+        version: { type: "integer", minimum: 1 },
+    },
+};
+export const workflowTaskSchema = {
+    $id: SCHEMA_VERSIONS.workflowTask,
+    type: "object",
+    required: [
+        "engineVersion",
+        "id",
+        "instanceId",
+        "nodeId",
+        "status",
+        "taskKind",
+        "originTaskId",
+        "returnSessionId",
+        "version",
+    ],
+    properties: {
+        schemaVersion: { const: SCHEMA_VERSIONS.workflowTask },
+        engineVersion: { const: "2.0" },
+        id: nonEmptyString,
+        instanceId: nonEmptyString,
+        nodeId: nonEmptyString,
+        status: {
+            enum: [
+                "assignment_pending",
+                "assigned",
+                "completed",
+                "rejected",
+                "returned",
+                "cancelled",
+                "expired",
+            ],
+        },
+        taskKind: { enum: ["normal", "return_review", "resume"] },
+        originTaskId: { type: ["string", "null"] },
+        returnSessionId: { type: ["string", "null"] },
+        version: { type: "integer", minimum: 1 },
+    },
+};
+export const workflowSurfaceSchema = {
+    $id: SCHEMA_VERSIONS.workflowSurface,
+    type: "object",
+    additionalProperties: false,
+    required: [
+        "protocolVersion",
+        "surfaceRevision",
+        "engineVersion",
+        "instance",
+        "task",
+        "presentation",
+        "fieldPolicy",
+        "operations",
+        "extensions",
+    ],
+    properties: {
+        schemaVersion: { const: SCHEMA_VERSIONS.workflowSurface },
+        protocolVersion: { const: "workflow_surface_v2" },
+        surfaceRevision: digest,
+        engineVersion: { const: "2.0" },
+        instance: { type: "object" },
+        task: { anyOf: [{ type: "object" }, { type: "null" }] },
+        presentation: { type: "object" },
+        fieldPolicy: { type: "object" },
+        operations: { type: "array", items: { type: "object" } },
+        extensions: { type: "object" },
+    },
+};
+export const workflowDelegationSchema = {
+    $id: SCHEMA_VERSIONS.workflowDelegation,
+    type: "object",
+    additionalProperties: false,
+    required: [
+        "schemaVersion",
+        "id",
+        "appCode",
+        "workflowCode",
+        "delegatorUserId",
+        "delegateUserId",
+        "delegatorRoleAssignmentId",
+        "delegateRoleAssignmentId",
+        "validFrom",
+        "validTo",
+        "status",
+        "reason",
+        "createdBy",
+        "createdAt",
+        "revokedAt",
+    ],
+    properties: {
+        schemaVersion: { const: SCHEMA_VERSIONS.workflowDelegation },
+        id: nonEmptyString,
+        appCode: nonEmptyString,
+        workflowCode: { type: ["string", "null"] },
+        delegatorUserId: nonEmptyString,
+        delegateUserId: nonEmptyString,
+        delegatorRoleAssignmentId: nonEmptyString,
+        delegateRoleAssignmentId: nonEmptyString,
+        validFrom: dateTime,
+        validTo: dateTime,
+        status: { enum: ["active", "revoked", "expired"] },
+        reason: nonEmptyString,
+        createdBy: nonEmptyString,
+        createdAt: dateTime,
+        revokedAt: { anyOf: [dateTime, { type: "null" }] },
+    },
+};
+export const workflowAssigneeProviderSchema = {
+    $id: SCHEMA_VERSIONS.workflowAssigneeProvider,
+    type: "object",
+    required: [
+        "schemaVersion",
+        "id",
+        "appCode",
+        "environmentKey",
+        "code",
+        "endpointPath",
+        "timeoutMs",
+        "status",
+        "signingSecretVersion",
+        "pendingSigningSecretVersion",
+        "rotationPending",
+        "revision",
+        "createdAt",
+        "updatedAt",
+    ],
+    properties: {
+        schemaVersion: { const: SCHEMA_VERSIONS.workflowAssigneeProvider },
+        id: nonEmptyString,
+        appCode: nonEmptyString,
+        environmentKey: nonEmptyString,
+        code: nonEmptyString,
+        endpointPath: nonEmptyString,
+        timeoutMs: { type: "integer", minimum: 100, maximum: 10000 },
+        status: { enum: ["active", "paused"] },
+        signingSecretVersion: { type: "integer", minimum: 1 },
+        pendingSigningSecretVersion: {
+            type: ["integer", "null"],
+            minimum: 2,
+        },
+        rotationPending: { type: "boolean" },
+        revision: { type: "integer", minimum: 1 },
+        signingSecret: { type: ["string", "null"] },
+        signingSecretReturnedOnce: { type: "boolean" },
+        createdAt: dateTime,
+        updatedAt: dateTime,
+    },
+};
+export const workflowAssigneeRequestSchema = {
+    $id: SCHEMA_VERSIONS.workflowAssigneeRequest,
+    type: "object",
+    additionalProperties: false,
+    required: [
+        "schemaVersion",
+        "requestId",
+        "providerCode",
+        "appCode",
+        "environmentKey",
+        "workflowCode",
+        "nodeId",
+        "facts",
+        "organizationContext",
+        "initiator",
+        "authzVersion",
+    ],
+    properties: {
+        schemaVersion: { const: SCHEMA_VERSIONS.workflowAssigneeRequest },
+        requestId: nonEmptyString,
+        providerCode: nonEmptyString,
+        appCode: nonEmptyString,
+        environmentKey: nonEmptyString,
+        workflowCode: nonEmptyString,
+        nodeId: nonEmptyString,
+        facts: { type: "object" },
+        organizationContext: { type: "object" },
+        initiator: { type: "object" },
+        authzVersion: { type: "integer", minimum: 1 },
+    },
+};
+export const workflowAssigneeResponseSchema = {
+    $id: SCHEMA_VERSIONS.workflowAssigneeResponse,
+    type: "object",
+    additionalProperties: false,
+    required: ["schemaVersion", "requestId", "candidates"],
+    properties: {
+        schemaVersion: { const: SCHEMA_VERSIONS.workflowAssigneeResponse },
+        requestId: nonEmptyString,
+        candidates: {
+            type: "array",
+            maxItems: 200,
+            items: {
+                type: "object",
+                required: ["userId", "source"],
+                properties: {
+                    userId: nonEmptyString,
+                    roleAssignmentId: nonEmptyString,
+                    roleCode: nonEmptyString,
+                    displayName: nonEmptyString,
+                    source: nonEmptyString,
+                },
+            },
+        },
+    },
+};
+export const workflowKernelDescriptorSchema = {
+    $id: SCHEMA_VERSIONS.workflowKernelDescriptor,
+    type: "object",
+    additionalProperties: false,
+    required: [
+        "schemaVersion",
+        "engineVersion",
+        "instanceId",
+        "appCode",
+        "status",
+        "businessKey",
+        "routes",
+        "authorizationMode",
+    ],
+    properties: {
+        schemaVersion: { const: SCHEMA_VERSIONS.workflowKernelDescriptor },
+        engineVersion: { const: "2.0" },
+        instanceId: nonEmptyString,
+        appCode: nonEmptyString,
+        status: nonEmptyString,
+        businessKey: { type: ["string", "null"] },
+        routes: {
+            type: "object",
+            minProperties: 1,
+            additionalProperties: nonEmptyString,
+        },
+        authorizationMode: { const: "role_session_v2" },
+    },
+};
+export const workflowKernelWorkItemSchema = {
+    $id: SCHEMA_VERSIONS.workflowKernelWorkItem,
+    type: "object",
+    additionalProperties: false,
+    required: [
+        "schemaVersion",
+        "engineVersion",
+        "appCode",
+        "instanceId",
+        "taskId",
+        "workflowCode",
+        "businessKey",
+        "status",
+        "nodeId",
+        "title",
+        "dataRef",
+        "updatedAt",
+        "startedAt",
+        "descriptorHref",
+        "surfaceHref",
+        "authorizationMode",
+    ],
+    properties: {
+        schemaVersion: { const: SCHEMA_VERSIONS.workflowKernelWorkItem },
+        engineVersion: { const: "2.0" },
+        appCode: nonEmptyString,
+        instanceId: nonEmptyString,
+        taskId: { type: ["string", "null"] },
+        workflowCode: { type: ["string", "null"] },
+        businessKey: { type: ["string", "null"] },
+        status: nonEmptyString,
+        nodeId: { type: ["string", "null"] },
+        title: { type: ["string", "null"] },
+        dataRef: { anyOf: [{ type: "object" }, { type: "null" }] },
+        updatedAt: dateTime,
+        startedAt: dateTime,
+        descriptorHref: nonEmptyString,
+        surfaceHref: nonEmptyString,
+        authorizationMode: { const: "role_session_v2" },
+    },
+};
+export const workflowKernelWorkCenterSchema = {
+    $id: SCHEMA_VERSIONS.workflowKernelWorkCenter,
+    type: "object",
+    additionalProperties: false,
+    required: [
+        "schemaVersion",
+        "category",
+        "roleSessionId",
+        "activeRoleAssignmentId",
+        "items",
+        "engineCounts",
+    ],
+    properties: {
+        schemaVersion: { const: SCHEMA_VERSIONS.workflowKernelWorkCenter },
+        category: { enum: ["pending", "completed", "created"] },
+        roleSessionId: nonEmptyString,
+        activeRoleAssignmentId: nonEmptyString,
+        items: {
+            type: "array",
+            items: { $ref: SCHEMA_VERSIONS.workflowKernelWorkItem },
+        },
+        engineCounts: {
+            type: "object",
+            additionalProperties: false,
+            properties: {
+                "2.0": { type: "integer", minimum: 0 },
+            },
+        },
+    },
+};
+export const contractSchemas = {
+    diagnostic: diagnosticSchema,
+    workspaceContext: workspaceContextSchema,
+    application: applicationSchema,
+    principal: principalSchema,
+    roleAssignment: roleAssignmentSchema,
+    relationshipGrant: relationshipGrantSchema,
+    roleSession: roleSessionSchema,
+    authorizationDecision: authorizationDecisionSchema,
+    authorizationBatchRequest: authorizationBatchRequestSchema,
+    authorizationBatchResult: authorizationBatchResultSchema,
+    directoryResolveRequest: directoryResolveRequestSchema,
+    directorySearchResult: directorySearchResultSchema,
+    dataRef: dataRefSchema,
+    dataResource: dataResourceSchema,
+    dataQuery: dataQuerySchema,
+    dataPage: dataPageSchema,
+    dataRecord: dataRecordSchema,
+    dataAggregateQuery: dataAggregateQuerySchema,
+    dataAggregatePage: dataAggregatePageSchema,
+    dataAuditPage: dataAuditPageSchema,
+    dataFileRef: dataFileRefSchema,
+    dataFileUploadPlan: dataFileUploadPlanSchema,
+    dataTransactionRequest: dataTransactionRequestSchema,
+    dataTransactionResult: dataTransactionResultSchema,
+    cloudEvent: cloudEventSchema,
+    eventSubscription: eventSubscriptionSchema,
+    eventDelivery: eventDeliverySchema,
+    eventReceiptCommand: eventReceiptCommandSchema,
+    eventReceiptResult: eventReceiptResultSchema,
+    applicationSecret: applicationSecretSchema,
+    timerSubscription: timerSubscriptionSchema,
+    workflowDefinition: workflowDefinitionSchema,
+    workflowBinding: workflowBindingSchema,
+    workflowPreparation: workflowPreparationSchema,
+    workflowInstance: workflowInstanceSchema,
+    workflowTask: workflowTaskSchema,
+    workflowSurface: workflowSurfaceSchema,
+    workflowDelegation: workflowDelegationSchema,
+    workflowAssigneeProvider: workflowAssigneeProviderSchema,
+    workflowAssigneeRequest: workflowAssigneeRequestSchema,
+    workflowAssigneeResponse: workflowAssigneeResponseSchema,
+    workflowKernelDescriptor: workflowKernelDescriptorSchema,
+    workflowKernelWorkItem: workflowKernelWorkItemSchema,
+    workflowKernelWorkCenter: workflowKernelWorkCenterSchema,
+    appPackage: appPackageSchema,
+    appVersion: appVersionSchema,
+    environmentHead: environmentHeadSchema,
+    deploymentRun: deploymentRunSchema,
+    platformCapabilities: platformCapabilitiesSchema,
+};
+//# sourceMappingURL=schemas.js.map