openxiangda-contracts 2.91.1 → 2.94.0

package/dist/schemas.d.ts

@@ -8426,6 +8426,72 @@ export declare const dataTransactionRequestSchema: {
                                 };
                             };
                         };
+                        readonly assertions: {
+                            readonly type: "array";
+                            readonly minItems: 1;
+                            readonly maxItems: 20;
+                            readonly items: {
+                                readonly oneOf: readonly [{
+                                    readonly type: "object";
+                                    readonly additionalProperties: false;
+                                    readonly required: readonly ["kind", "field", "operator"];
+                                    readonly properties: {
+                                        readonly kind: {
+                                            readonly const: "value";
+                                        };
+                                        readonly field: {
+                                            readonly type: "string";
+                                            readonly pattern: "^[A-Za-z][A-Za-z0-9_]{0,62}$";
+                                        };
+                                        readonly operator: {
+                                            readonly enum: readonly ["eq", "neq", "gt", "gte", "lt", "lte", "contains", "startsWith", "endsWith", "in", "between", "has", "hasAny", "hasAll", "overlaps", "containedBy", "jsonContains", "isEmpty", "isNotEmpty"];
+                                        };
+                                        readonly value: {};
+                                        readonly path: {
+                                            readonly type: "string";
+                                            readonly minLength: 1;
+                                            readonly maxLength: 128;
+                                        };
+                                    };
+                                }, {
+                                    readonly type: "object";
+                                    readonly additionalProperties: false;
+                                    readonly required: readonly ["kind", "leftField", "operator", "rightField"];
+                                    readonly properties: {
+                                        readonly kind: {
+                                            readonly const: "field";
+                                        };
+                                        readonly leftField: {
+                                            readonly type: "string";
+                                            readonly pattern: "^[A-Za-z][A-Za-z0-9_]{0,62}$";
+                                        };
+                                        readonly operator: {
+                                            readonly enum: readonly ["eq", "neq", "gt", "gte", "lt", "lte"];
+                                        };
+                                        readonly rightField: {
+                                            readonly type: "string";
+                                            readonly pattern: "^[A-Za-z][A-Za-z0-9_]{0,62}$";
+                                        };
+                                    };
+                                }, {
+                                    readonly type: "object";
+                                    readonly additionalProperties: false;
+                                    readonly required: readonly ["kind", "field", "operator"];
+                                    readonly properties: {
+                                        readonly kind: {
+                                            readonly const: "database-now";
+                                        };
+                                        readonly field: {
+                                            readonly type: "string";
+                                            readonly pattern: "^[A-Za-z][A-Za-z0-9_]{0,62}$";
+                                        };
+                                        readonly operator: {
+                                            readonly enum: readonly ["eq", "neq", "gt", "gte", "lt", "lte"];
+                                        };
+                                    };
+                                }];
+                            };
+                        };
                         readonly where: {
                             readonly $ref: "#/$defs/dataWhere";
                         };
@@ -12604,6 +12670,72 @@ export declare const businessProcessCommitSchema: {
                                         };
                                     };
                                 };
