@visiolab/effect-firebase 0.0.0-stage → 0.3.0

package/dist/functions/CallableMiddleware.d.mts

@@ -0,0 +1,213 @@
+import { CallableRequest } from "./CallableRequest.mjs";
+import { Any } from "./Callable.mjs";
+import { Context, Effect, Schema } from "effect";
+import { unhandled } from "effect/Types";
+declare namespace CallableMiddleware_d_exports {
+  export { AnyId, AnyKey, ApplyServices, CallableMiddleware, Error, ErrorConstraint, ErrorSchema, Options, Provides, Requires, Service, ServiceClass };
+}
+declare const TypeId = "~@visiolab/effect-firebase/functions/CallableMiddleware";
+/**
+ * The errors a middleware can fail with: one schema or an array.
+ *
+ * @stability unstable
+ * @category models
+ * @since 0.3.0
+ */
+export type ErrorConstraint = Schema.Top | ReadonlyArray<Schema.Top>;
+type ErrorSchemaFromConstraint<E> = E extends ReadonlyArray<Schema.Top> ? E[number] : E extends Schema.Top ? E : never;
+/**
+ * What a middleware's implementation is told about the call it wraps.
+ *
+ * @stability unstable
+ * @category models
+ * @since 0.3.0
+ */
+export interface Options {
+  /** The Callable being called. */
+  readonly callable: Any;
+}
+/**
+ * The implementation of a middleware: a function that wraps the rest of the
+ * call.
+ *
+ * **Details**
+ *
+ * `effect` is the rest of the call: the middleware inside this one, the
+ * Payload's decoding and the handler. It needs what this middleware
+ * `Provides`. The implementation may run it, fail instead, or catch what it
+ * fails with. It may require what middleware outside it provides, and always
+ * the {@link CallableRequest.CallableRequest}.
+ *
+ * A Payload that doesn't decode fails `effect` too. An implementation that
+ * catches every failure catches that one as well, and the caller then no
+ * longer gets `invalid-argument`. Catch only the errors you mean to.
+ *
+ * @stability unstable
+ * @category models
+ * @since 0.3.0
+ */
+export type CallableMiddleware<Provides, E extends ErrorConstraint, Requires> = (effect: Effect.Effect<unknown, unhandled, Provides>, options: Options) => Effect.Effect<unknown, unhandled | ErrorSchemaFromConstraint<E>["Type"], Requires | CallableRequest>;
+/**
+ * Any middleware, as the type of its service class's instances: what it
+ * provides, requires and fails with.
+ *
+ * @stability unstable
+ * @category models
+ * @since 0.3.0
+ */
+export interface AnyId {
+  readonly [TypeId]: {
+    readonly provides: any;
+    readonly requires: any;
+    readonly error: ErrorConstraint;
+  };
+}
+/**
+ * Any middleware's service key, as `.middleware` takes it.
+ *
+ * @stability unstable
+ * @category models
+ * @since 0.3.0
+ */
+export interface AnyKey extends Context.Key<any, any> {
+  readonly [TypeId]: typeof TypeId;
+  /** The schemas of the errors the middleware can fail with. */
+  readonly error: ReadonlySet<Schema.Top>;
+}
+/**
+ * The services a middleware provides to what it wraps.
+ *
+ * @stability unstable
+ * @category type-level
+ * @since 0.3.0
+ */
+export type Provides<A> = A extends {
+  readonly [TypeId]: {
+    readonly provides: infer P;
+  };
+} ? P : never;
+/**
+ * The services a middleware requires from the middleware outside it.
+ *
+ * @stability unstable
+ * @category type-level
+ * @since 0.3.0
+ */
+export type Requires<A> = A extends {
+  readonly [TypeId]: {
+    readonly requires: infer R;
+  };
+} ? R : never;
+/**
+ * The services still required after wrapping `R` in the middleware `A`: `A`'s
+ * `provides` are removed and its `requires` added.
+ *
+ * @stability unstable
+ * @category type-level
+ * @since 0.3.0
+ */
+export type ApplyServices<A extends AnyId, R> = Exclude<R, Provides<A>> | Requires<A>;
+/**
+ * The union of the error schemas of a middleware.
+ *
+ * @stability unstable
+ * @category type-level
+ * @since 0.3.0
+ */
+export type ErrorSchema<A> = A extends {
+  readonly [TypeId]: {
+    readonly error: infer E;
+  };
+} ? ErrorSchemaFromConstraint<E> : never;
+/**
+ * The errors a middleware can fail with.
+ *
+ * @stability unstable
+ * @category type-level
+ * @since 0.3.0
+ */
+export type Error<A> = ErrorSchema<A>["Type"];
+/**
+ * The class {@link Service} returns: a service key whose instances carry the
+ * middleware's types.
+ *
+ * @stability unstable
+ * @category models
+ * @since 0.3.0
+ */
+export type ServiceClass<Self, Id extends string, Config extends {
+  requires: any;
+  provides: any;
+  error: ErrorConstraint;
+}> = Context.Service<Self, CallableMiddleware<Config["provides"], Config["error"], Config["requires"]>> & {
+  new (_: never): Context.ServiceClass.Shape<Id, CallableMiddleware<Config["provides"], Config["error"], Config["requires"]>> & {
+    readonly [TypeId]: {
+      readonly error: Config["error"];
+      readonly requires: Config["requires"];
+      readonly provides: Config["provides"];
+    };
+  };
+  readonly [TypeId]: typeof TypeId;
+  /** The schemas of the errors the middleware can fail with. */
+  readonly error: ReadonlySet<Schema.Top>;
+};
+/**
+ * Declares a Callable Middleware as a class.
+ *
+ * **When to use**
+ *
+ * Use to state a requirement of a Callable, such as "the caller is a member of
+ * a tenant", as part of its contract. For "the caller is signed in", use the
+ * built-in `Caller.Authenticated`.
+ *
+ * **Details**
+ *
+ * `provides` is what the middleware gives the handler: the handler's Layer no
+ * longer needs it. `requires` is what it needs from middleware outside it; a
+ * `requires` that nothing outside provides is left for the Layers where the
+ * chain runs. The {@link CallableRequest.CallableRequest} is always there and
+ * is never listed.
+ *
+ * `error` is one schema or an array. A middleware's errors join the error
+ * union of every Callable it is attached to. They are sent like the
+ * Callable's declared errors, and the client decodes them back.
+ *
+ * The middleware runs before the Payload is decoded, so a call it rejects
+ * learns nothing from the Payload's decoding. The decoding runs inside the
+ * chain, so an implementation that catches every failure also catches a
+ * Payload that doesn't decode.
+ *
+ * @example Declaring a middleware
+ * ```ts
+ * import { Context } from "effect";
+ * import { CallableError, CallableMiddleware } from "@visiolab/effect-firebase/functions";
+ *
+ * class Tenant extends Context.Service<Tenant, { readonly id: string }>()("Tenant") {}
+ *
+ * class WithTenant extends CallableMiddleware.Service<WithTenant, { provides: Tenant }>()(
+ *   "WithTenant",
+ *   { error: CallableError.PermissionDenied },
+ * ) {}
+ * ```
+ *
+ * @see {@link Callable.Callable.middleware} for attaching it to a Callable
+ * @see {@link Caller.Authenticated} for the built-in middleware
+ *
+ * @stability unstable
+ * @category constructors
+ * @since 0.3.0
+ */
+export declare const Service: <Self, Config extends {
+  requires?: any;
+  provides?: any;
+} = {
+  requires: never;
+  provides: never;
+}>() => <const Id extends string, const Error extends ErrorConstraint = never>(id: Id, options?: {
+  readonly error?: Error | undefined;
+}) => ServiceClass<Self, Id, {
+  requires: "requires" extends keyof Config ? Config["requires"] : never;
+  provides: "provides" extends keyof Config ? Config["provides"] : never;
+  error: Error;
+}>;
+export { CallableMiddleware_d_exports };

