import { CB, DynamicValue, Failure, Maybe, Nullable, OneOrMoreOf, ValueOf } from "vest-utils";
import { IsolateKey, RegistryIndex, RuntimeEvents, TIsolate, TIsolateFocused } from "vestjs-runtime";
import { StandardSchemaV1 } from "vest-utils/standardSchemaSpec";

//#region src/hooks/optional/OptionalTypes.d.ts
type OptionalFields = Record<string, OptionalFieldDeclaration>;
type OptionalsInput<F extends string = string> = OneOrMoreOf<F> | OptionalsObject<F>;
type OptionalsObject<F extends string> = Record<F, TOptionalRule | any>;
type ImmediateOptionalFieldDeclaration = {
  type: OptionalFieldTypes.CUSTOM_LOGIC;
  rule: TOptionalRule;
  applied: boolean;
};
type DelayedOptionalFieldDeclaration = {
  type: OptionalFieldTypes.AUTO;
  applied: boolean;
  rule: null;
};
type TOptionalRule = DynamicValue<boolean>;
type OptionalFieldDeclaration = ImmediateOptionalFieldDeclaration | DelayedOptionalFieldDeclaration;
declare enum OptionalFieldTypes {
  CUSTOM_LOGIC = 0,
  AUTO = 1,
}
//#endregion
//#region src/suiteResult/Severity.d.ts
declare enum Severity {
  WARNINGS = "warnings",
  ERRORS = "errors",
}
declare enum TestSeverity {
  Error = "error",
  Warning = "warning",
}
//#endregion
//#region src/core/StateMachines/IsolateTestStateMachine.d.ts
declare const TestStatus: {
  CANCELED: string;
  FAILED: string;
  OMITTED: string;
  PASSING: string;
  SKIPPED: string;
  STARTED: string;
  UNTESTED: string;
  WARNING: string;
};
type TestStatus = ValueOf<typeof TestStatus>;
//#endregion
//#region src/core/test/TestTypes.d.ts
type TestFnPayload = {
  signal: AbortSignal;
};
type TestFn = (payload: TestFnPayload) => TestResult;
type AsyncTest = Promise<void>;
type TestResult = Maybe<AsyncTest | boolean> | void;
type TestMessage = string | undefined;
type WithFieldName<F extends TFieldName = TFieldName> = {
  fieldName: F;
};
//#endregion
//#region src/core/isolate/IsolateTest/IsolateTest.d.ts
type TIsolateTest<F extends TFieldName = TFieldName> = TIsolate<CommonTestFields<F> & IsolateTestPayload>;
type IsolateTestPayload<F extends TFieldName = TFieldName> = CommonTestFields<F> & {
  severity: TestSeverity;
  testStatus: TestStatus;
  asyncTest?: AsyncTest;
};
type CommonTestFields<F extends TFieldName = TFieldName> = {
  message?: Maybe<string>;
  fieldName: F;
  testFn: TestFn;
};
//#endregion
//#region src/suiteResult/SummaryFailure.d.ts
declare class SummaryFailure<F extends TFieldName, G extends TGroupName> implements WithFieldName<F> {
  fieldName: F;
  message: string | undefined;
  groupName: G | undefined;
  constructor(fieldName: F, message: string | undefined, groupName: G | undefined);
  static fromTestObject<F extends TFieldName, G extends TGroupName>(testObject: TIsolateTest<F>): SummaryFailure<F, G>;
}
//#endregion
//#region src/suiteResult/selectors/suiteSelectors.d.ts
type InputFieldName<F extends TFieldName> = F;
type InputGroupName<G extends TGroupName> = G;
declare function suiteSelectors<F extends TFieldName, G extends TGroupName>(summary: SuiteSummary<F, G>): SuiteSelectors<F, G>;
interface SuiteSelectors<F extends TFieldName, G extends TGroupName> {
  getWarning(): SummaryFailure<F, G> | undefined;
  getWarning(fieldName: InputFieldName<F>): string | undefined;
  getWarning(fieldName?: InputFieldName<F>): SummaryFailure<F, G> | string | undefined;
  getError(): SummaryFailure<F, G> | undefined;
  getError(fieldName: InputFieldName<F>): string | undefined;
  getError(fieldName?: InputFieldName<F>): SummaryFailure<F, G> | string | undefined;
  getMessage(fieldName: InputFieldName<F>): string | undefined;
  getErrors(): FailureMessages;
  getErrors(fieldName: InputFieldName<F>): string[];
  getErrors(fieldName?: InputFieldName<F>): string[] | FailureMessages;
  getWarnings(): FailureMessages;
  getWarnings(fieldName: InputFieldName<F>): string[];
  getWarnings(fieldName?: InputFieldName<F>): string[] | FailureMessages;
  getErrorsByGroup(groupName: InputGroupName<G>): FailureMessages;
  getErrorsByGroup(groupName: InputGroupName<G>, fieldName: InputFieldName<F>): string[];
  getErrorsByGroup(groupName: InputGroupName<G>, fieldName?: InputFieldName<F>): string[] | FailureMessages;
  getWarningsByGroup(groupName: InputGroupName<G>): FailureMessages;
  getWarningsByGroup(groupName: InputGroupName<G>, fieldName: InputFieldName<F>): string[];
  getWarningsByGroup(groupName: InputGroupName<G>, fieldName?: InputFieldName<F>): string[] | FailureMessages;
  hasErrors(fieldName?: InputFieldName<F>): boolean;
  hasWarnings(fieldName?: InputFieldName<F>): boolean;
  hasErrorsByGroup(groupName: InputGroupName<G>, fieldName?: InputFieldName<F>): boolean;
  hasWarningsByGroup(groupName: InputGroupName<G>, fieldName?: InputFieldName<F>): boolean;
  isTested(fieldName: InputFieldName<F>): boolean;
  isPending(fieldName?: InputFieldName<F>): boolean;
  isValid(fieldName?: InputFieldName<F>): boolean;
  isValidByGroup(groupName: InputGroupName<G>, fieldName?: InputFieldName<F>): boolean;
}
//#endregion
//#region src/core/VestBus/BusEvents.d.ts
type Events = {
  TEST_RUN_STARTED: void;
  TEST_COMPLETED: TIsolate;
  ALL_RUNNING_TESTS_FINISHED: void;
  REMOVE_FIELD: TFieldName;
  RESET_FIELD: TFieldName;
  RESET_SUITE: void;
  SUITE_RUN_STARTED: void;
  SUITE_CALLBACK_RUN_FINISHED: void;
  DONE_TEST_OMISSION_PASS: void;
  INITIALIZING_CALLBACKS: void;
  DEFER_THROW: Failure<any, any>;
};
//#endregion
//#region src/core/VestBus/VestBus.d.ts
type VestEvents = Events & RuntimeEvents;
type Subscribe = {
  <T$1 extends keyof VestEvents>(event: T$1, cb: (payload: VestEvents[T$1]) => void): CB<void>;
  (cb: CB): CB<void>;
};
//#endregion
//#region src/hooks/focused/focused.d.ts
type FieldExclusion<F extends string = TFieldName> = Maybe<OneOrMoreOf<F>>;
/**
 * Adds a field or a list of fields into the inclusion list
 *
 * @example
 *
 * only('username');
 */