+                                readonly assertions: {
+                                    readonly type: "array";
+                                    readonly minItems: 1;
+                                    readonly maxItems: 20;
+                                    readonly items: {
+                                        readonly oneOf: readonly [{
+                                            readonly type: "object";
+                                            readonly additionalProperties: false;
+                                            readonly required: readonly ["kind", "field", "operator"];
+                                            readonly properties: {
+                                                readonly kind: {
+                                                    readonly const: "value";
+                                                };
+                                                readonly field: {
+                                                    readonly type: "string";
+                                                    readonly pattern: "^[A-Za-z][A-Za-z0-9_]{0,62}$";
+                                                };
+                                                readonly operator: {
+                                                    readonly enum: readonly ["eq", "neq", "gt", "gte", "lt", "lte", "contains", "startsWith", "endsWith", "in", "between", "has", "hasAny", "hasAll", "overlaps", "containedBy", "jsonContains", "isEmpty", "isNotEmpty"];
+                                                };
+                                                readonly value: {};
+                                                readonly path: {
+                                                    readonly type: "string";
+                                                    readonly minLength: 1;
+                                                    readonly maxLength: 128;
+                                                };
+                                            };
+                                        }, {
+                                            readonly type: "object";
+                                            readonly additionalProperties: false;
+                                            readonly required: readonly ["kind", "leftField", "operator", "rightField"];
+                                            readonly properties: {
+                                                readonly kind: {
+                                                    readonly const: "field";
+                                                };
+                                                readonly leftField: {
+                                                    readonly type: "string";
+                                                    readonly pattern: "^[A-Za-z][A-Za-z0-9_]{0,62}$";
+                                                };
+                                                readonly operator: {
+                                                    readonly enum: readonly ["eq", "neq", "gt", "gte", "lt", "lte"];
+                                                };
+                                                readonly rightField: {
+                                                    readonly type: "string";
+                                                    readonly pattern: "^[A-Za-z][A-Za-z0-9_]{0,62}$";
+                                                };
+                                            };
+                                        }, {
+                                            readonly type: "object";
+                                            readonly additionalProperties: false;
+                                            readonly required: readonly ["kind", "field", "operator"];
+                                            readonly properties: {
+                                                readonly kind: {
+                                                    readonly const: "database-now";
+                                                };
+                                                readonly field: {
+                                                    readonly type: "string";
+                                                    readonly pattern: "^[A-Za-z][A-Za-z0-9_]{0,62}$";
+                                                };
+                                                readonly operator: {
+                                                    readonly enum: readonly ["eq", "neq", "gt", "gte", "lt", "lte"];
+                                                };
+                                            };
+                                        }];
+                                    };
+                                };
                                 readonly where: {
                                     readonly $ref: "#/$defs/dataWhere";
                                 };
@@ -13458,170 +13590,236 @@ export declare const businessProcessCommandWithDataSchema: {
                                         };
                                     };
                                 };
