import { As, Contains, Dictionary, EmptyObject, Err, ExpandDictionary, ExpandRecursively, Fallback, FromInputToken, HasRequiredProps, InputToken, IsEqual, IsLiteralLike, IsUndefined, IsUnion, IsWideObject, KebabCase, MakeKeysOptional, MergeObjects, Not, PascalCase, RetainAfter, RetainUntil, Split, StringKeys, StripChars, TrimEach, UnionExtends } from "inferred-types";
import { Concat, KebabCase as KebabCase$1, Split as Split$1 } from "inferred-types/types";

//#region src/types/base-types.d.ts
type Stringifyable = string | boolean | number | null | Dictionary | Array<any> | Date;
//#endregion
//#region src/types/KindError.d.ts
/**
 * The basic _shape_ of a `KindError`
 */
type KindErrorShape = {
  __kind: "KindError";
  kind: string;
  type: string;
  subType: string | undefined;
  message: string;
  stack?: string;
  stackTrace: () => KindStackItem[];
  context: Record<string, unknown>;
} & Error;
/**
 * **KindError**`<[TName],[TMsg],[TCtx]>`
 *
 * A `KindError`, which extends the Javascript `Error` type and
 * provides literal types where possible to describe the error.
 */
type KindError<TName extends string = string, TMsg extends string = string, TCtx extends Record<string, any> = EmptyObject> = ({
  __kind: "KindError";
  name: PascalCase<AsKindType<TName>>;
  kind: TName;
  type: AsKindType<TName>;
  subType: AsKindSubType<TName>;
  message: TMsg;
  stack?: string;
  stackTrace: () => KindStackItem[];
  context: TCtx;
  toString: () => string;
} & Error) extends infer KErr extends KindErrorShape ? KErr : never;
//#endregion
//#region src/types/KindErrorSignature.d.ts
/**
 * **KindErrorSignature**`<T>`
 *
 * Determines what the `KindErrorType`'s function signature
 * should look like. Variance is determined by the context
 * schema defined:
 *
 * - **No Schema**
 *     - when _no schema_ is defined in the `KindErrorType` we allow
 *       any key/value pairs to be added to context when instantiating
 *       to a `KindError`.
 * - **EmptyObject**
 *     - this implies that context is locked down and no properties are
 *       expected.
 *     - the function's only parameter will be the error message
 * - **No Variants**
 *     - if a error type defines one or more **static** / **non-variant**
 *       key/values these will be preserved and available in the final
 *       `KindError` but no other key/values are allowed when instantiating
 *     - the function's only parameter will be the error message
 * - **Required Variants**
 *     - If there are **variant** key/values defined in the schema, there
 *       will be a required `ctx` property added after message.
 * - **Optional Variants**
 *     - if all variant key/values defined in the schema are "optional"
 *       (aka, are a union type which includes `undefined`) then the
 *       `ctx` property will be added to the function signature but it
 *       will be optional.
 *
 * In all cases the _return type_ should be some form of a `KindError`.
 *
 * **Related:** `ResolveContext`
 */
type KindErrorSignature<TName extends string, TSchema extends Record<string, unknown>> = IsEqual<TSchema, Record<string, unknown>> extends true ? <TMsg extends string, const TCtx extends Record<string, unknown>>(msg: TMsg, ctx?: TCtx) => KindError<TName, TMsg, ResolveContext<Record<string, unknown>, TCtx>> : HasRequiredVariants<TSchema> extends true ? <TMsg extends string, const TCtx extends AsContextShape<TSchema>>(msg: TMsg, ctx: TCtx) => KindError<TName, TMsg, ResolveContext<TSchema, TCtx>> : <TMsg extends string, const TCtx extends AsContextShape<TSchema>>(msg: TMsg, ctx?: TCtx) => KindError<TName, TMsg, ResolveContext<TSchema, TCtx>>;
//#endregion
//#region src/types/KindErrorType.d.ts
/**
 * **KindErrorType**`<TName,TContext>`
 *
 * Defines an error type, exposing:
 *   - some key/value metadata properties
 *   - access to the `proxy()` and `partial()` modifiers
 *   - at the root it is a function which will convert
 *     this error type _into_ an actual `KindError`.
 */
