@degenerate/endpoints 0.0.11 → 0.0.13

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 (35) hide show
  1. package/dist/cors/endpoints/helpers/validate-incoming-request-data.d.ts.map +1 -1
  2. package/dist/cors/endpoints/helpers/validate-incoming-request-data.js +1 -0
  3. package/dist/cors/index.d.ts +1 -2
  4. package/dist/cors/index.d.ts.map +1 -1
  5. package/dist/cors/index.js +2 -3
  6. package/dist/cors/logging/add-unique-tracking.js +2 -2
  7. package/dist/cors/routes/authorities/v1.routes.d.ts.map +1 -1
  8. package/dist/cors/routes/authorities/v1.routes.js +8 -8
  9. package/dist/cors/routes/rules/v1/rule-set.routes.d.ts.map +1 -1
  10. package/dist/cors/routes/rules/v1/rule-set.routes.js +4 -6
  11. package/dist/index.d.ts +1 -0
  12. package/dist/index.d.ts.map +1 -1
  13. package/dist/index.js +16 -0
  14. package/package.json +3 -3
  15. package/dist/cors/endpoints/authorities/validate-authorities-transaction.d.ts +0 -30
  16. package/dist/cors/endpoints/authorities/validate-authorities-transaction.d.ts.map +0 -1
  17. package/dist/cors/endpoints/authorities/validate-authorities-transaction.js +0 -155
  18. package/dist/schema/authorities-transactions.schema.d.ts +0 -306
  19. package/dist/schema/authorities-transactions.schema.d.ts.map +0 -1
  20. package/dist/schema/authorities-transactions.schema.js +0 -71
  21. package/dist/schema/rules/rules-conditions.schema.d.ts +0 -402
  22. package/dist/schema/rules/rules-conditions.schema.d.ts.map +0 -1
  23. package/dist/schema/rules/rules-conditions.schema.js +0 -99
  24. package/dist/schema/rules/rules-enums.schema.d.ts +0 -39
  25. package/dist/schema/rules/rules-enums.schema.d.ts.map +0 -1
  26. package/dist/schema/rules/rules-enums.schema.js +0 -90
  27. package/dist/schema/rules/rules.schema.d.ts +0 -2839
  28. package/dist/schema/rules/rules.schema.d.ts.map +0 -1
  29. package/dist/schema/rules/rules.schema.js +0 -76
  30. package/dist/schema/rules-transactions.schema.d.ts +0 -450
  31. package/dist/schema/rules-transactions.schema.d.ts.map +0 -1
  32. package/dist/schema/rules-transactions.schema.js +0 -63
  33. package/dist/schema/transactions.schema.d.ts +0 -45
  34. package/dist/schema/transactions.schema.d.ts.map +0 -1
  35. package/dist/schema/transactions.schema.js +0 -43
