import { DomainError$1 as DomainError, ValidationError$1 as ValidationError } from "./base.errors-DyC_RLkA.js";
import { Result } from "@carbonteq/fp";
import z, { ZodEnum, ZodError } from "zod";

//#region src/domain/refined.types.d.ts
type Extensions<Schema extends z.ZodTypeAny, Tag extends string | symbol, Err extends DomainError> = {
  create: (data: unknown) => Result<Schema["_output"] & z.BRAND<Tag>, Err>;
  $infer: Schema["_output"] & z.BRAND<Tag>;
  $inferPrimitive: Schema["_output"];
  primitive(branded: Schema["_output"] & z.BRAND<Tag>): Schema["_output"];
};
type ZodBrandedWithFactory<Schema extends z.ZodTypeAny, Tag extends string | symbol, Err extends DomainError> = z.ZodBranded<Schema, Tag> & Extensions<Schema, Tag, Err>;
declare function createRefinedType<Tag extends string | symbol, Schema extends z.ZodTypeAny>(_tag: Tag, schema: Schema): ZodBrandedWithFactory<Schema, Tag, ValidationError>;
declare function createRefinedType<Tag extends string | symbol, Schema extends z.ZodTypeAny, Err extends DomainError>(_tag: Tag, schema: Schema, errTransformer: (data: Schema["_input"], err: z.ZodError) => Err): ZodBrandedWithFactory<Schema, Tag, Err>;
type Unbrand<T> = T extends z.ZodType<unknown, z.ZodTypeDef, infer U> ? U : T;
declare class InvalidUUID extends ValidationError {
  constructor(data: unknown);
}
declare class InvalidEmail extends ValidationError {
  constructor(data: unknown);
}
type TEmail = ZodBrandedWithFactory<z.ZodString, "Email", InvalidEmail>;
declare const Email: TEmail;
type Email = typeof Email.$infer;
type TUUIDSchema = z.ZodString;
type TUUIDInner = ZodBrandedWithFactory<TUUIDSchema, "UUID", InvalidUUID>;
declare const UUIDInner: TUUIDInner;
type UUID = typeof UUIDInner.$infer;
type TUUID = TUUIDInner & {
  init: () => UUID;
  fromTrusted: (s: string) => UUID;
};
declare const UUID: TUUID;
declare class InvalidDateTime extends ValidationError {
  constructor(data: unknown);
}
type TDTInnerSchema = z.ZodPipeline<z.ZodUnion<[z.ZodNumber, z.ZodString, z.ZodDate]>, z.ZodDate>;
type TDTInner = ZodBrandedWithFactory<TDTInnerSchema, "DateTime", InvalidDateTime>;
declare const DTInner: TDTInner;
type DateTime = typeof DTInner.$infer;
type TDateTime = TDTInner & {
  now: () => DateTime;
  from: (d: Date | DateTime) => DateTime;
};
declare const DateTime: TDateTime;
declare class EnumValidationError extends ValidationError {
  readonly tag: string | symbol;
  readonly data: unknown;
  readonly err: ZodError;
  constructor(tag: string | symbol, msg: string, data: unknown, err: ZodError);
}
type EnumTypeUtil<Tag extends string | symbol, U extends string, T extends [U, ...U[]]> = ZodBrandedWithFactory<z.ZodEnum<z.Writeable<T>>, Tag, EnumValidationError> & {
  from: (v: T[number]) => z.Writeable<T>[number] & z.BRAND<Tag>;
  values: Readonly<T>;
  eq: (a: T[number] | (T[number] & z.BRAND<Tag>), b: T[number] | (T[number] & z.BRAND<Tag>)) => boolean;
};
declare const createEnumType: <Tag extends string | symbol, U extends string, T extends [U, ...U[]]>(tag: Tag, enumValues: T) => EnumTypeUtil<Tag, U, T>;
type MatchActions<T extends string | symbol | number, R> = { [K in T]: () => R };
declare function matchEnum<Tag extends string | symbol, U extends string, T extends [U, ...U[]], EnumType extends ZodBrandedWithFactory<ZodEnum<T>, Tag, EnumValidationError>, Actions extends MatchActions<EnumType["$inferPrimitive"], any>>(value: EnumType["$infer"], _enumType: EnumType, actions: Actions): ReturnType<Actions[EnumType["$inferPrimitive"]]>;

//#endregion
export { DateTime as DateTime$1, Email as Email$1, EnumValidationError as EnumValidationError$1, InvalidDateTime as InvalidDateTime$1, InvalidEmail as InvalidEmail$1, InvalidUUID as InvalidUUID$1, UUID as UUID$1, Unbrand, createEnumType as createEnumType$1, createRefinedType as createRefinedType$1, matchEnum as matchEnum$1 };
//# sourceMappingURL=refined.types-Y15bJPl9.d.ts.map