package/dist/functions/CallableMiddleware.mjs

@@ -0,0 +1,52 @@
+import { __exportAll } from "../_virtual/_rolldown/runtime.mjs";
+import { Service as Service$1 } from "./internal/callableMiddleware.mjs";
+// src/functions/CallableMiddleware.ts
+var CallableMiddleware_exports = /* @__PURE__ */ __exportAll({ Service: () => Service });
+/**
+* Declares a Callable Middleware as a class.
+*
+* **When to use**
+*
+* Use to state a requirement of a Callable, such as "the caller is a member of
+* a tenant", as part of its contract. For "the caller is signed in", use the
+* built-in `Caller.Authenticated`.
+*
+* **Details**
+*
+* `provides` is what the middleware gives the handler: the handler's Layer no
+* longer needs it. `requires` is what it needs from middleware outside it; a
+* `requires` that nothing outside provides is left for the Layers where the
+* chain runs. The {@link CallableRequest.CallableRequest} is always there and
+* is never listed.
+*
+* `error` is one schema or an array. A middleware's errors join the error
+* union of every Callable it is attached to. They are sent like the
+* Callable's declared errors, and the client decodes them back.
+*
+* The middleware runs before the Payload is decoded, so a call it rejects
+* learns nothing from the Payload's decoding. The decoding runs inside the
+* chain, so an implementation that catches every failure also catches a
+* Payload that doesn't decode.
+*
+* @example Declaring a middleware
+* ```ts
+* import { Context } from "effect";
+* import { CallableError, CallableMiddleware } from "@visiolab/effect-firebase/functions";
+*
+* class Tenant extends Context.Service<Tenant, { readonly id: string }>()("Tenant") {}
+*
+* class WithTenant extends CallableMiddleware.Service<WithTenant, { provides: Tenant }>()(
+*   "WithTenant",
+*   { error: CallableError.PermissionDenied },
+* ) {}
+* ```
+*
+* @see {@link Callable.Callable.middleware} for attaching it to a Callable
+* @see {@link Caller.Authenticated} for the built-in middleware
+*
+* @stability unstable
+* @category constructors
+* @since 0.3.0
+*/
+const Service = () => (id, options) => Service$1(id, options);
+export { CallableMiddleware_exports, Service };

