readonly [EvoluTypeSymbol]: true;

readonly ~standard: Props<ReadonlySet<InferInput<ElementType>>, ReadonlySet<InferType<ElementType>>>;

readonly element: ElementType;

Error: SetError<InferError<ElementType>>;

type StringError = typeof String.Error;

readonly Errors:
  | SetError<InferError<ElementType>>
| SetError<InferParentError<ElementType>>;

type StringParentErrors = typeof String.Errors;

readonly from: (value: ReadonlySet) => Result<ReadonlySet<InferType<ElementType>>,
  | SetError<InferError<ElementType>>
| SetError<InferParentError<ElementType>>>;

readonly fromParent: (value: ReadonlySet) => Result<ReadonlySet<InferType<ElementType>>, SetError<InferError<ElementType>>>;

readonly fromUnknown: (value: unknown) => Result<ReadonlySet<InferType<ElementType>>,
  | SetError<InferError<ElementType>>
| SetError<InferParentError<ElementType>>>;

Input: ReadonlySet<InferInput<ElementType>>;

type StringInput = typeof String.Input;

readonly is: Refinement<unknown, ReadonlySet<InferType<ElementType>>>;

const value: unknown = "hello";
if (String.is(value)) {
  // TypeScript now knows `value` is a `string` here.
  console.log("This is a valid string!");
}

const strings: unknown[] = [1, "hello", true, "world"];
const filteredStrings = strings.filter(String.is);

console.log(filteredStrings); // ["hello", "world"]

readonly name: "Set";

readonly orNull: (value: ReadonlySet) =>
  | ReadonlySet<InferType<ElementType>>
  | null;

// Good: Optional user input
const age = PositiveInt.orNull(userInput);
if (age != null) {
  console.log("Valid age:", age);
}

// Good: Default fallback
const maxRetries = PositiveInt.orNull(config.retries) ?? 3;

// Avoid: When you need to know why validation failed (use `from` instead)
const result = PositiveInt.from(userInput);
if (!result.ok) {
  console.error(formatPositiveError(result.error));
}

readonly orThrow: (value: ReadonlySet) => ReadonlySet;

// Good: Known valid constant
const maxRetries = PositiveInt.orThrow(3);

// Good: App configuration that should crash on invalid values
const appName = Name.orThrow("MyApp");

// Good: Instead of assert when Type error is clear enough
// Context makes it obvious: count increments from non-negative value
const currentCount = counts.get(id) ?? 0;
const newCount = PositiveInt.orThrow(currentCount + 1);

// Good: Test setup with known valid values
const testUser = User.orThrow({ name: "Alice", age: 30 });

// Avoid: User input (use `from` instead)
const userAge = PositiveInt.orThrow(userInput); // Could crash!

// Better: Handle user input gracefully
const ageResult = PositiveInt.from(userInput);
if (!ageResult.ok) {
  // Handle validation error
}

Parent: ReadonlySet<InferParent<ElementType>>;

type StringParent = typeof String.Parent;

ParentError: SetError<InferParentError<ElementType>>;

type StringParentError = typeof String.ParentError;

readonly Type: ReadonlySet;

type String = typeof String.Type;