@appconda/sdk 1.0.681 → 1.0.683

package/src/modules/emploid/schema.ts

@@ -1017,6 +1017,12 @@ export const UpdateCollectionSchema = z.object({
     collectionId: z.string(),
     displayName: z.string().optional(),
     description: z.string().optional(),
+    // Legacy callers used the same fields under a `data` envelope. The
+    // backend accepts both shapes while direct fields remain canonical.
+    data: z.object({
+        displayName: z.string().optional(),
+        description: z.string().optional(),
+    }).optional(),
 });
 
 export const DeleteCollectionSchema = z.object({
@@ -1252,6 +1258,34 @@ export const EnsureGithubImportCredentialSchema = z.object({
     tenantId: z.string(),
 });
 
+const CsvImportInvalidRowPolicySchema = z.enum(["reject", "skip-row", "set-null"]);
+
+const CsvImportRowRepairSchema = z.object({
+    rowIndex: z.number().int().nonnegative(),
+    fieldId: z.string().min(1),
+    value: z.any(),
+});
+
+const CsvImportFieldMappingSchema = z.object({
+    fieldId: z.string().min(1),
+    type: z.string(),
+    displayName: z.string(),
+    name: z.string(),
+    required: z.boolean().optional(),
+    config: z.object({}).catchall(z.any()).optional(),
+    fallbackReason: z.string().optional(),
+    mode: z.enum(["field", "skip", "relation"]).optional(),
+    relation: z.object({
+        targetCollectionId: z.string().min(1),
+        matchFieldName: z.string().min(1),
+        unmatchedPolicy: z.enum(["reject", "ignore", "create"]),
+        cardinality: z.enum(["one", "many"]).optional(),
+        inverseCardinality: z.enum(["one", "many"]).optional(),
+        inverseDisplayName: z.string().optional(),
+        separator: z.string().max(8).optional(),
+    }).optional(),
+});
+
 export const PreviewCsvImportSchema = z.object({
     tenantId: z.string(),
     fileName: z.string(),
@@ -1264,7 +1298,10 @@ export const PreviewCsvImportSchema = z.object({
             index: z.number().int(),
         })
     ).min(1),
-    rows: z.array(z.object({}).catchall(z.any())).optional(),
+    rows: z.array(z.object({}).catchall(z.any())).max(1_000).optional(),
+    fields: z.array(CsvImportFieldMappingSchema).min(1).optional(),
+    rowRepairs: z.array(CsvImportRowRepairSchema).max(10_000).optional(),
+    invalidRowPolicy: CsvImportInvalidRowPolicySchema.optional(),
 });
 
 export const ListGmailImportSourcesSchema = z.object({
@@ -1302,22 +1339,14 @@ export const RunCsvImportSchema = z.object({
             index: z.number().int(),
         })
     ).min(1),
-    rows: z.array(z.object({}).catchall(z.any())),
+    rows: z.array(z.object({}).catchall(z.any())).max(1_000),
     collection: z.object({
         collectionKey: z.literal("rows"),
         collectionName: z.string(),
         collectionDisplayName: z.string(),
-        fields: z.array(
-            z.object({
-                fieldId: z.string(),
-                type: z.string(),
-                displayName: z.string(),
-                name: z.string(),
-                required: z.boolean().optional(),
-                config: z.object({}).catchall(z.any()).optional(),
-                fallbackReason: z.string().optional(),
-            })
-        ).min(1),
+        fields: z.array(CsvImportFieldMappingSchema).min(1),
+        invalidRowPolicy: CsvImportInvalidRowPolicySchema.optional(),
+        rowRepairs: z.array(CsvImportRowRepairSchema).max(10_000).optional(),
     }),
 });
 
@@ -1497,18 +1526,36 @@ export const RunTrelloImportSchema = z.object({
     ).min(1),
 });
 
