Schema.Union<
readonly [
Schema.Struct<{
readonly _tag: Schema.tag<"isStringFinite">
readonly regExp: Schema.RegExp
}>,
Schema.Struct<{
readonly _tag: Schema.tag<"isStringBigInt">
readonly regExp: Schema.RegExp
}>,
Schema.Struct<{
readonly _tag: Schema.tag<"isStringSymbol">
readonly regExp: Schema.RegExp
}>,
Schema.Struct<{
readonly _tag: Schema.tag<"isTrimmed">
readonly regExp: Schema.RegExp
}>,
Schema.Struct<{
readonly _tag: Schema.tag<"isUUID">
readonly regExp: Schema.RegExp
readonly version: Schema.UndefinedOr<
Schema.Literals<readonly [1, 2, 3, 4, 5, 6, 7, 8]>
>
}>,
Schema.Struct<{
readonly _tag: Schema.tag<"isGUID">
readonly regExp: Schema.RegExp
}>,
Schema.Struct<{
readonly _tag: Schema.tag<"isULID">
readonly regExp: Schema.RegExp
}>,
Schema.Struct<{
readonly _tag: Schema.tag<"isBase64">
readonly regExp: Schema.RegExp
}>,
Schema.Struct<{
readonly _tag: Schema.tag<"isBase64Url">
readonly regExp: Schema.RegExp
}>,
Schema.Struct<{
readonly _tag: Schema.tag<"isStartsWith">
readonly startsWith: Schema.String
readonly regExp: Schema.RegExp
}>,
Schema.Struct<{
readonly _tag: Schema.tag<"isEndsWith">
readonly endsWith: Schema.String
readonly regExp: Schema.RegExp
}>,
Schema.Struct<{
readonly _tag: Schema.tag<"isIncludes">
readonly includes: Schema.String
readonly regExp: Schema.RegExp
}>,
Schema.Struct<{
readonly _tag: Schema.tag<"isUppercased">
readonly regExp: Schema.RegExp
}>,
Schema.Struct<{
readonly _tag: Schema.tag<"isLowercased">
readonly regExp: Schema.RegExp
}>,
Schema.Struct<{
readonly _tag: Schema.tag<"isCapitalized">
readonly regExp: Schema.RegExp
}>,
Schema.Struct<{
readonly _tag: Schema.tag<"isUncapitalized">
readonly regExp: Schema.RegExp
}>,
Schema.Struct<{
readonly _tag: Schema.tag<"isMinLength">
readonly minLength: Schema.Int
}>,
Schema.Struct<{
readonly _tag: Schema.tag<"isMaxLength">
readonly maxLength: Schema.Int
}>,
Schema.Struct<{
readonly _tag: Schema.tag<"isPattern">
readonly regExp: Schema.RegExp
}>,
Schema.Struct<{
readonly _tag: Schema.tag<"isLengthBetween">
readonly minimum: Schema.Int
readonly maximum: Schema.Int
}>
]
>Schema for StringMeta.
schemasStringMeta
Source effect/SchemaRepresentation.ts:99122 lines
export const const $StringMeta: Schema.Union<readonly [Schema.Struct<{
readonly _tag: Schema.tag<"isStringFinite">;
readonly regExp: Schema.RegExp;
}>, Schema.Struct<{
readonly _tag: Schema.tag<"isStringBigInt">;
readonly regExp: Schema.RegExp;
}>, Schema.Struct<{
readonly _tag: Schema.tag<"isStringSymbol">;
readonly regExp: Schema.RegExp;
}>, Schema.Struct<{
readonly _tag: Schema.tag<"isTrimmed">;
readonly regExp: Schema.RegExp;
}>, Schema.Struct<{
readonly _tag: Schema.tag<"isUUID">;
readonly regExp: Schema.RegExp;
readonly version: Schema.UndefinedOr<Schema.Literals<readonly [1, 2, 3, 4, 5, 6, 7, 8]>>;
}>, ... 14 more ..., Schema.Struct<...>]>
const $StringMeta: {
Type: { [K in keyof Members]: Members[K]["Type"]; }[number];
Encoded: { [K in keyof Members]: Members[K]["Encoded"]; }[number];
DecodingServices: { [K in keyof Members]: Members[K]["DecodingServices"]; }[number];
EncodingServices: { [K in keyof Members]: Members[K]["EncodingServices"]; }[number];
Iso: { [K in keyof Members]: Members[K]["Iso"]; }[number];
members: Members;
mapMembers: (f: (members: readonly [Schema.Struct<{ readonly _tag: Schema.tag<'isStringFinite'>; readonly regExp: Schema.RegExp }>, Schema.Struct<{ readonly _tag: Schema.tag<'isStringBigInt'>; readonly regExp: Schema.RegExp }>, Schema.Struct<{ readonl…;
Rebuild: Rebuild;
ast: Ast;
annotate: (annotations: Schema.Annotations.Bottom<Schema.Struct.ReadonlySide<{ readonly _tag: Schema.tag<'isStringFinite'>; readonly regExp: Schema.RegExp; }, 'Type'> | Schema.Struct.ReadonlySide<{ readonly _tag: Schema.tag<'isStringBigInt'>; readon…;
annotateKey: (annotations: Schema.Annotations.Key<Schema.Struct.ReadonlySide<{ readonly _tag: Schema.tag<'isStringFinite'>; readonly regExp: Schema.RegExp }, 'Type'> | Schema.Struct.ReadonlySide<{ readonly _tag: Schema.tag<'isStringBigInt'>; readonly r…;
check: (checks_0: SchemaAST.Check<Schema.Struct.ReadonlySide<{ readonly _tag: Schema.tag<'isStringFinite'>; readonly regExp: Schema.RegExp }, 'Type'> | Schema.Struct.ReadonlySide<{ readonly _tag: Schema.tag<'isStringBigInt'>; readonly regExp: Sch…;
rebuild: (ast: SchemaAST.Union<SchemaAST.Objects>) => Schema.Union<readonly [Schema.Struct<{ readonly _tag: Schema.tag<'isStringFinite'>; readonly regExp: Schema.RegExp }>, Schema.Struct<{ readonly _tag: Schema.tag<'isStringBigInt'>; readonly regEx…;
make: (input: { readonly regExp: globalThis.RegExp; readonly _tag?: 'isStringFinite' | undefined } | { readonly regExp: globalThis.RegExp; readonly _tag?: 'isStringBigInt' | undefined } | { readonly regExp: globalThis.RegExp; readonly _tag?: 'is…;
makeOption: (input: { readonly regExp: globalThis.RegExp; readonly _tag?: 'isStringFinite' | undefined } | { readonly regExp: globalThis.RegExp; readonly _tag?: 'isStringBigInt' | undefined } | { readonly regExp: globalThis.RegExp; readonly _tag?: 'is…;
makeEffect: (input: { readonly regExp: globalThis.RegExp; readonly _tag?: 'isStringFinite' | undefined } | { readonly regExp: globalThis.RegExp; readonly _tag?: 'isStringBigInt' | undefined } | { readonly regExp: globalThis.RegExp; readonly _tag?: 'is…;
pipe: { <A>(this: A): A; <A, B = never>(this: A, ab: (_: A) => B): B; <A, B = never, C = never>(this: A, ab: (_: A) => B, bc: (_: B) => C): C; <A, B = never, C = never, D = never>(this: A, ab: (_: A) => B, bc: (_: B) => C, cd: (_: C) => D): D; <…;
}
Schema for
StringMeta
.
$StringMeta = import SchemaSchema.function Union<
Members extends ReadonlyArray<Constraint>
>(
members: Members,
options?: { mode?: "anyOf" | "oneOf" }
): Union<Members>
Creates a union schema from an array of member schemas. Members are tested in
order; the first match is returned.
Details
Optionally, specify mode:
"anyOf" (default) — matches if any member matches.
"oneOf" — matches if exactly one member matches.
Example (Defining a string or number union)
import { Schema } from "effect"
const schema = Schema.Union([Schema.String, Schema.Number])
Schema.decodeUnknownSync(schema)("hello") // "hello"
Schema.decodeUnknownSync(schema)(42) // 42
Union([
const $IsStringFinite: Schema.Struct<{
readonly _tag: Schema.tag<"isStringFinite">
readonly regExp: Schema.RegExp
}>
const $IsStringFinite: {
Type: Struct.Type<Fields>;
Encoded: Struct.Encoded<Fields>;
DecodingServices: Struct.DecodingServices<Fields>;
EncodingServices: Struct.EncodingServices<Fields>;
Iso: Struct.Iso<Fields>;
fields: Fields;
mapFields: (f: (fields: { readonly _tag: Schema.tag<'isStringFinite'>; readonly regExp: Schema.RegExp }) => To, options?: { readonly unsafePreserveChecks?: boolean | undefined } | undefined) => Schema.Struct<{ [K in keyof Readonly<To>]: Readonly<To>[…;
Rebuild: Rebuild;
ast: Ast;
annotate: (annotations: Schema.Annotations.Bottom<Schema.Struct.ReadonlySide<{ readonly _tag: Schema.tag<'isStringFinite'>; readonly regExp: Schema.RegExp; }, 'Type'>, readonly []>) => Schema.Struct<{ readonly _tag: Schema.tag<'isStringFinite'>; rea…;
annotateKey: (annotations: Schema.Annotations.Key<Schema.Struct.ReadonlySide<{ readonly _tag: Schema.tag<'isStringFinite'>; readonly regExp: Schema.RegExp }, 'Type'>>) => Schema.Struct<{ readonly _tag: Schema.tag<'isStringFinite'>; readonly regExp: Sch…;
check: (checks_0: SchemaAST.Check<Schema.Struct.ReadonlySide<{ readonly _tag: Schema.tag<'isStringFinite'>; readonly regExp: Schema.RegExp }, 'Type'>>, ...checks: Array<SchemaAST.Check<Schema.Struct.ReadonlySide<{ readonly _tag: Schema.tag<'isStr…;
rebuild: (ast: SchemaAST.Objects) => Schema.Struct<{ readonly _tag: Schema.tag<'isStringFinite'>; readonly regExp: Schema.RegExp }>;
make: (input: { readonly regExp: globalThis.RegExp; readonly _tag?: 'isStringFinite' | undefined }, options?: MakeOptions) => Struct.ReadonlySide<{ readonly _tag: tag<'isStringFinite'>; readonly regExp: RegExp }, 'Type'>;
makeOption: (input: { readonly regExp: globalThis.RegExp; readonly _tag?: 'isStringFinite' | undefined }, options?: MakeOptions) => Option_.Option<Struct.ReadonlySide<{ readonly _tag: tag<'isStringFinite'>; readonly regExp: RegExp }, 'Type'>>;
makeEffect: (input: { readonly regExp: globalThis.RegExp; readonly _tag?: 'isStringFinite' | undefined }, options?: MakeOptions) => Effect.Effect<Struct.ReadonlySide<{ readonly _tag: tag<'isStringFinite'>; readonly regExp: RegExp }, 'Type'>, SchemaErr…;
pipe: { <A>(this: A): A; <A, B = never>(this: A, ab: (_: A) => B): B; <A, B = never, C = never>(this: A, ab: (_: A) => B, bc: (_: B) => C): C; <A, B = never, C = never, D = never>(this: A, ab: (_: A) => B, bc: (_: B) => C, cd: (_: C) => D): D; <…;
}
$IsStringFinite,
const $IsStringBigInt: Schema.Struct<{
readonly _tag: Schema.tag<"isStringBigInt">
readonly regExp: Schema.RegExp
}>
const $IsStringBigInt: {
Type: Struct.Type<Fields>;
Encoded: Struct.Encoded<Fields>;
DecodingServices: Struct.DecodingServices<Fields>;
EncodingServices: Struct.EncodingServices<Fields>;
Iso: Struct.Iso<Fields>;
fields: Fields;
mapFields: (f: (fields: { readonly _tag: Schema.tag<'isStringBigInt'>; readonly regExp: Schema.RegExp }) => To, options?: { readonly unsafePreserveChecks?: boolean | undefined } | undefined) => Schema.Struct<{ [K in keyof Readonly<To>]: Readonly<To>[…;
Rebuild: Rebuild;
ast: Ast;
annotate: (annotations: Schema.Annotations.Bottom<Schema.Struct.ReadonlySide<{ readonly _tag: Schema.tag<'isStringBigInt'>; readonly regExp: Schema.RegExp; }, 'Type'>, readonly []>) => Schema.Struct<{ readonly _tag: Schema.tag<'isStringBigInt'>; rea…;
annotateKey: (annotations: Schema.Annotations.Key<Schema.Struct.ReadonlySide<{ readonly _tag: Schema.tag<'isStringBigInt'>; readonly regExp: Schema.RegExp }, 'Type'>>) => Schema.Struct<{ readonly _tag: Schema.tag<'isStringBigInt'>; readonly regExp: Sch…;
check: (checks_0: SchemaAST.Check<Schema.Struct.ReadonlySide<{ readonly _tag: Schema.tag<'isStringBigInt'>; readonly regExp: Schema.RegExp }, 'Type'>>, ...checks: Array<SchemaAST.Check<Schema.Struct.ReadonlySide<{ readonly _tag: Schema.tag<'isStr…;
rebuild: (ast: SchemaAST.Objects) => Schema.Struct<{ readonly _tag: Schema.tag<'isStringBigInt'>; readonly regExp: Schema.RegExp }>;
make: (input: { readonly regExp: globalThis.RegExp; readonly _tag?: 'isStringBigInt' | undefined }, options?: MakeOptions) => Struct.ReadonlySide<{ readonly _tag: tag<'isStringBigInt'>; readonly regExp: RegExp }, 'Type'>;
makeOption: (input: { readonly regExp: globalThis.RegExp; readonly _tag?: 'isStringBigInt' | undefined }, options?: MakeOptions) => Option_.Option<Struct.ReadonlySide<{ readonly _tag: tag<'isStringBigInt'>; readonly regExp: RegExp }, 'Type'>>;
makeEffect: (input: { readonly regExp: globalThis.RegExp; readonly _tag?: 'isStringBigInt' | undefined }, options?: MakeOptions) => Effect.Effect<Struct.ReadonlySide<{ readonly _tag: tag<'isStringBigInt'>; readonly regExp: RegExp }, 'Type'>, SchemaErr…;
pipe: { <A>(this: A): A; <A, B = never>(this: A, ab: (_: A) => B): B; <A, B = never, C = never>(this: A, ab: (_: A) => B, bc: (_: B) => C): C; <A, B = never, C = never, D = never>(this: A, ab: (_: A) => B, bc: (_: B) => C, cd: (_: C) => D): D; <…;
}
$IsStringBigInt,
const $IsStringSymbol: Schema.Struct<{
readonly _tag: Schema.tag<"isStringSymbol">
readonly regExp: Schema.RegExp
}>
const $IsStringSymbol: {
Type: Struct.Type<Fields>;
Encoded: Struct.Encoded<Fields>;
DecodingServices: Struct.DecodingServices<Fields>;
EncodingServices: Struct.EncodingServices<Fields>;
Iso: Struct.Iso<Fields>;
fields: Fields;
mapFields: (f: (fields: { readonly _tag: Schema.tag<'isStringSymbol'>; readonly regExp: Schema.RegExp }) => To, options?: { readonly unsafePreserveChecks?: boolean | undefined } | undefined) => Schema.Struct<{ [K in keyof Readonly<To>]: Readonly<To>[…;
Rebuild: Rebuild;
ast: Ast;
annotate: (annotations: Schema.Annotations.Bottom<Schema.Struct.ReadonlySide<{ readonly _tag: Schema.tag<'isStringSymbol'>; readonly regExp: Schema.RegExp; }, 'Type'>, readonly []>) => Schema.Struct<{ readonly _tag: Schema.tag<'isStringSymbol'>; rea…;
annotateKey: (annotations: Schema.Annotations.Key<Schema.Struct.ReadonlySide<{ readonly _tag: Schema.tag<'isStringSymbol'>; readonly regExp: Schema.RegExp }, 'Type'>>) => Schema.Struct<{ readonly _tag: Schema.tag<'isStringSymbol'>; readonly regExp: Sch…;
check: (checks_0: SchemaAST.Check<Schema.Struct.ReadonlySide<{ readonly _tag: Schema.tag<'isStringSymbol'>; readonly regExp: Schema.RegExp }, 'Type'>>, ...checks: Array<SchemaAST.Check<Schema.Struct.ReadonlySide<{ readonly _tag: Schema.tag<'isStr…;
rebuild: (ast: SchemaAST.Objects) => Schema.Struct<{ readonly _tag: Schema.tag<'isStringSymbol'>; readonly regExp: Schema.RegExp }>;
make: (input: { readonly regExp: globalThis.RegExp; readonly _tag?: 'isStringSymbol' | undefined }, options?: MakeOptions) => Struct.ReadonlySide<{ readonly _tag: tag<'isStringSymbol'>; readonly regExp: RegExp }, 'Type'>;
makeOption: (input: { readonly regExp: globalThis.RegExp; readonly _tag?: 'isStringSymbol' | undefined }, options?: MakeOptions) => Option_.Option<Struct.ReadonlySide<{ readonly _tag: tag<'isStringSymbol'>; readonly regExp: RegExp }, 'Type'>>;
makeEffect: (input: { readonly regExp: globalThis.RegExp; readonly _tag?: 'isStringSymbol' | undefined }, options?: MakeOptions) => Effect.Effect<Struct.ReadonlySide<{ readonly _tag: tag<'isStringSymbol'>; readonly regExp: RegExp }, 'Type'>, SchemaErr…;
pipe: { <A>(this: A): A; <A, B = never>(this: A, ab: (_: A) => B): B; <A, B = never, C = never>(this: A, ab: (_: A) => B, bc: (_: B) => C): C; <A, B = never, C = never, D = never>(this: A, ab: (_: A) => B, bc: (_: B) => C, cd: (_: C) => D): D; <…;
}
$IsStringSymbol,
const $IsTrimmed: Schema.Struct<{
readonly _tag: Schema.tag<"isTrimmed">
readonly regExp: Schema.RegExp
}>
const $IsTrimmed: {
Type: Struct.Type<Fields>;
Encoded: Struct.Encoded<Fields>;
DecodingServices: Struct.DecodingServices<Fields>;
EncodingServices: Struct.EncodingServices<Fields>;
Iso: Struct.Iso<Fields>;
fields: Fields;
mapFields: (f: (fields: { readonly _tag: Schema.tag<'isTrimmed'>; readonly regExp: Schema.RegExp }) => To, options?: { readonly unsafePreserveChecks?: boolean | undefined } | undefined) => Schema.Struct<{ [K in keyof Readonly<To>]: Readonly<To>[K]; }>;
Rebuild: Rebuild;
ast: Ast;
annotate: (annotations: Schema.Annotations.Bottom<Schema.Struct.ReadonlySide<{ readonly _tag: Schema.tag<'isTrimmed'>; readonly regExp: Schema.RegExp; }, 'Type'>, readonly []>) => Schema.Struct<{ readonly _tag: Schema.tag<'isTrimmed'>; readonly regE…;
annotateKey: (annotations: Schema.Annotations.Key<Schema.Struct.ReadonlySide<{ readonly _tag: Schema.tag<'isTrimmed'>; readonly regExp: Schema.RegExp }, 'Type'>>) => Schema.Struct<{ readonly _tag: Schema.tag<'isTrimmed'>; readonly regExp: Schema.RegExp…;
check: (checks_0: SchemaAST.Check<Schema.Struct.ReadonlySide<{ readonly _tag: Schema.tag<'isTrimmed'>; readonly regExp: Schema.RegExp }, 'Type'>>, ...checks: Array<SchemaAST.Check<Schema.Struct.ReadonlySide<{ readonly _tag: Schema.tag<'isTrimmed'…;
rebuild: (ast: SchemaAST.Objects) => Schema.Struct<{ readonly _tag: Schema.tag<'isTrimmed'>; readonly regExp: Schema.RegExp }>;
make: (input: { readonly regExp: globalThis.RegExp; readonly _tag?: 'isTrimmed' | undefined }, options?: MakeOptions) => Struct.ReadonlySide<{ readonly _tag: tag<'isTrimmed'>; readonly regExp: RegExp }, 'Type'>;
makeOption: (input: { readonly regExp: globalThis.RegExp; readonly _tag?: 'isTrimmed' | undefined }, options?: MakeOptions) => Option_.Option<Struct.ReadonlySide<{ readonly _tag: tag<'isTrimmed'>; readonly regExp: RegExp }, 'Type'>>;
makeEffect: (input: { readonly regExp: globalThis.RegExp; readonly _tag?: 'isTrimmed' | undefined }, options?: MakeOptions) => Effect.Effect<Struct.ReadonlySide<{ readonly _tag: tag<'isTrimmed'>; readonly regExp: RegExp }, 'Type'>, SchemaError, never>;
pipe: { <A>(this: A): A; <A, B = never>(this: A, ab: (_: A) => B): B; <A, B = never, C = never>(this: A, ab: (_: A) => B, bc: (_: B) => C): C; <A, B = never, C = never, D = never>(this: A, ab: (_: A) => B, bc: (_: B) => C, cd: (_: C) => D): D; <…;
}
$IsTrimmed,
const $IsUUID: Schema.Struct<{
readonly _tag: Schema.tag<"isUUID">
readonly regExp: Schema.RegExp
readonly version: Schema.UndefinedOr<
Schema.Literals<
readonly [1, 2, 3, 4, 5, 6, 7, 8]
>
>
}>
const $IsUUID: {
Type: Struct.Type<Fields>;
Encoded: Struct.Encoded<Fields>;
DecodingServices: Struct.DecodingServices<Fields>;
EncodingServices: Struct.EncodingServices<Fields>;
Iso: Struct.Iso<Fields>;
fields: Fields;
mapFields: (f: (fields: { readonly _tag: Schema.tag<'isUUID'>; readonly regExp: Schema.RegExp; readonly version: Schema.UndefinedOr<Schema.Literals<readonly [1, 2, 3, 4, 5, 6, 7, 8]>> }) => To, options?: { readonly unsafePreserveChecks?: boolean | un…;
Rebuild: Rebuild;
ast: Ast;
annotate: (annotations: Schema.Annotations.Bottom<Schema.Struct.ReadonlySide<{ readonly _tag: Schema.tag<'isUUID'>; readonly regExp: Schema.RegExp; readonly version: Schema.UndefinedOr<Schema.Literals<readonly [1, 2, 3, 4, 5, 6, 7, 8]>>; }, 'Type'>,…;
annotateKey: (annotations: Schema.Annotations.Key<Schema.Struct.ReadonlySide<{ readonly _tag: Schema.tag<'isUUID'>; readonly regExp: Schema.RegExp; readonly version: Schema.UndefinedOr<Schema.Literals<readonly [1, 2, 3, 4, 5, 6, 7, 8]>> }, 'Type'>>) =>…;
check: (checks_0: SchemaAST.Check<Schema.Struct.ReadonlySide<{ readonly _tag: Schema.tag<'isUUID'>; readonly regExp: Schema.RegExp; readonly version: Schema.UndefinedOr<Schema.Literals<readonly [1, 2, 3, 4, 5, 6, 7, 8]>> }, 'Type'>>, ...checks: A…;
rebuild: (ast: SchemaAST.Objects) => Schema.Struct<{ readonly _tag: Schema.tag<'isUUID'>; readonly regExp: Schema.RegExp; readonly version: Schema.UndefinedOr<Schema.Literals<readonly [1, 2, 3, 4, 5, 6, 7, 8]>> }>;
make: (input: { readonly regExp: globalThis.RegExp; readonly version: 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | undefined; readonly _tag?: 'isUUID' | undefined }, options?: MakeOptions) => Struct.ReadonlySide<{ readonly _tag: tag<'isUUID'>; readonly regEx…;
makeOption: (input: { readonly regExp: globalThis.RegExp; readonly version: 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | undefined; readonly _tag?: 'isUUID' | undefined }, options?: MakeOptions) => Option_.Option<Struct.ReadonlySide<{ readonly _tag: tag<'isUUID'>;…;
makeEffect: (input: { readonly regExp: globalThis.RegExp; readonly version: 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | undefined; readonly _tag?: 'isUUID' | undefined }, options?: MakeOptions) => Effect.Effect<Struct.ReadonlySide<{ readonly _tag: tag<'isUUID'>; …;
pipe: { <A>(this: A): A; <A, B = never>(this: A, ab: (_: A) => B): B; <A, B = never, C = never>(this: A, ab: (_: A) => B, bc: (_: B) => C): C; <A, B = never, C = never, D = never>(this: A, ab: (_: A) => B, bc: (_: B) => C, cd: (_: C) => D): D; <…;
}
$IsUUID,
const $IsGUID: Schema.Struct<{
readonly _tag: Schema.tag<"isGUID">
readonly regExp: Schema.RegExp
}>
const $IsGUID: {
Type: Struct.Type<Fields>;
Encoded: Struct.Encoded<Fields>;
DecodingServices: Struct.DecodingServices<Fields>;
EncodingServices: Struct.EncodingServices<Fields>;
Iso: Struct.Iso<Fields>;
fields: Fields;
mapFields: (f: (fields: { readonly _tag: Schema.tag<'isGUID'>; readonly regExp: Schema.RegExp }) => To, options?: { readonly unsafePreserveChecks?: boolean | undefined } | undefined) => Schema.Struct<{ [K in keyof Readonly<To>]: Readonly<To>[K]; }>;
Rebuild: Rebuild;
ast: Ast;
annotate: (annotations: Schema.Annotations.Bottom<Schema.Struct.ReadonlySide<{ readonly _tag: Schema.tag<'isGUID'>; readonly regExp: Schema.RegExp; }, 'Type'>, readonly []>) => Schema.Struct<{ readonly _tag: Schema.tag<'isGUID'>; readonly regExp: Sc…;
annotateKey: (annotations: Schema.Annotations.Key<Schema.Struct.ReadonlySide<{ readonly _tag: Schema.tag<'isGUID'>; readonly regExp: Schema.RegExp }, 'Type'>>) => Schema.Struct<{ readonly _tag: Schema.tag<'isGUID'>; readonly regExp: Schema.RegExp }>;
check: (checks_0: SchemaAST.Check<Schema.Struct.ReadonlySide<{ readonly _tag: Schema.tag<'isGUID'>; readonly regExp: Schema.RegExp }, 'Type'>>, ...checks: Array<SchemaAST.Check<Schema.Struct.ReadonlySide<{ readonly _tag: Schema.tag<'isGUID'>; rea…;
rebuild: (ast: SchemaAST.Objects) => Schema.Struct<{ readonly _tag: Schema.tag<'isGUID'>; readonly regExp: Schema.RegExp }>;
make: (input: { readonly regExp: globalThis.RegExp; readonly _tag?: 'isGUID' | undefined }, options?: MakeOptions) => Struct.ReadonlySide<{ readonly _tag: tag<'isGUID'>; readonly regExp: RegExp }, 'Type'>;
makeOption: (input: { readonly regExp: globalThis.RegExp; readonly _tag?: 'isGUID' | undefined }, options?: MakeOptions) => Option_.Option<Struct.ReadonlySide<{ readonly _tag: tag<'isGUID'>; readonly regExp: RegExp }, 'Type'>>;
makeEffect: (input: { readonly regExp: globalThis.RegExp; readonly _tag?: 'isGUID' | undefined }, options?: MakeOptions) => Effect.Effect<Struct.ReadonlySide<{ readonly _tag: tag<'isGUID'>; readonly regExp: RegExp }, 'Type'>, SchemaError, never>;
pipe: { <A>(this: A): A; <A, B = never>(this: A, ab: (_: A) => B): B; <A, B = never, C = never>(this: A, ab: (_: A) => B, bc: (_: B) => C): C; <A, B = never, C = never, D = never>(this: A, ab: (_: A) => B, bc: (_: B) => C, cd: (_: C) => D): D; <…;
}
$IsGUID,
const $IsULID: Schema.Struct<{
readonly _tag: Schema.tag<"isULID">
readonly regExp: Schema.RegExp
}>
const $IsULID: {
Type: Struct.Type<Fields>;
Encoded: Struct.Encoded<Fields>;
DecodingServices: Struct.DecodingServices<Fields>;
EncodingServices: Struct.EncodingServices<Fields>;
Iso: Struct.Iso<Fields>;
fields: Fields;
mapFields: (f: (fields: { readonly _tag: Schema.tag<'isULID'>; readonly regExp: Schema.RegExp }) => To, options?: { readonly unsafePreserveChecks?: boolean | undefined } | undefined) => Schema.Struct<{ [K in keyof Readonly<To>]: Readonly<To>[K]; }>;
Rebuild: Rebuild;
ast: Ast;
annotate: (annotations: Schema.Annotations.Bottom<Schema.Struct.ReadonlySide<{ readonly _tag: Schema.tag<'isULID'>; readonly regExp: Schema.RegExp; }, 'Type'>, readonly []>) => Schema.Struct<{ readonly _tag: Schema.tag<'isULID'>; readonly regExp: Sc…;
annotateKey: (annotations: Schema.Annotations.Key<Schema.Struct.ReadonlySide<{ readonly _tag: Schema.tag<'isULID'>; readonly regExp: Schema.RegExp }, 'Type'>>) => Schema.Struct<{ readonly _tag: Schema.tag<'isULID'>; readonly regExp: Schema.RegExp }>;
check: (checks_0: SchemaAST.Check<Schema.Struct.ReadonlySide<{ readonly _tag: Schema.tag<'isULID'>; readonly regExp: Schema.RegExp }, 'Type'>>, ...checks: Array<SchemaAST.Check<Schema.Struct.ReadonlySide<{ readonly _tag: Schema.tag<'isULID'>; rea…;
rebuild: (ast: SchemaAST.Objects) => Schema.Struct<{ readonly _tag: Schema.tag<'isULID'>; readonly regExp: Schema.RegExp }>;
make: (input: { readonly regExp: globalThis.RegExp; readonly _tag?: 'isULID' | undefined }, options?: MakeOptions) => Struct.ReadonlySide<{ readonly _tag: tag<'isULID'>; readonly regExp: RegExp }, 'Type'>;
makeOption: (input: { readonly regExp: globalThis.RegExp; readonly _tag?: 'isULID' | undefined }, options?: MakeOptions) => Option_.Option<Struct.ReadonlySide<{ readonly _tag: tag<'isULID'>; readonly regExp: RegExp }, 'Type'>>;
makeEffect: (input: { readonly regExp: globalThis.RegExp; readonly _tag?: 'isULID' | undefined }, options?: MakeOptions) => Effect.Effect<Struct.ReadonlySide<{ readonly _tag: tag<'isULID'>; readonly regExp: RegExp }, 'Type'>, SchemaError, never>;
pipe: { <A>(this: A): A; <A, B = never>(this: A, ab: (_: A) => B): B; <A, B = never, C = never>(this: A, ab: (_: A) => B, bc: (_: B) => C): C; <A, B = never, C = never, D = never>(this: A, ab: (_: A) => B, bc: (_: B) => C, cd: (_: C) => D): D; <…;
}
$IsULID,
const $IsBase64: Schema.Struct<{
readonly _tag: Schema.tag<"isBase64">
readonly regExp: Schema.RegExp
}>
const $IsBase64: {
Type: Struct.Type<Fields>;
Encoded: Struct.Encoded<Fields>;
DecodingServices: Struct.DecodingServices<Fields>;
EncodingServices: Struct.EncodingServices<Fields>;
Iso: Struct.Iso<Fields>;
fields: Fields;
mapFields: (f: (fields: { readonly _tag: Schema.tag<'isBase64'>; readonly regExp: Schema.RegExp }) => To, options?: { readonly unsafePreserveChecks?: boolean | undefined } | undefined) => Schema.Struct<{ [K in keyof Readonly<To>]: Readonly<To>[K]; }>;
Rebuild: Rebuild;
ast: Ast;
annotate: (annotations: Schema.Annotations.Bottom<Schema.Struct.ReadonlySide<{ readonly _tag: Schema.tag<'isBase64'>; readonly regExp: Schema.RegExp; }, 'Type'>, readonly []>) => Schema.Struct<{ readonly _tag: Schema.tag<'isBase64'>; readonly regExp…;
annotateKey: (annotations: Schema.Annotations.Key<Schema.Struct.ReadonlySide<{ readonly _tag: Schema.tag<'isBase64'>; readonly regExp: Schema.RegExp }, 'Type'>>) => Schema.Struct<{ readonly _tag: Schema.tag<'isBase64'>; readonly regExp: Schema.RegExp }>;
check: (checks_0: SchemaAST.Check<Schema.Struct.ReadonlySide<{ readonly _tag: Schema.tag<'isBase64'>; readonly regExp: Schema.RegExp }, 'Type'>>, ...checks: Array<SchemaAST.Check<Schema.Struct.ReadonlySide<{ readonly _tag: Schema.tag<'isBase64'>;…;
rebuild: (ast: SchemaAST.Objects) => Schema.Struct<{ readonly _tag: Schema.tag<'isBase64'>; readonly regExp: Schema.RegExp }>;
make: (input: { readonly regExp: globalThis.RegExp; readonly _tag?: 'isBase64' | undefined }, options?: MakeOptions) => Struct.ReadonlySide<{ readonly _tag: tag<'isBase64'>; readonly regExp: RegExp }, 'Type'>;
makeOption: (input: { readonly regExp: globalThis.RegExp; readonly _tag?: 'isBase64' | undefined }, options?: MakeOptions) => Option_.Option<Struct.ReadonlySide<{ readonly _tag: tag<'isBase64'>; readonly regExp: RegExp }, 'Type'>>;
makeEffect: (input: { readonly regExp: globalThis.RegExp; readonly _tag?: 'isBase64' | undefined }, options?: MakeOptions) => Effect.Effect<Struct.ReadonlySide<{ readonly _tag: tag<'isBase64'>; readonly regExp: RegExp }, 'Type'>, SchemaError, never>;
pipe: { <A>(this: A): A; <A, B = never>(this: A, ab: (_: A) => B): B; <A, B = never, C = never>(this: A, ab: (_: A) => B, bc: (_: B) => C): C; <A, B = never, C = never, D = never>(this: A, ab: (_: A) => B, bc: (_: B) => C, cd: (_: C) => D): D; <…;
}
$IsBase64,
const $IsBase64Url: Schema.Struct<{
readonly _tag: Schema.tag<"isBase64Url">
readonly regExp: Schema.RegExp
}>
const $IsBase64Url: {
Type: Struct.Type<Fields>;
Encoded: Struct.Encoded<Fields>;
DecodingServices: Struct.DecodingServices<Fields>;
EncodingServices: Struct.EncodingServices<Fields>;
Iso: Struct.Iso<Fields>;
fields: Fields;
mapFields: (f: (fields: { readonly _tag: Schema.tag<'isBase64Url'>; readonly regExp: Schema.RegExp }) => To, options?: { readonly unsafePreserveChecks?: boolean | undefined } | undefined) => Schema.Struct<{ [K in keyof Readonly<To>]: Readonly<To>[K];…;
Rebuild: Rebuild;
ast: Ast;
annotate: (annotations: Schema.Annotations.Bottom<Schema.Struct.ReadonlySide<{ readonly _tag: Schema.tag<'isBase64Url'>; readonly regExp: Schema.RegExp; }, 'Type'>, readonly []>) => Schema.Struct<{ readonly _tag: Schema.tag<'isBase64Url'>; readonly …;
annotateKey: (annotations: Schema.Annotations.Key<Schema.Struct.ReadonlySide<{ readonly _tag: Schema.tag<'isBase64Url'>; readonly regExp: Schema.RegExp }, 'Type'>>) => Schema.Struct<{ readonly _tag: Schema.tag<'isBase64Url'>; readonly regExp: Schema.Re…;
check: (checks_0: SchemaAST.Check<Schema.Struct.ReadonlySide<{ readonly _tag: Schema.tag<'isBase64Url'>; readonly regExp: Schema.RegExp }, 'Type'>>, ...checks: Array<SchemaAST.Check<Schema.Struct.ReadonlySide<{ readonly _tag: Schema.tag<'isBase64…;
rebuild: (ast: SchemaAST.Objects) => Schema.Struct<{ readonly _tag: Schema.tag<'isBase64Url'>; readonly regExp: Schema.RegExp }>;
make: (input: { readonly regExp: globalThis.RegExp; readonly _tag?: 'isBase64Url' | undefined }, options?: MakeOptions) => Struct.ReadonlySide<{ readonly _tag: tag<'isBase64Url'>; readonly regExp: RegExp }, 'Type'>;
makeOption: (input: { readonly regExp: globalThis.RegExp; readonly _tag?: 'isBase64Url' | undefined }, options?: MakeOptions) => Option_.Option<Struct.ReadonlySide<{ readonly _tag: tag<'isBase64Url'>; readonly regExp: RegExp }, 'Type'>>;
makeEffect: (input: { readonly regExp: globalThis.RegExp; readonly _tag?: 'isBase64Url' | undefined }, options?: MakeOptions) => Effect.Effect<Struct.ReadonlySide<{ readonly _tag: tag<'isBase64Url'>; readonly regExp: RegExp }, 'Type'>, SchemaError, ne…;
pipe: { <A>(this: A): A; <A, B = never>(this: A, ab: (_: A) => B): B; <A, B = never, C = never>(this: A, ab: (_: A) => B, bc: (_: B) => C): C; <A, B = never, C = never, D = never>(this: A, ab: (_: A) => B, bc: (_: B) => C, cd: (_: C) => D): D; <…;
}
$IsBase64Url,
const $IsStartsWith: Schema.Struct<{
readonly _tag: Schema.tag<"isStartsWith">
readonly startsWith: Schema.String
readonly regExp: Schema.RegExp
}>
const $IsStartsWith: {
Type: Struct.Type<Fields>;
Encoded: Struct.Encoded<Fields>;
DecodingServices: Struct.DecodingServices<Fields>;
EncodingServices: Struct.EncodingServices<Fields>;
Iso: Struct.Iso<Fields>;
fields: Fields;
mapFields: (f: (fields: { readonly _tag: Schema.tag<'isStartsWith'>; readonly startsWith: Schema.String; readonly regExp: Schema.RegExp }) => To, options?: { readonly unsafePreserveChecks?: boolean | undefined } | undefined) => Schema.Struct<{ [K in …;
Rebuild: Rebuild;
ast: Ast;
annotate: (annotations: Schema.Annotations.Bottom<Schema.Struct.ReadonlySide<{ readonly _tag: Schema.tag<'isStartsWith'>; readonly startsWith: Schema.String; readonly regExp: Schema.RegExp; }, 'Type'>, readonly []>) => Schema.Struct<{ readonly _tag:…;
annotateKey: (annotations: Schema.Annotations.Key<Schema.Struct.ReadonlySide<{ readonly _tag: Schema.tag<'isStartsWith'>; readonly startsWith: Schema.String; readonly regExp: Schema.RegExp }, 'Type'>>) => Schema.Struct<{ readonly _tag: Schema.tag<'isSt…;
check: (checks_0: SchemaAST.Check<Schema.Struct.ReadonlySide<{ readonly _tag: Schema.tag<'isStartsWith'>; readonly startsWith: Schema.String; readonly regExp: Schema.RegExp }, 'Type'>>, ...checks: Array<SchemaAST.Check<Schema.Struct.ReadonlySide<…;
rebuild: (ast: SchemaAST.Objects) => Schema.Struct<{ readonly _tag: Schema.tag<'isStartsWith'>; readonly startsWith: Schema.String; readonly regExp: Schema.RegExp }>;
make: (input: { readonly regExp: globalThis.RegExp; readonly startsWith: string; readonly _tag?: 'isStartsWith' | undefined }, options?: MakeOptions) => Struct.ReadonlySide<{ readonly _tag: tag<'isStartsWith'>; readonly startsWith: String; reado…;
makeOption: (input: { readonly regExp: globalThis.RegExp; readonly startsWith: string; readonly _tag?: 'isStartsWith' | undefined }, options?: MakeOptions) => Option_.Option<Struct.ReadonlySide<{ readonly _tag: tag<'isStartsWith'>; readonly startsWith…;
makeEffect: (input: { readonly regExp: globalThis.RegExp; readonly startsWith: string; readonly _tag?: 'isStartsWith' | undefined }, options?: MakeOptions) => Effect.Effect<Struct.ReadonlySide<{ readonly _tag: tag<'isStartsWith'>; readonly startsWith:…;
pipe: { <A>(this: A): A; <A, B = never>(this: A, ab: (_: A) => B): B; <A, B = never, C = never>(this: A, ab: (_: A) => B, bc: (_: B) => C): C; <A, B = never, C = never, D = never>(this: A, ab: (_: A) => B, bc: (_: B) => C, cd: (_: C) => D): D; <…;
}
$IsStartsWith,
const $IsEndsWith: Schema.Struct<{
readonly _tag: Schema.tag<"isEndsWith">
readonly endsWith: Schema.String
readonly regExp: Schema.RegExp
}>
const $IsEndsWith: {
Type: Struct.Type<Fields>;
Encoded: Struct.Encoded<Fields>;
DecodingServices: Struct.DecodingServices<Fields>;
EncodingServices: Struct.EncodingServices<Fields>;
Iso: Struct.Iso<Fields>;
fields: Fields;
mapFields: (f: (fields: { readonly _tag: Schema.tag<'isEndsWith'>; readonly endsWith: Schema.String; readonly regExp: Schema.RegExp }) => To, options?: { readonly unsafePreserveChecks?: boolean | undefined } | undefined) => Schema.Struct<{ [K in keyo…;
Rebuild: Rebuild;
ast: Ast;
annotate: (annotations: Schema.Annotations.Bottom<Schema.Struct.ReadonlySide<{ readonly _tag: Schema.tag<'isEndsWith'>; readonly endsWith: Schema.String; readonly regExp: Schema.RegExp; }, 'Type'>, readonly []>) => Schema.Struct<{ readonly _tag: Sch…;
annotateKey: (annotations: Schema.Annotations.Key<Schema.Struct.ReadonlySide<{ readonly _tag: Schema.tag<'isEndsWith'>; readonly endsWith: Schema.String; readonly regExp: Schema.RegExp }, 'Type'>>) => Schema.Struct<{ readonly _tag: Schema.tag<'isEndsWi…;
check: (checks_0: SchemaAST.Check<Schema.Struct.ReadonlySide<{ readonly _tag: Schema.tag<'isEndsWith'>; readonly endsWith: Schema.String; readonly regExp: Schema.RegExp }, 'Type'>>, ...checks: Array<SchemaAST.Check<Schema.Struct.ReadonlySide<{ re…;
rebuild: (ast: SchemaAST.Objects) => Schema.Struct<{ readonly _tag: Schema.tag<'isEndsWith'>; readonly endsWith: Schema.String; readonly regExp: Schema.RegExp }>;
make: (input: { readonly regExp: globalThis.RegExp; readonly endsWith: string; readonly _tag?: 'isEndsWith' | undefined }, options?: MakeOptions) => Struct.ReadonlySide<{ readonly _tag: tag<'isEndsWith'>; readonly endsWith: String; readonly regE…;
makeOption: (input: { readonly regExp: globalThis.RegExp; readonly endsWith: string; readonly _tag?: 'isEndsWith' | undefined }, options?: MakeOptions) => Option_.Option<Struct.ReadonlySide<{ readonly _tag: tag<'isEndsWith'>; readonly endsWith: String…;
makeEffect: (input: { readonly regExp: globalThis.RegExp; readonly endsWith: string; readonly _tag?: 'isEndsWith' | undefined }, options?: MakeOptions) => Effect.Effect<Struct.ReadonlySide<{ readonly _tag: tag<'isEndsWith'>; readonly endsWith: String;…;
pipe: { <A>(this: A): A; <A, B = never>(this: A, ab: (_: A) => B): B; <A, B = never, C = never>(this: A, ab: (_: A) => B, bc: (_: B) => C): C; <A, B = never, C = never, D = never>(this: A, ab: (_: A) => B, bc: (_: B) => C, cd: (_: C) => D): D; <…;
}
$IsEndsWith,
const $IsIncludes: Schema.Struct<{
readonly _tag: Schema.tag<"isIncludes">
readonly includes: Schema.String
readonly regExp: Schema.RegExp
}>
const $IsIncludes: {
Type: Struct.Type<Fields>;
Encoded: Struct.Encoded<Fields>;
DecodingServices: Struct.DecodingServices<Fields>;
EncodingServices: Struct.EncodingServices<Fields>;
Iso: Struct.Iso<Fields>;
fields: Fields;
mapFields: (f: (fields: { readonly _tag: Schema.tag<'isIncludes'>; readonly includes: Schema.String; readonly regExp: Schema.RegExp }) => To, options?: { readonly unsafePreserveChecks?: boolean | undefined } | undefined) => Schema.Struct<{ [K in keyo…;
Rebuild: Rebuild;
ast: Ast;
annotate: (annotations: Schema.Annotations.Bottom<Schema.Struct.ReadonlySide<{ readonly _tag: Schema.tag<'isIncludes'>; readonly includes: Schema.String; readonly regExp: Schema.RegExp; }, 'Type'>, readonly []>) => Schema.Struct<{ readonly _tag: Sch…;
annotateKey: (annotations: Schema.Annotations.Key<Schema.Struct.ReadonlySide<{ readonly _tag: Schema.tag<'isIncludes'>; readonly includes: Schema.String; readonly regExp: Schema.RegExp }, 'Type'>>) => Schema.Struct<{ readonly _tag: Schema.tag<'isInclud…;
check: (checks_0: SchemaAST.Check<Schema.Struct.ReadonlySide<{ readonly _tag: Schema.tag<'isIncludes'>; readonly includes: Schema.String; readonly regExp: Schema.RegExp }, 'Type'>>, ...checks: Array<SchemaAST.Check<Schema.Struct.ReadonlySide<{ re…;
rebuild: (ast: SchemaAST.Objects) => Schema.Struct<{ readonly _tag: Schema.tag<'isIncludes'>; readonly includes: Schema.String; readonly regExp: Schema.RegExp }>;
make: (input: { readonly includes: string; readonly regExp: globalThis.RegExp; readonly _tag?: 'isIncludes' | undefined }, options?: MakeOptions) => Struct.ReadonlySide<{ readonly _tag: tag<'isIncludes'>; readonly includes: String; readonly regE…;
makeOption: (input: { readonly includes: string; readonly regExp: globalThis.RegExp; readonly _tag?: 'isIncludes' | undefined }, options?: MakeOptions) => Option_.Option<Struct.ReadonlySide<{ readonly _tag: tag<'isIncludes'>; readonly includes: String…;
makeEffect: (input: { readonly includes: string; readonly regExp: globalThis.RegExp; readonly _tag?: 'isIncludes' | undefined }, options?: MakeOptions) => Effect.Effect<Struct.ReadonlySide<{ readonly _tag: tag<'isIncludes'>; readonly includes: String;…;
pipe: { <A>(this: A): A; <A, B = never>(this: A, ab: (_: A) => B): B; <A, B = never, C = never>(this: A, ab: (_: A) => B, bc: (_: B) => C): C; <A, B = never, C = never, D = never>(this: A, ab: (_: A) => B, bc: (_: B) => C, cd: (_: C) => D): D; <…;
}
$IsIncludes,
const $IsUppercased: Schema.Struct<{
readonly _tag: Schema.tag<"isUppercased">
readonly regExp: Schema.RegExp
}>
const $IsUppercased: {
Type: Struct.Type<Fields>;
Encoded: Struct.Encoded<Fields>;
DecodingServices: Struct.DecodingServices<Fields>;
EncodingServices: Struct.EncodingServices<Fields>;
Iso: Struct.Iso<Fields>;
fields: Fields;
mapFields: (f: (fields: { readonly _tag: Schema.tag<'isUppercased'>; readonly regExp: Schema.RegExp }) => To, options?: { readonly unsafePreserveChecks?: boolean | undefined } | undefined) => Schema.Struct<{ [K in keyof Readonly<To>]: Readonly<To>[K]…;
Rebuild: Rebuild;
ast: Ast;
annotate: (annotations: Schema.Annotations.Bottom<Schema.Struct.ReadonlySide<{ readonly _tag: Schema.tag<'isUppercased'>; readonly regExp: Schema.RegExp; }, 'Type'>, readonly []>) => Schema.Struct<{ readonly _tag: Schema.tag<'isUppercased'>; readonl…;
annotateKey: (annotations: Schema.Annotations.Key<Schema.Struct.ReadonlySide<{ readonly _tag: Schema.tag<'isUppercased'>; readonly regExp: Schema.RegExp }, 'Type'>>) => Schema.Struct<{ readonly _tag: Schema.tag<'isUppercased'>; readonly regExp: Schema.…;
check: (checks_0: SchemaAST.Check<Schema.Struct.ReadonlySide<{ readonly _tag: Schema.tag<'isUppercased'>; readonly regExp: Schema.RegExp }, 'Type'>>, ...checks: Array<SchemaAST.Check<Schema.Struct.ReadonlySide<{ readonly _tag: Schema.tag<'isUpper…;
rebuild: (ast: SchemaAST.Objects) => Schema.Struct<{ readonly _tag: Schema.tag<'isUppercased'>; readonly regExp: Schema.RegExp }>;
make: (input: { readonly regExp: globalThis.RegExp; readonly _tag?: 'isUppercased' | undefined }, options?: MakeOptions) => Struct.ReadonlySide<{ readonly _tag: tag<'isUppercased'>; readonly regExp: RegExp }, 'Type'>;
makeOption: (input: { readonly regExp: globalThis.RegExp; readonly _tag?: 'isUppercased' | undefined }, options?: MakeOptions) => Option_.Option<Struct.ReadonlySide<{ readonly _tag: tag<'isUppercased'>; readonly regExp: RegExp }, 'Type'>>;
makeEffect: (input: { readonly regExp: globalThis.RegExp; readonly _tag?: 'isUppercased' | undefined }, options?: MakeOptions) => Effect.Effect<Struct.ReadonlySide<{ readonly _tag: tag<'isUppercased'>; readonly regExp: RegExp }, 'Type'>, SchemaError, …;
pipe: { <A>(this: A): A; <A, B = never>(this: A, ab: (_: A) => B): B; <A, B = never, C = never>(this: A, ab: (_: A) => B, bc: (_: B) => C): C; <A, B = never, C = never, D = never>(this: A, ab: (_: A) => B, bc: (_: B) => C, cd: (_: C) => D): D; <…;
}
$IsUppercased,
const $IsLowercased: Schema.Struct<{
readonly _tag: Schema.tag<"isLowercased">
readonly regExp: Schema.RegExp
}>
const $IsLowercased: {
Type: Struct.Type<Fields>;
Encoded: Struct.Encoded<Fields>;
DecodingServices: Struct.DecodingServices<Fields>;
EncodingServices: Struct.EncodingServices<Fields>;
Iso: Struct.Iso<Fields>;
fields: Fields;
mapFields: (f: (fields: { readonly _tag: Schema.tag<'isLowercased'>; readonly regExp: Schema.RegExp }) => To, options?: { readonly unsafePreserveChecks?: boolean | undefined } | undefined) => Schema.Struct<{ [K in keyof Readonly<To>]: Readonly<To>[K]…;
Rebuild: Rebuild;
ast: Ast;
annotate: (annotations: Schema.Annotations.Bottom<Schema.Struct.ReadonlySide<{ readonly _tag: Schema.tag<'isLowercased'>; readonly regExp: Schema.RegExp; }, 'Type'>, readonly []>) => Schema.Struct<{ readonly _tag: Schema.tag<'isLowercased'>; readonl…;
annotateKey: (annotations: Schema.Annotations.Key<Schema.Struct.ReadonlySide<{ readonly _tag: Schema.tag<'isLowercased'>; readonly regExp: Schema.RegExp }, 'Type'>>) => Schema.Struct<{ readonly _tag: Schema.tag<'isLowercased'>; readonly regExp: Schema.…;
check: (checks_0: SchemaAST.Check<Schema.Struct.ReadonlySide<{ readonly _tag: Schema.tag<'isLowercased'>; readonly regExp: Schema.RegExp }, 'Type'>>, ...checks: Array<SchemaAST.Check<Schema.Struct.ReadonlySide<{ readonly _tag: Schema.tag<'isLower…;
rebuild: (ast: SchemaAST.Objects) => Schema.Struct<{ readonly _tag: Schema.tag<'isLowercased'>; readonly regExp: Schema.RegExp }>;
make: (input: { readonly regExp: globalThis.RegExp; readonly _tag?: 'isLowercased' | undefined }, options?: MakeOptions) => Struct.ReadonlySide<{ readonly _tag: tag<'isLowercased'>; readonly regExp: RegExp }, 'Type'>;
makeOption: (input: { readonly regExp: globalThis.RegExp; readonly _tag?: 'isLowercased' | undefined }, options?: MakeOptions) => Option_.Option<Struct.ReadonlySide<{ readonly _tag: tag<'isLowercased'>; readonly regExp: RegExp }, 'Type'>>;
makeEffect: (input: { readonly regExp: globalThis.RegExp; readonly _tag?: 'isLowercased' | undefined }, options?: MakeOptions) => Effect.Effect<Struct.ReadonlySide<{ readonly _tag: tag<'isLowercased'>; readonly regExp: RegExp }, 'Type'>, SchemaError, …;
pipe: { <A>(this: A): A; <A, B = never>(this: A, ab: (_: A) => B): B; <A, B = never, C = never>(this: A, ab: (_: A) => B, bc: (_: B) => C): C; <A, B = never, C = never, D = never>(this: A, ab: (_: A) => B, bc: (_: B) => C, cd: (_: C) => D): D; <…;
}
$IsLowercased,
const $IsCapitalized: Schema.Struct<{
readonly _tag: Schema.tag<"isCapitalized">
readonly regExp: Schema.RegExp
}>
const $IsCapitalized: {
Type: Struct.Type<Fields>;
Encoded: Struct.Encoded<Fields>;
DecodingServices: Struct.DecodingServices<Fields>;
EncodingServices: Struct.EncodingServices<Fields>;
Iso: Struct.Iso<Fields>;
fields: Fields;
mapFields: (f: (fields: { readonly _tag: Schema.tag<'isCapitalized'>; readonly regExp: Schema.RegExp }) => To, options?: { readonly unsafePreserveChecks?: boolean | undefined } | undefined) => Schema.Struct<{ [K in keyof Readonly<To>]: Readonly<To>[K…;
Rebuild: Rebuild;
ast: Ast;
annotate: (annotations: Schema.Annotations.Bottom<Schema.Struct.ReadonlySide<{ readonly _tag: Schema.tag<'isCapitalized'>; readonly regExp: Schema.RegExp; }, 'Type'>, readonly []>) => Schema.Struct<{ readonly _tag: Schema.tag<'isCapitalized'>; reado…;
annotateKey: (annotations: Schema.Annotations.Key<Schema.Struct.ReadonlySide<{ readonly _tag: Schema.tag<'isCapitalized'>; readonly regExp: Schema.RegExp }, 'Type'>>) => Schema.Struct<{ readonly _tag: Schema.tag<'isCapitalized'>; readonly regExp: Schem…;
check: (checks_0: SchemaAST.Check<Schema.Struct.ReadonlySide<{ readonly _tag: Schema.tag<'isCapitalized'>; readonly regExp: Schema.RegExp }, 'Type'>>, ...checks: Array<SchemaAST.Check<Schema.Struct.ReadonlySide<{ readonly _tag: Schema.tag<'isCapi…;
rebuild: (ast: SchemaAST.Objects) => Schema.Struct<{ readonly _tag: Schema.tag<'isCapitalized'>; readonly regExp: Schema.RegExp }>;
make: (input: { readonly regExp: globalThis.RegExp; readonly _tag?: 'isCapitalized' | undefined }, options?: MakeOptions) => Struct.ReadonlySide<{ readonly _tag: tag<'isCapitalized'>; readonly regExp: RegExp }, 'Type'>;
makeOption: (input: { readonly regExp: globalThis.RegExp; readonly _tag?: 'isCapitalized' | undefined }, options?: MakeOptions) => Option_.Option<Struct.ReadonlySide<{ readonly _tag: tag<'isCapitalized'>; readonly regExp: RegExp }, 'Type'>>;
makeEffect: (input: { readonly regExp: globalThis.RegExp; readonly _tag?: 'isCapitalized' | undefined }, options?: MakeOptions) => Effect.Effect<Struct.ReadonlySide<{ readonly _tag: tag<'isCapitalized'>; readonly regExp: RegExp }, 'Type'>, SchemaError…;
pipe: { <A>(this: A): A; <A, B = never>(this: A, ab: (_: A) => B): B; <A, B = never, C = never>(this: A, ab: (_: A) => B, bc: (_: B) => C): C; <A, B = never, C = never, D = never>(this: A, ab: (_: A) => B, bc: (_: B) => C, cd: (_: C) => D): D; <…;
}
$IsCapitalized,
const $IsUncapitalized: Schema.Struct<{
readonly _tag: Schema.tag<"isUncapitalized">
readonly regExp: Schema.RegExp
}>
const $IsUncapitalized: {
Type: Struct.Type<Fields>;
Encoded: Struct.Encoded<Fields>;
DecodingServices: Struct.DecodingServices<Fields>;
EncodingServices: Struct.EncodingServices<Fields>;
Iso: Struct.Iso<Fields>;
fields: Fields;
mapFields: (f: (fields: { readonly _tag: Schema.tag<'isUncapitalized'>; readonly regExp: Schema.RegExp }) => To, options?: { readonly unsafePreserveChecks?: boolean | undefined } | undefined) => Schema.Struct<{ [K in keyof Readonly<To>]: Readonly<To>…;
Rebuild: Rebuild;
ast: Ast;
annotate: (annotations: Schema.Annotations.Bottom<Schema.Struct.ReadonlySide<{ readonly _tag: Schema.tag<'isUncapitalized'>; readonly regExp: Schema.RegExp; }, 'Type'>, readonly []>) => Schema.Struct<{ readonly _tag: Schema.tag<'isUncapitalized'>; r…;
annotateKey: (annotations: Schema.Annotations.Key<Schema.Struct.ReadonlySide<{ readonly _tag: Schema.tag<'isUncapitalized'>; readonly regExp: Schema.RegExp }, 'Type'>>) => Schema.Struct<{ readonly _tag: Schema.tag<'isUncapitalized'>; readonly regExp: S…;
check: (checks_0: SchemaAST.Check<Schema.Struct.ReadonlySide<{ readonly _tag: Schema.tag<'isUncapitalized'>; readonly regExp: Schema.RegExp }, 'Type'>>, ...checks: Array<SchemaAST.Check<Schema.Struct.ReadonlySide<{ readonly _tag: Schema.tag<'isUn…;
rebuild: (ast: SchemaAST.Objects) => Schema.Struct<{ readonly _tag: Schema.tag<'isUncapitalized'>; readonly regExp: Schema.RegExp }>;
make: (input: { readonly regExp: globalThis.RegExp; readonly _tag?: 'isUncapitalized' | undefined }, options?: MakeOptions) => Struct.ReadonlySide<{ readonly _tag: tag<'isUncapitalized'>; readonly regExp: RegExp }, 'Type'>;
makeOption: (input: { readonly regExp: globalThis.RegExp; readonly _tag?: 'isUncapitalized' | undefined }, options?: MakeOptions) => Option_.Option<Struct.ReadonlySide<{ readonly _tag: tag<'isUncapitalized'>; readonly regExp: RegExp }, 'Type'>>;
makeEffect: (input: { readonly regExp: globalThis.RegExp; readonly _tag?: 'isUncapitalized' | undefined }, options?: MakeOptions) => Effect.Effect<Struct.ReadonlySide<{ readonly _tag: tag<'isUncapitalized'>; readonly regExp: RegExp }, 'Type'>, SchemaE…;
pipe: { <A>(this: A): A; <A, B = never>(this: A, ab: (_: A) => B): B; <A, B = never, C = never>(this: A, ab: (_: A) => B, bc: (_: B) => C): C; <A, B = never, C = never, D = never>(this: A, ab: (_: A) => B, bc: (_: B) => C, cd: (_: C) => D): D; <…;
}
$IsUncapitalized,
const $IsMinLength: Schema.Struct<{
readonly _tag: Schema.tag<"isMinLength">
readonly minLength: Schema.Int
}>
const $IsMinLength: {
Type: Struct.Type<Fields>;
Encoded: Struct.Encoded<Fields>;
DecodingServices: Struct.DecodingServices<Fields>;
EncodingServices: Struct.EncodingServices<Fields>;
Iso: Struct.Iso<Fields>;
fields: Fields;
mapFields: (f: (fields: { readonly _tag: Schema.tag<'isMinLength'>; readonly minLength: Schema.Int }) => To, options?: { readonly unsafePreserveChecks?: boolean | undefined } | undefined) => Schema.Struct<{ [K in keyof Readonly<To>]: Readonly<To>[K];…;
Rebuild: Rebuild;
ast: Ast;
annotate: (annotations: Schema.Annotations.Bottom<Schema.Struct.ReadonlySide<{ readonly _tag: Schema.tag<'isMinLength'>; readonly minLength: Schema.Int; }, 'Type'>, readonly []>) => Schema.Struct<{ readonly _tag: Schema.tag<'isMinLength'>; readonly …;
annotateKey: (annotations: Schema.Annotations.Key<Schema.Struct.ReadonlySide<{ readonly _tag: Schema.tag<'isMinLength'>; readonly minLength: Schema.Int }, 'Type'>>) => Schema.Struct<{ readonly _tag: Schema.tag<'isMinLength'>; readonly minLength: Schema…;
check: (checks_0: SchemaAST.Check<Schema.Struct.ReadonlySide<{ readonly _tag: Schema.tag<'isMinLength'>; readonly minLength: Schema.Int }, 'Type'>>, ...checks: Array<SchemaAST.Check<Schema.Struct.ReadonlySide<{ readonly _tag: Schema.tag<'isMinLen…;
rebuild: (ast: SchemaAST.Objects) => Schema.Struct<{ readonly _tag: Schema.tag<'isMinLength'>; readonly minLength: Schema.Int }>;
make: (input: { readonly minLength: number; readonly _tag?: 'isMinLength' | undefined }, options?: MakeOptions) => Struct.ReadonlySide<{ readonly _tag: tag<'isMinLength'>; readonly minLength: Int }, 'Type'>;
makeOption: (input: { readonly minLength: number; readonly _tag?: 'isMinLength' | undefined }, options?: MakeOptions) => Option_.Option<Struct.ReadonlySide<{ readonly _tag: tag<'isMinLength'>; readonly minLength: Int }, 'Type'>>;
makeEffect: (input: { readonly minLength: number; readonly _tag?: 'isMinLength' | undefined }, options?: MakeOptions) => Effect.Effect<Struct.ReadonlySide<{ readonly _tag: tag<'isMinLength'>; readonly minLength: Int }, 'Type'>, SchemaError, never>;
pipe: { <A>(this: A): A; <A, B = never>(this: A, ab: (_: A) => B): B; <A, B = never, C = never>(this: A, ab: (_: A) => B, bc: (_: B) => C): C; <A, B = never, C = never, D = never>(this: A, ab: (_: A) => B, bc: (_: B) => C, cd: (_: C) => D): D; <…;
}
$IsMinLength,
const $IsMaxLength: Schema.Struct<{
readonly _tag: Schema.tag<"isMaxLength">
readonly maxLength: Schema.Int
}>
const $IsMaxLength: {
Type: Struct.Type<Fields>;
Encoded: Struct.Encoded<Fields>;
DecodingServices: Struct.DecodingServices<Fields>;
EncodingServices: Struct.EncodingServices<Fields>;
Iso: Struct.Iso<Fields>;
fields: Fields;
mapFields: (f: (fields: { readonly _tag: Schema.tag<'isMaxLength'>; readonly maxLength: Schema.Int }) => To, options?: { readonly unsafePreserveChecks?: boolean | undefined } | undefined) => Schema.Struct<{ [K in keyof Readonly<To>]: Readonly<To>[K];…;
Rebuild: Rebuild;
ast: Ast;
annotate: (annotations: Schema.Annotations.Bottom<Schema.Struct.ReadonlySide<{ readonly _tag: Schema.tag<'isMaxLength'>; readonly maxLength: Schema.Int; }, 'Type'>, readonly []>) => Schema.Struct<{ readonly _tag: Schema.tag<'isMaxLength'>; readonly …;
annotateKey: (annotations: Schema.Annotations.Key<Schema.Struct.ReadonlySide<{ readonly _tag: Schema.tag<'isMaxLength'>; readonly maxLength: Schema.Int }, 'Type'>>) => Schema.Struct<{ readonly _tag: Schema.tag<'isMaxLength'>; readonly maxLength: Schema…;
check: (checks_0: SchemaAST.Check<Schema.Struct.ReadonlySide<{ readonly _tag: Schema.tag<'isMaxLength'>; readonly maxLength: Schema.Int }, 'Type'>>, ...checks: Array<SchemaAST.Check<Schema.Struct.ReadonlySide<{ readonly _tag: Schema.tag<'isMaxLen…;
rebuild: (ast: SchemaAST.Objects) => Schema.Struct<{ readonly _tag: Schema.tag<'isMaxLength'>; readonly maxLength: Schema.Int }>;
make: (input: { readonly maxLength: number; readonly _tag?: 'isMaxLength' | undefined }, options?: MakeOptions) => Struct.ReadonlySide<{ readonly _tag: tag<'isMaxLength'>; readonly maxLength: Int }, 'Type'>;
makeOption: (input: { readonly maxLength: number; readonly _tag?: 'isMaxLength' | undefined }, options?: MakeOptions) => Option_.Option<Struct.ReadonlySide<{ readonly _tag: tag<'isMaxLength'>; readonly maxLength: Int }, 'Type'>>;
makeEffect: (input: { readonly maxLength: number; readonly _tag?: 'isMaxLength' | undefined }, options?: MakeOptions) => Effect.Effect<Struct.ReadonlySide<{ readonly _tag: tag<'isMaxLength'>; readonly maxLength: Int }, 'Type'>, SchemaError, never>;
pipe: { <A>(this: A): A; <A, B = never>(this: A, ab: (_: A) => B): B; <A, B = never, C = never>(this: A, ab: (_: A) => B, bc: (_: B) => C): C; <A, B = never, C = never, D = never>(this: A, ab: (_: A) => B, bc: (_: B) => C, cd: (_: C) => D): D; <…;
}
$IsMaxLength,
const $IsPattern: Schema.Struct<{
readonly _tag: Schema.tag<"isPattern">
readonly regExp: Schema.RegExp
}>
const $IsPattern: {
Type: Struct.Type<Fields>;
Encoded: Struct.Encoded<Fields>;
DecodingServices: Struct.DecodingServices<Fields>;
EncodingServices: Struct.EncodingServices<Fields>;
Iso: Struct.Iso<Fields>;
fields: Fields;
mapFields: (f: (fields: { readonly _tag: Schema.tag<'isPattern'>; readonly regExp: Schema.RegExp }) => To, options?: { readonly unsafePreserveChecks?: boolean | undefined } | undefined) => Schema.Struct<{ [K in keyof Readonly<To>]: Readonly<To>[K]; }>;
Rebuild: Rebuild;
ast: Ast;
annotate: (annotations: Schema.Annotations.Bottom<Schema.Struct.ReadonlySide<{ readonly _tag: Schema.tag<'isPattern'>; readonly regExp: Schema.RegExp; }, 'Type'>, readonly []>) => Schema.Struct<{ readonly _tag: Schema.tag<'isPattern'>; readonly regE…;
annotateKey: (annotations: Schema.Annotations.Key<Schema.Struct.ReadonlySide<{ readonly _tag: Schema.tag<'isPattern'>; readonly regExp: Schema.RegExp }, 'Type'>>) => Schema.Struct<{ readonly _tag: Schema.tag<'isPattern'>; readonly regExp: Schema.RegExp…;
check: (checks_0: SchemaAST.Check<Schema.Struct.ReadonlySide<{ readonly _tag: Schema.tag<'isPattern'>; readonly regExp: Schema.RegExp }, 'Type'>>, ...checks: Array<SchemaAST.Check<Schema.Struct.ReadonlySide<{ readonly _tag: Schema.tag<'isPattern'…;
rebuild: (ast: SchemaAST.Objects) => Schema.Struct<{ readonly _tag: Schema.tag<'isPattern'>; readonly regExp: Schema.RegExp }>;
make: (input: { readonly regExp: globalThis.RegExp; readonly _tag?: 'isPattern' | undefined }, options?: MakeOptions) => Struct.ReadonlySide<{ readonly _tag: tag<'isPattern'>; readonly regExp: RegExp }, 'Type'>;
makeOption: (input: { readonly regExp: globalThis.RegExp; readonly _tag?: 'isPattern' | undefined }, options?: MakeOptions) => Option_.Option<Struct.ReadonlySide<{ readonly _tag: tag<'isPattern'>; readonly regExp: RegExp }, 'Type'>>;
makeEffect: (input: { readonly regExp: globalThis.RegExp; readonly _tag?: 'isPattern' | undefined }, options?: MakeOptions) => Effect.Effect<Struct.ReadonlySide<{ readonly _tag: tag<'isPattern'>; readonly regExp: RegExp }, 'Type'>, SchemaError, never>;
pipe: { <A>(this: A): A; <A, B = never>(this: A, ab: (_: A) => B): B; <A, B = never, C = never>(this: A, ab: (_: A) => B, bc: (_: B) => C): C; <A, B = never, C = never, D = never>(this: A, ab: (_: A) => B, bc: (_: B) => C, cd: (_: C) => D): D; <…;
}
$IsPattern,
const $IsLengthBetween: Schema.Struct<{
readonly _tag: Schema.tag<"isLengthBetween">
readonly minimum: Schema.Int
readonly maximum: Schema.Int
}>
const $IsLengthBetween: {
Type: Struct.Type<Fields>;
Encoded: Struct.Encoded<Fields>;
DecodingServices: Struct.DecodingServices<Fields>;
EncodingServices: Struct.EncodingServices<Fields>;
Iso: Struct.Iso<Fields>;
fields: Fields;
mapFields: (f: (fields: { readonly _tag: Schema.tag<'isLengthBetween'>; readonly minimum: Schema.Int; readonly maximum: Schema.Int }) => To, options?: { readonly unsafePreserveChecks?: boolean | undefined } | undefined) => Schema.Struct<{ [K in keyof…;
Rebuild: Rebuild;
ast: Ast;
annotate: (annotations: Schema.Annotations.Bottom<Schema.Struct.ReadonlySide<{ readonly _tag: Schema.tag<'isLengthBetween'>; readonly minimum: Schema.Int; readonly maximum: Schema.Int; }, 'Type'>, readonly []>) => Schema.Struct<{ readonly _tag: Sche…;
annotateKey: (annotations: Schema.Annotations.Key<Schema.Struct.ReadonlySide<{ readonly _tag: Schema.tag<'isLengthBetween'>; readonly minimum: Schema.Int; readonly maximum: Schema.Int }, 'Type'>>) => Schema.Struct<{ readonly _tag: Schema.tag<'isLengthB…;
check: (checks_0: SchemaAST.Check<Schema.Struct.ReadonlySide<{ readonly _tag: Schema.tag<'isLengthBetween'>; readonly minimum: Schema.Int; readonly maximum: Schema.Int }, 'Type'>>, ...checks: Array<SchemaAST.Check<Schema.Struct.ReadonlySide<{ rea…;
rebuild: (ast: SchemaAST.Objects) => Schema.Struct<{ readonly _tag: Schema.tag<'isLengthBetween'>; readonly minimum: Schema.Int; readonly maximum: Schema.Int }>;
make: (input: { readonly minimum: number; readonly maximum: number; readonly _tag?: 'isLengthBetween' | undefined }, options?: MakeOptions) => Struct.ReadonlySide<{ readonly _tag: tag<'isLengthBetween'>; readonly minimum: Int; readonly maximum: …;
makeOption: (input: { readonly minimum: number; readonly maximum: number; readonly _tag?: 'isLengthBetween' | undefined }, options?: MakeOptions) => Option_.Option<Struct.ReadonlySide<{ readonly _tag: tag<'isLengthBetween'>; readonly minimum: Int; rea…;
makeEffect: (input: { readonly minimum: number; readonly maximum: number; readonly _tag?: 'isLengthBetween' | undefined }, options?: MakeOptions) => Effect.Effect<Struct.ReadonlySide<{ readonly _tag: tag<'isLengthBetween'>; readonly minimum: Int; read…;
pipe: { <A>(this: A): A; <A, B = never>(this: A, ab: (_: A) => B): B; <A, B = never, C = never>(this: A, ab: (_: A) => B, bc: (_: B) => C): C; <A, B = never, C = never, D = never>(this: A, ab: (_: A) => B, bc: (_: B) => C, cd: (_: C) => D): D; <…;
}
$IsLengthBetween
]).Bottom<unknown, unknown, unknown, unknown, Union<...>, Union<...>, ... 8 more ..., "required">.annotate(annotations: Schema.Annotations.Bottom<Schema.Struct<Fields extends Schema.Struct.Fields>.ReadonlySide<{
readonly _tag: Schema.tag<"isStringFinite">;
readonly regExp: Schema.RegExp;
}, "Type"> | Schema.Struct.ReadonlySide<{
readonly _tag: Schema.tag<"isStringBigInt">;
readonly regExp: Schema.RegExp;
}, "Type"> | Schema.Struct.ReadonlySide<{
readonly _tag: Schema.tag<"isStringSymbol">;
readonly regExp: Schema.RegExp;
}, "Type"> | Schema.Struct.ReadonlySide<{
readonly _tag: Schema.tag<"isTrimmed">;
readonly regExp: Schema.RegExp;
}, "Type"> | ... 15 more ... | Schema.Struct.ReadonlySide<...>, readonly []>): Schema.Union<...>
annotate({ Annotations.Bottom<T, TypeParameters extends ReadonlyArray<Constraint>>.identifier?: string | undefinedStable identifier for this schema node.
Details
Identifiers are used by schema tooling, including JSON Schema
generation, to name references. The default formatter also uses
identifier as the expected label for type-level failures, such as
Expected UserId, got null.
identifier does not name a failed filter or refinement. If the base
type matches and a filter fails, put expected or message on the
filter/refinement instead.
identifier: "StringMeta" })Referenced by 1 symbols