type KindErrorType<TName extends string = string, TContext extends Record<string, unknown> = Record<string, unknown>> = {
  /** unique identifier of a `KindErrorType` */
  __kind: "KindErrorType";
  /** the _kind_ of the resultant KindError */
  kind: TName;
  /**
   * the `type` of the error
   */
  type: AsKindType<TName>;
  /**
   * the `subType` of the error (if present)
   */
  subType: AsKindSubType<TName>;
  /** the error's name when instantiated */
  errorName: KindErrorName<TName>;
  /**
   * the shape of the error's context properties
   */
  context: ParseContext<TContext>;
  /**
   * **proxy**`(err, [props]) -> KindError`
   *
   * Allows you to proxy an error or error-like variable:
   *
   * - if this error passed in is _already_ a `KindError` then it will
   * be passed through "as is"
   * - however, if the `err` passed in is not a `KindError` then this will
   *   return a `KindError` of this type:
   *      - a property `underlying` will be added and `err` will be placed here
   *      - if `err` has a "message" or a stringified version of itself then this
   *        will be placed in the error's `message` property
   *      - if `err` is a key/value object and has an overlapping property with
   *        the schema for this error type, AND the type is consistent with this
   *        error type's schema then it will be set accordingly.
   */
  proxy: <E, P extends AsContextShape<TContext>>(err: E, ...args: HasRequiredVariants<TContext> extends true ? [props: P] : [props?: P]) => E extends KindError ? E : ExpandRecursively<KindError<TName, string, ResolveContext<TContext, P>> & Record<"underlying", E>> & Error;
  /**
   * **partial**`(context) -> KindErrorType`
   *
   * Allows you to add _some_ (or _all_) of the schema properties for the defined error.
   * - this will return another `KindErrorType` with the same name but with less context
   * properties to set at instantiation (because these context parameters have now been
   * set and made static)
   */
  partial: <const T extends Partial<AsContextShape<TContext>>>(context: T) => KindErrorType<TName, MergeObjects<TContext, T>>;
  /**
   * **is**`(val): val is KindError<TName, string, TContext>`
   *
   * A type guard which validates the error type's
   */
  is: (val: unknown) => val is KindError<TName, string, ResolveContext<TContext, undefined>>;
  toString: () => string;
} & KindErrorSignature<TName, TContext>;
//#endregion
//#region src/types/ResolveContext.d.ts
/**
 * **ResolveContext**`<TSchema, TCtx>`
 *
 * Responsible for merging the context schema defined as part of the
 * `KindErrorType` with any context `TCtx` provided when the `KindError`
 * was produced.
 */
type ResolveContext<TSchema extends Record<string, unknown>, TCtx extends Record<string, any> | undefined> = As<IsUndefined<TCtx> extends true ? IsEqual<TSchema, Record<string, unknown>> extends true ? EmptyObject : IsEqual<TSchema, EmptyObject> extends true ? EmptyObject : TSchema : IsEqual<TSchema, Record<string, unknown>> extends true ? Fallback<TCtx, EmptyObject> : IsEqual<TSchema, EmptyObject> extends true ? EmptyObject : AsContextShape<TSchema> extends infer ContextShape ? IsEqual<ContextShape, EmptyObject> extends true ? IsEqual<TCtx, EmptyObject> extends true ? EmptyObject : IsEqual<TCtx, undefined> extends true ? EmptyObject : TCtx extends Record<string, unknown> ? ExpandDictionary<NonVariants<TSchema> & TCtx & Record<"__warning", `context was supposed to be empty as defined by the schema but context was added anyway!`>> : never : Fallback<TCtx, EmptyObject> extends ContextShape ? ExpandDictionary<NonVariants<TSchema> & Fallback<TCtx, EmptyObject>> : ExpandDictionary<NonVariants<TSchema> & Fallback<TCtx, EmptyObject> & {
  __warning: `The context provided for this error had properties which were inconsistent with the schema defined by the KindErrorType!`;
  __schema: TSchema;
}> : never, Record<string, unknown>>;
//#endregion
//#region src/types/type-utils.d.ts
/**
 * Type utility which converts a string literal to a valid
 * `kind` property.
 */
type PascalKind<T extends string> = string extends T ? string : PascalCase<StripChars<T, "<" | ">" | "[" | "]" | "(" | ")">>;
/**
 * Type utility which converts an array of strings into valid
 * values for the `kind` property.
 */
