import { Collection, Vertex } from "./vertex.js";
import { AllTrue, IsUnion, NoneIsUnion } from "./util.js";

//#region src/core/interfaces/vertices/util/edges.d.ts
declare const EDGE_TYPE_ID_KEY = "__edge_type_id";
declare const EDGE_INVALID_KEY = "__invalid";
declare const EDGE_VALUE_KEY = "__value";
type EdgeValueKey = typeof EDGE_VALUE_KEY;
type EdgeTypeIdValues = {
  PLAIN: 'PLAIN';
  WRAPPED: 'WRAPPED';
  COALESCED: 'COALESCED';
  GROUP_WITH_EXCLUDE: 'GROUP_WITH_EXCLUDE';
  AVAILABLE_LOCATION: 'AVAILABLE_LOCATION';
  THREAD_MESSAGE: 'THREAD_MESSAGE';
};
type EdgeTypeIdValue = (EdgeTypeIdValues)[keyof EdgeTypeIdValues];
type EdgeBase<ID extends EdgeTypeIdValue, Invalid extends boolean> = {
  [EDGE_TYPE_ID_KEY]: ID;
  [EDGE_INVALID_KEY]: Invalid;
};
type EdgeIsValid<T extends EdgeBase<any, any>> = [T] extends [{
  [EDGE_INVALID_KEY]: false;
}] ? true : false;
declare namespace Plain {
  namespace Util {}
  type Edge<V extends Vertex<Collection>> = EdgeBase<EdgeTypeIdValues['PLAIN'], NoneIsUnion<[V]> extends never ? true : false> & {
    [EDGE_VALUE_KEY]: V;
  };
}
declare namespace Wrapped {
  namespace Util {
    type Options<T extends string> = {
      key: T;
    };
    type Value<K extends string, To, Extra = object> = Extra & { [k in K]: To };
  }
  type Edge<K extends string, V extends Vertex<Collection>, E extends object = object> = EdgeBase<EdgeTypeIdValues['WRAPPED'], NoneIsUnion<[K, V]> extends never ? true : false> & {
    [EDGE_VALUE_KEY]: Util.Value<K, V, E>;
  };
}
declare namespace Coalesced {
  namespace Util {
    export namespace Keys {
      const TO = "to";
      type To = typeof TO;
      const TO_MODEL = "toModel";
      type ToModel = typeof TO_MODEL;
    }
    export type Options = {
      optional?: boolean;
    };
    type makePartial<T, O extends Options> = O extends {
      optional: true;
    } ? Partial<T> : T;
    export type ToModel<V extends Vertex<Collection>> = V extends Vertex<infer C> ? C extends 'events' ? C | 'courseevents' : C : never;
    export type Value<To, ToModel, Opts extends Util.Options = object, Extra = object> = Extra & makePartial<{
      [Keys.TO]: To;
      [Keys.TO_MODEL]: ToModel;
    }, Opts>;
    export {};
  }
  type Edge<V extends Vertex<Collection>, Opts extends Util.Options = object, E extends object = object> = EdgeBase<EdgeTypeIdValues['COALESCED'], NoneIsUnion<[V]> extends never ? true : false> & {
    [EDGE_VALUE_KEY]: Util.Value<V, Util.ToModel<V>, Opts, E>;
  };
}
declare namespace GroupWithExclude {
  namespace Util {
    namespace Keys {
      const TO = "to";
      type To = typeof TO;
      const EXCLUDE = "exclude";
      type Exclude = typeof EXCLUDE;
    }
    type Value<To, Exclude, Extra = object> = Extra & {
      [Keys.TO]: To;
      [Keys.EXCLUDE]?: Exclude[];
    };
  }
  type Edge<G extends Vertex<Collection>, P extends Vertex<Collection>, E extends object = object> = EdgeBase<EdgeTypeIdValues['GROUP_WITH_EXCLUDE'], NoneIsUnion<[G, P]> extends never ? true : false> & {
    [EDGE_VALUE_KEY]: Util.Value<G, P[], E>;
  };
}
declare namespace AvailableLocation {
  namespace Util {
    namespace Keys {
      const LOCATIONS = "locations";
      type Locations = typeof LOCATIONS;
    }
    type Value<L, Extra = object> = Extra & {
      [Keys.LOCATIONS]: [L];
    };
  }
  type Edge<L extends Vertex<Collection>, E extends object = object> = EdgeBase<EdgeTypeIdValues['AVAILABLE_LOCATION'], NoneIsUnion<[L]> extends never ? true : false> & {
    [EDGE_VALUE_KEY]: Util.Value<L, E>;
  };
}
declare namespace ThreadMessage {
  namespace Util {
    namespace Keys {
      const USER = "user";
      type User = typeof USER;
      const TAGGED_PERSONS = "taggedPersons";
      type TaggedPersons = typeof TAGGED_PERSONS;
    }
    type Value<P, T, Extra = object> = Extra & {
      [Keys.USER]: P;
      [Keys.TAGGED_PERSONS]?: T[];
    };
  }
  type Edge<P extends Vertex<Collection>, T extends Vertex<Collection>, E extends object = object> = EdgeBase<EdgeTypeIdValues['THREAD_MESSAGE'], NoneIsUnion<[P, T]> extends never ? true : false> & {
    [EDGE_VALUE_KEY]: Util.Value<P, T, E>;
  };
}
type AllowedEdgeType<T extends EdgeBase<EdgeTypeIdValue, boolean>> = IsUnion<T> extends never ? true : T extends Coalesced.Edge<any, any> ? true : false;
type EdgeMultiplicity = 'single' | 'array';
type EdgeWrapper<M extends EdgeMultiplicity, T extends EdgeBase<EdgeTypeIdValue, boolean> | null | undefined> = AllTrue<[AllowedEdgeType<NonNullable<T>>, EdgeIsValid<NonNullable<T>>]> extends false ? never : {
  __edge_multiplicity: M;
  __edge_type: T;
};
//#endregion
export { AvailableLocation, Coalesced, EdgeBase, EdgeMultiplicity, EdgeValueKey, EdgeWrapper, GroupWithExclude, Plain, ThreadMessage, Wrapped };
//# sourceMappingURL=edges.d.ts.map