openxiangda-contracts 2.92.0 → 2.95.0

package/dist/schemas.d.ts

@@ -19905,7 +19905,7 @@ export declare const configurationBundleSchema: {
                                             readonly maxItems: 8;
                                             readonly uniqueItems: true;
                                             readonly items: {
-                                                readonly enum: readonly ["draft.read", "draft.update", "validate", "create", "own.list", "own.read", "public.list", "public.read"];
+                                                readonly enum: readonly ["draft.read", "draft.update", "validate", "create", "own.list", "own.read", "public.list", "public.read", "public.query"];
                                             };
                                         };
                                         readonly fields: {
@@ -20063,6 +20063,170 @@ export declare const configurationBundleSchema: {
                                                 };
                                             };
                                         };
+                                        readonly publicQueries: {
+                                            readonly type: "array";
+                                            readonly maxItems: 16;
+                                            readonly uniqueItems: true;
+                                            readonly items: {
+                                                readonly type: "object";
+                                                readonly additionalProperties: false;
+                                                readonly required: readonly ["code", "kind", "resourceCode", "fields", "defaultLimit", "maxLimit"];
+                                                readonly properties: {
+                                                    readonly code: {
+                                                        readonly type: "string";
+                                                        readonly pattern: "^[a-z][a-z0-9]*(?:[-_.][a-z0-9]+)*$";
+                                                        readonly maxLength: 128;
+                                                    };
+                                                    readonly kind: {
+                                                        readonly enum: readonly ["records", "aggregate"];
+                                                    };
+                                                    readonly resourceCode: {
+                                                        readonly type: "string";
+                                                        readonly pattern: "^[a-z][a-z0-9]*(?:[-_.][a-z0-9]+)*$";
+                                                        readonly maxLength: 128;
+                                                    };
+                                                    readonly fields: {
+                                                        readonly type: "array";
+                                                        readonly minItems: 1;
+                                                        readonly maxItems: 64;
+                                                        readonly uniqueItems: true;
+                                                        readonly items: {
+                                                            readonly type: "string";
+                                                            readonly pattern: "^[A-Za-z][A-Za-z0-9_]{0,62}$";
+                                                        };
+                                                    };
+                                                    readonly sort: {
+                                                        readonly type: "array";
+                                                        readonly maxItems: 4;
+                                                        readonly uniqueItems: true;
+                                                        readonly items: {
+                                                            readonly type: "object";
+                                                            readonly additionalProperties: false;
+                                                            readonly required: readonly ["field", "direction"];
+                                                            readonly properties: {
+                                                                readonly field: {
+                                                                    readonly type: "string";
+                                                                    readonly pattern: "^[A-Za-z][A-Za-z0-9_]{0,62}$";
+                                                                };
+                                                                readonly direction: {
+                                                                    readonly enum: readonly ["asc", "desc"];
+                                                                };
+                                                            };
+                                                        };
+                                                    };
+                                                    readonly defaultLimit: {
+                                                        readonly type: "integer";
+                                                        readonly minimum: 1;
+                                                        readonly maximum: 100;
+                                                    };
+                                                    readonly maxLimit: {
+                                                        readonly type: "integer";
+                                                        readonly minimum: 1;
+                                                        readonly maximum: 100;
+                                                    };
+                                                    readonly parameters: {
+                                                        readonly type: "array";
+                                                        readonly maxItems: 8;
+                                                        readonly uniqueItems: true;
+                                                        readonly items: {
+                                                            readonly type: "object";
+                                                            readonly additionalProperties: false;
+                                                            readonly required: readonly ["name", "field", "operator", "type"];
+                                                            readonly properties: {
+                                                                readonly name: {
+                                                                    readonly type: "string";
+                                                                    readonly pattern: "^[a-z][a-z0-9]*(?:[-_.][a-z0-9]+)*$";
+                                                                    readonly maxLength: 128;
+                                                                };
+                                                                readonly field: {
+                                                                    readonly type: "string";
+                                                                    readonly pattern: "^[A-Za-z][A-Za-z0-9_]{0,62}$";
+                                                                };
+                                                                readonly operator: {
+                                                                    readonly enum: readonly ["eq", "contains", "in"];
+                                                                };
+                                                                readonly type: {
+                                                                    readonly enum: readonly ["string", "number", "boolean", "string[]"];
+                                                                };
+                                                            };
+                                                        };
+                                                    };
+                                                    readonly aggregate: {
+                                                        readonly type: "object";
+                                                        readonly additionalProperties: false;
+                                                        readonly required: readonly ["measures"];
+                                                        readonly properties: {
+                                                            readonly dimensions: {
+                                                                readonly type: "array";
+                                                                readonly maxItems: 3;
+                                                                readonly items: {
+                                                                    readonly type: "object";
+                                                                    readonly additionalProperties: false;
+                                                                    readonly required: readonly ["field", "as"];
+                                                                    readonly properties: {
+                                                                        readonly field: {
+                                                                            readonly type: "string";
+                                                                            readonly pattern: "^[A-Za-z][A-Za-z0-9_]{0,62}$";
+                                                                        };
+                                                                        readonly as: {
+                                                                            readonly type: "string";
+                                                                            readonly pattern: "^[A-Za-z][A-Za-z0-9_]{0,62}$";
+                                                                        };
+                                                                        readonly bucket: {
+                                                                            readonly enum: readonly ["day", "week", "month", "quarter", "year"];
+                                                                        };
+                                                                    };
+                                                                };
+                                                            };
+                                                            readonly measures: {
+                                                                readonly type: "array";
+                                                                readonly minItems: 1;
+                                                                readonly maxItems: 8;
+                                                                readonly items: {
+                                                                    readonly type: "object";
+                                                                    readonly additionalProperties: false;
+                                                                    readonly required: readonly ["type", "as"];
+                                                                    readonly properties: {
+                                                                        readonly type: {
+                                                                            readonly enum: readonly ["count", "countDistinct", "sum", "avg", "min", "max"];
+                                                                        };
+                                                                        readonly field: {
+                                                                            readonly type: "string";
+                                                                            readonly pattern: "^[A-Za-z][A-Za-z0-9_]{0,62}$";
+                                                                        };
+                                                                        readonly as: {
+                                                                            readonly type: "string";
+                                                                            readonly pattern: "^[A-Za-z][A-Za-z0-9_]{0,62}$";
+                                                                        };
+                                                                    };
+                                                                };
+                                                            };
+                                                            readonly order: {
+                                                                readonly type: "array";
+                                                                readonly maxItems: 10;
+                                                                readonly items: {
+                                                                    readonly type: "object";
+                                                                    readonly additionalProperties: false;
+                                                                    readonly required: readonly ["field"];
+                                                                    readonly properties: {
+                                                                        readonly field: {
+                                                                            readonly type: "string";
+                                                                            readonly pattern: "^[A-Za-z][A-Za-z0-9_]{0,62}$";
+                                                                        };
+                                                                        readonly direction: {
+                                                                            readonly enum: readonly ["asc", "desc"];
+                                                                        };
+                                                                        readonly nulls: {
+                                                                            readonly enum: readonly ["first", "last"];
+                                                                        };
+                                                                    };
+                                                                };
+                                                            };
+                                                        };
+                                                    };
+                                                };
+                                            };
+                                        };
                                         readonly draft: {
                                             readonly type: "object";
                                             readonly additionalProperties: false;
@@ -21218,7 +21382,7 @@ export declare const contractBundleSchema: {
                                     readonly maxItems: 8;
                                     readonly uniqueItems: true;
                                     readonly items: {
-                                        readonly enum: readonly ["draft.read", "draft.update", "validate", "create", "own.list", "own.read", "public.list", "public.read"];
+                                        readonly enum: readonly ["draft.read", "draft.update", "validate", "create", "own.list", "own.read", "public.list", "public.read", "public.query"];
                                     };
                                 };
                                 readonly fields: {
@@ -21376,6 +21540,170 @@ export declare const contractBundleSchema: {
                                         };
                                     };
                                 };