type PascalName<T extends readonly string[]> = { [K in keyof T]: PascalKind<T[K]> };
/**
 * Type utility which converts a string literal into a
 * valid `kind` property.
 */
type KebabKind<T extends string> = KebabCase<StripChars<T, "<" | ">" | "[" | "]" | "(" | ")">>;
/**
 * converts the kind **name** into the **type** properties string literal
 */
type AsKindType<T extends string> = string extends T ? string : RetainUntil<T, "/">;
type PrepUnion<T extends string> = TrimEach<Split<T, "|">>[number];
/**
 * converts the kind **name** into the **subType** property's string literal
 * value (or _undefined_ if no `/` character found in the )
 */
type AsKindSubType<T extends string> = As<string extends T ? string | undefined : RetainAfter<T, "/"> extends infer SubType extends string ? SubType extends "" ? undefined : Contains<SubType, "|"> extends true ? PrepUnion<SubType> : SubType : never, string | undefined>;
/**
 * **DetectOptionalValues**`<T>`
 *
 * Looks for values in the dictionary which are a union with `undefined`
 * and makes these key/values optional.
 */
type DetectOptionalValues<T extends Record<string, unknown>, K$1 extends readonly (keyof T & string)[] = StringKeys<T>, R extends readonly string[] = []> = K$1 extends [infer Head extends string & keyof T, ...infer Rest extends readonly (string & keyof T)[]] ? UnionExtends<T[Head], undefined> extends true ? DetectOptionalValues<T, Rest, [...R, Head]> : DetectOptionalValues<T, Rest, R> : MakeKeysOptional<T, R>;
/**
 * Converts any `InputToken` values found in the `KindErrorType`'s
 * context object into the type that the token represents. All other
 * values are left as is.
 */
type ParseContext<T extends Record<string, unknown>, K$1 extends readonly (string & keyof T)[] = StringKeys<T>, R extends Record<string, unknown> = EmptyObject> = K$1 extends [infer Head extends string & keyof T, ...infer Rest extends readonly (string & keyof T)[]] ? T[Head] extends InputToken ? FromInputToken<T[Head]> extends Error ? ParseContext<T, Rest, R & Record<Head, T[Head]>> : ParseContext<T, Rest, R & Record<Head, FromInputToken<T[Head]>>> : ParseContext<T, Rest, R & Record<Head, T[Head]>> : ExpandRecursively<R>;
//#endregion
//#region src/types/types.d.ts
declare const KindErrorSymbol = "__kind";
/**
 * a type utility which produces the _type_ for the `name` property
 * of a `KindErrorType`'s constructor function.
 */
type KindErrorTypeName<T extends string> = PascalName<Split$1<T, "/">> extends readonly string[] ? Concat<[...PascalName<Split$1<T, "/">>, "ErrorType"]> : never;
type KindErrorName<T extends string> = PascalName<Split$1<T, "/">> extends readonly string[] ? Concat<PascalName<Split$1<T, "/">>> : never;
/**
 * a type utility which produces the _type_ for the `type` property
 * of a `KindError`.
 */
type KindErrorTypeProp<T extends string> = string extends T ? string : Split$1<T, "/"> extends readonly string[] ? KebabCase$1<Split$1<T, "/">[0]> : never;
/**
 * a type utility which produces the _type_ for the `type` property
 * of a `KindError`.
 */
type KindErrorSubTypeProp<T extends string> = string extends T ? string : Split$1<T, "/"> extends readonly string[] ? Split$1<T, "/">[1] extends string ? KebabCase$1<Split$1<T, "/">[1]> : undefined : never;
interface KindStackItem {
  file: string | undefined;
  function?: string;
  args?: any[];
  col?: number;
  line?: number;
  raw?: string;
}
/**
 * A Base Javascript Error
 */
type JsError = Error & {
  name: string;
  message: string;
  stack?: string;
  toString: () => string;
};
/**
 * an _failed_ network response from the native **fetch** method.
 */
type FetchError = Response & {
  ok: false;
};
type FetchSuccess = Response & {
  ok: true;
};
//#endregion
//#region src/types/variants.d.ts
/**
 * **IsNonVariant**`<T>`
 *
 * Tests whether the type `T` is non-variant (aka, it can only have ONE value/type).
 */