package/dist/schema/rules/rules-conditions.schema.d.ts DELETED
@@ -1,402 +0,0 @@
1
- import { ConditionTypeSpecial, ConditionTypeSingle } from '@degenerate/generic';
2
- import { z } from 'zod';
3
- /**
4
- * This is the base schema for all conditions.
5
- */
6
- export declare const IConditionBaseSchema: z.ZodObject<{
7
- conditionType: z.ZodUnion<[z.ZodEnum<[ConditionTypeSingle.TYPEOF, ConditionTypeSingle.EQUAL, ConditionTypeSingle.CONTAINS, ConditionTypeSingle.NULL, ConditionTypeSingle.EMPTY, ConditionTypeSingle.SHARE_RULE]>, z.ZodEnum<[import("@degenerate/generic").ConditionTypeRange.GREATER_THAN, import("@degenerate/generic").ConditionTypeRange.LESS_THAN, import("@degenerate/generic").ConditionTypeRange.GREATER_THAN_OR_EQUAL, import("@degenerate/generic").ConditionTypeRange.LESS_THAN_OR_EQUAL]>, z.ZodEnum<[import("@degenerate/generic").ConditionTypeStartsEndsWith.STARTS_WITH, import("@degenerate/generic").ConditionTypeStartsEndsWith.ENDS_WITH]>, z.ZodEnum<[import("@degenerate/generic").ConditionTypeBoolean.TRUE, import("@degenerate/generic").ConditionTypeBoolean.FALSE]>, z.ZodEnum<[ConditionTypeSpecial]>]>;
8
- conditionTypeQualifier: z.ZodEnum<[import("@degenerate/generic").ConditionTypeQualifier.IS, import("@degenerate/generic").ConditionTypeQualifier.IS_NOT]>;
9
- targettedProperty: z.ZodString;
10
- }, "strip", z.ZodTypeAny, {
11
- conditionType: ConditionTypeSingle | import("@degenerate/generic").ConditionTypeRange | import("@degenerate/generic").ConditionTypeStartsEndsWith | import("@degenerate/generic").ConditionTypeBoolean | ConditionTypeSpecial;
12
- conditionTypeQualifier: import("@degenerate/generic").ConditionTypeQualifier;
13
- targettedProperty: string;
14
- }, {
15
- conditionType: ConditionTypeSingle | import("@degenerate/generic").ConditionTypeRange | import("@degenerate/generic").ConditionTypeStartsEndsWith | import("@degenerate/generic").ConditionTypeBoolean | ConditionTypeSpecial;
16
- conditionTypeQualifier: import("@degenerate/generic").ConditionTypeQualifier;
17
- targettedProperty: string;
18
- }>;
19
- /**
20
- * This is the schema for the special condition.
21
- */
22
- export declare const IConditionSpecialSchema: z.ZodObject<z.objectUtil.extendShape<{
23
- conditionType: z.ZodUnion<[z.ZodEnum<[ConditionTypeSingle.TYPEOF, ConditionTypeSingle.EQUAL, ConditionTypeSingle.CONTAINS, ConditionTypeSingle.NULL, ConditionTypeSingle.EMPTY, ConditionTypeSingle.SHARE_RULE]>, z.ZodEnum<[import("@degenerate/generic").ConditionTypeRange.GREATER_THAN, import("@degenerate/generic").ConditionTypeRange.LESS_THAN, import("@degenerate/generic").ConditionTypeRange.GREATER_THAN_OR_EQUAL, import("@degenerate/generic").ConditionTypeRange.LESS_THAN_OR_EQUAL]>, z.ZodEnum<[import("@degenerate/generic").ConditionTypeStartsEndsWith.STARTS_WITH, import("@degenerate/generic").ConditionTypeStartsEndsWith.ENDS_WITH]>, z.ZodEnum<[import("@degenerate/generic").ConditionTypeBoolean.TRUE, import("@degenerate/generic").ConditionTypeBoolean.FALSE]>, z.ZodEnum<[ConditionTypeSpecial]>]>;
24
- conditionTypeQualifier: z.ZodEnum<[import("@degenerate/generic").ConditionTypeQualifier.IS, import("@degenerate/generic").ConditionTypeQualifier.IS_NOT]>;
25
- targettedProperty: z.ZodString;
26
- }, {
27
- conditionType: z.ZodLiteral<ConditionTypeSpecial>;
28
- conditionValue: z.ZodString;
29
- }>, "strip", z.ZodTypeAny, {
30
- conditionType: ConditionTypeSpecial;
31
- conditionTypeQualifier: import("@degenerate/generic").ConditionTypeQualifier;
32
- targettedProperty: string;
33
- conditionValue: string;
34
- }, {
35
- conditionType: ConditionTypeSpecial;
36
- conditionTypeQualifier: import("@degenerate/generic").ConditionTypeQualifier;
37
- targettedProperty: string;
38
- conditionValue: string;
39
- }>;
40
- /**
41
- * This is the schema for the empty condition.
42
- */
43
- export declare const IConditionEmptySchema: z.ZodObject<z.objectUtil.extendShape<{
44
- conditionType: z.ZodUnion<[z.ZodEnum<[ConditionTypeSingle.TYPEOF, ConditionTypeSingle.EQUAL, ConditionTypeSingle.CONTAINS, ConditionTypeSingle.NULL, ConditionTypeSingle.EMPTY, ConditionTypeSingle.SHARE_RULE]>, z.ZodEnum<[import("@degenerate/generic").ConditionTypeRange.GREATER_THAN, import("@degenerate/generic").ConditionTypeRange.LESS_THAN, import("@degenerate/generic").ConditionTypeRange.GREATER_THAN_OR_EQUAL, import("@degenerate/generic").ConditionTypeRange.LESS_THAN_OR_EQUAL]>, z.ZodEnum<[import("@degenerate/generic").ConditionTypeStartsEndsWith.STARTS_WITH, import("@degenerate/generic").ConditionTypeStartsEndsWith.ENDS_WITH]>, z.ZodEnum<[import("@degenerate/generic").ConditionTypeBoolean.TRUE, import("@degenerate/generic").ConditionTypeBoolean.FALSE]>, z.ZodEnum<[ConditionTypeSpecial]>]>;
45
- conditionTypeQualifier: z.ZodEnum<[import("@degenerate/generic").ConditionTypeQualifier.IS, import("@degenerate/generic").ConditionTypeQualifier.IS_NOT]>;
46
- targettedProperty: z.ZodString;
47
- }, {
48
- conditionType: z.ZodLiteral<ConditionTypeSingle.EMPTY>;
49
- }>, "strip", z.ZodTypeAny, {
50
- conditionType: ConditionTypeSingle.EMPTY;
51
- conditionTypeQualifier: import("@degenerate/generic").ConditionTypeQualifier;
52
- targettedProperty: string;
53
- }, {
54
- conditionType: ConditionTypeSingle.EMPTY;
55
- conditionTypeQualifier: import("@degenerate/generic").ConditionTypeQualifier;
56
- targettedProperty: string;
57
- }>;
58
- /**
59
- * This is the schema for the boolean condition.
60
- */
61
- export declare const IConditionBooleanSchema: z.ZodObject<z.objectUtil.extendShape<{
62
- conditionType: z.ZodUnion<[z.ZodEnum<[ConditionTypeSingle.TYPEOF, ConditionTypeSingle.EQUAL, ConditionTypeSingle.CONTAINS, ConditionTypeSingle.NULL, ConditionTypeSingle.EMPTY, ConditionTypeSingle.SHARE_RULE]>, z.ZodEnum<[import("@degenerate/generic").ConditionTypeRange.GREATER_THAN, import("@degenerate/generic").ConditionTypeRange.LESS_THAN, import("@degenerate/generic").ConditionTypeRange.GREATER_THAN_OR_EQUAL, import("@degenerate/generic").ConditionTypeRange.LESS_THAN_OR_EQUAL]>, z.ZodEnum<[import("@degenerate/generic").ConditionTypeStartsEndsWith.STARTS_WITH, import("@degenerate/generic").ConditionTypeStartsEndsWith.ENDS_WITH]>, z.ZodEnum<[import("@degenerate/generic").ConditionTypeBoolean.TRUE, import("@degenerate/generic").ConditionTypeBoolean.FALSE]>, z.ZodEnum<[ConditionTypeSpecial]>]>;
63
- conditionTypeQualifier: z.ZodEnum<[import("@degenerate/generic").ConditionTypeQualifier.IS, import("@degenerate/generic").ConditionTypeQualifier.IS_NOT]>;
64
- targettedProperty: z.ZodString;
65
- }, {
66
- conditionType: z.ZodEnum<[import("@degenerate/generic").ConditionTypeBoolean.TRUE, import("@degenerate/generic").ConditionTypeBoolean.FALSE]>;
67
- }>, "strip", z.ZodTypeAny, {
68
- conditionType: import("@degenerate/generic").ConditionTypeBoolean;
69
- conditionTypeQualifier: import("@degenerate/generic").ConditionTypeQualifier;
70
- targettedProperty: string;
71
- }, {
72
- conditionType: import("@degenerate/generic").ConditionTypeBoolean;
73
- conditionTypeQualifier: import("@degenerate/generic").ConditionTypeQualifier;
74
- targettedProperty: string;
75
- }>;
76
- /**
77
- * This is the schema for the null condition.
78
- */
79
- export declare const IConditionNullSchema: z.ZodObject<z.objectUtil.extendShape<{
80
- conditionType: z.ZodUnion<[z.ZodEnum<[ConditionTypeSingle.TYPEOF, ConditionTypeSingle.EQUAL, ConditionTypeSingle.CONTAINS, ConditionTypeSingle.NULL, ConditionTypeSingle.EMPTY, ConditionTypeSingle.SHARE_RULE]>, z.ZodEnum<[import("@degenerate/generic").ConditionTypeRange.GREATER_THAN, import("@degenerate/generic").ConditionTypeRange.LESS_THAN, import("@degenerate/generic").ConditionTypeRange.GREATER_THAN_OR_EQUAL, import("@degenerate/generic").ConditionTypeRange.LESS_THAN_OR_EQUAL]>, z.ZodEnum<[import("@degenerate/generic").ConditionTypeStartsEndsWith.STARTS_WITH, import("@degenerate/generic").ConditionTypeStartsEndsWith.ENDS_WITH]>, z.ZodEnum<[import("@degenerate/generic").ConditionTypeBoolean.TRUE, import("@degenerate/generic").ConditionTypeBoolean.FALSE]>, z.ZodEnum<[ConditionTypeSpecial]>]>;
81
- conditionTypeQualifier: z.ZodEnum<[import("@degenerate/generic").ConditionTypeQualifier.IS, import("@degenerate/generic").ConditionTypeQualifier.IS_NOT]>;
82
- targettedProperty: z.ZodString;
83
- }, {
84
- conditionType: z.ZodLiteral<ConditionTypeSingle.NULL>;
85
- }>, "strip", z.ZodTypeAny, {
86
- conditionType: ConditionTypeSingle.NULL;
87
- conditionTypeQualifier: import("@degenerate/generic").ConditionTypeQualifier;
88
- targettedProperty: string;
89
- }, {
90
- conditionType: ConditionTypeSingle.NULL;
91
- conditionTypeQualifier: import("@degenerate/generic").ConditionTypeQualifier;
92
- targettedProperty: string;
93
- }>;
94
- /**
95
- * This is the schema for the starts with and ends with condition.
96
- */
97
- export declare const IConditionStartsEndsWithSchema: z.ZodObject<z.objectUtil.extendShape<{
98
- conditionType: z.ZodUnion<[z.ZodEnum<[ConditionTypeSingle.TYPEOF, ConditionTypeSingle.EQUAL, ConditionTypeSingle.CONTAINS, ConditionTypeSingle.NULL, ConditionTypeSingle.EMPTY, ConditionTypeSingle.SHARE_RULE]>, z.ZodEnum<[import("@degenerate/generic").ConditionTypeRange.GREATER_THAN, import("@degenerate/generic").ConditionTypeRange.LESS_THAN, import("@degenerate/generic").ConditionTypeRange.GREATER_THAN_OR_EQUAL, import("@degenerate/generic").ConditionTypeRange.LESS_THAN_OR_EQUAL]>, z.ZodEnum<[import("@degenerate/generic").ConditionTypeStartsEndsWith.STARTS_WITH, import("@degenerate/generic").ConditionTypeStartsEndsWith.ENDS_WITH]>, z.ZodEnum<[import("@degenerate/generic").ConditionTypeBoolean.TRUE, import("@degenerate/generic").ConditionTypeBoolean.FALSE]>, z.ZodEnum<[ConditionTypeSpecial]>]>;
99
- conditionTypeQualifier: z.ZodEnum<[import("@degenerate/generic").ConditionTypeQualifier.IS, import("@degenerate/generic").ConditionTypeQualifier.IS_NOT]>;
100
- targettedProperty: z.ZodString;
101
- }, {
102
- conditionType: z.ZodEnum<[import("@degenerate/generic").ConditionTypeStartsEndsWith.STARTS_WITH, import("@degenerate/generic").ConditionTypeStartsEndsWith.ENDS_WITH]>;
103
- conditionValue: z.ZodString;
104
- }>, "strip", z.ZodTypeAny, {
105
- conditionType: import("@degenerate/generic").ConditionTypeStartsEndsWith;
106
- conditionTypeQualifier: import("@degenerate/generic").ConditionTypeQualifier;
107
- targettedProperty: string;
108
- conditionValue: string;
109
- }, {
110
- conditionType: import("@degenerate/generic").ConditionTypeStartsEndsWith;
111
- conditionTypeQualifier: import("@degenerate/generic").ConditionTypeQualifier;
112
- targettedProperty: string;
113
- conditionValue: string;
114
- }>;
115
- /**
116
- * This is the schema for the contains condition.
117
- */
118
- export declare const IConditionContainsSchema: z.ZodObject<z.objectUtil.extendShape<{
119
- conditionType: z.ZodUnion<[z.ZodEnum<[ConditionTypeSingle.TYPEOF, ConditionTypeSingle.EQUAL, ConditionTypeSingle.CONTAINS, ConditionTypeSingle.NULL, ConditionTypeSingle.EMPTY, ConditionTypeSingle.SHARE_RULE]>, z.ZodEnum<[import("@degenerate/generic").ConditionTypeRange.GREATER_THAN, import("@degenerate/generic").ConditionTypeRange.LESS_THAN, import("@degenerate/generic").ConditionTypeRange.GREATER_THAN_OR_EQUAL, import("@degenerate/generic").ConditionTypeRange.LESS_THAN_OR_EQUAL]>, z.ZodEnum<[import("@degenerate/generic").ConditionTypeStartsEndsWith.STARTS_WITH, import("@degenerate/generic").ConditionTypeStartsEndsWith.ENDS_WITH]>, z.ZodEnum<[import("@degenerate/generic").ConditionTypeBoolean.TRUE, import("@degenerate/generic").ConditionTypeBoolean.FALSE]>, z.ZodEnum<[ConditionTypeSpecial]>]>;
120
- conditionTypeQualifier: z.ZodEnum<[import("@degenerate/generic").ConditionTypeQualifier.IS, import("@degenerate/generic").ConditionTypeQualifier.IS_NOT]>;
121
- targettedProperty: z.ZodString;
122
- }, {
123
- conditionType: z.ZodLiteral<ConditionTypeSingle.CONTAINS>;
124
- conditionValue: z.ZodUnion<[z.ZodString, z.ZodArray<z.ZodString, "many">, z.ZodArray<z.ZodNumber, "many">]>;
125
- }>, "strip", z.ZodTypeAny, {
126
- conditionType: ConditionTypeSingle.CONTAINS;
127
- conditionTypeQualifier: import("@degenerate/generic").ConditionTypeQualifier;
128
- targettedProperty: string;
129
- conditionValue: string | string[] | number[];
130
- }, {
131
- conditionType: ConditionTypeSingle.CONTAINS;
132
- conditionTypeQualifier: import("@degenerate/generic").ConditionTypeQualifier;
133
- targettedProperty: string;
134
- conditionValue: string | string[] | number[];
135
- }>;
136
- /**
137
- * This is the schema for the range condition.
138
- */
139
- export declare const IConditionRangeSchema: z.ZodObject<z.objectUtil.extendShape<{
140
- conditionType: z.ZodUnion<[z.ZodEnum<[ConditionTypeSingle.TYPEOF, ConditionTypeSingle.EQUAL, ConditionTypeSingle.CONTAINS, ConditionTypeSingle.NULL, ConditionTypeSingle.EMPTY, ConditionTypeSingle.SHARE_RULE]>, z.ZodEnum<[import("@degenerate/generic").ConditionTypeRange.GREATER_THAN, import("@degenerate/generic").ConditionTypeRange.LESS_THAN, import("@degenerate/generic").ConditionTypeRange.GREATER_THAN_OR_EQUAL, import("@degenerate/generic").ConditionTypeRange.LESS_THAN_OR_EQUAL]>, z.ZodEnum<[import("@degenerate/generic").ConditionTypeStartsEndsWith.STARTS_WITH, import("@degenerate/generic").ConditionTypeStartsEndsWith.ENDS_WITH]>, z.ZodEnum<[import("@degenerate/generic").ConditionTypeBoolean.TRUE, import("@degenerate/generic").ConditionTypeBoolean.FALSE]>, z.ZodEnum<[ConditionTypeSpecial]>]>;
141
- conditionTypeQualifier: z.ZodEnum<[import("@degenerate/generic").ConditionTypeQualifier.IS, import("@degenerate/generic").ConditionTypeQualifier.IS_NOT]>;
142
- targettedProperty: z.ZodString;
143
- }, {
144
- conditionType: z.ZodEnum<[import("@degenerate/generic").ConditionTypeRange.GREATER_THAN, import("@degenerate/generic").ConditionTypeRange.LESS_THAN, import("@degenerate/generic").ConditionTypeRange.GREATER_THAN_OR_EQUAL, import("@degenerate/generic").ConditionTypeRange.LESS_THAN_OR_EQUAL]>;
145
- conditionValue: z.ZodUnion<[z.ZodString, z.ZodNumber]>;
146
- }>, "strip", z.ZodTypeAny, {
147
- conditionType: import("@degenerate/generic").ConditionTypeRange;
148
- conditionTypeQualifier: import("@degenerate/generic").ConditionTypeQualifier;
149
- targettedProperty: string;
150
- conditionValue: string | number;
151
- }, {
152
- conditionType: import("@degenerate/generic").ConditionTypeRange;
153
- conditionTypeQualifier: import("@degenerate/generic").ConditionTypeQualifier;
154
- targettedProperty: string;
155
- conditionValue: string | number;
156
- }>;
157
- /**
158
- * This is the schema for the equality condition.
159
- */
160
- export declare const IConditionEqualitySchema: z.ZodObject<z.objectUtil.extendShape<{
161
- conditionType: z.ZodUnion<[z.ZodEnum<[ConditionTypeSingle.TYPEOF, ConditionTypeSingle.EQUAL, ConditionTypeSingle.CONTAINS, ConditionTypeSingle.NULL, ConditionTypeSingle.EMPTY, ConditionTypeSingle.SHARE_RULE]>, z.ZodEnum<[import("@degenerate/generic").ConditionTypeRange.GREATER_THAN, import("@degenerate/generic").ConditionTypeRange.LESS_THAN, import("@degenerate/generic").ConditionTypeRange.GREATER_THAN_OR_EQUAL, import("@degenerate/generic").ConditionTypeRange.LESS_THAN_OR_EQUAL]>, z.ZodEnum<[import("@degenerate/generic").ConditionTypeStartsEndsWith.STARTS_WITH, import("@degenerate/generic").ConditionTypeStartsEndsWith.ENDS_WITH]>, z.ZodEnum<[import("@degenerate/generic").ConditionTypeBoolean.TRUE, import("@degenerate/generic").ConditionTypeBoolean.FALSE]>, z.ZodEnum<[ConditionTypeSpecial]>]>;
162
- conditionTypeQualifier: z.ZodEnum<[import("@degenerate/generic").ConditionTypeQualifier.IS, import("@degenerate/generic").ConditionTypeQualifier.IS_NOT]>;
163
- targettedProperty: z.ZodString;
164
- }, {
165
- conditionType: z.ZodLiteral<ConditionTypeSingle.EQUAL>;
166
- conditionValue: z.ZodUnion<[z.ZodString, z.ZodNumber]>;
167
- }>, "strip", z.ZodTypeAny, {
168
- conditionType: ConditionTypeSingle.EQUAL;
169
- conditionTypeQualifier: import("@degenerate/generic").ConditionTypeQualifier;
170
- targettedProperty: string;
171
- conditionValue: string | number;
172
- }, {
173
- conditionType: ConditionTypeSingle.EQUAL;
174
- conditionTypeQualifier: import("@degenerate/generic").ConditionTypeQualifier;
175
- targettedProperty: string;
176
- conditionValue: string | number;
177
- }>;
178
- /**
179
- * This is the schema for the type of condition.
180
- */
181
- export declare const IConditionTypeOfSchema: z.ZodObject<z.objectUtil.extendShape<{
182
- conditionType: z.ZodUnion<[z.ZodEnum<[ConditionTypeSingle.TYPEOF, ConditionTypeSingle.EQUAL, ConditionTypeSingle.CONTAINS, ConditionTypeSingle.NULL, ConditionTypeSingle.EMPTY, ConditionTypeSingle.SHARE_RULE]>, z.ZodEnum<[import("@degenerate/generic").ConditionTypeRange.GREATER_THAN, import("@degenerate/generic").ConditionTypeRange.LESS_THAN, import("@degenerate/generic").ConditionTypeRange.GREATER_THAN_OR_EQUAL, import("@degenerate/generic").ConditionTypeRange.LESS_THAN_OR_EQUAL]>, z.ZodEnum<[import("@degenerate/generic").ConditionTypeStartsEndsWith.STARTS_WITH, import("@degenerate/generic").ConditionTypeStartsEndsWith.ENDS_WITH]>, z.ZodEnum<[import("@degenerate/generic").ConditionTypeBoolean.TRUE, import("@degenerate/generic").ConditionTypeBoolean.FALSE]>, z.ZodEnum<[ConditionTypeSpecial]>]>;
183
- conditionTypeQualifier: z.ZodEnum<[import("@degenerate/generic").ConditionTypeQualifier.IS, import("@degenerate/generic").ConditionTypeQualifier.IS_NOT]>;
184
- targettedProperty: z.ZodString;
185
- }, {
186
- conditionType: z.ZodLiteral<ConditionTypeSingle.TYPEOF>;
187
- conditionValue: z.ZodEnum<[import("@degenerate/generic").ConditionTypeOf.STRING, import("@degenerate/generic").ConditionTypeOf.NUMBER, import("@degenerate/generic").ConditionTypeOf.INTEGER, import("@degenerate/generic").ConditionTypeOf.BOOLEAN, import("@degenerate/generic").ConditionTypeOf.OBJECT, import("@degenerate/generic").ConditionTypeOf.ARRAY, import("@degenerate/generic").ConditionTypeOf.NULL, import("@degenerate/generic").ConditionTypeOf.UNDEFINED, import("@degenerate/generic").ConditionTypeOf.FUNCTION, import("@degenerate/generic").ConditionTypeOf.BIGINT]>;
188
- }>, "strip", z.ZodTypeAny, {
189
- conditionType: ConditionTypeSingle.TYPEOF;
190
- conditionTypeQualifier: import("@degenerate/generic").ConditionTypeQualifier;
191
- targettedProperty: string;
192
- conditionValue: import("@degenerate/generic").ConditionTypeOf;
193
- }, {
194
- conditionType: ConditionTypeSingle.TYPEOF;
195
- conditionTypeQualifier: import("@degenerate/generic").ConditionTypeQualifier;
196
- targettedProperty: string;
197
- conditionValue: import("@degenerate/generic").ConditionTypeOf;
198
- }>;
199
- /**
200
- * This is the schema for the share rule condition.
201
- */
202
- export declare const IConditionShareRuleSchema: z.ZodObject<z.objectUtil.extendShape<{
203
- conditionType: z.ZodUnion<[z.ZodEnum<[ConditionTypeSingle.TYPEOF, ConditionTypeSingle.EQUAL, ConditionTypeSingle.CONTAINS, ConditionTypeSingle.NULL, ConditionTypeSingle.EMPTY, ConditionTypeSingle.SHARE_RULE]>, z.ZodEnum<[import("@degenerate/generic").ConditionTypeRange.GREATER_THAN, import("@degenerate/generic").ConditionTypeRange.LESS_THAN, import("@degenerate/generic").ConditionTypeRange.GREATER_THAN_OR_EQUAL, import("@degenerate/generic").ConditionTypeRange.LESS_THAN_OR_EQUAL]>, z.ZodEnum<[import("@degenerate/generic").ConditionTypeStartsEndsWith.STARTS_WITH, import("@degenerate/generic").ConditionTypeStartsEndsWith.ENDS_WITH]>, z.ZodEnum<[import("@degenerate/generic").ConditionTypeBoolean.TRUE, import("@degenerate/generic").ConditionTypeBoolean.FALSE]>, z.ZodEnum<[ConditionTypeSpecial]>]>;
204
- conditionTypeQualifier: z.ZodEnum<[import("@degenerate/generic").ConditionTypeQualifier.IS, import("@degenerate/generic").ConditionTypeQualifier.IS_NOT]>;
205
- targettedProperty: z.ZodString;
206
- }, {
207
- conditionType: z.ZodLiteral<ConditionTypeSingle.SHARE_RULE>;
208
- conditionValue: z.ZodLazy<z.ZodType<any, z.ZodTypeDef, any>>;
209
- }>, "strip", z.ZodTypeAny, {
210
- conditionType: ConditionTypeSingle.SHARE_RULE;
211
- conditionTypeQualifier: import("@degenerate/generic").ConditionTypeQualifier;
212
- targettedProperty: string;
213
- conditionValue?: any;
214
- }, {
215
- conditionType: ConditionTypeSingle.SHARE_RULE;
216
- conditionTypeQualifier: import("@degenerate/generic").ConditionTypeQualifier;
217
- targettedProperty: string;
218
- conditionValue?: any;
219
- }>;
220
- /**
221
- * This is the interface for the condition.
222
- */
223
- export type IConditionTypeOf = z.infer<typeof IConditionTypeOfSchema>;
224
- export type IConditionEquality = z.infer<typeof IConditionEqualitySchema>;
225
- export type IConditionRange = z.infer<typeof IConditionRangeSchema>;
226
- export type IConditionContains = z.infer<typeof IConditionContainsSchema>;
227
- export type IConditionStartsEndsWith = z.infer<typeof IConditionStartsEndsWithSchema>;
228
- export type IConditionNull = z.infer<typeof IConditionNullSchema>;
229
- export type IConditionBoolean = z.infer<typeof IConditionBooleanSchema>;
230
- export type IConditionEmpty = z.infer<typeof IConditionEmptySchema>;
231
- export type IConditionShareRule = z.infer<typeof IConditionShareRuleSchema>;
232
- export type IConditionSpecial = z.infer<typeof IConditionSpecialSchema>;
233
- /**
234
- * This is the union of all the conditions.
235
- */
236
- export declare const IConditionSchema: z.ZodUnion<[z.ZodObject<z.objectUtil.extendShape<{
237
- conditionType: z.ZodUnion<[z.ZodEnum<[ConditionTypeSingle.TYPEOF, ConditionTypeSingle.EQUAL, ConditionTypeSingle.CONTAINS, ConditionTypeSingle.NULL, ConditionTypeSingle.EMPTY, ConditionTypeSingle.SHARE_RULE]>, z.ZodEnum<[import("@degenerate/generic").ConditionTypeRange.GREATER_THAN, import("@degenerate/generic").ConditionTypeRange.LESS_THAN, import("@degenerate/generic").ConditionTypeRange.GREATER_THAN_OR_EQUAL, import("@degenerate/generic").ConditionTypeRange.LESS_THAN_OR_EQUAL]>, z.ZodEnum<[import("@degenerate/generic").ConditionTypeStartsEndsWith.STARTS_WITH, import("@degenerate/generic").ConditionTypeStartsEndsWith.ENDS_WITH]>, z.ZodEnum<[import("@degenerate/generic").ConditionTypeBoolean.TRUE, import("@degenerate/generic").ConditionTypeBoolean.FALSE]>, z.ZodEnum<[ConditionTypeSpecial]>]>;
238
- conditionTypeQualifier: z.ZodEnum<[import("@degenerate/generic").ConditionTypeQualifier.IS, import("@degenerate/generic").ConditionTypeQualifier.IS_NOT]>;
239
- targettedProperty: z.ZodString;
240
- }, {
241
- conditionType: z.ZodLiteral<ConditionTypeSingle.TYPEOF>;
242
- conditionValue: z.ZodEnum<[import("@degenerate/generic").ConditionTypeOf.STRING, import("@degenerate/generic").ConditionTypeOf.NUMBER, import("@degenerate/generic").ConditionTypeOf.INTEGER, import("@degenerate/generic").ConditionTypeOf.BOOLEAN, import("@degenerate/generic").ConditionTypeOf.OBJECT, import("@degenerate/generic").ConditionTypeOf.ARRAY, import("@degenerate/generic").ConditionTypeOf.NULL, import("@degenerate/generic").ConditionTypeOf.UNDEFINED, import("@degenerate/generic").ConditionTypeOf.FUNCTION, import("@degenerate/generic").ConditionTypeOf.BIGINT]>;
243
- }>, "strip", z.ZodTypeAny, {
244
- conditionType: ConditionTypeSingle.TYPEOF;
245
- conditionTypeQualifier: import("@degenerate/generic").ConditionTypeQualifier;
246
- targettedProperty: string;
247
- conditionValue: import("@degenerate/generic").ConditionTypeOf;
248
- }, {
249
- conditionType: ConditionTypeSingle.TYPEOF;
250
- conditionTypeQualifier: import("@degenerate/generic").ConditionTypeQualifier;
251
- targettedProperty: string;
252
- conditionValue: import("@degenerate/generic").ConditionTypeOf;
253
- }>, z.ZodObject<z.objectUtil.extendShape<{
254
- conditionType: z.ZodUnion<[z.ZodEnum<[ConditionTypeSingle.TYPEOF, ConditionTypeSingle.EQUAL, ConditionTypeSingle.CONTAINS, ConditionTypeSingle.NULL, ConditionTypeSingle.EMPTY, ConditionTypeSingle.SHARE_RULE]>, z.ZodEnum<[import("@degenerate/generic").ConditionTypeRange.GREATER_THAN, import("@degenerate/generic").ConditionTypeRange.LESS_THAN, import("@degenerate/generic").ConditionTypeRange.GREATER_THAN_OR_EQUAL, import("@degenerate/generic").ConditionTypeRange.LESS_THAN_OR_EQUAL]>, z.ZodEnum<[import("@degenerate/generic").ConditionTypeStartsEndsWith.STARTS_WITH, import("@degenerate/generic").ConditionTypeStartsEndsWith.ENDS_WITH]>, z.ZodEnum<[import("@degenerate/generic").ConditionTypeBoolean.TRUE, import("@degenerate/generic").ConditionTypeBoolean.FALSE]>, z.ZodEnum<[ConditionTypeSpecial]>]>;
255
- conditionTypeQualifier: z.ZodEnum<[import("@degenerate/generic").ConditionTypeQualifier.IS, import("@degenerate/generic").ConditionTypeQualifier.IS_NOT]>;
256
- targettedProperty: z.ZodString;
257
- }, {
258
- conditionType: z.ZodLiteral<ConditionTypeSingle.EQUAL>;
259
- conditionValue: z.ZodUnion<[z.ZodString, z.ZodNumber]>;
260
- }>, "strip", z.ZodTypeAny, {
261
- conditionType: ConditionTypeSingle.EQUAL;
262
- conditionTypeQualifier: import("@degenerate/generic").ConditionTypeQualifier;
263
- targettedProperty: string;
264
- conditionValue: string | number;
265
- }, {
266
- conditionType: ConditionTypeSingle.EQUAL;
267
- conditionTypeQualifier: import("@degenerate/generic").ConditionTypeQualifier;
268
- targettedProperty: string;
269
- conditionValue: string | number;
270
- }>, z.ZodObject<z.objectUtil.extendShape<{
271
- conditionType: z.ZodUnion<[z.ZodEnum<[ConditionTypeSingle.TYPEOF, ConditionTypeSingle.EQUAL, ConditionTypeSingle.CONTAINS, ConditionTypeSingle.NULL, ConditionTypeSingle.EMPTY, ConditionTypeSingle.SHARE_RULE]>, z.ZodEnum<[import("@degenerate/generic").ConditionTypeRange.GREATER_THAN, import("@degenerate/generic").ConditionTypeRange.LESS_THAN, import("@degenerate/generic").ConditionTypeRange.GREATER_THAN_OR_EQUAL, import("@degenerate/generic").ConditionTypeRange.LESS_THAN_OR_EQUAL]>, z.ZodEnum<[import("@degenerate/generic").ConditionTypeStartsEndsWith.STARTS_WITH, import("@degenerate/generic").ConditionTypeStartsEndsWith.ENDS_WITH]>, z.ZodEnum<[import("@degenerate/generic").ConditionTypeBoolean.TRUE, import("@degenerate/generic").ConditionTypeBoolean.FALSE]>, z.ZodEnum<[ConditionTypeSpecial]>]>;
272
- conditionTypeQualifier: z.ZodEnum<[import("@degenerate/generic").ConditionTypeQualifier.IS, import("@degenerate/generic").ConditionTypeQualifier.IS_NOT]>;
273
- targettedProperty: z.ZodString;
274
- }, {
275
- conditionType: z.ZodEnum<[import("@degenerate/generic").ConditionTypeRange.GREATER_THAN, import("@degenerate/generic").ConditionTypeRange.LESS_THAN, import("@degenerate/generic").ConditionTypeRange.GREATER_THAN_OR_EQUAL, import("@degenerate/generic").ConditionTypeRange.LESS_THAN_OR_EQUAL]>;
276
- conditionValue: z.ZodUnion<[z.ZodString, z.ZodNumber]>;
277
- }>, "strip", z.ZodTypeAny, {
278
- conditionType: import("@degenerate/generic").ConditionTypeRange;
279
- conditionTypeQualifier: import("@degenerate/generic").ConditionTypeQualifier;
280
- targettedProperty: string;
281
- conditionValue: string | number;
282
- }, {
283
- conditionType: import("@degenerate/generic").ConditionTypeRange;
284
- conditionTypeQualifier: import("@degenerate/generic").ConditionTypeQualifier;
285
- targettedProperty: string;
286
- conditionValue: string | number;
287
- }>, z.ZodObject<z.objectUtil.extendShape<{
288
- conditionType: z.ZodUnion<[z.ZodEnum<[ConditionTypeSingle.TYPEOF, ConditionTypeSingle.EQUAL, ConditionTypeSingle.CONTAINS, ConditionTypeSingle.NULL, ConditionTypeSingle.EMPTY, ConditionTypeSingle.SHARE_RULE]>, z.ZodEnum<[import("@degenerate/generic").ConditionTypeRange.GREATER_THAN, import("@degenerate/generic").ConditionTypeRange.LESS_THAN, import("@degenerate/generic").ConditionTypeRange.GREATER_THAN_OR_EQUAL, import("@degenerate/generic").ConditionTypeRange.LESS_THAN_OR_EQUAL]>, z.ZodEnum<[import("@degenerate/generic").ConditionTypeStartsEndsWith.STARTS_WITH, import("@degenerate/generic").ConditionTypeStartsEndsWith.ENDS_WITH]>, z.ZodEnum<[import("@degenerate/generic").ConditionTypeBoolean.TRUE, import("@degenerate/generic").ConditionTypeBoolean.FALSE]>, z.ZodEnum<[ConditionTypeSpecial]>]>;
289
- conditionTypeQualifier: z.ZodEnum<[import("@degenerate/generic").ConditionTypeQualifier.IS, import("@degenerate/generic").ConditionTypeQualifier.IS_NOT]>;
290
- targettedProperty: z.ZodString;
291
- }, {
292
- conditionType: z.ZodLiteral<ConditionTypeSingle.CONTAINS>;
293
- conditionValue: z.ZodUnion<[z.ZodString, z.ZodArray<z.ZodString, "many">, z.ZodArray<z.ZodNumber, "many">]>;
294
- }>, "strip", z.ZodTypeAny, {
295
- conditionType: ConditionTypeSingle.CONTAINS;
296
- conditionTypeQualifier: import("@degenerate/generic").ConditionTypeQualifier;
297
- targettedProperty: string;
298
- conditionValue: string | string[] | number[];
299
- }, {
300
- conditionType: ConditionTypeSingle.CONTAINS;
301
- conditionTypeQualifier: import("@degenerate/generic").ConditionTypeQualifier;
302
- targettedProperty: string;
303
- conditionValue: string | string[] | number[];
304
- }>, z.ZodObject<z.objectUtil.extendShape<{
305
- conditionType: z.ZodUnion<[z.ZodEnum<[ConditionTypeSingle.TYPEOF, ConditionTypeSingle.EQUAL, ConditionTypeSingle.CONTAINS, ConditionTypeSingle.NULL, ConditionTypeSingle.EMPTY, ConditionTypeSingle.SHARE_RULE]>, z.ZodEnum<[import("@degenerate/generic").ConditionTypeRange.GREATER_THAN, import("@degenerate/generic").ConditionTypeRange.LESS_THAN, import("@degenerate/generic").ConditionTypeRange.GREATER_THAN_OR_EQUAL, import("@degenerate/generic").ConditionTypeRange.LESS_THAN_OR_EQUAL]>, z.ZodEnum<[import("@degenerate/generic").ConditionTypeStartsEndsWith.STARTS_WITH, import("@degenerate/generic").ConditionTypeStartsEndsWith.ENDS_WITH]>, z.ZodEnum<[import("@degenerate/generic").ConditionTypeBoolean.TRUE, import("@degenerate/generic").ConditionTypeBoolean.FALSE]>, z.ZodEnum<[ConditionTypeSpecial]>]>;
306
- conditionTypeQualifier: z.ZodEnum<[import("@degenerate/generic").ConditionTypeQualifier.IS, import("@degenerate/generic").ConditionTypeQualifier.IS_NOT]>;
307
- targettedProperty: z.ZodString;
308
- }, {
309
- conditionType: z.ZodEnum<[import("@degenerate/generic").ConditionTypeStartsEndsWith.STARTS_WITH, import("@degenerate/generic").ConditionTypeStartsEndsWith.ENDS_WITH]>;
310
- conditionValue: z.ZodString;
311
- }>, "strip", z.ZodTypeAny, {
312
- conditionType: import("@degenerate/generic").ConditionTypeStartsEndsWith;
313
- conditionTypeQualifier: import("@degenerate/generic").ConditionTypeQualifier;
314
- targettedProperty: string;
315
- conditionValue: string;
316
- }, {
317
- conditionType: import("@degenerate/generic").ConditionTypeStartsEndsWith;
318
- conditionTypeQualifier: import("@degenerate/generic").ConditionTypeQualifier;
319
- targettedProperty: string;
320
- conditionValue: string;
321
- }>, z.ZodObject<z.objectUtil.extendShape<{
322
- conditionType: z.ZodUnion<[z.ZodEnum<[ConditionTypeSingle.TYPEOF, ConditionTypeSingle.EQUAL, ConditionTypeSingle.CONTAINS, ConditionTypeSingle.NULL, ConditionTypeSingle.EMPTY, ConditionTypeSingle.SHARE_RULE]>, z.ZodEnum<[import("@degenerate/generic").ConditionTypeRange.GREATER_THAN, import("@degenerate/generic").ConditionTypeRange.LESS_THAN, import("@degenerate/generic").ConditionTypeRange.GREATER_THAN_OR_EQUAL, import("@degenerate/generic").ConditionTypeRange.LESS_THAN_OR_EQUAL]>, z.ZodEnum<[import("@degenerate/generic").ConditionTypeStartsEndsWith.STARTS_WITH, import("@degenerate/generic").ConditionTypeStartsEndsWith.ENDS_WITH]>, z.ZodEnum<[import("@degenerate/generic").ConditionTypeBoolean.TRUE, import("@degenerate/generic").ConditionTypeBoolean.FALSE]>, z.ZodEnum<[ConditionTypeSpecial]>]>;
323
- conditionTypeQualifier: z.ZodEnum<[import("@degenerate/generic").ConditionTypeQualifier.IS, import("@degenerate/generic").ConditionTypeQualifier.IS_NOT]>;
324
- targettedProperty: z.ZodString;
325
- }, {
326
- conditionType: z.ZodLiteral<ConditionTypeSingle.NULL>;
327
- }>, "strip", z.ZodTypeAny, {
328
- conditionType: ConditionTypeSingle.NULL;
329
- conditionTypeQualifier: import("@degenerate/generic").ConditionTypeQualifier;
330
- targettedProperty: string;
331
- }, {
332
- conditionType: ConditionTypeSingle.NULL;
333
- conditionTypeQualifier: import("@degenerate/generic").ConditionTypeQualifier;
334
- targettedProperty: string;
335
- }>, z.ZodObject<z.objectUtil.extendShape<{
336
- conditionType: z.ZodUnion<[z.ZodEnum<[ConditionTypeSingle.TYPEOF, ConditionTypeSingle.EQUAL, ConditionTypeSingle.CONTAINS, ConditionTypeSingle.NULL, ConditionTypeSingle.EMPTY, ConditionTypeSingle.SHARE_RULE]>, z.ZodEnum<[import("@degenerate/generic").ConditionTypeRange.GREATER_THAN, import("@degenerate/generic").ConditionTypeRange.LESS_THAN, import("@degenerate/generic").ConditionTypeRange.GREATER_THAN_OR_EQUAL, import("@degenerate/generic").ConditionTypeRange.LESS_THAN_OR_EQUAL]>, z.ZodEnum<[import("@degenerate/generic").ConditionTypeStartsEndsWith.STARTS_WITH, import("@degenerate/generic").ConditionTypeStartsEndsWith.ENDS_WITH]>, z.ZodEnum<[import("@degenerate/generic").ConditionTypeBoolean.TRUE, import("@degenerate/generic").ConditionTypeBoolean.FALSE]>, z.ZodEnum<[ConditionTypeSpecial]>]>;
337
- conditionTypeQualifier: z.ZodEnum<[import("@degenerate/generic").ConditionTypeQualifier.IS, import("@degenerate/generic").ConditionTypeQualifier.IS_NOT]>;
338
- targettedProperty: z.ZodString;
339
- }, {
340
- conditionType: z.ZodEnum<[import("@degenerate/generic").ConditionTypeBoolean.TRUE, import("@degenerate/generic").ConditionTypeBoolean.FALSE]>;
341
- }>, "strip", z.ZodTypeAny, {
342
- conditionType: import("@degenerate/generic").ConditionTypeBoolean;
343
- conditionTypeQualifier: import("@degenerate/generic").ConditionTypeQualifier;
344
- targettedProperty: string;
345
- }, {
346
- conditionType: import("@degenerate/generic").ConditionTypeBoolean;
347
- conditionTypeQualifier: import("@degenerate/generic").ConditionTypeQualifier;
348
- targettedProperty: string;
349
- }>, z.ZodObject<z.objectUtil.extendShape<{
350
- conditionType: z.ZodUnion<[z.ZodEnum<[ConditionTypeSingle.TYPEOF, ConditionTypeSingle.EQUAL, ConditionTypeSingle.CONTAINS, ConditionTypeSingle.NULL, ConditionTypeSingle.EMPTY, ConditionTypeSingle.SHARE_RULE]>, z.ZodEnum<[import("@degenerate/generic").ConditionTypeRange.GREATER_THAN, import("@degenerate/generic").ConditionTypeRange.LESS_THAN, import("@degenerate/generic").ConditionTypeRange.GREATER_THAN_OR_EQUAL, import("@degenerate/generic").ConditionTypeRange.LESS_THAN_OR_EQUAL]>, z.ZodEnum<[import("@degenerate/generic").ConditionTypeStartsEndsWith.STARTS_WITH, import("@degenerate/generic").ConditionTypeStartsEndsWith.ENDS_WITH]>, z.ZodEnum<[import("@degenerate/generic").ConditionTypeBoolean.TRUE, import("@degenerate/generic").ConditionTypeBoolean.FALSE]>, z.ZodEnum<[ConditionTypeSpecial]>]>;
351
- conditionTypeQualifier: z.ZodEnum<[import("@degenerate/generic").ConditionTypeQualifier.IS, import("@degenerate/generic").ConditionTypeQualifier.IS_NOT]>;
352
- targettedProperty: z.ZodString;
353
- }, {
354
- conditionType: z.ZodLiteral<ConditionTypeSingle.EMPTY>;
355
- }>, "strip", z.ZodTypeAny, {
356
- conditionType: ConditionTypeSingle.EMPTY;
357
- conditionTypeQualifier: import("@degenerate/generic").ConditionTypeQualifier;
358
- targettedProperty: string;
359
- }, {
360
- conditionType: ConditionTypeSingle.EMPTY;
361
- conditionTypeQualifier: import("@degenerate/generic").ConditionTypeQualifier;
362
- targettedProperty: string;
363
- }>, z.ZodObject<z.objectUtil.extendShape<{
364
- conditionType: z.ZodUnion<[z.ZodEnum<[ConditionTypeSingle.TYPEOF, ConditionTypeSingle.EQUAL, ConditionTypeSingle.CONTAINS, ConditionTypeSingle.NULL, ConditionTypeSingle.EMPTY, ConditionTypeSingle.SHARE_RULE]>, z.ZodEnum<[import("@degenerate/generic").ConditionTypeRange.GREATER_THAN, import("@degenerate/generic").ConditionTypeRange.LESS_THAN, import("@degenerate/generic").ConditionTypeRange.GREATER_THAN_OR_EQUAL, import("@degenerate/generic").ConditionTypeRange.LESS_THAN_OR_EQUAL]>, z.ZodEnum<[import("@degenerate/generic").ConditionTypeStartsEndsWith.STARTS_WITH, import("@degenerate/generic").ConditionTypeStartsEndsWith.ENDS_WITH]>, z.ZodEnum<[import("@degenerate/generic").ConditionTypeBoolean.TRUE, import("@degenerate/generic").ConditionTypeBoolean.FALSE]>, z.ZodEnum<[ConditionTypeSpecial]>]>;
365
- conditionTypeQualifier: z.ZodEnum<[import("@degenerate/generic").ConditionTypeQualifier.IS, import("@degenerate/generic").ConditionTypeQualifier.IS_NOT]>;
366
- targettedProperty: z.ZodString;
367
- }, {
368
- conditionType: z.ZodLiteral<ConditionTypeSingle.SHARE_RULE>;
369
- conditionValue: z.ZodLazy<z.ZodType<any, z.ZodTypeDef, any>>;
370
- }>, "strip", z.ZodTypeAny, {
371
- conditionType: ConditionTypeSingle.SHARE_RULE;
372
- conditionTypeQualifier: import("@degenerate/generic").ConditionTypeQualifier;
373
- targettedProperty: string;
374
- conditionValue?: any;
375
- }, {
376
- conditionType: ConditionTypeSingle.SHARE_RULE;
377
- conditionTypeQualifier: import("@degenerate/generic").ConditionTypeQualifier;
378
- targettedProperty: string;
379
- conditionValue?: any;
380
- }>, z.ZodObject<z.objectUtil.extendShape<{
381
- conditionType: z.ZodUnion<[z.ZodEnum<[ConditionTypeSingle.TYPEOF, ConditionTypeSingle.EQUAL, ConditionTypeSingle.CONTAINS, ConditionTypeSingle.NULL, ConditionTypeSingle.EMPTY, ConditionTypeSingle.SHARE_RULE]>, z.ZodEnum<[import("@degenerate/generic").ConditionTypeRange.GREATER_THAN, import("@degenerate/generic").ConditionTypeRange.LESS_THAN, import("@degenerate/generic").ConditionTypeRange.GREATER_THAN_OR_EQUAL, import("@degenerate/generic").ConditionTypeRange.LESS_THAN_OR_EQUAL]>, z.ZodEnum<[import("@degenerate/generic").ConditionTypeStartsEndsWith.STARTS_WITH, import("@degenerate/generic").ConditionTypeStartsEndsWith.ENDS_WITH]>, z.ZodEnum<[import("@degenerate/generic").ConditionTypeBoolean.TRUE, import("@degenerate/generic").ConditionTypeBoolean.FALSE]>, z.ZodEnum<[ConditionTypeSpecial]>]>;
382
- conditionTypeQualifier: z.ZodEnum<[import("@degenerate/generic").ConditionTypeQualifier.IS, import("@degenerate/generic").ConditionTypeQualifier.IS_NOT]>;
383
- targettedProperty: z.ZodString;
384
- }, {
385
- conditionType: z.ZodLiteral<ConditionTypeSpecial>;
386
- conditionValue: z.ZodString;
387
- }>, "strip", z.ZodTypeAny, {
388
- conditionType: ConditionTypeSpecial;
389
- conditionTypeQualifier: import("@degenerate/generic").ConditionTypeQualifier;
390
- targettedProperty: string;
391
- conditionValue: string;
392
- }, {
393
- conditionType: ConditionTypeSpecial;
394
- conditionTypeQualifier: import("@degenerate/generic").ConditionTypeQualifier;
395
- targettedProperty: string;
396
- conditionValue: string;
397
- }>]>;
398
- /**
399
- * This is the interface for the conditional information in the checks.
400
- */
401
- export type ICondition = z.infer<typeof IConditionSchema>;
402
- //# sourceMappingURL=rules-conditions.schema.d.ts.map
package/dist/schema/rules/rules-conditions.schema.d.ts.map DELETED
@@ -1 +0,0 @@
1
- {"version":3,"file":"rules-conditions.schema.d.ts","sourceRoot":"","sources":["../../../src/schema/rules/rules-conditions.schema.ts"],"names":[],"mappings":"AAGA,OAAO,EACH,oBAAoB,EACpB,mBAAmB,EACtB,MAAM,qBAAqB,CAAC;AAC7B,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAWxB;;GAEG;AACH,eAAO,MAAM,oBAAoB;;;;;;;;;;;;EAI/B,CAAC;AAEH;;GAEG;AACH,eAAO,MAAM,uBAAuB;;;;;;;;;;;;;;;;;EAGlC,CAAC;AAEH;;GAEG;AACH,eAAO,MAAM,qBAAqB;;;;;;;;;;;;;;EAEhC,CAAC;AAEH;;GAEG;AACH,eAAO,MAAM,uBAAuB;;;;;;;;;;;;;;EAElC,CAAC;AAEH;;GAEG;AACH,eAAO,MAAM,oBAAoB;;;;;;;;;;;;;;EAE/B,CAAC;AAEH;;GAEG;AACH,eAAO,MAAM,8BAA8B;;;;;;;;;;;;;;;;;EAGzC,CAAC;AAEH;;GAEG;AACH,eAAO,MAAM,wBAAwB;;;;;;;;;;;;;;;;;EAGnC,CAAC;AAEH;;GAEG;AACH,eAAO,MAAM,qBAAqB;;;;;;;;;;;;;;;;;EAGhC,CAAC;AAEH;;GAEG;AACH,eAAO,MAAM,wBAAwB;;;;;;;;;;;;;;;;;EAGnC,CAAC;AAEH;;GAEG;AACH,eAAO,MAAM,sBAAsB;;;;;;;;;;;;;;;;;EAGjC,CAAC;AAEH;;GAEG;AACH,eAAO,MAAM,yBAAyB;;;;;;;;;;;;;;;;;EAGpC,CAAC;AAEH;;GAEG;AACH,MAAM,MAAM,gBAAgB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,sBAAsB,CAAC,CAAC;AACtE,MAAM,MAAM,kBAAkB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,wBAAwB,CAAC,CAAC;AAC1E,MAAM,MAAM,eAAe,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,qBAAqB,CAAC,CAAC;AACpE,MAAM,MAAM,kBAAkB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,wBAAwB,CAAC,CAAC;AAC1E,MAAM,MAAM,wBAAwB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,8BAA8B,CAAC,CAAC;AACtF,MAAM,MAAM,cAAc,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,oBAAoB,CAAC,CAAC;AAClE,MAAM,MAAM,iBAAiB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,uBAAuB,CAAC,CAAC;AACxE,MAAM,MAAM,eAAe,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,qBAAqB,CAAC,CAAC;AACpE,MAAM,MAAM,mBAAmB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,yBAAyB,CAAC,CAAC;AAC5E,MAAM,MAAM,iBAAiB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,uBAAuB,CAAC,CAAC;AAExE;;GAEG;AACH,eAAO,MAAM,gBAAgB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;IAW3B,CAAC;AAEH;;GAEG;AACH,MAAM,MAAM,UAAU,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,gBAAgB,CAAC,CAAC"}
package/dist/schema/rules/rules-conditions.schema.js DELETED
@@ -1,99 +0,0 @@
1
- "use strict";
2
- //#region Conditions
3
- Object.defineProperty(exports, "__esModule", { value: true });
4
- exports.IConditionSchema = exports.IConditionShareRuleSchema = exports.IConditionTypeOfSchema = exports.IConditionEqualitySchema = exports.IConditionRangeSchema = exports.IConditionContainsSchema = exports.IConditionStartsEndsWithSchema = exports.IConditionNullSchema = exports.IConditionBooleanSchema = exports.IConditionEmptySchema = exports.IConditionSpecialSchema = exports.IConditionBaseSchema = void 0;
5
- const generic_1 = require("@degenerate/generic");
6
- const zod_1 = require("zod");
7
- const rules_enums_schema_1 = require("./rules-enums.schema");
8
- const rules_schema_1 = require("./rules.schema");
9
- /**
10
- * This is the base schema for all conditions.
11
- */
12
- exports.IConditionBaseSchema = zod_1.z.object({
13
- conditionType: rules_enums_schema_1.ConditionTypeSchema,
14
- conditionTypeQualifier: rules_enums_schema_1.ConditionTypeQualifierSchema,
15
- targettedProperty: zod_1.z.string(),
16
- });
17
- /**
18
- * This is the schema for the special condition.
19
- */
20
- exports.IConditionSpecialSchema = exports.IConditionBaseSchema.extend({
21
- conditionType: zod_1.z.literal(generic_1.ConditionTypeSpecial.PATTERN),
22
- conditionValue: zod_1.z.string(),
23
- });
24
- /**
25
- * This is the schema for the empty condition.
26
- */
27
- exports.IConditionEmptySchema = exports.IConditionBaseSchema.extend({
28
- conditionType: zod_1.z.literal(generic_1.ConditionTypeSingle.EMPTY),
29
- });
30
- /**
31
- * This is the schema for the boolean condition.
32
- */
33
- exports.IConditionBooleanSchema = exports.IConditionBaseSchema.extend({
34
- conditionType: rules_enums_schema_1.ConditionTypeBooleanSchema,
35
- });
36
- /**
37
- * This is the schema for the null condition.
38
- */
39
- exports.IConditionNullSchema = exports.IConditionBaseSchema.extend({
40
- conditionType: zod_1.z.literal(generic_1.ConditionTypeSingle.NULL),
41
- });
42
- /**
43
- * This is the schema for the starts with and ends with condition.
44
- */
45
- exports.IConditionStartsEndsWithSchema = exports.IConditionBaseSchema.extend({
46
- conditionType: rules_enums_schema_1.ConditionTypeStartsEndsWithSchema,
47
- conditionValue: zod_1.z.string(),
48
- });
49
- /**
50
- * This is the schema for the contains condition.
51
- */
52
- exports.IConditionContainsSchema = exports.IConditionBaseSchema.extend({
53
- conditionType: zod_1.z.literal(generic_1.ConditionTypeSingle.CONTAINS),
54
- conditionValue: zod_1.z.union([zod_1.z.string(), zod_1.z.array(zod_1.z.string()), zod_1.z.array(zod_1.z.number())]),
55
- });
56
- /**
57
- * This is the schema for the range condition.
58
- */
59
- exports.IConditionRangeSchema = exports.IConditionBaseSchema.extend({
60
- conditionType: rules_enums_schema_1.ConditionTypeRangeSchema,
61
- conditionValue: zod_1.z.union([zod_1.z.string(), zod_1.z.number()]),
62
- });
63
- /**
64
- * This is the schema for the equality condition.
65
- */
66
- exports.IConditionEqualitySchema = exports.IConditionBaseSchema.extend({
67
- conditionType: zod_1.z.literal(generic_1.ConditionTypeSingle.EQUAL),
68
- conditionValue: zod_1.z.union([zod_1.z.string(), zod_1.z.number()]),
69
- });
70
- /**
71
- * This is the schema for the type of condition.
72
- */
73
- exports.IConditionTypeOfSchema = exports.IConditionBaseSchema.extend({
74
- conditionType: zod_1.z.literal(generic_1.ConditionTypeSingle.TYPEOF),
75
- conditionValue: rules_enums_schema_1.ConditionTypeOfSchema,
76
- });
77
- /**
78
- * This is the schema for the share rule condition.
79
- */
80
- exports.IConditionShareRuleSchema = exports.IConditionBaseSchema.extend({
81
- conditionType: zod_1.z.literal(generic_1.ConditionTypeSingle.SHARE_RULE),
82
- conditionValue: zod_1.z.lazy(() => rules_schema_1.IShareRuleSchema),
83
- });
84
- /**
85
- * This is the union of all the conditions.
86
- */
87
- exports.IConditionSchema = zod_1.z.union([
88
- exports.IConditionTypeOfSchema,
89
- exports.IConditionEqualitySchema,
90
- exports.IConditionRangeSchema,
91
- exports.IConditionContainsSchema,
92
- exports.IConditionStartsEndsWithSchema,
93
- exports.IConditionNullSchema,
94
- exports.IConditionBooleanSchema,
95
- exports.IConditionEmptySchema,
96
- exports.IConditionShareRuleSchema,
97
- exports.IConditionSpecialSchema,
98
- ]);
99
- //#endregion Conditions
package/dist/schema/rules/rules-enums.schema.d.ts DELETED
@@ -1,39 +0,0 @@
1
- import { ConditionTypeBoolean, ConditionTypeOf, ConditionTypeQualifier, ConditionTypeRange, ConditionTypeSingle, ConditionTypeSpecial, ConditionTypeStartsEndsWith, LogicalOperator } from '@degenerate/generic';
2
- import z from 'zod';
3
- /**
4
- * These are the different choices for the types of data in a condition.
5
- */
6
- export declare const ConditionTypeOfSchema: z.ZodEnum<[ConditionTypeOf.STRING, ConditionTypeOf.NUMBER, ConditionTypeOf.INTEGER, ConditionTypeOf.BOOLEAN, ConditionTypeOf.OBJECT, ConditionTypeOf.ARRAY, ConditionTypeOf.NULL, ConditionTypeOf.UNDEFINED, ConditionTypeOf.FUNCTION, ConditionTypeOf.BIGINT]>;
7
- /**
8
- * This contains the choices for the logical operators.
9
- */
10
- export declare const LogicalOperatorSchema: z.ZodEnum<[LogicalOperator.AND, LogicalOperator.OR]>;
11
- /**
12
- * This contains the choices for the type of qualifier.
13
- */
14
- export declare const ConditionTypeQualifierSchema: z.ZodEnum<[ConditionTypeQualifier.IS, ConditionTypeQualifier.IS_NOT]>;
15
- /**
16
- * This contains the choices for the type of condition.
17
- */
18
- export declare const ConditionTypeSingleSchema: z.ZodEnum<[ConditionTypeSingle.TYPEOF, ConditionTypeSingle.EQUAL, ConditionTypeSingle.CONTAINS, ConditionTypeSingle.NULL, ConditionTypeSingle.EMPTY, ConditionTypeSingle.SHARE_RULE]>;
19
- /**
20
- * This contains the choices for the range conditions.
21
- */
22
- export declare const ConditionTypeRangeSchema: z.ZodEnum<[ConditionTypeRange.GREATER_THAN, ConditionTypeRange.LESS_THAN, ConditionTypeRange.GREATER_THAN_OR_EQUAL, ConditionTypeRange.LESS_THAN_OR_EQUAL]>;
23
- /**
24
- * This contains the choices for the starts with and ends with conditions.
25
- */
26
- export declare const ConditionTypeStartsEndsWithSchema: z.ZodEnum<[ConditionTypeStartsEndsWith.STARTS_WITH, ConditionTypeStartsEndsWith.ENDS_WITH]>;
27
- /**
28
- * This contains the choices for the boolean conditions.
29
- */
30
- export declare const ConditionTypeBooleanSchema: z.ZodEnum<[ConditionTypeBoolean.TRUE, ConditionTypeBoolean.FALSE]>;
31
- /**
32
- * This contains the choices for the special conditions.
33
- */
34
- export declare const ConditionTypeSpecialSchema: z.ZodEnum<[ConditionTypeSpecial]>;
35
- /**
36
- * Create the union schema for ConditionType
37
- */
38
- export declare const ConditionTypeSchema: z.ZodUnion<[z.ZodEnum<[ConditionTypeSingle.TYPEOF, ConditionTypeSingle.EQUAL, ConditionTypeSingle.CONTAINS, ConditionTypeSingle.NULL, ConditionTypeSingle.EMPTY, ConditionTypeSingle.SHARE_RULE]>, z.ZodEnum<[ConditionTypeRange.GREATER_THAN, ConditionTypeRange.LESS_THAN, ConditionTypeRange.GREATER_THAN_OR_EQUAL, ConditionTypeRange.LESS_THAN_OR_EQUAL]>, z.ZodEnum<[ConditionTypeStartsEndsWith.STARTS_WITH, ConditionTypeStartsEndsWith.ENDS_WITH]>, z.ZodEnum<[ConditionTypeBoolean.TRUE, ConditionTypeBoolean.FALSE]>, z.ZodEnum<[ConditionTypeSpecial]>]>;
39
- //# sourceMappingURL=rules-enums.schema.d.ts.map
package/dist/schema/rules/rules-enums.schema.d.ts.map DELETED
@@ -1 +0,0 @@
1
- {"version":3,"file":"rules-enums.schema.d.ts","sourceRoot":"","sources":["../../../src/schema/rules/rules-enums.schema.ts"],"names":[],"mappings":"AACA,OAAO,EACH,oBAAoB,EACpB,eAAe,EACf,sBAAsB,EACtB,kBAAkB,EAClB,mBAAmB,EACnB,oBAAoB,EACpB,2BAA2B,EAC3B,eAAe,EAClB,MAAM,qBAAqB,CAAC;AAC7B,OAAO,CAAC,MAAM,KAAK,CAAC;AAGpB;;GAEG;AACH,eAAO,MAAM,qBAAqB,iQAWhC,CAAC;AAEH;;GAEG;AACH,eAAO,MAAM,qBAAqB,sDAGhC,CAAC;AAEH;;GAEG;AACH,eAAO,MAAM,4BAA4B,uEAGvC,CAAC;AAEH;;GAEG;AACH,eAAO,MAAM,yBAAyB,uLAOpC,CAAC;AAEH;;GAEG;AACH,eAAO,MAAM,wBAAwB,6JAKnC,CAAC;AAEH;;GAEG;AACH,eAAO,MAAM,iCAAiC,6FAG5C,CAAC;AAEH;;GAEG;AACH,eAAO,MAAM,0BAA0B,oEAGrC,CAAC;AAEH;;GAEG;AACH,eAAO,MAAM,0BAA0B,mCAErC,CAAC;AAEH;;GAEG;AACH,eAAO,MAAM,mBAAmB,siBAM9B,CAAC"}