declare function only(match: FieldExclusion<string> | false): TIsolateFocused | undefined;
/**
 * Adds a field or a list of fields into the exclusion list
 *
 * @example
 *
 * skip('username');
 */
declare function skip(match: FieldExclusion<string> | boolean): TIsolateFocused | undefined;
//#endregion
//#region src/suite/getTypedMethods.d.ts
type TTypedMethods<F extends TFieldName, G extends TGroupName> = {
  include: (fieldName: F) => {
    when: (condition: F | TDraftCondition<F, G>) => void;
  };
  omitWhen: (conditional: TDraftCondition<F, G>, callback: CB) => void;
  only: {
    (item: FieldExclusion<F>): void;
  };
  optional: (optionals: OptionalsInput<F>) => void;
  skip: {
    (item: FieldExclusion<F>): void;
  };
  skipWhen: (condition: TDraftCondition<F, G>, callback: CB) => void;
  test: {
    (fieldName: F, message: TestMessage, cb: TestFn): TIsolateTest;
    (fieldName: F, cb: TestFn): TIsolateTest;
    (fieldName: F, message: TestMessage, cb: TestFn, key: IsolateKey): TIsolateTest;
    (fieldName: F, cb: TestFn, key: IsolateKey): TIsolateTest;
  };
  group: {
    (callback: () => void): TIsolate;
    (groupName: G, callback: () => void): TIsolate;
  };
};
type TDraftCondition<F extends TFieldName, G extends TGroupName> = DynamicValue<boolean, [draft: SuiteResult<F, G>]>;
//#endregion
//#region src/suite/SuiteTypes.d.ts
type SuiteCallbackWithSchema<S extends TSchema, T$1 extends CB> = S extends undefined ? T$1 : (data: InferSchemaOutput<S>, ...args: any[]) => void;
type Suite<F extends TFieldName, G extends TGroupName, T$1 extends CB = CB, S extends TSchema = undefined> = SuiteMethods<F, G, T$1, S> & StandardSchemaV1<InferSchemaData<S>, InferSchemaData<S>>;
type SuiteMethods<F extends TFieldName, G extends TGroupName, T$1 extends CB, S extends TSchema> = {
  dump: CB<TIsolateSuite>;
  get: CB<SuiteResult<F, G, S>>;
  resume: CB<void, [TIsolateSuite]>;
  reset: CB<void>;
  remove: CB<void, [fieldName: F]>;
  resetField: CB<void, [fieldName: F]>;
  run: (...args: S extends undefined ? Parameters<T$1> : [data: InferSchemaData<S>, ...args: any[]]) => SuiteResult<F, G, S>;
  runStatic: (...args: S extends undefined ? Parameters<T$1> : [data: InferSchemaData<S>, ...args: any[]]) => SuiteResult<F, G, S>;
  validate: (...args: S extends undefined ? Parameters<T$1> : [data: InferSchemaData<S>, ...args: any[]]) => SuiteResult<F, G, S>;
  subscribe: Subscribe;
} & AfterMethods<F, G, T$1, S> & TTypedMethods<F, G> & SuiteSelectors<F, G>;
type FocusedMethods<F extends TFieldName, G extends TGroupName, T$1 extends CB, S extends TSchema> = {
  afterEach: CB<FocusedMethods<F, G, T$1, S>, [callback: CB]>;
  afterField: CB<FocusedMethods<F, G, T$1, S>, [fieldName: F, callback: CB]>;
  focus: CB<FocusedMethods<F, G, T$1, S>, [config: SuiteModifiers<F, G>]>;
  only: CB<FocusedMethods<F, G, T$1, S>, [onlyField: FieldExclusion<F>]>;
  run: (...args: S extends undefined ? Parameters<T$1> : [data: Partial<InferSchemaData<S>>, ...args: any[]]) => SuiteResult<F, G, S>;
};
type AfterMethods<F extends TFieldName, G extends TGroupName, T$1 extends CB, S extends TSchema> = {
  afterEach: CB<AfterMethods<F, G, T$1, S>, [callback: CB]>;
  afterField: CB<AfterMethods<F, G, T$1, S>, [fieldName: F, callback: CB]>;
  focus: CB<FocusedMethods<F, G, T$1, S>, [config: SuiteModifiers<F, G>]>;
  only: CB<FocusedMethods<F, G, T$1, S>, [onlyField: FieldExclusion<F>]>;
  run: (...args: S extends undefined ? Parameters<T$1> : [data: InferSchemaData<S>, ...args: any[]]) => SuiteResult<F, G, S>;
};
/**
 * Modifiers that control which fields and groups are included or excluded
 * during a focused suite run. These can be provided either via
 * `suite.focus(modifiers)` or via shorthand methods:
 *   - `suite.only(field)` is a shortcut for `suite.focus({ only: field })`
 *
 * - `only` — Run only the specified field(s). All others are excluded unless
 *   explicitly included via `include()`.
 * - `skip` — Skip the specified field(s). All others run as usual.
 * - `skipGroup` — Skip all tests inside the named group(s). Tests outside the
 *   matched groups are unaffected.
 * - `onlyGroup` — Run only tests inside the named group(s). Top-level tests
 *   outside any group are also excluded.
 */
