@croct/sdk 0.17.12 → 0.18.1

package/validation/functionType.d.cts

@@ -0,0 +1,9 @@
+import { TypeSchema } from './schema.cjs';
+
+declare class FunctionType implements TypeSchema {
+    getTypes(): string[];
+    isValidType(value: unknown): value is boolean;
+    validate(value: unknown, path?: string[]): void;
+}
+
+export { FunctionType };

package/validation/functionType.js

@@ -1,5 +1,5 @@
-import { Violation } from "./schema";
-import { describe, formatPath } from "./violation";
+import { Violation } from "./schema.js";
+import { describe, formatPath } from "./violation.js";
 class FunctionType {
   getTypes() {
     return ["function"];

package/validation/index.cjs

@@ -33,18 +33,18 @@ __export(validation_exports, {
   UnionType: () => import_unionType.UnionType
 });
 module.exports = __toCommonJS(validation_exports);
-__reExport(validation_exports, require("./schema"), module.exports);
-__reExport(validation_exports, require("./violation"), module.exports);
-var import_arrayType = require("./arrayType");
-var import_booleanType = require("./booleanType");
-var import_functionType = require("./functionType");
-var import_jsonType = require("./jsonType");
-var import_mixedSchema = require("./mixedSchema");
-var import_nullType = require("./nullType");
-var import_numberType = require("./numberType");
-var import_objectType = require("./objectType");
-var import_stringType = require("./stringType");
-var import_unionType = require("./unionType");
+__reExport(validation_exports, require('./schema.cjs'), module.exports);
+__reExport(validation_exports, require('./violation.cjs'), module.exports);
+var import_arrayType = require('./arrayType.cjs');
+var import_booleanType = require('./booleanType.cjs');
+var import_functionType = require('./functionType.cjs');
+var import_jsonType = require('./jsonType.cjs');
+var import_mixedSchema = require('./mixedSchema.cjs');
+var import_nullType = require('./nullType.cjs');
+var import_numberType = require('./numberType.cjs');
+var import_objectType = require('./objectType.cjs');
+var import_stringType = require('./stringType.cjs');
+var import_unionType = require('./unionType.cjs');
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   ArrayType,
@@ -60,6 +60,6 @@ var import_unionType = require("./unionType");
   ObjectType,
   StringType,
   UnionType,
-  ...require("./schema"),
-  ...require("./violation")
+  ...require('./schema.cjs'),
+  ...require('./violation.cjs')
 });

package/validation/index.d.cts

@@ -0,0 +1,12 @@
+export { Schema, TypeSchema, Violation } from './schema.cjs';
+export { describe, formatPath } from './violation.cjs';
+export { ArrayType } from './arrayType.cjs';
+export { BooleanType } from './booleanType.cjs';
+export { FunctionType } from './functionType.cjs';
+export { JsonArrayType, JsonObjectType, JsonPrimitiveType, JsonType } from './jsonType.cjs';
+export { MixedSchema } from './mixedSchema.cjs';
+export { NullType } from './nullType.cjs';
+export { NumberType } from './numberType.cjs';
+export { ObjectType } from './objectType.cjs';
+export { StringType } from './stringType.cjs';
+export { UnionType } from './unionType.cjs';

package/validation/index.js