+                                readonly publicQueries: {
+                                    readonly type: "array";
+                                    readonly maxItems: 16;
+                                    readonly uniqueItems: true;
+                                    readonly items: {
+                                        readonly type: "object";
+                                        readonly additionalProperties: false;
+                                        readonly required: readonly ["code", "kind", "resourceCode", "fields", "defaultLimit", "maxLimit"];
+                                        readonly properties: {
+                                            readonly code: {
+                                                readonly type: "string";
+                                                readonly pattern: "^[a-z][a-z0-9]*(?:[-_.][a-z0-9]+)*$";
+                                                readonly maxLength: 128;
+                                            };
+                                            readonly kind: {
+                                                readonly enum: readonly ["records", "aggregate"];
+                                            };
+                                            readonly resourceCode: {
+                                                readonly type: "string";
+                                                readonly pattern: "^[a-z][a-z0-9]*(?:[-_.][a-z0-9]+)*$";
+                                                readonly maxLength: 128;
+                                            };
+                                            readonly fields: {
+                                                readonly type: "array";
+                                                readonly minItems: 1;
+                                                readonly maxItems: 64;
+                                                readonly uniqueItems: true;
+                                                readonly items: {
+                                                    readonly type: "string";
+                                                    readonly pattern: "^[A-Za-z][A-Za-z0-9_]{0,62}$";
+                                                };
+                                            };
+                                            readonly sort: {
+                                                readonly type: "array";
+                                                readonly maxItems: 4;
+                                                readonly uniqueItems: true;
+                                                readonly items: {
+                                                    readonly type: "object";
+                                                    readonly additionalProperties: false;
+                                                    readonly required: readonly ["field", "direction"];
+                                                    readonly properties: {
+                                                        readonly field: {
+                                                            readonly type: "string";
+                                                            readonly pattern: "^[A-Za-z][A-Za-z0-9_]{0,62}$";
+                                                        };
+                                                        readonly direction: {
+                                                            readonly enum: readonly ["asc", "desc"];
+                                                        };
+                                                    };
+                                                };
+                                            };
+                                            readonly defaultLimit: {
+                                                readonly type: "integer";
+                                                readonly minimum: 1;
+                                                readonly maximum: 100;
+                                            };
+                                            readonly maxLimit: {
+                                                readonly type: "integer";
+                                                readonly minimum: 1;
+                                                readonly maximum: 100;
+                                            };
+                                            readonly parameters: {
+                                                readonly type: "array";
+                                                readonly maxItems: 8;
+                                                readonly uniqueItems: true;
+                                                readonly items: {
+                                                    readonly type: "object";
+                                                    readonly additionalProperties: false;
+                                                    readonly required: readonly ["name", "field", "operator", "type"];
+                                                    readonly properties: {
+                                                        readonly name: {
+                                                            readonly type: "string";
+                                                            readonly pattern: "^[a-z][a-z0-9]*(?:[-_.][a-z0-9]+)*$";
+                                                            readonly maxLength: 128;
+                                                        };
+                                                        readonly field: {
+                                                            readonly type: "string";
+                                                            readonly pattern: "^[A-Za-z][A-Za-z0-9_]{0,62}$";
+                                                        };
+                                                        readonly operator: {
+                                                            readonly enum: readonly ["eq", "contains", "in"];
+                                                        };
+                                                        readonly type: {
+                                                            readonly enum: readonly ["string", "number", "boolean", "string[]"];
+                                                        };
+                                                    };
+                                                };
+                                            };
+                                            readonly aggregate: {
+                                                readonly type: "object";
+                                                readonly additionalProperties: false;
+                                                readonly required: readonly ["measures"];
+                                                readonly properties: {
+                                                    readonly dimensions: {
+                                                        readonly type: "array";
+                                                        readonly maxItems: 3;
+                                                        readonly items: {
+                                                            readonly type: "object";
+                                                            readonly additionalProperties: false;
+                                                            readonly required: readonly ["field", "as"];
+                                                            readonly properties: {
+                                                                readonly field: {
+                                                                    readonly type: "string";
+                                                                    readonly pattern: "^[A-Za-z][A-Za-z0-9_]{0,62}$";
+                                                                };
+                                                                readonly as: {
+                                                                    readonly type: "string";
+                                                                    readonly pattern: "^[A-Za-z][A-Za-z0-9_]{0,62}$";
+                                                                };
+                                                                readonly bucket: {
+                                                                    readonly enum: readonly ["day", "week", "month", "quarter", "year"];
+                                                                };
+                                                            };
+                                                        };
+                                                    };
+                                                    readonly measures: {
+                                                        readonly type: "array";
+                                                        readonly minItems: 1;
+                                                        readonly maxItems: 8;
+                                                        readonly items: {
+                                                            readonly type: "object";
+                                                            readonly additionalProperties: false;
+                                                            readonly required: readonly ["type", "as"];
+                                                            readonly properties: {
+                                                                readonly type: {
+                                                                    readonly enum: readonly ["count", "countDistinct", "sum", "avg", "min", "max"];
+                                                                };
+                                                                readonly field: {
+                                                                    readonly type: "string";
+                                                                    readonly pattern: "^[A-Za-z][A-Za-z0-9_]{0,62}$";
+                                                                };
+                                                                readonly as: {
+                                                                    readonly type: "string";
+                                                                    readonly pattern: "^[A-Za-z][A-Za-z0-9_]{0,62}$";
+                                                                };
+                                                            };
+                                                        };
+                                                    };
+                                                    readonly order: {
+                                                        readonly type: "array";
+                                                        readonly maxItems: 10;
+                                                        readonly items: {
+                                                            readonly type: "object";
+                                                            readonly additionalProperties: false;
+                                                            readonly required: readonly ["field"];
+                                                            readonly properties: {
+                                                                readonly field: {
+                                                                    readonly type: "string";
+                                                                    readonly pattern: "^[A-Za-z][A-Za-z0-9_]{0,62}$";
+                                                                };
+                                                                readonly direction: {
+                                                                    readonly enum: readonly ["asc", "desc"];
+                                                                };
+                                                                readonly nulls: {
+                                                                    readonly enum: readonly ["first", "last"];
+                                                                };
+                                                            };
+                                                        };
+                                                    };
+                                                };
+                                            };
+                                        };
+                                    };
+                                };
                                 readonly draft: {
                                     readonly type: "object";
                                     readonly additionalProperties: false;
@@ -32514,6 +32842,364 @@ export declare const contractSchemas: {
                 readonly type: "object";
                 readonly additionalProperties: false;
                 readonly properties: {
+                    readonly peopleSources: {
+                        readonly type: "array";
+                        readonly maxItems: 32;
+                        readonly items: {
+                            readonly type: "object";
+                            readonly additionalProperties: false;
+                            readonly required: readonly ["code", "title", "entry", "parameters"];
+                            readonly properties: {
+                                readonly code: {
+                                    readonly type: "string";
+                                    readonly pattern: "^[a-z][a-z0-9-]{0,63}$";
+                                };
+                                readonly title: {
+                                    type: string;
+                                    minLength: number;
+                                    maxLength: number;
+                                    pattern: string;
+                                };
+                                readonly entry: {
+                                    readonly type: "object";
+                                    readonly additionalProperties: false;
+                                    readonly required: readonly ["provider"];
+                                    readonly allOf: readonly [{
+                                        readonly if: {
+                                            readonly required: readonly ["roleCodes"];
+                                        };
+                                        readonly then: {
+                                            readonly properties: {
+                                                readonly provider: {
+                                                    readonly enum: readonly ["app_role", "app_role_in_scope"];
+                                                };
+                                            };
+                                            readonly not: {
+                                                readonly anyOf: readonly [{
+                                                    readonly required: readonly ["roleCode"];
+                                                }, {
+                                                    readonly required: readonly ["candidateField"];
+                                                }];
+                                            };
+                                        };
+                                    }, {
+                                        readonly if: {
+                                            readonly required: readonly ["candidateField"];
+                                        };
+                                        readonly then: {
+                                            readonly required: readonly ["inputPath"];
+                                            readonly properties: {
+                                                readonly provider: {
+                                                    readonly const: "form_field_users";
+                                                };
+                                            };
+                                            readonly not: {
+                                                readonly anyOf: readonly [{
+                                                    readonly required: readonly ["roleCode"];
+                                                }, {
+                                                    readonly required: readonly ["scope"];
+                                                }, {
+                                                    readonly required: readonly ["routing"];
+                                                }];
+                                            };
+                                        };
+                                    }, {
+                                        readonly if: {
+                                            readonly required: readonly ["selectedInputPath"];
+                                        };
+                                        readonly then: {
+                                            readonly properties: {
+                                                readonly provider: {
+                                                    readonly enum: readonly ["app_role", "app_role_in_scope"];
+                                                };
+                                            };
+                                            readonly anyOf: readonly [{
+                                                readonly required: readonly ["roleCode"];
+                                            }, {
+                                                readonly required: readonly ["roleCodes"];
+                                            }];
+                                            readonly not: {
+                                                readonly anyOf: readonly [{
+                                                    readonly required: readonly ["candidateField"];
+                                                }, {
+                                                    readonly required: readonly ["inputPath"];
+                                                }, {
+                                                    readonly required: readonly ["routing"];
+                                                }];
+                                            };
+                                        };
+                                    }];
+                                    readonly properties: {
+                                        readonly provider: {
+                                            readonly enum: readonly ["fixed_users", "initiator", "input_users", "form_field_users", "department_supervisor", "supervisor_chain", "app_role", "app_role_in_scope", "business_relation", "previous_node_actor", "initiator_select", "application_provider"];
+                                        };
+                                        readonly users: {
+                                            readonly type: "array";
+                                            readonly uniqueItems: true;
+                                            readonly items: {
+                                                readonly type: "string";
+                                                readonly minLength: 1;
+                                            };
+                                        };
+                                        readonly inputPath: {
+                                            readonly type: "string";
+                                        };
+                                        readonly selectedInputPath: {
+                                            readonly type: "string";
+                                            readonly maxLength: 255;
+                                            readonly pattern: "^[A-Za-z][A-Za-z0-9_-]*(?:\\.[A-Za-z][A-Za-z0-9_-]*)*$";
+                                        };
+                                        readonly candidateField: {
+                                            readonly type: "string";
+                                            readonly pattern: "^[A-Za-z][A-Za-z0-9_]{0,62}$";
+                                        };
+                                        readonly from: {
+                                            readonly oneOf: readonly [{
+                                                readonly const: "initiator";
+                                            }, {
+                                                readonly type: "object";
+                                                readonly additionalProperties: false;
+                                                readonly required: readonly ["field"];
+                                                readonly properties: {
+                                                    readonly field: {
+                                                        readonly type: "string";
+                                                        readonly maxLength: 255;
+                                                    };
+                                                };
+                                            }];
+                                        };
+                                        readonly until: {
+                                            readonly oneOf: readonly [{
+                                                readonly const: "top";
+                                            }, {
+                                                readonly type: "object";
+                                                readonly additionalProperties: false;
+                                                readonly required: readonly ["level"];
+                                                readonly properties: {
+                                                    readonly level: {
+                                                        readonly type: "integer";
+                                                        readonly minimum: 1;
+                                                        readonly maximum: 20;
+                                                    };
+                                                };
+                                            }, {
+                                                readonly type: "object";
+                                                readonly additionalProperties: false;
+                                                readonly required: readonly ["roleCode"];
+                                                readonly properties: {
+                                                    readonly roleCode: {
+                                                        readonly type: "string";
+                                                        readonly minLength: 1;
+                                                    };
+                                                };
+                                            }];
+                                        };
+                                        readonly continuous: {
+                                            readonly type: "boolean";
+                                        };
+                                        readonly missing: {
+                                            readonly enum: readonly ["skip_level", "block"];
+                                        };
+                                        readonly departmentIdFrom: {
+                                            readonly type: "string";
+                                        };
+                                        readonly level: {
+                                            readonly type: "integer";
+                                            readonly minimum: 1;
+                                            readonly maximum: 20;
+                                        };
+                                        readonly fallbackToAncestorSupervisor: {
+                                            readonly type: "boolean";
+                                        };
+                                        readonly roleCode: {
+                                            readonly type: "string";
+                                        };
+                                        readonly roleCodes: {
+                                            readonly type: "array";
+                                            readonly minItems: 2;
+                                            readonly maxItems: 8;
+                                            readonly uniqueItems: true;
+                                            readonly items: {
+                                                readonly type: "string";
+                                                readonly maxLength: 128;
+                                                readonly pattern: "^[a-z][a-z0-9]*(?:[-_.][a-z0-9]+)*$";
+                                            };
+                                        };
+                                        readonly scope: {
+                                            readonly type: "object";
+                                            readonly additionalProperties: false;
+                                            readonly required: readonly ["dimension"];
+                                            readonly properties: {
+                                                readonly dimension: {
+                                                    readonly type: "string";
+                                                    readonly minLength: 1;
+                                                };
+                                                readonly valueFrom: {
+                                                    readonly type: "string";
+                                                };
+                                                readonly value: {
+                                                    readonly type: "string";
+                                                };
+                                            };
+                                        };
+                                        readonly relationCode: {
+                                            readonly type: "string";
+                                        };
+                                        readonly resourceCode: {
+                                            readonly type: "string";
+                                        };
+                                        readonly resourceIdFrom: {
+                                            readonly type: "string";
+                                        };
+                                        readonly providerCode: {
+                                            readonly type: "string";
+                                        };
+                                        readonly min: {
+                                            readonly type: "integer";
+                                            readonly minimum: 1;
+                                            readonly maximum: 200;
+                                        };
+                                        readonly max: {
+                                            readonly type: "integer";
+                                            readonly minimum: 1;
+                                            readonly maximum: 200;
+                                        };
+                                        readonly delegatable: {
+                                            readonly type: "boolean";
+                                        };
+                                        readonly routing: {
+                                            readonly type: "object";
+                                            readonly additionalProperties: false;
+                                            readonly required: readonly ["policyCode", "title", "strategy", "dimensions", "sources"];
+                                            readonly properties: {
+                                                readonly policyCode: {
+                                                    readonly type: "string";
+                                                    readonly pattern: "^[a-z][a-z0-9_-]{0,127}$";
+                                                };
+                                                readonly title: {
+                                                    readonly type: "string";
+                                                    readonly minLength: 1;
+                                                    readonly maxLength: 128;
+                                                };
+                                                readonly strategy: {
+                                                    readonly enum: readonly ["replace_then_append", "replace_only"];
+                                                };
+                                                readonly dimensions: {
+                                                    readonly type: "object";
+                                                    readonly maxProperties: 8;
+                                                    readonly propertyNames: {
+                                                        readonly type: "string";
+                                                        readonly pattern: "^[a-z][a-z0-9_-]{0,127}$";
+                                                    };
+                                                    readonly additionalProperties: {
+                                                        readonly type: "object";
+                                                        readonly additionalProperties: false;
+                                                        readonly required: readonly ["title", "valueFrom"];
+                                                        readonly properties: {
+                                                            readonly title: {
+                                                                readonly type: "string";
+                                                                readonly minLength: 1;
+                                                                readonly maxLength: 128;
+                                                            };
+                                                            readonly valueFrom: {
+                                                                readonly type: "string";
+                                                                readonly minLength: 1;
+                                                                readonly maxLength: 255;
+                                                            };
+                                                        };
+                                                    };
+                                                };
+                                                readonly sources: {
+                                                    readonly type: "object";
+                                                    readonly minProperties: 1;
+                                                    readonly maxProperties: 16;
+                                                    readonly propertyNames: {
+                                                        readonly type: "string";
+                                                        readonly pattern: "^[a-z][a-z0-9_-]{0,127}$";
+                                                    };
+                                                    readonly additionalProperties: {
+                                                        readonly type: "object";
+                                                        readonly additionalProperties: false;
+                                                        readonly required: readonly ["title", "provider", "roleCode"];
+                                                        readonly properties: {
+                                                            readonly title: {
+                                                                readonly type: "string";
+                                                                readonly minLength: 1;
+                                                                readonly maxLength: 128;
+                                                            };
+                                                            readonly provider: {
+                                                                readonly enum: readonly ["app_role", "app_role_in_scope"];
+                                                            };
+                                                            readonly roleCode: {
+                                                                readonly type: "string";
+                                                                readonly pattern: "^[a-z][a-z0-9_-]{0,127}$";
+                                                            };
+                                                            readonly scope: {
+                                                                readonly type: "object";
+                                                                readonly additionalProperties: false;
+                                                                readonly required: readonly ["dimension"];
+                                                                readonly properties: {
+                                                                    readonly dimension: {
+                                                                        readonly type: "string";
+                                                                        readonly pattern: "^[a-z][a-z0-9_-]{0,127}$";
+                                                                    };
+                                                                    readonly value: {
+                                                                        readonly type: "string";
+                                                                        readonly minLength: 1;
+                                                                        readonly maxLength: 255;
+                                                                    };
+                                                                    readonly valueFrom: {
+                                                                        readonly type: "string";
+                                                                        readonly minLength: 1;
+                                                                        readonly maxLength: 255;
+                                                                    };
+                                                                };
+                                                            };
+                                                        };
+                                                    };
+                                                };
+                                            };
+                                        };
+                                    };
+                                };
+                                readonly parameters: {
+                                    readonly type: "object";
+                                    readonly minProperties: 1;
+                                    readonly maxProperties: 8;
+                                    readonly additionalProperties: {
+                                        readonly oneOf: readonly [{
+                                            readonly type: "object";
+                                            readonly additionalProperties: false;
+                                            readonly required: readonly ["values"];
+                                            readonly properties: {
+                                                readonly values: {
+                                                    readonly type: "array";
+                                                    readonly minItems: 1;
+                                                    readonly maxItems: 32;
+                                                };
+                                            };
+                                        }, {
+                                            readonly type: "object";
+                                            readonly additionalProperties: false;
+                                            readonly required: readonly ["minimum", "maximum"];
+                                            readonly properties: {
+                                                readonly minimum: {
+                                                    readonly type: "integer";
+                                                    readonly minimum: 1;
+                                                    readonly maximum: 200;
+                                                };
+                                                readonly maximum: {
+                                                    readonly type: "integer";
+                                                    readonly minimum: 1;
+                                                    readonly maximum: 200;
+                                                };
+                                            };
+                                        }];
+                                    };
+                                };
+                            };
+                        };
+                    };
                     readonly businessSteps: {
                         readonly type: "array";
                         readonly maxItems: 100;
@@ -34145,7 +34831,7 @@ export declare const contractSchemas: {
                                         readonly assignee: {
                                             readonly properties: {
                                                 readonly provider: {
-                                                    readonly enum: readonly ["fixed_users", "app_role", "app_role_in_scope", "supervisor_chain", "form_field_users", "input_users", "initiator", "previous_node_actor", "business_relation"];
+                                                    readonly enum: readonly ["fixed_users", "app_role", "app_role_in_scope", "supervisor_chain", "department_supervisor", "form_field_users", "input_users", "initiator", "previous_node_actor", "business_relation"];
                                                 };
                                                 readonly users: {
                                                     readonly type: "array";
@@ -34450,7 +35136,7 @@ export declare const contractSchemas: {
                             readonly otherwise: {
                                 readonly properties: {
                                     readonly provider: {
-                                        readonly enum: readonly ["fixed_users", "app_role", "app_role_in_scope", "supervisor_chain", "form_field_users", "input_users", "initiator", "previous_node_actor", "business_relation"];
+                                        readonly enum: readonly ["fixed_users", "app_role", "app_role_in_scope", "supervisor_chain", "department_supervisor", "form_field_users", "input_users", "initiator", "previous_node_actor", "business_relation"];
                                     };
                                     readonly users: {
                                         readonly type: "array";
@@ -44852,7 +45538,7 @@ export declare const contractSchemas: {
                                                 readonly maxItems: 8;
                                                 readonly uniqueItems: true;
                                                 readonly items: {
-                                                    readonly enum: readonly ["draft.read", "draft.update", "validate", "create", "own.list", "own.read", "public.list", "public.read"];
+                                                    readonly enum: readonly ["draft.read", "draft.update", "validate", "create", "own.list", "own.read", "public.list", "public.read", "public.query"];
                                                 };
                                             };
                                             readonly fields: {
@@ -45010,6 +45696,170 @@ export declare const contractSchemas: {
                                                     };
                                                 };
                                             };
+                                            readonly publicQueries: {
+                                                readonly type: "array";
+                                                readonly maxItems: 16;
+                                                readonly uniqueItems: true;
+                                                readonly items: {
+                                                    readonly type: "object";
+                                                    readonly additionalProperties: false;
+                                                    readonly required: readonly ["code", "kind", "resourceCode", "fields", "defaultLimit", "maxLimit"];
+                                                    readonly properties: {
+                                                        readonly code: {
+                                                            readonly type: "string";
+                                                            readonly pattern: "^[a-z][a-z0-9]*(?:[-_.][a-z0-9]+)*$";
+                                                            readonly maxLength: 128;
+                                                        };
+                                                        readonly kind: {
+                                                            readonly enum: readonly ["records", "aggregate"];
+                                                        };
+                                                        readonly resourceCode: {
+                                                            readonly type: "string";
+                                                            readonly pattern: "^[a-z][a-z0-9]*(?:[-_.][a-z0-9]+)*$";
+                                                            readonly maxLength: 128;
+                                                        };
+                                                        readonly fields: {
+                                                            readonly type: "array";
+                                                            readonly minItems: 1;
+                                                            readonly maxItems: 64;
+                                                            readonly uniqueItems: true;
+                                                            readonly items: {
+                                                                readonly type: "string";
+                                                                readonly pattern: "^[A-Za-z][A-Za-z0-9_]{0,62}$";
+                                                            };
+                                                        };
+                                                        readonly sort: {
+                                                            readonly type: "array";
+                                                            readonly maxItems: 4;
+                                                            readonly uniqueItems: true;
+                                                            readonly items: {
+                                                                readonly type: "object";
+                                                                readonly additionalProperties: false;
+                                                                readonly required: readonly ["field", "direction"];
+                                                                readonly properties: {
+                                                                    readonly field: {
+                                                                        readonly type: "string";
+                                                                        readonly pattern: "^[A-Za-z][A-Za-z0-9_]{0,62}$";
+                                                                    };
+                                                                    readonly direction: {
+                                                                        readonly enum: readonly ["asc", "desc"];
+                                                                    };
+                                                                };
+                                                            };
+                                                        };
+                                                        readonly defaultLimit: {
+                                                            readonly type: "integer";
+                                                            readonly minimum: 1;
+                                                            readonly maximum: 100;
+                                                        };
+                                                        readonly maxLimit: {
+                                                            readonly type: "integer";
+                                                            readonly minimum: 1;
+                                                            readonly maximum: 100;
+                                                        };
+                                                        readonly parameters: {
+                                                            readonly type: "array";
+                                                            readonly maxItems: 8;
+                                                            readonly uniqueItems: true;
+                                                            readonly items: {
+                                                                readonly type: "object";
+                                                                readonly additionalProperties: false;
+                                                                readonly required: readonly ["name", "field", "operator", "type"];
+                                                                readonly properties: {
+                                                                    readonly name: {
+                                                                        readonly type: "string";
+                                                                        readonly pattern: "^[a-z][a-z0-9]*(?:[-_.][a-z0-9]+)*$";
+                                                                        readonly maxLength: 128;
+                                                                    };
+                                                                    readonly field: {
+                                                                        readonly type: "string";
+                                                                        readonly pattern: "^[A-Za-z][A-Za-z0-9_]{0,62}$";
+                                                                    };
+                                                                    readonly operator: {
+                                                                        readonly enum: readonly ["eq", "contains", "in"];
+                                                                    };
+                                                                    readonly type: {
+                                                                        readonly enum: readonly ["string", "number", "boolean", "string[]"];
+                                                                    };
+                                                                };
+                                                            };
+                                                        };
+                                                        readonly aggregate: {
+                                                            readonly type: "object";
+                                                            readonly additionalProperties: false;
+                                                            readonly required: readonly ["measures"];
+                                                            readonly properties: {
+                                                                readonly dimensions: {
+                                                                    readonly type: "array";
+                                                                    readonly maxItems: 3;
+                                                                    readonly items: {
+                                                                        readonly type: "object";
+                                                                        readonly additionalProperties: false;
+                                                                        readonly required: readonly ["field", "as"];
+                                                                        readonly properties: {
+                                                                            readonly field: {
+                                                                                readonly type: "string";
+                                                                                readonly pattern: "^[A-Za-z][A-Za-z0-9_]{0,62}$";
+                                                                            };
+                                                                            readonly as: {
+                                                                                readonly type: "string";
+                                                                                readonly pattern: "^[A-Za-z][A-Za-z0-9_]{0,62}$";
+                                                                            };
+                                                                            readonly bucket: {
+                                                                                readonly enum: readonly ["day", "week", "month", "quarter", "year"];
+                                                                            };
+                                                                        };
+                                                                    };
+                                                                };
+                                                                readonly measures: {
+                                                                    readonly type: "array";
+                                                                    readonly minItems: 1;
+                                                                    readonly maxItems: 8;
+                                                                    readonly items: {
+                                                                        readonly type: "object";
+                                                                        readonly additionalProperties: false;
+                                                                        readonly required: readonly ["type", "as"];
+                                                                        readonly properties: {
+                                                                            readonly type: {
+                                                                                readonly enum: readonly ["count", "countDistinct", "sum", "avg", "min", "max"];
+                                                                            };
+                                                                            readonly field: {
+                                                                                readonly type: "string";
+                                                                                readonly pattern: "^[A-Za-z][A-Za-z0-9_]{0,62}$";
+                                                                            };
+                                                                            readonly as: {
+                                                                                readonly type: "string";
+                                                                                readonly pattern: "^[A-Za-z][A-Za-z0-9_]{0,62}$";
+                                                                            };
+                                                                        };
+                                                                    };
+                                                                };
+                                                                readonly order: {
+                                                                    readonly type: "array";
+                                                                    readonly maxItems: 10;
+                                                                    readonly items: {
+                                                                        readonly type: "object";
+                                                                        readonly additionalProperties: false;
+                                                                        readonly required: readonly ["field"];
+                                                                        readonly properties: {
+                                                                            readonly field: {
+                                                                                readonly type: "string";
+                                                                                readonly pattern: "^[A-Za-z][A-Za-z0-9_]{0,62}$";
+                                                                            };
+                                                                            readonly direction: {
+                                                                                readonly enum: readonly ["asc", "desc"];
+                                                                            };
+                                                                            readonly nulls: {
+                                                                                readonly enum: readonly ["first", "last"];
+                                                                            };
+                                                                        };
+                                                                    };
+                                                                };
+                                                            };
+                                                        };
+                                                    };
+                                                };
+                                            };
                                             readonly draft: {
                                                 readonly type: "object";
                                                 readonly additionalProperties: false;
@@ -46165,7 +47015,7 @@ export declare const contractSchemas: {
                                         readonly maxItems: 8;
                                         readonly uniqueItems: true;
                                         readonly items: {
-                                            readonly enum: readonly ["draft.read", "draft.update", "validate", "create", "own.list", "own.read", "public.list", "public.read"];
+                                            readonly enum: readonly ["draft.read", "draft.update", "validate", "create", "own.list", "own.read", "public.list", "public.read", "public.query"];
                                         };
                                     };
                                     readonly fields: {
@@ -46323,6 +47173,170 @@ export declare const contractSchemas: {
                                             };
                                         };
                                     };
+                                    readonly publicQueries: {
+                                        readonly type: "array";
+                                        readonly maxItems: 16;
+                                        readonly uniqueItems: true;
+                                        readonly items: {
+                                            readonly type: "object";
+                                            readonly additionalProperties: false;
+                                            readonly required: readonly ["code", "kind", "resourceCode", "fields", "defaultLimit", "maxLimit"];
+                                            readonly properties: {
+                                                readonly code: {
+                                                    readonly type: "string";
+                                                    readonly pattern: "^[a-z][a-z0-9]*(?:[-_.][a-z0-9]+)*$";
+                                                    readonly maxLength: 128;
+                                                };
+                                                readonly kind: {
+                                                    readonly enum: readonly ["records", "aggregate"];
+                                                };
+                                                readonly resourceCode: {
+                                                    readonly type: "string";
+                                                    readonly pattern: "^[a-z][a-z0-9]*(?:[-_.][a-z0-9]+)*$";
+                                                    readonly maxLength: 128;
+                                                };
+                                                readonly fields: {
+                                                    readonly type: "array";
+                                                    readonly minItems: 1;
+                                                    readonly maxItems: 64;
+                                                    readonly uniqueItems: true;
+                                                    readonly items: {
+                                                        readonly type: "string";
+                                                        readonly pattern: "^[A-Za-z][A-Za-z0-9_]{0,62}$";
+                                                    };
+                                                };
+                                                readonly sort: {
+                                                    readonly type: "array";
+                                                    readonly maxItems: 4;
+                                                    readonly uniqueItems: true;
+                                                    readonly items: {
+                                                        readonly type: "object";
+                                                        readonly additionalProperties: false;
+                                                        readonly required: readonly ["field", "direction"];
+                                                        readonly properties: {
+                                                            readonly field: {
+                                                                readonly type: "string";
+                                                                readonly pattern: "^[A-Za-z][A-Za-z0-9_]{0,62}$";
+                                                            };
+                                                            readonly direction: {
+                                                                readonly enum: readonly ["asc", "desc"];
+                                                            };
+                                                        };
+                                                    };
+                                                };
+                                                readonly defaultLimit: {
+                                                    readonly type: "integer";
+                                                    readonly minimum: 1;
+                                                    readonly maximum: 100;
+                                                };
+                                                readonly maxLimit: {
+                                                    readonly type: "integer";
+                                                    readonly minimum: 1;
+                                                    readonly maximum: 100;
+                                                };
+                                                readonly parameters: {
+                                                    readonly type: "array";
+                                                    readonly maxItems: 8;
+                                                    readonly uniqueItems: true;
+                                                    readonly items: {
+                                                        readonly type: "object";
+                                                        readonly additionalProperties: false;
+                                                        readonly required: readonly ["name", "field", "operator", "type"];
+                                                        readonly properties: {
+                                                            readonly name: {
+                                                                readonly type: "string";
+                                                                readonly pattern: "^[a-z][a-z0-9]*(?:[-_.][a-z0-9]+)*$";
+                                                                readonly maxLength: 128;
+                                                            };
+                                                            readonly field: {
+                                                                readonly type: "string";
+                                                                readonly pattern: "^[A-Za-z][A-Za-z0-9_]{0,62}$";
+                                                            };
+                                                            readonly operator: {
+                                                                readonly enum: readonly ["eq", "contains", "in"];
+                                                            };
+                                                            readonly type: {
+                                                                readonly enum: readonly ["string", "number", "boolean", "string[]"];
+                                                            };
+                                                        };
+                                                    };
+                                                };
+                                                readonly aggregate: {
+                                                    readonly type: "object";
+                                                    readonly additionalProperties: false;
+                                                    readonly required: readonly ["measures"];
+                                                    readonly properties: {
+                                                        readonly dimensions: {
+                                                            readonly type: "array";
+                                                            readonly maxItems: 3;
+                                                            readonly items: {
+                                                                readonly type: "object";
+                                                                readonly additionalProperties: false;
+                                                                readonly required: readonly ["field", "as"];
+                                                                readonly properties: {
+                                                                    readonly field: {
+                                                                        readonly type: "string";
+                                                                        readonly pattern: "^[A-Za-z][A-Za-z0-9_]{0,62}$";
+                                                                    };
+                                                                    readonly as: {
+                                                                        readonly type: "string";
+                                                                        readonly pattern: "^[A-Za-z][A-Za-z0-9_]{0,62}$";
+                                                                    };
+                                                                    readonly bucket: {
+                                                                        readonly enum: readonly ["day", "week", "month", "quarter", "year"];
+                                                                    };
+                                                                };
+                                                            };
+                                                        };
+                                                        readonly measures: {
+                                                            readonly type: "array";
+                                                            readonly minItems: 1;
+                                                            readonly maxItems: 8;
+                                                            readonly items: {
+                                                                readonly type: "object";
+                                                                readonly additionalProperties: false;
+                                                                readonly required: readonly ["type", "as"];
+                                                                readonly properties: {
+                                                                    readonly type: {
+                                                                        readonly enum: readonly ["count", "countDistinct", "sum", "avg", "min", "max"];
+                                                                    };
+                                                                    readonly field: {
+                                                                        readonly type: "string";
+                                                                        readonly pattern: "^[A-Za-z][A-Za-z0-9_]{0,62}$";
+                                                                    };
+                                                                    readonly as: {
+                                                                        readonly type: "string";
+                                                                        readonly pattern: "^[A-Za-z][A-Za-z0-9_]{0,62}$";
+                                                                    };
+                                                                };
+                                                            };
+                                                        };
+                                                        readonly order: {
+                                                            readonly type: "array";
+                                                            readonly maxItems: 10;
+                                                            readonly items: {
+                                                                readonly type: "object";
+                                                                readonly additionalProperties: false;
+                                                                readonly required: readonly ["field"];
+                                                                readonly properties: {
+                                                                    readonly field: {
+                                                                        readonly type: "string";
+                                                                        readonly pattern: "^[A-Za-z][A-Za-z0-9_]{0,62}$";
+                                                                    };
+                                                                    readonly direction: {
+                                                                        readonly enum: readonly ["asc", "desc"];
+                                                                    };
+                                                                    readonly nulls: {
+                                                                        readonly enum: readonly ["first", "last"];
+                                                                    };
+                                                                };
+                                                            };
+                                                        };
+                                                    };
+                                                };
+                                            };
+                                        };
+                                    };
                                     readonly draft: {
                                         readonly type: "object";
                                         readonly additionalProperties: false;