schema.validateSync(data, { abortEarly: false })

schema.validateSync(data, { abortEarly: false, strict: true })

schema.run(data)

schema.parse(data)

schema.parse(data)

schema.inspect(data)

schema.validateSync(data, { abortEarly: true })

Value.Parse(schema, data)

schema(data)

// const compiledScriptSchema = Schema.Compile(scriptSchema);
compiledScriptSchema.Parse(data);

(Commented code is not benchmarked)

// const compiled = Compile(schema);
compiled.Parse(data);

(Commented code is not benchmarked)

Schema.Parse(schema, data)

schema.safeParse(data, { jitless: true })

// const compiledSchema = Schema.Compile(schema);
compiledSchema.Parse(data);

(Commented code is not benchmarked)

schema.safeParse(data)

const [error] = schema.validate(data);
for (const failure of error.failures()) {
  // ...
}

const [error] = validate(data, schema);
for (const failure of error.failures()) {
  // ...
}

schema.validateSync(data, { abortEarly: true, strict: true })

schema.decode(data)

schema.safeParse(data)

schema.safeParse(data, { jitless: true })

schema.validate(data, { abortEarly: false })

schema.validate(data, { abortEarly: false, convert: false })

schema.safeParse(data)

validate(data, schema)

v.safeParse(schema, data, { abortPipeEarly: true })

v.safeParse(schema, data)

// const decodeAll = Schema.decodeUnknownEither(
//  schema, 
//  { errors: "all" }
// );
decodeAll(data)

(Commented code is not benchmarked)

// const decode = Schema.decodeUnknownOption(schema);
decode(data, { errors: "all" })

(Commented code is not benchmarked)

typia.validate<TypiaSchema>(data)

// const validate = typia.createValidate<TypiaSchema>();
validate(data);

(Commented code is not benchmarked)

bagSchema.safeParse(data)

schema.safeParse(data)

compactSchema.safeParse(data)

schema.validate(data)

validate(data, schema)

p.object(...).parse(data)

// const decodeFirst = Schema.decodeUnknownEither(
//  schema, 
//  { errors: "first" }
// );
decodeFirst(data)

(Commented code is not benchmarked)

// const parser = S.parser(S.schema(...));
parser(data);

(Commented code is not benchmarked)

S.safe(() => parser(data))

schema.parse(data)

schema.decode(data)

schema.validate(data, { abortEarly: true })

p.object(...).safeParse(data)

schema.validate(data, { abortEarly: true, convert: false })

schema.safeParse(data)

// const decode = Schema.decodeUnknownOption(schema);
decode(data, { errors: "first" })

(Commented code is not benchmarked)

v.safeParse(schema, data, { abortEarly: true })

validate(data, schema, { abortEarly: true })

schema.validate(data)