@@ -1,15 +1,15 @@
-export * from "./schema";
-export * from "./violation";
-import { ArrayType } from "./arrayType";
-import { BooleanType } from "./booleanType";
-import { FunctionType } from "./functionType";
-import { JsonType, JsonArrayType, JsonObjectType, JsonPrimitiveType } from "./jsonType";
-import { MixedSchema } from "./mixedSchema";
-import { NullType } from "./nullType";
-import { NumberType } from "./numberType";
-import { ObjectType } from "./objectType";
-import { StringType } from "./stringType";
-import { UnionType } from "./unionType";
+export * from "./schema.js";
+export * from "./violation.js";
+import { ArrayType } from "./arrayType.js";
+import { BooleanType } from "./booleanType.js";
+import { FunctionType } from "./functionType.js";
+import { JsonType, JsonArrayType, JsonObjectType, JsonPrimitiveType } from "./jsonType.js";
+import { MixedSchema } from "./mixedSchema.js";
+import { NullType } from "./nullType.js";
+import { NumberType } from "./numberType.js";
+import { ObjectType } from "./objectType.js";
+import { StringType } from "./stringType.js";
+import { UnionType } from "./unionType.js";
 export {
   ArrayType,
   BooleanType,

package/validation/jsonType.cjs

@@ -23,8 +23,8 @@ __export(jsonType_exports, {
   JsonType: () => JsonType
 });
 module.exports = __toCommonJS(jsonType_exports);
-var import_schema = require("./schema");
-var import_violation = require("./violation");
+var import_schema = require('./schema.cjs');
+var import_violation = require('./violation.cjs');
 function isJsonPrimitive(value) {
   return value === null || typeof value === "string" || typeof value === "boolean" || typeof value === "number";
 }

package/validation/jsonType.d.cts

@@ -0,0 +1,35 @@
+import { TypeSchema, Schema } from './schema.cjs';
+
+type JsonObjectDefinition = {
+    properties?: Schema;
+    propertyNames?: Schema;
+};
+declare class JsonObjectType implements TypeSchema {
+    private readonly definition;
+    constructor(definition?: JsonObjectDefinition);
+    getTypes(): string[];
+    isValidType(value: unknown): boolean;
+    validate(value: unknown, path?: string[]): void;
+}
+type JsonArrayDefinition = {
+    items?: Schema;
+};
+declare class JsonArrayType implements TypeSchema {
+    private readonly definition;
+    constructor(definition?: JsonArrayDefinition);
+    getTypes(): string[];
+    isValidType(value: unknown): boolean;
+    validate(value: unknown, path?: string[]): void;
+}
+declare class JsonPrimitiveType implements TypeSchema {
+    getTypes(): string[];
+    isValidType(value: unknown): boolean;
+    validate(value: unknown, path?: string[]): void;
+}
+declare class JsonType implements TypeSchema {
+    getTypes(): string[];
+    isValidType(value: unknown): boolean;
+    validate(value: unknown, path?: string[]): void;
+}
+
+export { JsonArrayType, JsonObjectType, JsonPrimitiveType, JsonType };

package/validation/jsonType.js

@@ -1,5 +1,5 @@
-import { Violation } from "./schema";
-import { describe, formatPath } from "./violation";
+import { Violation } from "./schema.js";
+import { describe, formatPath } from "./violation.js";
 function isJsonPrimitive(value) {
   return value === null || typeof value === "string" || typeof value === "boolean" || typeof value === "number";
 }

package/validation/mixedSchema.d.cts

@@ -0,0 +1,7 @@
+import { Schema } from './schema.cjs';
+
+declare class MixedSchema implements Schema {
+    validate(): void;
+}
+
+export { MixedSchema };

package/validation/nullType.cjs

@@ -20,8 +20,8 @@ __export(nullType_exports, {
   NullType: () => NullType
 });
 module.exports = __toCommonJS(nullType_exports);
-var import_schema = require("./schema");
-var import_violation = require("./violation");
+var import_schema = require('./schema.cjs');
+var import_violation = require('./violation.cjs');
 class NullType {
   getTypes() {
     return ["null"];

package/validation/nullType.d.cts

@@ -0,0 +1,9 @@
+import { TypeSchema } from './schema.cjs';
+
+declare class NullType implements TypeSchema {
+    getTypes(): string[];
+    isValidType(value: unknown): value is null;
+    validate(value: unknown, path?: string[]): void;
+}
+
+export { NullType };

package/validation/nullType.js

@@ -1,5 +1,5 @@
-import { Violation } from "./schema";
-import { describe, formatPath } from "./violation";
+import { Violation } from "./schema.js";
+import { describe, formatPath } from "./violation.js";
 class NullType {
   getTypes() {
     return ["null"];

package/validation/numberType.cjs

@@ -20,8 +20,8 @@ __export(numberType_exports, {
   NumberType: () => NumberType
 });
 module.exports = __toCommonJS(numberType_exports);
-var import_schema = require("./schema");
-var import_violation = require("./violation");
+var import_schema = require('./schema.cjs');
+var import_violation = require('./violation.cjs');
 class NumberType {
   constructor(definition = {}) {
     this.definition = {

package/validation/numberType.d.cts

@@ -0,0 +1,16 @@
+import { TypeSchema } from './schema.cjs';
+
+type NumberDefinition = {
+    integer: boolean;
+    minimum: number;
+    maximum: number;
+};
+declare class NumberType implements TypeSchema {
+    private readonly definition;
+    constructor(definition?: Partial<NumberDefinition>);
+    getTypes(): string[];
+    isValidType(value: unknown): value is number;
+    validate(value: unknown, path?: string[]): void;
+}
+
+export { NumberType };

package/validation/numberType.js

@@ -1,5 +1,5 @@
-import { Violation } from "./schema";
-import { describe, formatPath } from "./violation";
+import { Violation } from "./schema.js";
+import { describe, formatPath } from "./violation.js";
 class NumberType {
   constructor(definition = {}) {
     this.definition = {

package/validation/objectType.cjs

@@ -20,9 +20,9 @@ __export(objectType_exports, {
   ObjectType: () => ObjectType
 });
 module.exports = __toCommonJS(objectType_exports);
-var import_schema = require("./schema");
-var import_mixedSchema = require("./mixedSchema");
-var import_violation = require("./violation");
+var import_schema = require('./schema.cjs');
+var import_mixedSchema = require('./mixedSchema.cjs');
+var import_violation = require('./violation.cjs');
 class ObjectType {
   constructor(schema = {}) {
     this.definition = {

package/validation/objectType.d.cts

@@ -0,0 +1,30 @@
+import { TypeSchema, Schema } from './schema.cjs';
+
+type ObjectDefinition = {
+    type?: {
+        new (...args: any): any;
+    };
+    properties: {
+        [key: string]: Schema;
+    };
+    additionalProperties: boolean | Schema;
+    subtypes?: {
+        discriminator: string;
+        schemas: {
+            [key: string]: ObjectType;
+        };
+    };
+    propertyNames: Schema;
+    required: string[];
+    minProperties: number;
+    maxProperties: number;
+};
+declare class ObjectType implements TypeSchema {
+    private readonly definition;
+    constructor(schema?: Partial<ObjectDefinition>);
+    getTypes(): string[];
+    isValidType(value: unknown): value is object;
+    validate(value: unknown, path?: string[]): void;
+}
+
+export { ObjectType };

package/validation/objectType.js

@@ -1,6 +1,6 @@
-import { Violation } from "./schema";
-import { MixedSchema } from "./mixedSchema";
-import { describe, formatPath } from "./violation";
+import { Violation } from "./schema.js";
+import { MixedSchema } from "./mixedSchema.js";
+import { describe, formatPath } from "./violation.js";
 class ObjectType {
   constructor(schema = {}) {
     this.definition = {

package/validation/schema.d.cts

@@ -0,0 +1,18 @@
+interface Schema {
+    validate(value: unknown, path?: string[]): void;
+}
+interface TypeSchema extends Schema {
+    getTypes(): string[];
+    isValidType(value: unknown): boolean;
+}
+declare class Violation extends Error {
+    readonly path: string[];
+    readonly params: {
+        [key: string]: unknown;
+    };
+    constructor(message: string, path: string[], params: {
+        [p: string]: unknown;
+    });
+}
+
+export { type Schema, type TypeSchema, Violation };

package/validation/stringType.cjs

@@ -20,8 +20,8 @@ __export(stringType_exports, {
   StringType: () => StringType
 });
 module.exports = __toCommonJS(stringType_exports);
-var import_schema = require("./schema");
-var import_violation = require("./violation");
+var import_schema = require('./schema.cjs');
+var import_violation = require('./violation.cjs');
 const FORMAT = {
   pointer: function pointer(value) {
     return /^(\.|([a-zA-Z_][a-zA-Z0-9_]*|\[[0-9]+])(\.[a-zA-Z_][a-zA-Z0-9_]*|\[[0-9]+])*)$/.test(value);

package/validation/stringType.d.cts

@@ -0,0 +1,24 @@
+import { TypeSchema } from './schema.cjs';
+
+interface Format {
+    (value: string): boolean;
+}
+declare const FORMAT: {
+    [key: string]: Format;
+};
+type StringDefinition = {
+    minLength: number;
+    maxLength: number;
+    enumeration: string[];
+    pattern?: RegExp;
+    format?: keyof typeof FORMAT;
+};
+declare class StringType implements TypeSchema {
+    private readonly definition;
+    constructor(definition?: Partial<StringDefinition>);
+    getTypes(): string[];
+    isValidType(value: unknown): value is string;
+    validate(value: unknown, path?: string[]): void;
+}
+
+export { StringType };

package/validation/stringType.js

@@ -1,5 +1,5 @@
-import { Violation } from "./schema";
-import { describe, formatPath } from "./violation";
+import { Violation } from "./schema.js";
+import { describe, formatPath } from "./violation.js";
 const FORMAT = {
   pointer: function pointer(value) {
     return /^(\.|([a-zA-Z_][a-zA-Z0-9_]*|\[[0-9]+])(\.[a-zA-Z_][a-zA-Z0-9_]*|\[[0-9]+])*)$/.test(value);

package/validation/unionType.cjs

@@ -20,8 +20,8 @@ __export(unionType_exports, {
   UnionType: () => UnionType
 });
 module.exports = __toCommonJS(unionType_exports);
-var import_schema = require("./schema");
-var import_violation = require("./violation");
+var import_schema = require('./schema.cjs');
+var import_violation = require('./violation.cjs');
 class UnionType {
   constructor(first, second, ...others) {
     this.schemas = [first, second, ...others];

package/validation/unionType.d.cts

@@ -0,0 +1,11 @@
+import { TypeSchema } from './schema.cjs';
+
+declare class UnionType implements TypeSchema {
+    private readonly schemas;
+    constructor(first: TypeSchema, second: TypeSchema, ...others: TypeSchema[]);
+    getTypes(): string[];
+    isValidType(value: unknown): boolean;
+    validate(value: unknown, path?: string[]): void;
+}
+
+export { UnionType };

package/validation/unionType.js

@@ -1,5 +1,5 @@
-import { Violation } from "./schema";
-import { describe, formatPath } from "./violation";
+import { Violation } from "./schema.js";
+import { describe, formatPath } from "./violation.js";
 class UnionType {
   constructor(first, second, ...others) {
     this.schemas = [first, second, ...others];

package/validation/violation.d.cts

@@ -0,0 +1,4 @@
+declare function describe(value: unknown): string;
+declare function formatPath(path: string[]): string;
+
+export { describe, formatPath };