npm - openxiangda-contracts - Versions diffs - 2.92.0 → 2.94.0 - Mend

openxiangda-contracts 2.92.0 → 2.94.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (12) hide show

package/dist/native-compiler/compiler.js +203 -3
package/dist/native-compiler/compiler.js.map +1 -1
package/dist/native-compiler/index.cjs +4 -4
package/dist/native-compiler/index.js +4 -4
package/dist/native.d.ts +48 -1
package/dist/native.d.ts.map +1 -1
package/dist/native.js.map +1 -1
package/dist/schemas.d.ts +660 -4
package/dist/schemas.d.ts.map +1 -1
package/dist/schemas.js +105 -0
package/dist/schemas.js.map +1 -1
package/package.json +1 -1

package/dist/schemas.d.ts CHANGED Viewed

@@ -19905,7 +19905,7 @@ export declare const configurationBundleSchema: {
                                             readonly maxItems: 8;
                                             readonly uniqueItems: true;
                                             readonly items: {
-                                                readonly enum: readonly ["draft.read", "draft.update", "validate", "create", "own.list", "own.read", "public.list", "public.read"];
+                                                readonly enum: readonly ["draft.read", "draft.update", "validate", "create", "own.list", "own.read", "public.list", "public.read", "public.query"];
                                             };
                                         };
                                         readonly fields: {
@@ -20063,6 +20063,170 @@ export declare const configurationBundleSchema: {
                                                 };
                                             };
                                         };
