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: anyconst $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.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
]).annotate({ identifier: stringidentifier: "StringMeta" })Referenced by 1 symbols