package/dist/functions/CallableRequest.d.mts

@@ -0,0 +1,166 @@
+import { Context } from "effect";
+import * as HttpServerRequest from "effect/http/HttpServerRequest";
+declare namespace CallableRequest_d_exports {
+  export { App, Auth, CallableRequest, Input };
+}
+/**
+ * Who made a call: the signed-in user's uid, the claims of their ID token and
+ * the raw ID token.
+ *
+ * @stability unstable
+ * @category models
+ * @since 0.3.0
+ */
+export interface Auth {
+  /** The signed-in user's uid. */
+  readonly uid: string;
+  /** The decoded claims of the user's ID token. */
+  readonly token: Readonly<Record<string, unknown>>;
+  /** The ID token as the client sent it. */
+  readonly rawToken: string;
+}
+/**
+ * The app a call came from, as App Check attested it.
+ *
+ * @stability unstable
+ * @category models
+ * @since 0.3.0
+ */
+export interface App {
+  /** The app ID of the attested Firebase app. */
+  readonly appId: string;
+  /** The decoded claims of the App Check token. */
+  readonly token: Readonly<Record<string, unknown>>;
+  /** Whether the App Check token was already used, when replay protection is on. */
+  readonly alreadyConsumed?: boolean | undefined;
+}
+/**
+ * The call a Callable is answering.
+ *
+ * **Details**
+ *
+ * `data` is the raw Payload, the `Schema.toCodecJson` output the client sent.
+ * Callable Middleware runs before the Payload is decoded, so it sees only
+ * `data`.
+ *
+ * `rawRequest` is the HTTP request the call came in, as Effect's
+ * `HttpServerRequest`. `Functions` builds it from Firebase's request,
+ * streaming its body without copying the bytes, and `Callable.handler` takes
+ * it from {@link Input.rawRequest}.
+ *
+ * @stability unstable
+ * @category models
+ * @since 0.3.0
+ */
+export interface CallableRequest {
+  /** The signed-in caller, absent for a signed-out call. */
+  readonly auth?: Auth | undefined;
+  /** The app the call came from, absent without App Check. */
+  readonly app?: App | undefined;
+  /** An unverified Firebase Instance ID token, if the client sent one. */
+  readonly instanceIdToken?: string | undefined;
+  /** The raw Payload, before it is decoded. */
+  readonly data: unknown;
+  /**
+   * The HTTP request the call came in: its headers, method, URL, body and the
+   * caller's `remoteAddress`.
+   *
+   * **Details**
+   *
+   * The Firebase web SDK's `httpsCallable` can't send custom headers, so a
+   * header of your own comes only from callers that don't use it, such as
+   * another server. Headers the browser or the SDK sets, such as `user-agent`
+   * and `accept-language`, are there for every caller.
+   *
+   * `remoteAddress` is the caller's IP address as the platform reports it,
+   * `Option.none()` when it is unknown.
+   */
+  readonly rawRequest: HttpServerRequest.HttpServerRequest;
+}
+/**
+ * The service key of the {@link CallableRequest}.
+ *
+ * **Details**
+ *
+ * Every call provides it, so Callable Middleware may read it without listing
+ * it in `requires`.
+ *
+ * @stability unstable
+ * @category services
+ * @since 0.3.0
+ */
+export declare const CallableRequest: Context.Service<CallableRequest, CallableRequest>;
+/**
+ * What `Callable.handler` takes about a call: who makes it, from which app and
+ * over which HTTP request. `Callable.handler` fills `data` by encoding the
+ * Payload.
+ *
+ * **Details**
+ *
+ * Pass `{}` for a signed-out call and `{ auth: { uid, token } }` for a
+ * signed-in one. `rawToken` defaults to an empty string, since a call made in
+ * process has no real ID token.
+ *
+ * @stability unstable
+ * @category models
+ * @since 0.3.0
+ */
+export interface Input {
+  /** The signed-in caller, absent for a signed-out call. */
+  readonly auth?: {
+    readonly uid: string;
+    readonly token: Readonly<Record<string, unknown>>;
+    readonly rawToken?: string | undefined;
+  } | undefined;
+  /** The app the call came from. */
+  readonly app?: App | undefined;
+  /** A Firebase Instance ID token. */
+  readonly instanceIdToken?: string | undefined;
+  /**
+   * The HTTP request the call comes in, for middleware that reads headers or
+   * the caller's address.
+   *
+   * **Details**
+   *
+   * Left out, it is a `POST` of the encoded Payload as JSON to
+   * `http://localhost/<deployed name>`, with `content-type:
+   * application/json`, no other headers and no `remoteAddress`. Build one with
+   * `HttpServerRequest.fromWeb` from `effect/http/HttpServerRequest`, and set
+   * `remoteAddress` with its `modify`.
+   *
+   * @example Calling with a request of your own
+   * ```ts
+   * import { Effect, Layer, Option } from "effect";
+   * import * as HttpServerRequest from "effect/http/HttpServerRequest";
+   * import { Callable, CallableMiddleware, CallableRequest } from "@visiolab/effect-firebase/functions";
+   *
+   * class LogLocale extends CallableMiddleware.Service<LogLocale>()("LogLocale") {}
+   *
+   * const Ping = Callable.make("ping").middleware(LogLocale);
+   *
+   * const program = Effect.gen(function* () {
+   *   const ping = yield* Callable.handler(Ping);
+   *   const rawRequest = HttpServerRequest.fromWeb(
+   *     new Request("https://example.com/ping", {
+   *       method: "POST",
+   *       headers: { "accept-language": "de-CH" },
+   *     }),
+   *   ).modify({ remoteAddress: Option.some("203.0.113.7") });
+   *   yield* ping(undefined, { rawRequest });
+   * }).pipe(
+   *   Effect.provide(
+   *     Layer.mergeAll(
+   *       Callable.toLayer(Ping, () => Effect.void),
+   *       Layer.succeed(LogLocale, (effect) =>
+   *         Effect.flatMap(Effect.service(CallableRequest.CallableRequest), ({ rawRequest }) =>
+   *           Effect.andThen(Effect.logInfo("Locale", rawRequest.headers["accept-language"]), effect),
+   *         ),
+   *       ),
+   *     ),
+   *   ),
+   * );
+   * ```
+   */
+  readonly rawRequest?: HttpServerRequest.HttpServerRequest | undefined;
+}
+export { CallableRequest_d_exports };