type IsNonVariant<T> = IsUnion<T> extends true ? false : T extends InputToken ? FromInputToken<T> extends Error ? IsLiteralLike<T> extends true ? IsUnion<T> extends true ? false : true : false : FromInputToken<T> extends infer Token ? IsLiteralLike<Token> extends true ? IsUnion<Token> extends true ? false : true : false : false : IsLiteralLike<T> extends true ? IsUnion<T> extends true ? false : true : false;
/**
 * **IsVariant**`<T>`
 *
 * Tests whether the type `T` is variant type (aka, the type has more than one variant).
 */
type IsVariant<T> = Not<IsNonVariant<T>>;
/**
 * tests whether the schema `T` has any literal values which are not variants,
 * in it's key/value definition.
 */
type HasNonVariant<T extends Record<string, unknown>, K$1 extends readonly (string & keyof T)[] = StringKeys<T>> = IsEqual<T, Record<string, unknown>> extends true ? true : IsEqual<T, EmptyObject> extends true ? false : K$1 extends [infer Head extends string & keyof T, ...infer Rest extends readonly (string & keyof T)[]] ? IsNonVariant<T[Head]> extends true ? true : HasNonVariant<T, Rest> : false;
/**
 * **Variants**`<T>`
 *
 * Reduces the `KindErrorType`'s context/schema to only key/values
 * which have _variant_ values/types.
 */
type Variants<T extends Record<string, unknown>, K$1 extends readonly (keyof T & string)[] = StringKeys<T>, R extends Record<string, unknown> = EmptyObject> = IsEqual<T, EmptyObject> extends true ? EmptyObject : IsEqual<T, Record<string, unknown>> extends true ? Record<string, unknown> : IsWideObject<T> extends true ? T : K$1 extends [infer Head extends keyof T & string, ...infer Rest extends readonly (keyof T & string)[]] ? T[Head] extends InputToken ? FromInputToken<T[Head]> extends Error ? IsNonVariant<T[Head]> extends true ? Variants<T, Rest, R> : Variants<T, Rest, R & Record<Head, T[Head]>> : IsNonVariant<FromInputToken<T[Head]>> extends true ? Variants<T, Rest, R> : Variants<T, Rest, R & Record<Head, FromInputToken<T[Head]>>> : IsNonVariant<T[Head]> extends true ? Variants<T, Rest, R> : Variants<T, Rest, R & Record<Head, T[Head]>> : ExpandRecursively<R>;
/**
 * **HasVariant**`<T>`
 *
 * Tests whether a `KindErrorType`'s has a optional or required "variant"
 * key/value as part of it's schema.
 */
type HasVariant<T extends Record<string, unknown>, _K extends readonly (string & keyof T)[] = StringKeys<T>> = IsEqual<Variants<T>, EmptyObject> extends true ? false : true;
/**
 * **NonVariants**`<T>`
 *
 * When provided a `KindErrorType`'s context schema, it will return only the
 * key/values where the value is a _non-variant_ (aka, the type only allows a
 * single type/value).
 */
type NonVariants<T extends Record<string, unknown>, K$1 extends readonly (keyof T & string)[] = StringKeys<T>, R extends Record<string, unknown> = EmptyObject> = IsEqual<T, Record<string, unknown>> extends true ? EmptyObject : IsEqual<T, EmptyObject> extends true ? EmptyObject : K$1 extends [infer Head extends keyof T & string, ...infer Rest extends readonly (keyof T & string)[]] ? IsNonVariant<T[Head]> extends true ? NonVariants<T, Rest, R & Record<Head, T[Head]>> : NonVariants<T, Rest, R> : ExpandRecursively<R>;
/**
 * **RemoveVariants**`<T>`
 *
 * Type utility which takes a `KindErrorType`'s schema context and removes all key/values
 * which are not actually "default values" but instead represent a type variant.
 *
 * - This utility helps us to produce a valid key/value of static literals which were
 *   defined in the type and will be merged into the context properties defined in the
 *   instantiation of the `ErrorType`.
 * - Because we mutate the `KindErrorType`'s schema to represent something more meaningful
 *   to the caller in the type system (the _runtime_ still has token definitions) this utility
 *   will in effect remove all key/values which are typed as unions as these are all _variant_.
 */