-export const BulkUpdateRecordsSchema = z.object({
+const BulkUpdateRecordSchema = z.object({
+    recordId: z.string(),
+    data: z.object({}).catchall(z.any()),
+});
+
+const LegacyBulkUpdateRecordSchema = z.object({
+    id: z.string().optional(),
+    recordId: z.string().optional(),
+    data: z.object({}).catchall(z.any()),
+}).refine((item) => Boolean(item.id || item.recordId), {
+    message: "Each bulk update item must include id or recordId",
+});
+
+const BulkUpdateRecordsBaseSchema = z.object({
     tenantId: z.string(),
     collectionId: z.string(),
-
-    records: z.array(
-        z.object({
-            recordId: z.string(),
-            data: z.object({}).catchall(z.any()),
-        })
-    ),
+    actor: z.string().optional(),
 });
 
+export const BulkUpdateRecordsSchema = z.union([
+    BulkUpdateRecordsBaseSchema.extend({
+        records: z.array(BulkUpdateRecordSchema).min(1),
+        items: z.array(LegacyBulkUpdateRecordSchema).optional(),
+    }),
+    BulkUpdateRecordsBaseSchema.extend({
+        records: z.array(BulkUpdateRecordSchema).optional(),
+        items: z.array(LegacyBulkUpdateRecordSchema).min(1),
+    }),
+]);
+
 export const BulkDeleteRecordsSchema = z.object({
     tenantId: z.string(),
     collectionId: z.string(),
@@ -1534,7 +1581,10 @@ export const QueryRecordsSchema = z.object({
     filter: z.object({}).catchall(z.any()).optional(),
 
     // projection (hangi alanlar gelsin)
-    fields: z.object({}).catchall(z.any()).optional(),
+    fields: z.union([
+        z.array(z.string()),
+        z.object({}).catchall(z.any()),
+    ]).optional(),
 
     // sorting
     sort: z.object({}).catchall(z.string()).optional(),
@@ -1542,15 +1592,26 @@ export const QueryRecordsSchema = z.object({
     // pagination
     limit: z.number().optional(),
     offset: z.number().optional(),
+
+    // Compatibility with the original backend action, which expected the
+    // complete query DSL in one parameter.
+    query: z.object({
+        where: z.object({}).catchall(z.any()).optional(),
+        filter: z.object({}).catchall(z.any()).optional(),
+        fields: z.union([
+            z.array(z.string()),
+            z.object({}).catchall(z.any()),
+        ]).optional(),
+        sort: z.object({}).catchall(z.string()).optional(),
+        limit: z.number().optional(),
+        offset: z.number().optional(),
+    }).optional(),
 });
 
-export const SearchRecordsSchema = z.object({
+const SearchRecordsBaseSchema = z.object({
     tenantId: z.string(),
     collectionId: z.string(),
 
-    // arama metni
-    query: z.string(),
-
     // opsiyonel: hangi alanlarda aransın
     fields: z.array(z.string()).optional(),
 
@@ -1565,6 +1626,19 @@ export const SearchRecordsSchema = z.object({
     offset: z.number().optional(),
 });
 
+export const SearchRecordsSchema = z.union([
+    SearchRecordsBaseSchema.extend({
+        // Canonical public name.
+        query: z.string().min(1),
+        q: z.string().optional(),
+    }),
+    SearchRecordsBaseSchema.extend({
+        // Compatibility with the original backend action and Agent Flow node.
+        query: z.string().optional(),
+        q: z.string().min(1),
+    }),
+]);
+
 export const CountRecordsSchema = z.object({
     tenantId: z.string(),
     collectionId: z.string(),
@@ -1625,6 +1699,56 @@ export const DistinctFieldValuesSchema = z.object({
     limit: z.number().optional(),
 });
 
+export const CollectionDerivedConditionSchema = z.object({
+    fieldId: z.string(),
+    fieldName: z.string().optional(),
+    operator: z.enum([
+        "eq", "neq", "contains", "not-contains", "gt", "gte", "lt", "lte",
+        "is-empty", "is-not-empty",
+    ]),
+    value: z.unknown().optional(),
+});
+
+export const CollectionFieldConfigSchema = z.object({
+    relationFieldId: z.string().optional(),
+    relationFieldName: z.string().optional(),
+    relationId: z.string().optional(),
+    targetCollectionId: z.string().optional(),
+    targetFieldId: z.string().optional(),
+    targetFieldName: z.string().optional(),
+    resultMode: z.enum(["first", "list"]).optional(),
+    operation: z.enum([
+        "count", "count-values", "count-unique", "sum", "average", "min", "max",
+    ]).optional(),
+    condition: CollectionDerivedConditionSchema.optional(),
+    maxItems: z.number().int().min(1).max(500).optional(),
+    min: z.number().optional(),
+    max: z.number().optional(),
+    precision: z.number().int().min(0).max(4).optional(),
+    mode: z.enum(["typed", "drawn", "both"]).optional(),
+    source: z.enum(["organization", "users", "employees", "both"]).optional(),
+    includeInactive: z.boolean().optional(),
+}).catchall(z.any());
+
+export const CollectionChecklistItemSchema = z.object({
+    id: z.string().min(1).max(128),
+    text: z.string().min(1).max(1000),
+    checked: z.boolean(),
+});
+
+export const CollectionSignatureValueSchema = z.object({
+    kind: z.enum(["typed", "drawn"]),
+    value: z.string().min(1),
+    signedAt: z.string().datetime(),
+    signedBy: z.string().min(1),
+});
+
+/** Browser/import input. signedAt and signedBy are server-managed output fields. */
+export const CollectionSignatureInputSchema = CollectionSignatureValueSchema.pick({
+    kind: true,
+    value: true,
+});
+
 export const CreateCollectionFieldSchema = z.object({
     tenantId: z.string(),
     dataModelId: z.string(),
@@ -1636,7 +1760,7 @@ export const CreateCollectionFieldSchema = z.object({
     required: z.boolean().optional(),
 
     // field-specific config (min, max, enum, format, relation, etc.)
-    config: z.object({}).catchall(z.any()).optional(),
+    config: CollectionFieldConfigSchema.optional(),
 
     // opsiyonel sıralama
     order: z.number().optional(),
@@ -1653,7 +1777,7 @@ export const UpdateCollectionFieldSchema = z.object({
     required: z.boolean().optional(),
 
     // field-specific config (min, max, enum, relation vb.)
-    config: z.object({}).catchall(z.any()).optional(),
+    config: CollectionFieldConfigSchema.optional(),
 
     // opsiyonel sıralama
     order: z.number().optional(),
@@ -1673,6 +1797,9 @@ export const ListCollectionAutomationRulesSchema = z.object({
 
 const CollectionAutomationRuleTriggerConfigSchema = z.object({
     updatedFieldId: z.string().nullable().optional(),
+    cron: z.string().max(191).nullable().optional(),
+    timezone: z.string().max(64).nullable().optional(),
+    maxRecords: z.number().int().min(1).max(100).optional(),
 });
 
 const CollectionAutomationRuleConditionSchema = z.object({
@@ -1682,6 +1809,40 @@ const CollectionAutomationRuleConditionSchema = z.object({
     value: z.union([z.string(), z.array(z.string()), z.boolean(), z.null()]).optional(),
 });
 
+const CollectionAutomationRuleActionSchema: z.ZodType<Record<string, unknown>> = z.lazy(() => z.object({
+    id: z.string().min(1),
+    type: z.enum([
+        "create", "update", "delete", "append-description", "script",
+        "conditional-branch", "find-records", "for-each", "copy-record",
+        "move-record", "webhook", "approval",
+    ]).nullable(),
+    fieldId: z.string().nullable().optional(),
+    value: z.string().optional(),
+    valueMode: z.enum(["literal", "formula"]).optional(),
+    formula: z.string().optional(),
+    template: z.string().optional(),
+    script: z.string().optional(),
+    condition: CollectionAutomationRuleConditionSchema.nullable().optional(),
+    thenActions: z.array(CollectionAutomationRuleActionSchema).max(100).optional(),
+    elseActions: z.array(CollectionAutomationRuleActionSchema).max(100).optional(),
+    collectionId: z.string().nullable().optional(),
+    filters: z.array(CollectionAutomationRuleConditionSchema).max(25).optional(),
+    limit: z.number().int().min(1).max(100).optional(),
+    resultKey: z.string().max(80).optional(),
+    sourceKey: z.string().max(80).optional(),
+    maxIterations: z.number().int().min(1).max(50).optional(),
+    actions: z.array(CollectionAutomationRuleActionSchema).max(100).optional(),
+    targetCollectionId: z.string().nullable().optional(),
+    fieldMap: z.record(z.string(), z.string()).optional(),
+    url: z.string().max(2048).optional(),
+    method: z.enum(["GET", "POST", "PUT", "PATCH", "DELETE"]).optional(),
+    headers: z.record(z.string(), z.string()).optional(),
+    body: z.unknown().optional(),
+    timeoutMs: z.number().int().min(1).max(10_000).optional(),
+    approverIds: z.array(z.string()).max(25).optional(),
+    approvalMessage: z.string().max(2_000).optional(),
+}));
+
 export const CreateCollectionAutomationRuleSchema = z.object({
     tenantId: z.string(),
     dataModelId: z.string(),
@@ -1692,7 +1853,7 @@ export const CreateCollectionAutomationRuleSchema = z.object({
     trigger: z.enum(["created", "updated", "linked", "unlinked", "schedule"]),
     triggerConfig: CollectionAutomationRuleTriggerConfigSchema.nullable().optional(),
     conditions: z.array(CollectionAutomationRuleConditionSchema).optional(),
-    actions: z.array(z.object({}).catchall(z.any())),
+    actions: z.array(CollectionAutomationRuleActionSchema).min(1).max(100),
 });
 
 export const UpdateCollectionAutomationRuleSchema = z.object({
@@ -1705,7 +1866,7 @@ export const UpdateCollectionAutomationRuleSchema = z.object({
     trigger: z.enum(["created", "updated", "linked", "unlinked", "schedule"]).optional(),
     triggerConfig: CollectionAutomationRuleTriggerConfigSchema.nullable().optional(),
     conditions: z.array(CollectionAutomationRuleConditionSchema).optional(),
-    actions: z.array(z.object({}).catchall(z.any())).optional(),
+    actions: z.array(CollectionAutomationRuleActionSchema).min(1).max(100).optional(),
 });
 
 export const DeleteCollectionAutomationRuleSchema = z.object({
@@ -1714,6 +1875,22 @@ export const DeleteCollectionAutomationRuleSchema = z.object({
     ruleId: z.string(),
 });
 
+export const ListCollectionAutomationExecutionsSchema = z.object({
+    tenantId: z.string(),
+    collectionId: z.string().optional(),
+    ruleId: z.string().optional(),
+    status: z.enum(["queued", "running", "waiting_approval", "succeeded", "failed", "skipped", "cancelled"]).optional(),
+    cursor: z.string().optional(),
+    limit: z.number().int().min(1).max(100).optional(),
+});
+
+export const DecideCollectionAutomationApprovalSchema = z.object({
+    tenantId: z.string(),
+    approvalId: z.string(),
+    decision: z.enum(["approved", "rejected"]),
+    note: z.string().max(2_000).optional(),
+});
+
 export const ListCollectionViewsSchema = z.object({
     tenantId: z.string(),
     collectionId: z.string(),
@@ -1723,18 +1900,20 @@ export const CreateCollectionViewSchema = z.object({
     tenantId: z.string(),
     dataModelId: z.string(),
     collectionId: z.string(),
-    name: z.string(),
-    type: z.string(),
+    name: z.string().trim().min(1).max(191),
+    type: z.enum(["grid", "board", "calendar", "timeline", "tree", "gallery", "map", "document"]),
     config: z.object({}).catchall(z.any()),
+    visibility: z.enum(["shared", "personal"]).optional(),
 });
 
 export const UpdateCollectionViewSchema = z.object({
     tenantId: z.string(),
     collectionId: z.string(),
     viewId: z.string(),
-    name: z.string().optional(),
-    type: z.string().optional(),
+    name: z.string().trim().min(1).max(191).optional(),
+    type: z.enum(["grid", "board", "calendar", "timeline", "tree", "gallery", "map", "document"]).optional(),
     config: z.object({}).catchall(z.any()).optional(),
+    visibility: z.enum(["shared", "personal"]).optional(),
 });
 
 export const DeleteCollectionViewSchema = z.object({
@@ -1743,6 +1922,23 @@ export const DeleteCollectionViewSchema = z.object({
     viewId: z.string(),
 });
 
+export const UpsertCollectionViewPreferenceSchema = z.object({
+    tenantId: z.string(),
+    collectionId: z.string(),
+    viewId: z.string(),
+    columns: z.array(z.object({
+        fieldName: z.string().trim().min(1).max(191),
+        visible: z.boolean(),
+        width: z.number().positive().max(2_000).optional(),
+    })).max(500),
+});
+
+export const DeleteCollectionViewPreferenceSchema = z.object({
+    tenantId: z.string(),
+    collectionId: z.string(),
+    viewId: z.string(),
+});
+
 export const ListCollectionButtonsSchema = z.object({
     tenantId: z.string(),
     collectionId: z.string().optional(),
@@ -1838,18 +2034,33 @@ export const GetRecordRelationsSchema = z.object({
     recordId: z.string(),
 });
 
-export const ReorderCollectionFieldsSchema = z.object({
+const ReorderCollectionFieldsBaseSchema = z.object({
     tenantId: z.string(),
     collectionId: z.string(),
+});
 
-    // yeni sıralama: fieldId + order
-    fields: z.array(
+export const ReorderCollectionFieldsSchema = z.union([
+    ReorderCollectionFieldsBaseSchema.extend({
+        // Canonical shape: explicit field/order pairs.
+        fields: z.array(
         z.object({
             fieldId: z.string(),
             order: z.number(),
         })
-    ),
-});
+        ).min(1),
+        fieldIds: z.array(z.string()).optional(),
+    }),
+    ReorderCollectionFieldsBaseSchema.extend({
+        fields: z.array(
+            z.object({
+                fieldId: z.string(),
+                order: z.number(),
+            })
+        ).optional(),
+        // Compatibility with the original backend action.
+        fieldIds: z.array(z.string()).min(1),
+    }),
+]);
 
 export const GetCollectionSchemaSchema = z.object({
     tenantId: z.string(),
@@ -1889,39 +2100,243 @@ export const CheckRecordPermissionSchema = z.object({
     action: z.string(), // read | update | delete | restore | duplicate | custom
 });
 
-export const ListRecordPermissionsSchema = z.object({
-    tenantId: z.string(),
-    collectionId: z.string(),
-    recordId: z.string(),
+export const CollectionAccessPolicyScopeTypeSchema = z.enum(["app", "list", "field"]);
+export const CollectionAccessPolicySubjectTypeSchema = z.enum(["user", "role", "team", "service"]);
+export const CollectionAccessPolicyEffectSchema = z.enum(["allow", "deny"]);
+export const CollectionAccessPolicyActionSchema = z.enum(["read", "create", "update", "delete", "comment", "assign"]);
+export const CollectionAccessPolicyRowOperatorSchema = z.enum(["me", "user", "team", "linked-record"]);
+
+export const CollectionAccessPolicyRowFilterSchema = z.object({
+    match: z.enum(["all", "any"]),
+    conditions: z.array(z.object({
+        fieldId: z.string().min(1),
+        operator: CollectionAccessPolicyRowOperatorSchema,
+        value: z.string().optional(),
+    })).min(1).max(20),
+}).superRefine((filter, context) => {
+    filter.conditions.forEach((condition, index) => {
+        if (
+            (condition.operator === "user"
+                || condition.operator === "team"
+                || condition.operator === "linked-record")
+            && !condition.value?.trim()
+        ) {
+            context.addIssue({
+                code: z.ZodIssueCode.custom,
+                path: ["conditions", index, "value"],
+                message: `${condition.operator} filters require a value`,
+            });
+        }
+    });
+});
+
+export const ListCollectionAccessPoliciesSchema = z.object({
+    tenantId: z.string().min(1),
+    dataModelId: z.string().optional(),
+    collectionId: z.string().optional(),
 });
 
-export const GrantRecordPermissionSchema = z.object({
-    tenantId: z.string(),
-    collectionId: z.string(),
-    recordId: z.string(),
+const CollectionAccessPolicyWriteSchema = z.object({
+    tenantId: z.string().min(1),
+    dataModelId: z.string().min(1),
+    policyId: z.string().optional(),
+    name: z.string().trim().min(1).max(160),
+    scopeType: CollectionAccessPolicyScopeTypeSchema,
+    collectionId: z.string().optional(),
+    fieldId: z.string().optional(),
+    subjectType: CollectionAccessPolicySubjectTypeSchema,
+    subjectId: z.string().trim().min(1).max(255),
+    effect: CollectionAccessPolicyEffectSchema,
+    actions: z.array(CollectionAccessPolicyActionSchema).min(1).max(6),
+    rowFilter: CollectionAccessPolicyRowFilterSchema.nullable().optional(),
+    enabled: z.boolean().optional(),
+});
 
-    // yetki verilecek subject
-    subjectType: z.string(), // user | role | group | service | custom
-    subjectId: z.string(),
+function validateCollectionAccessPolicyShape(
+    policy: {
+        scopeType: z.infer<typeof CollectionAccessPolicyScopeTypeSchema>;
+        collectionId?: string | undefined;
+        fieldId?: string | undefined;
+        actions: Array<z.infer<typeof CollectionAccessPolicyActionSchema>>;
+        rowFilter?: z.infer<typeof CollectionAccessPolicyRowFilterSchema> | null | undefined;
+    },
+    context: z.RefinementCtx
+) {
+    if (policy.scopeType === "app") {
+        if (policy.collectionId) {
+            context.addIssue({ code: z.ZodIssueCode.custom, path: ["collectionId"], message: "App policies cannot target a collection" });
+        }
+        if (policy.fieldId) {
+            context.addIssue({ code: z.ZodIssueCode.custom, path: ["fieldId"], message: "App policies cannot target a field" });
+        }
+    } else if (!policy.collectionId) {
+        context.addIssue({ code: z.ZodIssueCode.custom, path: ["collectionId"], message: "List and field policies require a collection" });
+    }
+
+    if (policy.scopeType === "field") {
+        if (!policy.fieldId) {
+            context.addIssue({ code: z.ZodIssueCode.custom, path: ["fieldId"], message: "Field policies require a field" });
+        }
+        if (policy.actions.some((action) => action !== "read" && action !== "update")) {
+            context.addIssue({ code: z.ZodIssueCode.custom, path: ["actions"], message: "Field policies only support read and update" });
+        }
+    } else if (policy.fieldId) {
+        context.addIssue({ code: z.ZodIssueCode.custom, path: ["fieldId"], message: "Only field policies can target a field" });
+    }
+
+    if (policy.scopeType !== "list" && policy.rowFilter) {
+        context.addIssue({ code: z.ZodIssueCode.custom, path: ["rowFilter"], message: "Data limits can only be attached to list policies" });
+    }
+}
+
+export const UpsertCollectionAccessPolicySchema = CollectionAccessPolicyWriteSchema
+    .superRefine(validateCollectionAccessPolicyShape);
+
+export const DeleteCollectionAccessPolicySchema = z.object({
+    tenantId: z.string().min(1),
+    policyId: z.string().min(1),
+});
 
-    // izin verilen aksiyonlar
-    actions: z.array(z.string()), // read | update | delete | restore | duplicate | custom
+export const ListCollectionAccessTeamMembersSchema = z.object({
+    tenantId: z.string().min(1),
+    teamId: z.string().min(1),
 });
 
-export const RevokeRecordPermissionSchema = z.object({
+export const SetCollectionAccessTeamMembersSchema = z.object({
+    tenantId: z.string().min(1),
+    teamId: z.string().min(1),
+    userIds: z.array(z.string().min(1)).max(1_000),
+});
+
+export const PreviewCollectionAccessPolicySchema = z.object({
+    tenantId: z.string().min(1),
+    dataModelId: z.string().min(1),
+    collectionId: z.string().optional(),
+    policy: CollectionAccessPolicyWriteSchema.omit({
+        tenantId: true,
+        dataModelId: true,
+        policyId: true,
+    }).extend({
+        dataModelId: z.string().optional(),
+        collectionId: z.string().optional(),
+    }).superRefine(validateCollectionAccessPolicyShape),
+    record: z.record(z.string(), z.unknown()).optional(),
+});
+
+const CollectionCollaborationRecordScopeSchema = z.object({
+    tenantId: z.string().min(1),
+    collectionId: z.string().min(1),
+    recordId: z.string().min(1),
+});
+
+const CollectionCollaborationRequestIdSchema = z.string().max(191).optional();
+
+export const CreateCollectionCommentSchema = CollectionCollaborationRecordScopeSchema.extend({
+    body: z.string().trim().min(1).max(10_000),
+    parentId: z.string().min(1).optional(),
+    mentionUserIds: z.array(z.string().min(1)).max(25).optional(),
+    requestId: CollectionCollaborationRequestIdSchema,
+});
+
+export const UpdateCollectionCommentSchema = CollectionCollaborationRecordScopeSchema.extend({
+    commentId: z.string().min(1),
+    body: z.string().trim().min(1).max(10_000),
+    mentionUserIds: z.array(z.string().min(1)).max(25).optional(),
+    requestId: CollectionCollaborationRequestIdSchema,
+});
+
+export const DeleteCollectionCommentSchema = CollectionCollaborationRecordScopeSchema.extend({
+    commentId: z.string().min(1),
+    requestId: CollectionCollaborationRequestIdSchema,
+});
+
+export const ListCollectionCommentsSchema = CollectionCollaborationRecordScopeSchema.extend({
+    limit: z.coerce.number().int().min(1).max(100).optional(),
+    offset: z.coerce.number().int().min(0).max(1_000_000).optional(),
+});
+
+export const ListCollectionRecordActivitySchema = ListCollectionCommentsSchema;
+
+export const ListCollectionRecordCollaboratorsSchema = CollectionCollaborationRecordScopeSchema;
+
+export const SetCollectionRecordCollaboratorsSchema = CollectionCollaborationRecordScopeSchema.extend({
+    assigneeIds: z.array(z.string().min(1)).max(20),
+    watcherIds: z.array(z.string().min(1)).max(100),
+    requestId: CollectionCollaborationRequestIdSchema,
+});
+
+export const ListCollectionNotificationsSchema = z.object({
+    tenantId: z.string().min(1),
+    limit: z.coerce.number().int().min(1).max(50).optional(),
+    offset: z.coerce.number().int().min(0).max(1_000_000).optional(),
+    unreadOnly: z.boolean().optional(),
+});
+
+export const MarkCollectionNotificationsReadSchema = z.object({
+    tenantId: z.string().min(1),
+    notificationIds: z.array(z.string().min(1)).max(100),
+});
+
+export const ListRecordPermissionsSchema = z.object({
     tenantId: z.string(),
     collectionId: z.string(),
     recordId: z.string(),
+    actor: z.string().optional(),
+    subjectType: z.string().optional(),
+    subjectId: z.string().optional(),
+});
 
-    // yetkisi kaldırılacak subject
-    subjectType: z.string(), // user | role | group | service | custom
-    subjectId: z.string(),
-
-    // kaldırılacak aksiyonlar
-    // tamamını kaldırmak için ["*"] gönderilebilir
-    actions: z.array(z.string()),
+const RecordPermissionScopeSchema = z.object({
+    tenantId: z.string(),
+    collectionId: z.string(),
+    recordId: z.string(),
 });
 
+export const GrantRecordPermissionSchema = z.union([
+    RecordPermissionScopeSchema.extend({
+        // Canonical public shape.
+        subjectType: z.string(), // user | role | group | service | custom
+        subjectId: z.string(),
+        actions: z.array(z.string()).min(1),
+        effect: z.enum(["allow", "deny"]).optional(),
+        grantedBy: z.string().optional(),
+        actor: z.string().optional(),
+        action: z.string().optional(),
+    }),
+    RecordPermissionScopeSchema.extend({
+        // Compatibility with the original single-action backend contract.
+        actor: z.string(),
+        action: z.string(),
+        effect: z.enum(["allow", "deny"]).optional(),
+        grantedBy: z.string().optional(),
+        subjectType: z.string().optional(),
+        subjectId: z.string().optional(),
+        actions: z.array(z.string()).optional(),
+    }),
+]);
+
+export const RevokeRecordPermissionSchema = z.union([
+    RecordPermissionScopeSchema.extend({
+        // Canonical public shape.
+        subjectType: z.string(), // user | role | group | service | custom
+        subjectId: z.string(),
+        // tamamını kaldırmak için ["*"] gönderilebilir
+        actions: z.array(z.string()).min(1),
+        revokedBy: z.string().optional(),
+        actor: z.string().optional(),
+        action: z.string().optional(),
+    }),
+    RecordPermissionScopeSchema.extend({
+        // Compatibility with the original single-action backend contract.
+        actor: z.string(),
+        action: z.string(),
+        revokedBy: z.string().optional(),
+        subjectType: z.string().optional(),
+        subjectId: z.string().optional(),
+        actions: z.array(z.string()).optional(),
+    }),
+]);
+
 
 
 //---wiki--------------------------------
@@ -2617,3 +3032,278 @@ export const EnhanceTopicSchema = z.object({
     entityDescription: z.string(),
     categories: z.string().array().optional()
 })
+
+export const CollectionFormLayoutFieldSchema = z.object({
+    fieldId: z.string().trim().min(1).max(191),
+    label: z.string().max(255).optional(),
+    helpText: z.string().max(1_000).optional(),
+    placeholder: z.string().max(500).optional(),
+    required: z.boolean().optional(),
+    width: z.enum(["full", "half"]).optional(),
+}).strict();
+
+export const CollectionFormLayoutSectionSchema = z.object({
+    id: z.string().trim().min(1).max(128),
+    title: z.string().max(255).optional(),
+    description: z.string().max(2_000).optional(),
+    fields: z.array(CollectionFormLayoutFieldSchema).max(50),
+}).strict();
+
+export const CollectionFormLayoutSchema = z.object({
+    sections: z.array(CollectionFormLayoutSectionSchema).min(1).max(10),
+}).strict().superRefine((layout, context) => {
+    const sectionIds = new Set<string>();
+    const fieldIds = new Set<string>();
+    let fieldCount = 0;
+    layout.sections.forEach((section, sectionIndex) => {
+        if (sectionIds.has(section.id)) {
+            context.addIssue({
+                code: z.ZodIssueCode.custom,
+                path: ["sections", sectionIndex, "id"],
+                message: "Form section ids must be unique",
+            });
+        }
+        sectionIds.add(section.id);
+        section.fields.forEach((field, fieldIndex) => {
+            fieldCount += 1;
+            if (fieldIds.has(field.fieldId)) {
+                context.addIssue({
+                    code: z.ZodIssueCode.custom,
+                    path: ["sections", sectionIndex, "fields", fieldIndex, "fieldId"],
+                    message: "A field can appear only once in a form",
+                });
+            }
+            fieldIds.add(field.fieldId);
+        });
+    });
+    if (fieldCount === 0 || fieldCount > 50) {
+        context.addIssue({
+            code: z.ZodIssueCode.custom,
+            path: ["sections"],
+            message: "A form must contain between 1 and 50 fields",
+        });
+    }
+});
+
+export const ListCollectionFormsSchema = z.object({
+    tenantId: z.string().min(1),
+    dataModelId: z.string().min(1),
+    collectionId: z.string().min(1),
+});
+
+export const UpsertCollectionFormSchema = z.object({
+    tenantId: z.string().min(1),
+    dataModelId: z.string().min(1),
+    collectionId: z.string().min(1),
+    formId: z.string().min(1).optional(),
+    name: z.string().trim().min(1).max(191),
+    description: z.string().max(10_000).optional(),
+    layout: CollectionFormLayoutSchema,
+    submitLabel: z.string().trim().min(1).max(100).optional(),
+    successMessage: z.string().trim().min(1).max(2_000).optional(),
+    enabled: z.boolean().optional(),
+    rateLimitPerMinute: z.number().int().min(1).max(100).optional(),
+    maxSubmissions: z.number().int().min(1).max(1_000_000).nullable().optional(),
+});
+
+export const ResolveCollectionFormSchema = z.object({
+    tenantId: z.string().min(1),
+    formId: z.string().min(1),
+});
+
+export const SubmitCollectionFormSchema = ResolveCollectionFormSchema.extend({
+    values: z.record(z.string(), z.unknown()).refine(
+        (values) => Object.keys(values).length <= 50,
+        "A form submission can contain at most 50 fields"
+    ),
+    submissionKey: z.string().trim().min(8).max(128),
+});
+
+export const PublishCollectionFormSchema = ResolveCollectionFormSchema.extend({
+    expiresInDays: z.number().int().min(1).max(365).optional(),
+});
+
+export const RevokeCollectionFormSchema = ResolveCollectionFormSchema;
+export const DeleteCollectionFormSchema = ResolveCollectionFormSchema;
+
+export const CollectionReportTypeSchema = z.enum(["table", "metric", "chart"]);
+export const CollectionReportVisibilitySchema = z.enum(["personal", "shared"]);
+const CollectionReportFilterSchema = z.record(z.string(), z.unknown()).superRefine((filter, context) => {
+    if (JSON.stringify(filter).length > 16 * 1024) {
+        context.addIssue({ code: z.ZodIssueCode.custom, message: "Report filter is too large" });
+    }
+});
+const CollectionReportBaseSchema = z.object({
+    tenantId: z.string().min(1),
+    dataModelId: z.string().min(1),
+    collectionId: z.string().min(1),
+    reportId: z.string().min(1).optional(),
+    name: z.string().trim().min(1).max(191),
+    description: z.string().max(4_000).optional(),
+    visibility: CollectionReportVisibilitySchema.optional(),
+});
+export const CollectionReportTableConfigSchema = z.object({
+    filter: CollectionReportFilterSchema.optional(),
+    fields: z.array(z.string().min(1)).min(1).max(50),
+    sort: z.record(z.string(), z.enum(["asc", "desc"])).refine(
+        (sort) => Object.keys(sort).length <= 5,
+        "Report sort cannot contain more than 5 fields"
+    ).optional(),
+    limit: z.number().int().min(1).max(500).optional(),
+}).strict();
+const CollectionReportAggregateConfigBaseSchema = z.object({
+    filter: CollectionReportFilterSchema.optional(),
+    aggregate: z.enum(["count", "sum", "avg", "min", "max"]),
+    valueField: z.string().min(1).optional(),
+});
+export const CollectionReportMetricConfigSchema = CollectionReportAggregateConfigBaseSchema.extend({
+    limit: z.literal(1).optional(),
+}).strict().superRefine((config, context) => {
+    if (config.aggregate !== "count" && !config.valueField) {
+        context.addIssue({ code: z.ZodIssueCode.custom, path: ["valueField"], message: "This aggregate requires valueField" });
+    }
+});
+export const CollectionReportChartConfigSchema = CollectionReportAggregateConfigBaseSchema.extend({
+    groupBy: z.string().min(1),
+    limit: z.number().int().min(1).max(100).optional(),
+}).strict().superRefine((config, context) => {
+    if (config.aggregate !== "count" && !config.valueField) {
+        context.addIssue({ code: z.ZodIssueCode.custom, path: ["valueField"], message: "This aggregate requires valueField" });
+    }
+});
+export const UpsertCollectionReportSchema = z.discriminatedUnion("type", [
+    CollectionReportBaseSchema.extend({ type: z.literal("table"), config: CollectionReportTableConfigSchema }),
+    CollectionReportBaseSchema.extend({ type: z.literal("metric"), config: CollectionReportMetricConfigSchema }),
+    CollectionReportBaseSchema.extend({ type: z.literal("chart"), config: CollectionReportChartConfigSchema }),
+]);
+export const ListCollectionReportsSchema = z.object({
+    tenantId: z.string().min(1),
+    dataModelId: z.string().min(1),
+    collectionId: z.string().min(1),
+    limit: z.number().int().min(1).max(200).optional(),
+    offset: z.number().int().min(0).max(10_000).optional(),
+});
+export const CollectionReportReferenceSchema = z.object({
+    tenantId: z.string().min(1),
+    reportId: z.string().min(1),
+});
+export const DeleteCollectionReportSchema = CollectionReportReferenceSchema;
+export const EvaluateCollectionReportSchema = CollectionReportReferenceSchema;
+
+const CollectionDashboardWidgetBaseSchema = z.object({
+    id: z.string().min(1).optional(),
+    reportId: z.string().min(1),
+    title: z.string().trim().min(1).max(191),
+});
+export const CollectionDashboardWidgetSchema = z.discriminatedUnion("type", [
+    CollectionDashboardWidgetBaseSchema.extend({
+        type: z.literal("table"),
+        config: z.object({
+            pageSize: z.number().int().min(1).max(100).optional(),
+            showHeaders: z.boolean().optional(),
+        }).strict().optional(),
+    }),
+    CollectionDashboardWidgetBaseSchema.extend({
+        type: z.literal("metric"),
+        config: z.object({
+            prefix: z.string().max(32).optional(),
+            suffix: z.string().max(32).optional(),
+            decimals: z.number().int().min(0).max(6).optional(),
+        }).strict().optional(),
+    }),
+    CollectionDashboardWidgetBaseSchema.extend({
+        type: z.literal("chart"),
+        config: z.object({
+            kind: z.enum(["bar", "line", "pie"]).optional(),
+            showLegend: z.boolean().optional(),
+        }).strict().optional(),
+    }),
+]);
+export const ListCollectionDashboardsSchema = z.object({
+    tenantId: z.string().min(1),
+    dataModelId: z.string().min(1),
+    collectionId: z.string().min(1),
+    limit: z.number().int().min(1).max(100).optional(),
+    offset: z.number().int().min(0).max(10_000).optional(),
+});
+export const UpsertCollectionDashboardSchema = z.object({
+    tenantId: z.string().min(1),
+    dataModelId: z.string().min(1),
+    collectionId: z.string().min(1),
+    dashboardId: z.string().min(1).optional(),
+    name: z.string().trim().min(1).max(191),
+    description: z.string().max(4_000).optional(),
+    settings: z.object({
+        columns: z.number().int().min(1).max(4).optional(),
+        compact: z.boolean().optional(),
+    }).strict().optional(),
+    visibility: CollectionReportVisibilitySchema.optional(),
+    widgets: z.array(CollectionDashboardWidgetSchema).max(20),
+});
+export const CollectionDashboardReferenceSchema = z.object({
+    tenantId: z.string().min(1),
+    dashboardId: z.string().min(1),
+});
+export const DeleteCollectionDashboardSchema = CollectionDashboardReferenceSchema;
+export const EvaluateCollectionDashboardSchema = CollectionDashboardReferenceSchema;
+
+export const PreviewCollectionAppGenerationSchema = z.object({
+    tenantId: z.string().trim().min(1).max(191),
+    prompt: z.string().trim().min(1).max(4_000),
+}).strict();
+
+export const ApplyCollectionAppGenerationSchema = z.object({
+    tenantId: z.string().trim().min(1).max(191),
+    planId: z.string().trim().min(1).max(191),
+    expectedProposalHash: z.string().regex(/^[a-f0-9]{64}$/),
+    idempotencyKey: z.string().trim().min(8).max(128),
+}).strict();
+
+export const RollbackCollectionAppGenerationSchema = z.object({
+    tenantId: z.string().trim().min(1).max(191),
+    runId: z.string().trim().min(1).max(191),
+    idempotencyKey: z.string().trim().min(8).max(128),
+}).strict();
+
+export const ResumeCollectionAppGenerationRunSchema = z.object({
+    tenantId: z.string().trim().min(1).max(191),
+    runId: z.string().trim().min(1).max(191),
+}).strict();
+
+export const GetCollectionAppGenerationPlanSchema = z.object({
+    tenantId: z.string().trim().min(1).max(191),
+    planId: z.string().trim().min(1).max(191),
+}).strict();
+
+export const ListCollectionAppGenerationPlansSchema = z.object({
+    tenantId: z.string().trim().min(1).max(191),
+    status: z.enum(["previewed", "applying", "compensating", "applied", "failed", "compensation_failed", "rollback_retained", "rolled_back"]).optional(),
+    offset: z.number().int().min(0).max(1_000_000).optional(),
+    limit: z.number().int().min(1).max(50).optional(),
+}).strict();
+
+export const GetCollectionAppGenerationRunSchema = z.object({
+    tenantId: z.string().trim().min(1).max(191),
+    runId: z.string().trim().min(1).max(191),
+}).strict();
+
+export const ListCollectionAppGenerationRunsSchema = z.object({
+    tenantId: z.string().trim().min(1).max(191),
+    planId: z.string().trim().min(1).max(191).optional(),
+    status: z.enum([
+        "applying",
+        "provisioning",
+        "compensating",
+        "applied",
+        "failed",
+        "compensation_failed",
+        "rolling_back",
+        "rollback_cleanup",
+        "rollback_cleanup_failed",
+        "rollback_failed",
+        "rollback_retained",
+        "rolled_back",
+    ]).optional(),
+    offset: z.number().int().min(0).max(1_000_000).optional(),
+    limit: z.number().int().min(1).max(50).optional(),
+}).strict();