import { type MaxLengthString, type MinLengthString, type NonEmptyString, type RelaxedExclude, type SupportedLength } from 'ts-type-forge';
import { type Type } from '../type.mjs';
export declare function string(defaultValue?: string): Type<string>;
export declare function string<S extends string, const C extends RawConstraints>(defaultValue: S & DefaultValueType<S, C>, constraints: C): Type<ConstraintsResultType<C>>;
type RawConstraints = Partial<Readonly<{
    nonempty: true;
    minLength: number;
    maxLength: number;
    startsWith: string;
    endsWith: string;
    includes: string;
    uppercase: true;
    lowercase: true;
    regex: RegExp;
}>>;
/**
 * The set of constraints accepted by {@link string}.
 */
export type StringTypeConstraints = RawConstraints;
/**
 * The result type produced by {@link string} for a given set of constraints
 * `C` (e.g. `nonempty` yields {@link NonEmptyString}, `minLength` /
 * `maxLength` yield {@link MinLengthString} / {@link MaxLengthString},
 * `startsWith` narrows to a template literal type, etc.).
 */
export type StringConstraintsResultType<C extends StringTypeConstraints> = ConstraintsResultType<C>;
type DefaultValueType<S extends string, C extends RawConstraints> = DefaultValueWhenNonemptyIsOn<S, C> & DefaultValueWhenMinLengthIsOn<S, C> & DefaultValueWhenMaxLengthIsOn<S, C> & DefaultValueWhenStartsWithIsOn<C> & DefaultValueWhenEndsWithIsOn<C> & DefaultValueWhenIncludesIsOn<C> & DefaultValueWhenUppercaseIsOn<S, C> & DefaultValueWhenLowercaseIsOn<S, C>;
type ConstraintsResultType<C extends RawConstraints> = ConstraintsResultTypeWhenNonemptyIsOn<C> & ConstraintsResultTypeWhenMinLengthIsOn<C> & ConstraintsResultTypeWhenMaxLengthIsOn<C> & DefaultValueWhenStartsWithIsOn<C> & DefaultValueWhenEndsWithIsOn<C> & DefaultValueWhenIncludesIsOn<C>;
type DefaultValueWhenStartsWithIsOn<C extends RawConstraints> = C extends Readonly<{
    startsWith: infer S extends string;
}> ? `${S}${string}` : string;
type DefaultValueWhenEndsWithIsOn<C extends RawConstraints> = C extends Readonly<{
    endsWith: infer E extends string;
}> ? `${string}${E}` : string;
type DefaultValueWhenIncludesIsOn<C extends RawConstraints> = C extends Readonly<{
    includes: infer M extends string;
}> ? `${string}${M}${string}` : string;
type DefaultValueWhenUppercaseIsOn<S extends string, C extends RawConstraints> = C extends Readonly<{
    uppercase: true;
}> ? CastUppercase<S> : string;
type DefaultValueWhenLowercaseIsOn<S extends string, C extends RawConstraints> = C extends Readonly<{
    lowercase: true;
}> ? CastLowercase<S> : string;
type CastLowercase<S extends string> = S extends Lowercase<S> ? S : never;
type CastUppercase<S extends string> = S extends Uppercase<S> ? S : never;
type DefaultValueWhenNonemptyIsOn<S extends string, C extends RawConstraints> = C extends Readonly<{
    nonempty: true;
}> ? RejectEmptyString<S> : string;
type RejectEmptyString<S extends string> = S extends '' ? never : S;
type ConstraintsResultTypeWhenNonemptyIsOn<C extends RawConstraints> = C extends Readonly<{
    nonempty: true;
}> ? NonEmptyString : string;
/**
 * The length-bound literals supported at the type level:
 * `RelaxedExclude<SupportedLength, 0>` (i.e. `1 | 2 | ... | 2048`, the shared
 * cap of the branded length-constrained types in ts-type-forge). Only bounds
 * within this range are encoded in the result brand; larger literals and
 * non-literal `number`s collapse to plain `string` to keep the type-level
 * computation cheap (the runtime constraint applies regardless). Non-integer
 * bounds and bounds less than 1 throw a `TypeError` when the type is
 * constructed.
 */
type SupportedLengthLiteral = RelaxedExclude<SupportedLength, 0>;
type ConstraintsResultTypeWhenMinLengthIsOn<C extends RawConstraints> = C extends Readonly<{
    minLength: infer M extends SupportedLengthLiteral;
}> ? MinLengthString<M> : string;
type ConstraintsResultTypeWhenMaxLengthIsOn<C extends RawConstraints> = C extends Readonly<{
    maxLength: infer M extends SupportedLengthLiteral;
}> ? MaxLengthString<M> : string;
type DefaultValueWhenMinLengthIsOn<S extends string, C extends RawConstraints> = C extends Readonly<{
    minLength: infer M extends SupportedLengthLiteral;
}> ? StringWithMinLength<S, M> : string;
type DefaultValueWhenMaxLengthIsOn<S extends string, C extends RawConstraints> = C extends Readonly<{
    maxLength: infer M extends SupportedLengthLiteral;
}> ? StringWithMaxLength<S, M> : string;
type StringWithMinLength<S extends string, N extends number> = HasLengthAtLeast<S, N> extends true ? S : never;
type StringWithMaxLength<S extends string, N extends number> = HasLengthAtMost<S, N> extends true ? S : never;
type HasLengthAtLeast<S extends string, N extends number, Acc extends readonly unknown[] = readonly []> = string extends S ? true : Acc['length'] extends N ? true : S extends '' ? false : S extends `${infer _}${infer Rest}` ? HasLengthAtLeast<Rest, N, readonly [...Acc, unknown]> : false;
type HasLengthAtMost<S extends string, N extends number, Acc extends readonly unknown[] = readonly []> = string extends S ? true : S extends '' ? true : Acc['length'] extends N ? false : S extends `${infer _}${infer Rest}` ? HasLengthAtMost<Rest, N, readonly [...Acc, unknown]> : false;
export {};
//# sourceMappingURL=string.d.mts.map