-                                readonly where: {
-                                    readonly $ref: "#/$defs/dataWhere";
-                                };
-                            };
-                        }, {
-                            readonly type: "object";
-                            readonly additionalProperties: false;
-                            readonly required: readonly ["kind", "errorCode", "anyOf"];
-                            readonly properties: {
-                                readonly kind: {
-                                    readonly const: "actor-authority";
-                                };
-                                readonly errorCode: {
-                                    readonly type: "string";
-                                    readonly pattern: "^OPENXIANGDA_[A-Z0-9_]{1,96}$";
-                                };
-                                readonly allowAppSuperAdmin: {
-                                    readonly type: "boolean";
-                                };
-                                readonly anyOf: {
-                                    readonly type: "array";
-                                    readonly minItems: 1;
-                                    readonly maxItems: 20;
-                                    readonly uniqueItems: true;
-                                    readonly items: {
-                                        readonly type: "object";
-                                        readonly additionalProperties: false;
-                                        readonly required: readonly ["roleCode"];
-                                        readonly properties: {
-                                            readonly roleCode: {
-                                                readonly type: "string";
-                                                readonly pattern: "^[a-z][a-z0-9]*(?:[-_.][a-z0-9]+)*$";
-                                                readonly maxLength: 100;
-                                            };
-                                            readonly scope: {
-                                                readonly type: "object";
-                                                readonly additionalProperties: false;
-                                                readonly required: readonly ["dimensionCode", "value", "operation"];
-                                                readonly properties: {
-                                                    readonly dimensionCode: {
-                                                        readonly type: "string";
-                                                        readonly pattern: "^[a-z][a-z0-9]*(?:[-_.][a-z0-9]+)*$";
-                                                        readonly maxLength: 100;
-                                                    };
-                                                    readonly value: {
-                                                        readonly type: "string";
-                                                        readonly minLength: 1;
-                                                        readonly maxLength: 255;
-                                                        readonly pattern: "^\\S(?:[\\s\\S]*\\S)?$";
-                                                    };
-                                                    readonly operation: {
-                                                        readonly type: "string";
-                                                        readonly maxLength: 64;
-                                                        readonly pattern: "^[A-Za-z0-9*][A-Za-z0-9*._:-]*$";
-                                                    };
-                                                };
-                                            };
-                                        };
-                                    };
-                                };
-                            };
-                        }, {
-                            readonly type: "object";
-                            readonly additionalProperties: false;
-                            readonly required: readonly ["kind", "operationIndex", "field", "operator", "offsetMilliseconds", "errorCode"];
-                            readonly properties: {
-                                readonly kind: {
-                                    readonly const: "operation-time";
-                                };
-                                readonly operationIndex: {
-                                    readonly type: "integer";
-                                    readonly minimum: 0;
-                                    readonly maximum: number;
-                                };
-                                readonly field: {
-                                    readonly type: "string";
-                                    readonly pattern: "^[A-Za-z][A-Za-z0-9_]{0,62}$";
-                                };
-                                readonly operator: {
-                                    readonly enum: readonly ["eq", "neq", "gt", "gte", "lt", "lte"];
-                                };
-                                readonly offsetMilliseconds: {
-                                    readonly type: "integer";
-                                    readonly minimum: -31622400000;
-                                    readonly maximum: 31622400000;
-                                };
-                                readonly errorCode: {
-                                    readonly type: "string";
-                                    readonly pattern: "^OPENXIANGDA_[A-Z0-9_]{1,96}$";
-                                };
-                            };
-                        }, {
-                            readonly type: "object";
-                            readonly additionalProperties: false;
-                            readonly required: readonly ["kind", "userId", "roleCode", "errorCode"];
-                            readonly properties: {
-                                readonly kind: {
-                                    readonly const: "role-member";
-                                };
-                                readonly userId: {
-                                    readonly type: "string";
-                                    readonly minLength: 1;
-                                    readonly maxLength: 255;
-                                };
-                                readonly roleCode: {
-                                    readonly type: "string";
-                                    readonly pattern: "^[a-z][a-z0-9]*(?:[-_.][a-z0-9]+)*$";
-                                    readonly maxLength: 100;
-                                };
-                                readonly errorCode: {
-                                    readonly type: "string";
-                                    readonly pattern: "^OPENXIANGDA_[A-Z0-9_]{1,96}$";
-                                };
-                            };
-                        }, {
-                            readonly type: "object";
-                            readonly additionalProperties: false;
-                            readonly required: readonly ["kind", "resourceCode", "lockKey", "errorCode", "where"];
-                            readonly properties: {
-                                readonly kind: {
-                                    readonly const: "query-empty";
-                                };
-                                readonly resourceCode: {
-                                    readonly type: "string";
-                                    readonly pattern: "^[a-z][a-z0-9]*(?:-[a-z0-9]+)*$";
-                                };
-                                readonly lockKey: {
-                                    readonly type: "string";
-                                    readonly minLength: 1;
-                                    readonly maxLength: 128;
-                                };
-                                readonly errorCode: {
-                                    readonly type: "string";
-                                    readonly pattern: "^OPENXIANGDA_[A-Z0-9_]{1,96}$";
-                                };
-                                readonly where: {
-                                    readonly $ref: "#/$defs/dataWhere";
-                                };
-                            };
-                        }, {
-                            readonly type: "object";
-                            readonly additionalProperties: false;
-                            readonly required: readonly ["kind", "resourceCode", "lockKey", "errorCode", "id", "assertions"];
-                            readonly properties: {
-                                readonly kind: {
-                                    readonly const: "record-assert";
-                                };
-                                readonly resourceCode: {
-                                    readonly type: "string";
-                                    readonly pattern: "^[a-z][a-z0-9]*(?:-[a-z0-9]+)*$";
-                                };
-                                readonly lockKey: {
-                                    readonly type: "string";
-                                    readonly minLength: 1;
-                                    readonly maxLength: 128;
-                                };
-                                readonly errorCode: {
-                                    readonly type: "string";
-                                    readonly pattern: "^OPENXIANGDA_[A-Z0-9_]{1,96}$";
-                                };
-                                readonly id: {
-                                    readonly type: "string";
-                                    readonly minLength: 1;
-                                };
+                                readonly assertions: {
+                                    readonly type: "array";
+                                    readonly minItems: 1;
+                                    readonly maxItems: 20;
+                                    readonly items: {
+                                        readonly oneOf: readonly [{
+                                            readonly type: "object";
+                                            readonly additionalProperties: false;
+                                            readonly required: readonly ["kind", "field", "operator"];
+                                            readonly properties: {
+                                                readonly kind: {
+                                                    readonly const: "value";
+                                                };
+                                                readonly field: {
+                                                    readonly type: "string";
+                                                    readonly pattern: "^[A-Za-z][A-Za-z0-9_]{0,62}$";
+                                                };
+                                                readonly operator: {
+                                                    readonly enum: readonly ["eq", "neq", "gt", "gte", "lt", "lte", "contains", "startsWith", "endsWith", "in", "between", "has", "hasAny", "hasAll", "overlaps", "containedBy", "jsonContains", "isEmpty", "isNotEmpty"];
+                                                };
+                                                readonly value: {};
+                                                readonly path: {
+                                                    readonly type: "string";
+                                                    readonly minLength: 1;
+                                                    readonly maxLength: 128;
+                                                };
+                                            };
+                                        }, {
+                                            readonly type: "object";
+                                            readonly additionalProperties: false;
+                                            readonly required: readonly ["kind", "leftField", "operator", "rightField"];
+                                            readonly properties: {
+                                                readonly kind: {
+                                                    readonly const: "field";
+                                                };
+                                                readonly leftField: {
+                                                    readonly type: "string";
+                                                    readonly pattern: "^[A-Za-z][A-Za-z0-9_]{0,62}$";
+                                                };
+                                                readonly operator: {
+                                                    readonly enum: readonly ["eq", "neq", "gt", "gte", "lt", "lte"];
+                                                };
+                                                readonly rightField: {
+                                                    readonly type: "string";
+                                                    readonly pattern: "^[A-Za-z][A-Za-z0-9_]{0,62}$";
+                                                };
+                                            };
+                                        }, {
+                                            readonly type: "object";
+                                            readonly additionalProperties: false;
+                                            readonly required: readonly ["kind", "field", "operator"];
+                                            readonly properties: {
+                                                readonly kind: {
+                                                    readonly const: "database-now";
+                                                };
+                                                readonly field: {
+                                                    readonly type: "string";
+                                                    readonly pattern: "^[A-Za-z][A-Za-z0-9_]{0,62}$";
+                                                };
+                                                readonly operator: {
+                                                    readonly enum: readonly ["eq", "neq", "gt", "gte", "lt", "lte"];
+                                                };
+                                            };
+                                        }];
+                                    };
+                                };
+                                readonly where: {
+                                    readonly $ref: "#/$defs/dataWhere";
+                                };
+                            };
+                        }, {
+                            readonly type: "object";
+                            readonly additionalProperties: false;
+                            readonly required: readonly ["kind", "errorCode", "anyOf"];
+                            readonly properties: {
+                                readonly kind: {
+                                    readonly const: "actor-authority";
+                                };
+                                readonly errorCode: {
+                                    readonly type: "string";
+                                    readonly pattern: "^OPENXIANGDA_[A-Z0-9_]{1,96}$";
+                                };
+                                readonly allowAppSuperAdmin: {
+                                    readonly type: "boolean";
+                                };
+                                readonly anyOf: {
+                                    readonly type: "array";
+                                    readonly minItems: 1;
+                                    readonly maxItems: 20;
+                                    readonly uniqueItems: true;
+                                    readonly items: {
+                                        readonly type: "object";
+                                        readonly additionalProperties: false;
+                                        readonly required: readonly ["roleCode"];
+                                        readonly properties: {
+                                            readonly roleCode: {
+                                                readonly type: "string";
+                                                readonly pattern: "^[a-z][a-z0-9]*(?:[-_.][a-z0-9]+)*$";
+                                                readonly maxLength: 100;
+                                            };
+                                            readonly scope: {
+                                                readonly type: "object";
+                                                readonly additionalProperties: false;
+                                                readonly required: readonly ["dimensionCode", "value", "operation"];
+                                                readonly properties: {
+                                                    readonly dimensionCode: {
+                                                        readonly type: "string";
+                                                        readonly pattern: "^[a-z][a-z0-9]*(?:[-_.][a-z0-9]+)*$";
+                                                        readonly maxLength: 100;
+                                                    };
+                                                    readonly value: {
+                                                        readonly type: "string";
+                                                        readonly minLength: 1;
+                                                        readonly maxLength: 255;
+                                                        readonly pattern: "^\\S(?:[\\s\\S]*\\S)?$";
+                                                    };
+                                                    readonly operation: {
+                                                        readonly type: "string";
+                                                        readonly maxLength: 64;
+                                                        readonly pattern: "^[A-Za-z0-9*][A-Za-z0-9*._:-]*$";
+                                                    };
+                                                };
+                                            };
+                                        };
+                                    };
+                                };
+                            };
+                        }, {
+                            readonly type: "object";
+                            readonly additionalProperties: false;
+                            readonly required: readonly ["kind", "operationIndex", "field", "operator", "offsetMilliseconds", "errorCode"];
+                            readonly properties: {
+                                readonly kind: {
+                                    readonly const: "operation-time";
+                                };
+                                readonly operationIndex: {
+                                    readonly type: "integer";
+                                    readonly minimum: 0;
+                                    readonly maximum: number;
+                                };
+                                readonly field: {
+                                    readonly type: "string";
+                                    readonly pattern: "^[A-Za-z][A-Za-z0-9_]{0,62}$";
+                                };
+                                readonly operator: {
+                                    readonly enum: readonly ["eq", "neq", "gt", "gte", "lt", "lte"];
+                                };
+                                readonly offsetMilliseconds: {
+                                    readonly type: "integer";
+                                    readonly minimum: -31622400000;
+                                    readonly maximum: 31622400000;
+                                };
+                                readonly errorCode: {
+                                    readonly type: "string";
+                                    readonly pattern: "^OPENXIANGDA_[A-Z0-9_]{1,96}$";
+                                };
+                            };
+                        }, {
+                            readonly type: "object";
+                            readonly additionalProperties: false;
+                            readonly required: readonly ["kind", "userId", "roleCode", "errorCode"];
+                            readonly properties: {
+                                readonly kind: {
+                                    readonly const: "role-member";
+                                };
+                                readonly userId: {
+                                    readonly type: "string";
+                                    readonly minLength: 1;
+                                    readonly maxLength: 255;
+                                };
+                                readonly roleCode: {
+                                    readonly type: "string";
+                                    readonly pattern: "^[a-z][a-z0-9]*(?:[-_.][a-z0-9]+)*$";
+                                    readonly maxLength: 100;
+                                };
+                                readonly errorCode: {
+                                    readonly type: "string";
+                                    readonly pattern: "^OPENXIANGDA_[A-Z0-9_]{1,96}$";
+                                };
+                            };
+                        }, {
+                            readonly type: "object";
+                            readonly additionalProperties: false;
+                            readonly required: readonly ["kind", "resourceCode", "lockKey", "errorCode", "where"];
+                            readonly properties: {
+                                readonly kind: {
+                                    readonly const: "query-empty";
+                                };
+                                readonly resourceCode: {
+                                    readonly type: "string";
+                                    readonly pattern: "^[a-z][a-z0-9]*(?:-[a-z0-9]+)*$";
+                                };
+                                readonly lockKey: {
+                                    readonly type: "string";
+                                    readonly minLength: 1;
+                                    readonly maxLength: 128;
+                                };
+                                readonly errorCode: {
+                                    readonly type: "string";
+                                    readonly pattern: "^OPENXIANGDA_[A-Z0-9_]{1,96}$";
+                                };
+                                readonly where: {
+                                    readonly $ref: "#/$defs/dataWhere";
+                                };
+                            };
+                        }, {
+                            readonly type: "object";
+                            readonly additionalProperties: false;
+                            readonly required: readonly ["kind", "resourceCode", "lockKey", "errorCode", "id", "assertions"];
+                            readonly properties: {
+                                readonly kind: {
+                                    readonly const: "record-assert";
+                                };
+                                readonly resourceCode: {
+                                    readonly type: "string";
+                                    readonly pattern: "^[a-z][a-z0-9]*(?:-[a-z0-9]+)*$";
+                                };
+                                readonly lockKey: {
+                                    readonly type: "string";
+                                    readonly minLength: 1;
+                                    readonly maxLength: 128;
+                                };
+                                readonly errorCode: {
+                                    readonly type: "string";
+                                    readonly pattern: "^OPENXIANGDA_[A-Z0-9_]{1,96}$";
+                                };
+                                readonly id: {
+                                    readonly type: "string";
+                                    readonly minLength: 1;
+                                };
                                 readonly assertions: {
                                     readonly type: "array";
                                     readonly minItems: 1;
@@ -18393,6 +18591,31 @@ export declare const configurationBundleSchema: {
                                 readonly additionalProperties: false;
                                 readonly minProperties: 1;
                                 readonly properties: {
+                                    readonly transactionTime: {
+                                        readonly type: "object";
+                                        readonly additionalProperties: false;
+                                        readonly required: readonly ["mode"];
+                                        readonly properties: {
+                                            readonly mode: {
+                                                readonly const: "database-accepted";
+                                            };
+                                            readonly recordSetAssertions: {
+                                                readonly const: true;
+                                            };
+                                        };
+                                    };
+                                    readonly directoryClasses: {
+                                        readonly type: "object";
+                                        readonly additionalProperties: false;
+                                        readonly required: readonly ["maxIds"];
+                                        readonly properties: {
+                                            readonly maxIds: {
+                                                readonly type: "integer";
+                                                readonly minimum: 1;
+                                                readonly maximum: 20;
+                                            };
+                                        };
+                                    };
                                     readonly ownedSubject: {
                                         readonly type: "object";
                                         readonly additionalProperties: false;
@@ -19682,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: {
@@ -19840,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;
@@ -20995,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: {
@@ -21153,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;
@@ -30359,6 +30910,72 @@ export declare const contractSchemas: {
                                     };
                                 };
                             };
+                            readonly assertions: {
+                                readonly type: "array";
+                                readonly minItems: 1;
+                                readonly maxItems: 20;
+                                readonly items: {
+                                    readonly oneOf: readonly [{
+                                        readonly type: "object";
+                                        readonly additionalProperties: false;
+                                        readonly required: readonly ["kind", "field", "operator"];
+                                        readonly properties: {
+                                            readonly kind: {
+                                                readonly const: "value";
+                                            };
+                                            readonly field: {
+                                                readonly type: "string";
+                                                readonly pattern: "^[A-Za-z][A-Za-z0-9_]{0,62}$";
+                                            };
+                                            readonly operator: {
+                                                readonly enum: readonly ["eq", "neq", "gt", "gte", "lt", "lte", "contains", "startsWith", "endsWith", "in", "between", "has", "hasAny", "hasAll", "overlaps", "containedBy", "jsonContains", "isEmpty", "isNotEmpty"];
+                                            };
+                                            readonly value: {};
+                                            readonly path: {
+                                                readonly type: "string";
+                                                readonly minLength: 1;
+                                                readonly maxLength: 128;
+                                            };
+                                        };
+                                    }, {
+                                        readonly type: "object";
+                                        readonly additionalProperties: false;
+                                        readonly required: readonly ["kind", "leftField", "operator", "rightField"];
+                                        readonly properties: {
+                                            readonly kind: {
+                                                readonly const: "field";
+                                            };
+                                            readonly leftField: {
+                                                readonly type: "string";
+                                                readonly pattern: "^[A-Za-z][A-Za-z0-9_]{0,62}$";
+                                            };
+                                            readonly operator: {
+                                                readonly enum: readonly ["eq", "neq", "gt", "gte", "lt", "lte"];
+                                            };
+                                            readonly rightField: {
+                                                readonly type: "string";
+                                                readonly pattern: "^[A-Za-z][A-Za-z0-9_]{0,62}$";
+                                            };
+                                        };
+                                    }, {
+                                        readonly type: "object";
+                                        readonly additionalProperties: false;
+                                        readonly required: readonly ["kind", "field", "operator"];
+                                        readonly properties: {
+                                            readonly kind: {
+                                                readonly const: "database-now";
+                                            };
+                                            readonly field: {
+                                                readonly type: "string";
+                                                readonly pattern: "^[A-Za-z][A-Za-z0-9_]{0,62}$";
+                                            };
+                                            readonly operator: {
+                                                readonly enum: readonly ["eq", "neq", "gt", "gte", "lt", "lte"];
+                                            };
+                                        };
+                                    }];
+                                };
+                            };
                             readonly where: {
                                 readonly $ref: "#/$defs/dataWhere";
                             };
@@ -37562,6 +38179,72 @@ export declare const contractSchemas: {
                                             };
                                         };
                                     };
+                                    readonly assertions: {
+                                        readonly type: "array";
+                                        readonly minItems: 1;
+                                        readonly maxItems: 20;
+                                        readonly items: {
+                                            readonly oneOf: readonly [{
+                                                readonly type: "object";
+                                                readonly additionalProperties: false;
+                                                readonly required: readonly ["kind", "field", "operator"];
+                                                readonly properties: {
+                                                    readonly kind: {
+                                                        readonly const: "value";
+                                                    };
+                                                    readonly field: {
+                                                        readonly type: "string";
+                                                        readonly pattern: "^[A-Za-z][A-Za-z0-9_]{0,62}$";
+                                                    };
+                                                    readonly operator: {
+                                                        readonly enum: readonly ["eq", "neq", "gt", "gte", "lt", "lte", "contains", "startsWith", "endsWith", "in", "between", "has", "hasAny", "hasAll", "overlaps", "containedBy", "jsonContains", "isEmpty", "isNotEmpty"];
+                                                    };
+                                                    readonly value: {};
+                                                    readonly path: {
+                                                        readonly type: "string";
+                                                        readonly minLength: 1;
+                                                        readonly maxLength: 128;
+                                                    };
+                                                };
+                                            }, {
+                                                readonly type: "object";
+                                                readonly additionalProperties: false;
+                                                readonly required: readonly ["kind", "leftField", "operator", "rightField"];
+                                                readonly properties: {
+                                                    readonly kind: {
+                                                        readonly const: "field";
+                                                    };
+                                                    readonly leftField: {
+                                                        readonly type: "string";
+                                                        readonly pattern: "^[A-Za-z][A-Za-z0-9_]{0,62}$";
+                                                    };
+                                                    readonly operator: {
+                                                        readonly enum: readonly ["eq", "neq", "gt", "gte", "lt", "lte"];
+                                                    };
+                                                    readonly rightField: {
+                                                        readonly type: "string";
+                                                        readonly pattern: "^[A-Za-z][A-Za-z0-9_]{0,62}$";
+                                                    };
+                                                };
+                                            }, {
+                                                readonly type: "object";
+                                                readonly additionalProperties: false;
+                                                readonly required: readonly ["kind", "field", "operator"];
+                                                readonly properties: {
+                                                    readonly kind: {
+                                                        readonly const: "database-now";
+                                                    };
+                                                    readonly field: {
+                                                        readonly type: "string";
+                                                        readonly pattern: "^[A-Za-z][A-Za-z0-9_]{0,62}$";
+                                                    };
+                                                    readonly operator: {
+                                                        readonly enum: readonly ["eq", "neq", "gt", "gte", "lt", "lte"];
+                                                    };
+                                                };
+                                            }];
+                                        };
+                                    };
                                     readonly where: {
                                         readonly $ref: "#/$defs/dataWhere";
                                     };
@@ -38416,6 +39099,72 @@ export declare const contractSchemas: {
                                             };
                                         };
                                     };
+                                    readonly assertions: {
+                                        readonly type: "array";
+                                        readonly minItems: 1;
+                                        readonly maxItems: 20;
+                                        readonly items: {
+                                            readonly oneOf: readonly [{
+                                                readonly type: "object";
+                                                readonly additionalProperties: false;
+                                                readonly required: readonly ["kind", "field", "operator"];
+                                                readonly properties: {
+                                                    readonly kind: {
+                                                        readonly const: "value";
+                                                    };
+                                                    readonly field: {
+                                                        readonly type: "string";
+                                                        readonly pattern: "^[A-Za-z][A-Za-z0-9_]{0,62}$";
+                                                    };
+                                                    readonly operator: {
+                                                        readonly enum: readonly ["eq", "neq", "gt", "gte", "lt", "lte", "contains", "startsWith", "endsWith", "in", "between", "has", "hasAny", "hasAll", "overlaps", "containedBy", "jsonContains", "isEmpty", "isNotEmpty"];
+                                                    };
+                                                    readonly value: {};
+                                                    readonly path: {
+                                                        readonly type: "string";
+                                                        readonly minLength: 1;
+                                                        readonly maxLength: 128;
+                                                    };
+                                                };
+                                            }, {
+                                                readonly type: "object";
+                                                readonly additionalProperties: false;
+                                                readonly required: readonly ["kind", "leftField", "operator", "rightField"];
+                                                readonly properties: {
+                                                    readonly kind: {
+                                                        readonly const: "field";
+                                                    };
+                                                    readonly leftField: {
+                                                        readonly type: "string";
+                                                        readonly pattern: "^[A-Za-z][A-Za-z0-9_]{0,62}$";
+                                                    };
+                                                    readonly operator: {
+                                                        readonly enum: readonly ["eq", "neq", "gt", "gte", "lt", "lte"];
+                                                    };
+                                                    readonly rightField: {
+                                                        readonly type: "string";
+                                                        readonly pattern: "^[A-Za-z][A-Za-z0-9_]{0,62}$";
+                                                    };
+                                                };
+                                            }, {
+                                                readonly type: "object";
+                                                readonly additionalProperties: false;
+                                                readonly required: readonly ["kind", "field", "operator"];
+                                                readonly properties: {
+                                                    readonly kind: {
+                                                        readonly const: "database-now";
+                                                    };
+                                                    readonly field: {
+                                                        readonly type: "string";
+                                                        readonly pattern: "^[A-Za-z][A-Za-z0-9_]{0,62}$";
+                                                    };
+                                                    readonly operator: {
+                                                        readonly enum: readonly ["eq", "neq", "gt", "gte", "lt", "lte"];
+                                                    };
+                                                };
+                                            }];
+                                        };
+                                    };
                                     readonly where: {
                                         readonly $ref: "#/$defs/dataWhere";
                                     };
@@ -43117,6 +43866,31 @@ export declare const contractSchemas: {
                                     readonly additionalProperties: false;
                                     readonly minProperties: 1;
                                     readonly properties: {
+                                        readonly transactionTime: {
+                                            readonly type: "object";
+                                            readonly additionalProperties: false;
+                                            readonly required: readonly ["mode"];
+                                            readonly properties: {
+                                                readonly mode: {
+                                                    readonly const: "database-accepted";
+                                                };
+                                                readonly recordSetAssertions: {
+                                                    readonly const: true;
+                                                };
+                                            };
+                                        };
+                                        readonly directoryClasses: {
+                                            readonly type: "object";
+                                            readonly additionalProperties: false;
+                                            readonly required: readonly ["maxIds"];
+                                            readonly properties: {
+                                                readonly maxIds: {
+                                                    readonly type: "integer";
+                                                    readonly minimum: 1;
+                                                    readonly maximum: 20;
+                                                };
+                                            };
+                                        };
                                         readonly ownedSubject: {
                                             readonly type: "object";
                                             readonly additionalProperties: false;
@@ -44406,7 +45180,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: {
@@ -44564,6 +45338,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;
@@ -45719,7 +46657,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: {
@@ -45877,6 +46815,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;