package/dist/functions/CallableRequest.mjs

@@ -0,0 +1,18 @@
+import { __exportAll } from "../_virtual/_rolldown/runtime.mjs";
+import { CallableRequest as CallableRequest$1 } from "./internal/callableRequest.mjs";
+// src/functions/CallableRequest.ts
+var CallableRequest_exports = /* @__PURE__ */ __exportAll({ CallableRequest: () => CallableRequest });
+/**
+* The service key of the {@link CallableRequest}.
+*
+* **Details**
+*
+* Every call provides it, so Callable Middleware may read it without listing
+* it in `requires`.
+*
+* @stability unstable
+* @category services
+* @since 0.3.0
+*/
+const CallableRequest = CallableRequest$1;
+export { CallableRequest, CallableRequest_exports };

package/dist/functions/Caller.d.mts

@@ -0,0 +1,103 @@
+import { Unauthenticated } from "./CallableError.mjs";
+import { ServiceClass } from "./CallableMiddleware.mjs";
+import { Context, Layer } from "effect";
+declare namespace Caller_d_exports {
+  export { Authenticated, Caller };
+}
+/**
+ * The signed-in user making a call.
+ *
+ * **Details**
+ *
+ * A portable shape, not `firebase-admin`'s `DecodedIdToken`. There is no
+ * constructor: {@link Authenticated} provides it from the request, and a test
+ * provides a fake one from a stub middleware Layer.
+ *
+ * @stability unstable
+ * @category models
+ * @since 0.3.0
+ */
+export interface Caller {
+  /** The user's uid. */
+  readonly uid: string;
+  /** The decoded claims of the user's ID token. */
+  readonly token: Readonly<Record<string, unknown>>;
+  /** The ID token as the client sent it. */
+  readonly rawToken: string;
+}
+/**
+ * The service key of the {@link Caller}.
+ *
+ * @stability unstable
+ * @category services
+ * @since 0.3.0
+ */
+export declare const Caller: Context.Service<Caller, Caller>;
+declare const Authenticated_base: ServiceClass<Authenticated, "@visiolab/effect-firebase/functions/Caller/Authenticated", {
+  requires: never;
+  provides: Caller;
+  error: typeof Unauthenticated;
+}>;
+/**
+ * The built-in middleware that requires a signed-in caller and provides the
+ * {@link Caller}.
+ *
+ * **When to use**
+ *
+ * Use on every Callable that only a signed-in user may call. Write a
+ * middleware of your own with {@link CallableMiddleware.Service} for other
+ * requirements, such as a custom claim.
+ *
+ * **Details**
+ *
+ * A call without auth fails with `CallableError.Unauthenticated`, before its
+ * Payload is decoded. Provide {@link Authenticated.layer} where the chain
+ * runs, or a stub Layer that provides a fake Caller in tests.
+ *
+ * @example Stubbing the Caller in process
+ * ```ts
+ * import { Effect, Layer, Schema } from "effect";
+ * import { Callable, Caller } from "@visiolab/effect-firebase/functions";
+ *
+ * const WhoAmI = Callable.make("whoAmI", { success: Schema.String }).middleware(
+ *   Caller.Authenticated,
+ * );
+ *
+ * const WhoAmILive = Callable.toLayer(WhoAmI, () =>
+ *   Effect.map(Effect.service(Caller.Caller), ({ uid }) => uid),
+ * );
+ *
+ * const AsAda = Layer.succeed(Caller.Authenticated, (effect) =>
+ *   Effect.provideService(effect, Caller.Caller, { uid: "ada", token: {}, rawToken: "" }),
+ * );
+ *
+ * const program = Effect.gen(function* () {
+ *   const whoAmI = yield* Callable.handler(WhoAmI);
+ *   return yield* whoAmI(undefined, {});
+ * }).pipe(Effect.provide(Layer.merge(WhoAmILive, AsAda)));
+ * ```
+ *
+ * @see {@link Caller} for what it provides
+ * @see {@link CallableMiddleware.Service} for declaring a middleware of your own
+ *
+ * @stability unstable
+ * @category middleware
+ * @since 0.3.0
+ */
+export declare class Authenticated extends Authenticated_base {
+  /**
+   * The implementation of {@link Authenticated}: provides the {@link Caller}
+   * from the request's auth, and fails with `CallableError.Unauthenticated`
+   * when there is none.
+   *
+   * **When to use**
+   *
+   * Use where the chain runs, in production and in process alike.
+   *
+   * @stability unstable
+   * @category layers
+   * @since 0.3.0
+   */
+  static readonly layer: Layer.Layer<Authenticated>;
+}
+export { Caller_d_exports };