+                                        readonly publicQueries: {
+                                            readonly type: "array";
+                                            readonly maxItems: 16;
+                                            readonly uniqueItems: true;
+                                            readonly items: {
+                                                readonly type: "object";
+                                                readonly additionalProperties: false;
+                                                readonly required: readonly ["code", "kind", "resourceCode", "fields", "defaultLimit", "maxLimit"];
+                                                readonly properties: {
+                                                    readonly code: {
+                                                        readonly type: "string";
+                                                        readonly pattern: "^[a-z][a-z0-9]*(?:[-_.][a-z0-9]+)*$";
+                                                        readonly maxLength: 128;
+                                                    };
+                                                    readonly kind: {
+                                                        readonly enum: readonly ["records", "aggregate"];
+                                                    };
+                                                    readonly resourceCode: {
+                                                        readonly type: "string";
+                                                        readonly pattern: "^[a-z][a-z0-9]*(?:[-_.][a-z0-9]+)*$";
+                                                        readonly maxLength: 128;
+                                                    };
+                                                    readonly fields: {
+                                                        readonly type: "array";
+                                                        readonly minItems: 1;
+                                                        readonly maxItems: 64;
+                                                        readonly uniqueItems: true;
+                                                        readonly items: {
+                                                            readonly type: "string";
+                                                            readonly pattern: "^[A-Za-z][A-Za-z0-9_]{0,62}$";
+                                                        };
+                                                    };
+                                                    readonly sort: {
+                                                        readonly type: "array";
+                                                        readonly maxItems: 4;
+                                                        readonly uniqueItems: true;
+                                                        readonly items: {
+                                                            readonly type: "object";
+                                                            readonly additionalProperties: false;
+                                                            readonly required: readonly ["field", "direction"];
+                                                            readonly properties: {
+                                                                readonly field: {
+                                                                    readonly type: "string";
+                                                                    readonly pattern: "^[A-Za-z][A-Za-z0-9_]{0,62}$";
+                                                                };
+                                                                readonly direction: {
+                                                                    readonly enum: readonly ["asc", "desc"];
+                                                                };
+                                                            };
+                                                        };
+                                                    };
+                                                    readonly defaultLimit: {
+                                                        readonly type: "integer";
+                                                        readonly minimum: 1;
+                                                        readonly maximum: 100;
+                                                    };
+                                                    readonly maxLimit: {
+                                                        readonly type: "integer";
+                                                        readonly minimum: 1;
+                                                        readonly maximum: 100;
+                                                    };
+                                                    readonly parameters: {
+                                                        readonly type: "array";
+                                                        readonly maxItems: 8;
+                                                        readonly uniqueItems: true;
+                                                        readonly items: {
+                                                            readonly type: "object";
+                                                            readonly additionalProperties: false;
+                                                            readonly required: readonly ["name", "field", "operator", "type"];
+                                                            readonly properties: {
+                                                                readonly name: {
+                                                                    readonly type: "string";
+                                                                    readonly pattern: "^[a-z][a-z0-9]*(?:[-_.][a-z0-9]+)*$";
+                                                                    readonly maxLength: 128;
+                                                                };
+                                                                readonly field: {
+                                                                    readonly type: "string";
+                                                                    readonly pattern: "^[A-Za-z][A-Za-z0-9_]{0,62}$";
+                                                                };
+                                                                readonly operator: {
+                                                                    readonly enum: readonly ["eq", "contains", "in"];
+                                                                };
+                                                                readonly type: {
+                                                                    readonly enum: readonly ["string", "number", "boolean", "string[]"];
+                                                                };
+                                                            };
+                                                        };
+                                                    };
+                                                    readonly aggregate: {
+                                                        readonly type: "object";
+                                                        readonly additionalProperties: false;
+                                                        readonly required: readonly ["measures"];
+                                                        readonly properties: {
+                                                            readonly dimensions: {
+                                                                readonly type: "array";
+                                                                readonly maxItems: 3;
+                                                                readonly items: {
+                                                                    readonly type: "object";
+                                                                    readonly additionalProperties: false;
+                                                                    readonly required: readonly ["field", "as"];
+                                                                    readonly properties: {
+                                                                        readonly field: {
+                                                                            readonly type: "string";
+                                                                            readonly pattern: "^[A-Za-z][A-Za-z0-9_]{0,62}$";
+                                                                        };
+                                                                        readonly as: {
+                                                                            readonly type: "string";
+                                                                            readonly pattern: "^[A-Za-z][A-Za-z0-9_]{0,62}$";
+                                                                        };
+                                                                        readonly bucket: {
+                                                                            readonly enum: readonly ["day", "week", "month", "quarter", "year"];
+                                                                        };
+                                                                    };
+                                                                };
+                                                            };
+                                                            readonly measures: {
+                                                                readonly type: "array";
+                                                                readonly minItems: 1;
+                                                                readonly maxItems: 8;
+                                                                readonly items: {
+                                                                    readonly type: "object";
+                                                                    readonly additionalProperties: false;
+                                                                    readonly required: readonly ["type", "as"];
+                                                                    readonly properties: {
+                                                                        readonly type: {
+                                                                            readonly enum: readonly ["count", "countDistinct", "sum", "avg", "min", "max"];
+                                                                        };
+                                                                        readonly field: {
+                                                                            readonly type: "string";
+                                                                            readonly pattern: "^[A-Za-z][A-Za-z0-9_]{0,62}$";
+                                                                        };
+                                                                        readonly as: {
+                                                                            readonly type: "string";
+                                                                            readonly pattern: "^[A-Za-z][A-Za-z0-9_]{0,62}$";
+                                                                        };
+                                                                    };
+                                                                };
+                                                            };
+                                                            readonly order: {
+                                                                readonly type: "array";
+                                                                readonly maxItems: 10;
+                                                                readonly items: {
+                                                                    readonly type: "object";
+                                                                    readonly additionalProperties: false;
+                                                                    readonly required: readonly ["field"];
+                                                                    readonly properties: {
+                                                                        readonly field: {
+                                                                            readonly type: "string";
+                                                                            readonly pattern: "^[A-Za-z][A-Za-z0-9_]{0,62}$";
+                                                                        };
+                                                                        readonly direction: {
+                                                                            readonly enum: readonly ["asc", "desc"];
+                                                                        };
+                                                                        readonly nulls: {
+                                                                            readonly enum: readonly ["first", "last"];
+                                                                        };
+                                                                    };
+                                                                };
+                                                            };
+                                                        };
+                                                    };
+                                                };
+                                            };
+                                        };
                                         readonly draft: {
                                             readonly type: "object";
                                             readonly additionalProperties: false;
@@ -21218,7 +21382,7 @@ export declare const contractBundleSchema: {
                                     readonly maxItems: 8;
                                     readonly uniqueItems: true;
                                     readonly items: {
-                                        readonly enum: readonly ["draft.read", "draft.update", "validate", "create", "own.list", "own.read", "public.list", "public.read"];
+                                        readonly enum: readonly ["draft.read", "draft.update", "validate", "create", "own.list", "own.read", "public.list", "public.read", "public.query"];
                                     };
                                 };
                                 readonly fields: {
@@ -21376,6 +21540,170 @@ export declare const contractBundleSchema: {
                                         };
                                     };
                                 };