type SuiteModifiers<F extends TFieldName, G extends TGroupName = TGroupName> = {
  only?: FieldExclusion<F>;
  onlyGroup?: G | G[];
  skip?: FieldExclusion<F>;
  skipGroup?: G | G[];
};
//#endregion
//#region src/suiteResult/SuiteResultTypes.d.ts
declare class SummaryBase {
  errorCount: number;
  warnCount: number;
  testCount: number;
  pendingCount: number;
}
declare class SuiteSummary<F extends TFieldName, G extends TGroupName, D = unknown, S extends TSchema = undefined> extends SummaryBase {
  [Severity.ERRORS]: SummaryFailure<F, G>[];
  [Severity.WARNINGS]: SummaryFailure<F, G>[];
  groups: Groups<G, F>;
  tests: Tests<F>;
  run: {
    data: {
      raw: D | undefined;
      parsed: Partial<InferSchemaOutput<S>> | undefined;
    };
    time: Date;
    focus?: SuiteModifiers<F, G>;
  };
  valid: Nullable<boolean>;
  constructor();
}
type Groups<G extends TGroupName, F extends TFieldName> = { [key in G]: Group<F> };
type Group<F extends TFieldName> = { [key in F]: SingleTestSummary } & ValidProperty;
type Tests<F extends TFieldName> = { [key in F]: SingleTestSummary };
type SingleTestSummary = SummaryBase & CommonSummaryProperties & ValidProperty;
type ValidProperty = {
  valid: Nullable<boolean>;
};
type CommonSummaryProperties = SummaryBase & {
  errors: string[];
  warnings: string[];
};
type FailureMessages = Record<string, string[]>;
type TSchema = any;
type InferSchemaData<S> = S extends {
  '~standard': {
    types: {
      input: infer I;
    };
  };
} ? I : S extends {
  infer: infer T;
} ? { [K in keyof T]: T[K] } & NonNullable<unknown> : any;
type InferSchemaOutput<S> = S extends {
  '~standard': {
    types: {
      output: infer O;
    };
  };
} ? O : S extends {
  infer: infer T;
} ? { [K in keyof T]: T[K] } & NonNullable<unknown> : any;
type SuiteResultData<F extends TFieldName, G extends TGroupName, S extends TSchema = undefined, D = unknown> = (Omit<SuiteSummary<F, G, D, S>, 'valid'> & SuiteSelectors<F, G> & {
  valid: true;
  value: InferSchemaOutput<S>;
  issues?: undefined;
}) | (Omit<SuiteSummary<F, G, D, S>, 'valid'> & SuiteSelectors<F, G> & {
  valid: false;
  issues: ReadonlyArray<StandardSchemaV1.Issue>;
  value?: undefined;
}) | (Omit<SuiteSummary<F, G, D, S>, 'valid'> & SuiteSelectors<F, G> & {
  valid: null;
  issues?: undefined;
  value?: undefined;
});
type BrandedFieldName<F extends string> = F & TFieldName;
type BrandedGroupName<G extends string> = G & TGroupName;
type SuiteResult<F extends string = TFieldName, G extends string = TGroupName, S extends TSchema = undefined, D = unknown> = SuiteResultData<BrandedFieldName<F>, BrandedGroupName<G>, S, D> & {
  dump: CB<TIsolateSuite>;
  types: S extends undefined ? undefined : {
    input: InferSchemaData<S>;
    output: InferSchemaOutput<S>;
  };
};
type TFieldName = string;
type TGroupName = string;
//#endregion
//#region src/core/isolate/VestIsolateType.d.ts
type TVestIsolate<P = void> = TIsolate<P & {
  tests: TIsolateTest[];
}>;
//#endregion
//#region src/core/isolate/IsolateSuite/IsolateSuite.d.ts
type TIsolateSuite = TVestIsolate<{
  optional: OptionalFields;
  resolver: CB<SuiteResult<TFieldName, TGroupName, any>>;
  registry_all?: RegistryIndex;
  registry_failed?: RegistryIndex;
  registry_omitted?: RegistryIndex;
  registry_passing?: RegistryIndex;
  registry_pending?: RegistryIndex;
  registry_tested?: RegistryIndex;
  registry_valid?: RegistryIndex;
  registry_warning?: RegistryIndex;
}>;
//#endregion
export { TestMessage as _, SuiteSummary as a, TSchema as c, TDraftCondition as d, only as f, TestFn as g, TIsolateTest as h, SuiteResult as i, Suite as l, suiteSelectors as m, TVestIsolate as n, TFieldName as o, skip as p, InferSchemaOutput as r, TGroupName as s, TIsolateSuite as t, SuiteCallbackWithSchema as u, OptionalsInput as v };
//# sourceMappingURL=IsolateSuite-D5Qr0Oyg.d.mts.map