HttpApiMiddleware

declare function isSecurity(u: TagClassAny): u is TagClassSecurityAny;

interface HttpApiMiddleware<Provides, E> extends Effect<
  Provides,
  E,
  HttpRouter.HttpRouter.Provided
> {}

type HttpApiMiddlewareSecurity<
  Security extends Record<string, HttpApiSecurity.HttpApiSecurity>,
  Provides,
  E,
> = {
  [K in keyof Security]: (
    _: HttpApiSecurity.HttpApiSecurity.Type<Security[K]>,
  ) => Effect.Effect<Provides, E, HttpRouter.HttpRouter.Provided>;
};

type TagClass<Self, Name extends string, Options> = Options extends {
  readonly security: Record<string, HttpApiSecurity.HttpApiSecurity>;
}
  ? TagClass.BaseSecurity<
      Self,
      Name,
      Options,
      Simplify<
        HttpApiMiddlewareSecurity<
          Options["security"],
          TagClass.Service<Options>,
          TagClass.FailureService<Options>
        >
      >,
      Options["security"]
    >
  : TagClass.Base<
      Self,
      Name,
      Options,
      HttpApiMiddleware<TagClass.Service<Options>, TagClass.FailureService<Options>>
    >;

interface TagClassAny extends Tag<any, Any> {
  readonly [TypeId]: typeof TypeId;
  readonly failure: All;
  readonly optional: boolean;
  readonly provides?: any;
}

interface TagClassSecurityAny extends TagClassAny {
  readonly [SecurityTypeId]: typeof SecurityTypeId;
  readonly security: Record<string, HttpApiSecurity.HttpApiSecurity>;
}

declare function Tag<Self>(): <
  Name extends string,
  Options extends {
    readonly failure?: any;
    readonly optional?: boolean;
    readonly provides?: any;
    readonly security?: Record<string, HttpApiSecurity>;
  },
>(
  id: Name,
  options?: Options,
) => TagClass<Self, Name, Options>;

declare const SecurityTypeId: unique symbol;

type SecurityTypeId = typeof SecurityTypeId;

declare const TypeId: unique symbol;

type TypeId = typeof TypeId;