package/dist/functions/Caller.mjs

@@ -0,0 +1,115 @@
+import { __exportAll } from "../_virtual/_rolldown/runtime.mjs";
+import { Unauthenticated } from "./CallableError.mjs";
+import { Service } from "./CallableMiddleware.mjs";
+import { CallableRequest } from "./CallableRequest.mjs";
+import { Context, Effect, Layer } from "effect";
+// src/functions/Caller.ts
+/**
+* The Caller: the signed-in user making a call, and the built-in
+* `Authenticated` middleware that provides it.
+*
+* A Callable that requires a signed-in caller attaches {@link Authenticated}.
+* Its handler then reads the {@link Caller} instead of the raw request, and a
+* signed-out call fails with `CallableError.Unauthenticated` before its
+* Payload is decoded.
+*
+* @example Reading the Caller in a handler
+* ```ts
+* import { Effect, Schema } from "effect";
+* import { Callable, Caller } from "@visiolab/effect-firebase/functions";
+*
+* const WhoAmI = Callable.make("whoAmI", { success: Schema.String }).middleware(
+*   Caller.Authenticated,
+* );
+*
+* const WhoAmILive = Callable.toLayer(WhoAmI, () =>
+*   Effect.map(Effect.service(Caller.Caller), ({ uid }) => uid),
+* );
+* ```
+*
+* @stability unstable
+* @since 0.3.0
+*/
+var Caller_exports = /* @__PURE__ */ __exportAll({
+	Authenticated: () => Authenticated,
+	Caller: () => Caller
+});
+/**
+* The service key of the {@link Caller}.
+*
+* @stability unstable
+* @category services
+* @since 0.3.0
+*/
+const Caller = Context.Service("@visiolab/effect-firebase/functions/Caller");
+/**
+* The built-in middleware that requires a signed-in caller and provides the
+* {@link Caller}.
+*
+* **When to use**
+*
+* Use on every Callable that only a signed-in user may call. Write a
+* middleware of your own with {@link CallableMiddleware.Service} for other
+* requirements, such as a custom claim.
+*
+* **Details**
+*
+* A call without auth fails with `CallableError.Unauthenticated`, before its
+* Payload is decoded. Provide {@link Authenticated.layer} where the chain
+* runs, or a stub Layer that provides a fake Caller in tests.
+*
+* @example Stubbing the Caller in process
+* ```ts
+* import { Effect, Layer, Schema } from "effect";
+* import { Callable, Caller } from "@visiolab/effect-firebase/functions";
+*
+* const WhoAmI = Callable.make("whoAmI", { success: Schema.String }).middleware(
+*   Caller.Authenticated,
+* );
+*
+* const WhoAmILive = Callable.toLayer(WhoAmI, () =>
+*   Effect.map(Effect.service(Caller.Caller), ({ uid }) => uid),
+* );
+*
+* const AsAda = Layer.succeed(Caller.Authenticated, (effect) =>
+*   Effect.provideService(effect, Caller.Caller, { uid: "ada", token: {}, rawToken: "" }),
+* );
+*
+* const program = Effect.gen(function* () {
+*   const whoAmI = yield* Callable.handler(WhoAmI);
+*   return yield* whoAmI(undefined, {});
+* }).pipe(Effect.provide(Layer.merge(WhoAmILive, AsAda)));
+* ```
+*
+* @see {@link Caller} for what it provides
+* @see {@link CallableMiddleware.Service} for declaring a middleware of your own
+*
+* @stability unstable
+* @category middleware
+* @since 0.3.0
+*/
+var Authenticated = class extends Service()("@visiolab/effect-firebase/functions/Caller/Authenticated", { error: Unauthenticated }) {
+	/**
+	* The implementation of {@link Authenticated}: provides the {@link Caller}
+	* from the request's auth, and fails with `CallableError.Unauthenticated`
+	* when there is none.
+	*
+	* **When to use**
+	*
+	* Use where the chain runs, in production and in process alike.
+	*
+	* @stability unstable
+	* @category layers
+	* @since 0.3.0
+	*/
+	static layer = Layer.succeed(this, (effect) => Effect.gen(function* () {
+		const { auth } = yield* Effect.service(CallableRequest);
+		if (auth === void 0) return yield* new Unauthenticated();
+		return yield* Effect.provideService(effect, Caller, {
+			uid: auth.uid,
+			token: auth.token,
+			rawToken: auth.rawToken
+		});
+	}));
+};
+export { Authenticated, Caller, Caller_exports };