+                                readonly publicQueries: {
+                                    readonly type: "array";
+                                    readonly maxItems: 16;
+                                    readonly uniqueItems: true;
+                                    readonly items: {
+                                        readonly type: "object";
+                                        readonly additionalProperties: false;
+                                        readonly required: readonly ["code", "kind", "resourceCode", "fields", "defaultLimit", "maxLimit"];
+                                        readonly properties: {
+                                            readonly code: {
+                                                readonly type: "string";
+                                                readonly pattern: "^[a-z][a-z0-9]*(?:[-_.][a-z0-9]+)*$";
+                                                readonly maxLength: 128;
+                                            };
+                                            readonly kind: {
+                                                readonly enum: readonly ["records", "aggregate"];
+                                            };
+                                            readonly resourceCode: {
+                                                readonly type: "string";
+                                                readonly pattern: "^[a-z][a-z0-9]*(?:[-_.][a-z0-9]+)*$";
+                                                readonly maxLength: 128;
+                                            };
+                                            readonly fields: {
+                                                readonly type: "array";
+                                                readonly minItems: 1;
+                                                readonly maxItems: 64;
+                                                readonly uniqueItems: true;
+                                                readonly items: {
+                                                    readonly type: "string";
+                                                    readonly pattern: "^[A-Za-z][A-Za-z0-9_]{0,62}$";
+                                                };
+                                            };
+                                            readonly sort: {
+                                                readonly type: "array";
+                                                readonly maxItems: 4;
+                                                readonly uniqueItems: true;
+                                                readonly items: {
+                                                    readonly type: "object";
+                                                    readonly additionalProperties: false;
+                                                    readonly required: readonly ["field", "direction"];
+                                                    readonly properties: {
+                                                        readonly field: {
+                                                            readonly type: "string";
+                                                            readonly pattern: "^[A-Za-z][A-Za-z0-9_]{0,62}$";
+                                                        };
+                                                        readonly direction: {
+                                                            readonly enum: readonly ["asc", "desc"];
+                                                        };
+                                                    };
+                                                };
+                                            };
+                                            readonly defaultLimit: {
+                                                readonly type: "integer";
+                                                readonly minimum: 1;
+                                                readonly maximum: 100;
+                                            };
+                                            readonly maxLimit: {
+                                                readonly type: "integer";
+                                                readonly minimum: 1;
+                                                readonly maximum: 100;
+                                            };
+                                            readonly parameters: {
+                                                readonly type: "array";
+                                                readonly maxItems: 8;
+                                                readonly uniqueItems: true;
+                                                readonly items: {
+                                                    readonly type: "object";
+                                                    readonly additionalProperties: false;
+                                                    readonly required: readonly ["name", "field", "operator", "type"];
+                                                    readonly properties: {
+                                                        readonly name: {
+                                                            readonly type: "string";
+                                                            readonly pattern: "^[a-z][a-z0-9]*(?:[-_.][a-z0-9]+)*$";
+                                                            readonly maxLength: 128;
+                                                        };
+                                                        readonly field: {
+                                                            readonly type: "string";
+                                                            readonly pattern: "^[A-Za-z][A-Za-z0-9_]{0,62}$";
+                                                        };
+                                                        readonly operator: {
+                                                            readonly enum: readonly ["eq", "contains", "in"];
+                                                        };
+                                                        readonly type: {
+                                                            readonly enum: readonly ["string", "number", "boolean", "string[]"];
+                                                        };
+                                                    };
+                                                };
+                                            };
+                                            readonly aggregate: {
+                                                readonly type: "object";
+                                                readonly additionalProperties: false;
+                                                readonly required: readonly ["measures"];
+                                                readonly properties: {
+                                                    readonly dimensions: {
+                                                        readonly type: "array";
+                                                        readonly maxItems: 3;
+                                                        readonly items: {
+                                                            readonly type: "object";
+                                                            readonly additionalProperties: false;
+                                                            readonly required: readonly ["field", "as"];
+                                                            readonly properties: {
+                                                                readonly field: {
+                                                                    readonly type: "string";
+                                                                    readonly pattern: "^[A-Za-z][A-Za-z0-9_]{0,62}$";
+                                                                };
+                                                                readonly as: {
+                                                                    readonly type: "string";
+                                                                    readonly pattern: "^[A-Za-z][A-Za-z0-9_]{0,62}$";
+                                                                };
+                                                                readonly bucket: {
+                                                                    readonly enum: readonly ["day", "week", "month", "quarter", "year"];
+                                                                };
+                                                            };
+                                                        };
+                                                    };
+                                                    readonly measures: {
+                                                        readonly type: "array";
+                                                        readonly minItems: 1;
+                                                        readonly maxItems: 8;
+                                                        readonly items: {
+                                                            readonly type: "object";
+                                                            readonly additionalProperties: false;
+                                                            readonly required: readonly ["type", "as"];
+                                                            readonly properties: {
+                                                                readonly type: {
+                                                                    readonly enum: readonly ["count", "countDistinct", "sum", "avg", "min", "max"];
+                                                                };
+                                                                readonly field: {
+                                                                    readonly type: "string";
+                                                                    readonly pattern: "^[A-Za-z][A-Za-z0-9_]{0,62}$";
+                                                                };
+                                                                readonly as: {
+                                                                    readonly type: "string";
+                                                                    readonly pattern: "^[A-Za-z][A-Za-z0-9_]{0,62}$";
+                                                                };
+                                                            };
+                                                        };
+                                                    };
+                                                    readonly order: {
+                                                        readonly type: "array";
+                                                        readonly maxItems: 10;
+                                                        readonly items: {
+                                                            readonly type: "object";
+                                                            readonly additionalProperties: false;
+                                                            readonly required: readonly ["field"];
+                                                            readonly properties: {
+                                                                readonly field: {
+                                                                    readonly type: "string";
+                                                                    readonly pattern: "^[A-Za-z][A-Za-z0-9_]{0,62}$";
+                                                                };
+                                                                readonly direction: {
+                                                                    readonly enum: readonly ["asc", "desc"];
+                                                                };
+                                                                readonly nulls: {
+                                                                    readonly enum: readonly ["first", "last"];
+                                                                };
+                                                            };
+                                                        };
+                                                    };
+                                                };
+                                            };
+                                        };
+                                    };
+                                };
                                 readonly draft: {
                                     readonly type: "object";
                                     readonly additionalProperties: false;
@@ -44852,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: {
@@ -45010,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;
@@ -46165,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: {
@@ -46323,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;