type RemoveVariants<T extends Record<string, unknown>, K$1 extends readonly (string & keyof T)[] = StringKeys<T>, R extends Record<string, unknown> = EmptyObject> = IsEqual<T, EmptyObject> extends true ? EmptyObject : IsEqual<T, Record<string, unknown>> extends true ? EmptyObject : K$1 extends [infer Head extends string & keyof T, ...infer Rest extends readonly (string & keyof T)[]] ? IsUnion<T[Head]> extends true ? RemoveVariants<T, Rest, R> : RemoveVariants<T, Rest, R & Record<Head, T[Head]>> : ExpandRecursively<R>;
/**
 * Tests whether the context shape defined in the `KindErrorType` has
 * any **required** variant keys that must be defined when creating
 * the `KindError`.
 */
type HasRequiredVariants<T extends Record<string, unknown>> = AsContextShape<T> extends infer Context extends Record<string, unknown> ? HasRequiredProps<Context> : never;
/**
 * **AsContextShape**`<TCtx>`
 *
 * Type utility which converts the KindErrorType's context definition
 * into the type the KindError's context property.
 *
 * - if `undefined` then there are no _variant_ properties for KindError to define
 * - otherwise the properties which are "variant" will be brought forward to the
 *   KindError but any union with `undefined` will be treated as an optional property
 */
type AsContextShape<TSchema extends Record<string, unknown>> = DetectOptionalValues<Variants<TSchema>>;
//#endregion
//#region src/createKindError.d.ts
type Rtn<TName extends string, TContext extends Record<string, unknown>> = Contains<TName, "<" | ">" | "[" | "]" | "(" | ")"> extends true ? Err<"invalid-name", `The name for a KindError must not include any of the following characters: "<", ">", "[", "]", "(", ")"`> : KindErrorType<TName, TContext>;
/**
 * **createKindError**`(name, context)`
 *
 * Creates a `KindErrorType` which can then be called to create
 * the underlying `KindError` instance.
 */
declare function createKindError<const TName extends string, const TContext extends Record<string, unknown>>(name: TName, context?: TContext): Rtn<TName, TContext>;
//#endregion
//#region src/type-guards/isError.d.ts
declare function isError(val: unknown): val is JsError;
//#endregion
//#region src/type-guards/isFetchError.d.ts
/**
 * type guard which tests whether `val` is a failed `Response` object
 * from a `fetch` call.
 */
declare function isFetchError(val: unknown): val is FetchError;
//#endregion
//#region src/type-guards/isFetchResponse.d.ts
/**
 * A type guard which tests whether `val` is a `Response` object from the
 * **fetch** API.
 *
 * **Related:** `isFetchError()`
 */
declare function isFetchResponse(val: unknown): val is Response;
//#endregion
//#region src/type-guards/isKindError.d.ts
/**
 * Type guard to detect whether `val` passed in is a `KindError`.
 *
 * - you may _optionally_ test for a specific `kind` of `KindError`
 * - when testing for a specific "kind" the _comparator_ and _kind_ are normalized
 *   to a kebab cased variant to increase matching likelihood
 *     - this is meant as convenience to the caller; if you want a stricter
 *       matching then use the `KindErrorType`'s `is(val)` type guard.
 */
declare function isKindError<K$1 extends string | undefined>(val: unknown, kind?: K$1): val is K$1 extends string ? KindError<KebabCase<K$1>> : KindError;
//#endregion
//#region src/type-guards/isKindErrorType.d.ts
declare function isKindErrorType(val: unknown): val is KindErrorType;
//#endregion
//#region src/type-guards/isStringifyable.d.ts
declare function isStringifyable(val: unknown): val is Stringifyable;
//#endregion
export { AsContextShape, AsKindSubType, AsKindType, DetectOptionalValues, FetchError, FetchSuccess, HasNonVariant, HasRequiredVariants, HasVariant, IsNonVariant, IsVariant, JsError, KebabKind, KindError, KindErrorName, KindErrorShape, KindErrorSignature, KindErrorSubTypeProp, KindErrorSymbol, KindErrorType, KindErrorTypeName, KindErrorTypeProp, KindStackItem, NonVariants, ParseContext, PascalKind, PascalName, RemoveVariants, ResolveContext, Stringifyable, Variants, createKindError, isError, isFetchError, isFetchResponse, isKindError, isKindErrorType, isStringifyable };
//# sourceMappingURL=index.d.ts.map