better-supabase 0.8.0 → 0.9.0

package/dist/blocks/entitlements/react/index.d.ts

@@ -0,0 +1,24 @@
+import { t as EntitlementClaimOptions } from "../../../entitlements-CbzCKalR.js";
+import { i as FeatureGateSnapshot, t as FeatureGateActions } from "../../../client-BVZtq_rQ.js";
+//#region src/blocks/entitlements/react/index.d.ts
+export interface UseFeatureGateOptions {
+  /** The organization to check. Default the session's active one. */
+  readonly organizationId?: string | null;
+  /** `config.claims.features` (default `features`), or `{ claim, keys }` for short codes. */
+  readonly claim?: string | EntitlementClaimOptions;
+  /** The tenant claim, `config.claims.tenant` (default `tenant_id`). */
+  readonly tenantClaim?: string;
+}
+export interface FeatureGateState extends FeatureGateSnapshot, FeatureGateActions {}
+/**
+ * Whether the active organization's plan includes `feature`, from the
+ * provider session's plan-features claim; `allowed` is `undefined` while
+ * the session loads. UX only: RLS enforces the feature. The same hook runs
+ * in React DOM and React Native.
+ *
+ * ```tsx
+ * const { allowed } = useFeatureGate("exports");
+ * ```
+ */
+export declare function useFeatureGate(feature: string, options?: UseFeatureGateOptions): FeatureGateState;
+//#endregion

package/dist/blocks/entitlements/react/index.js

@@ -0,0 +1,35 @@
+"use client";
+import { t as createFeatureGateController } from "../../../client-Ezlbskjq.js";
+import { t as useController } from "../../../react-controller-Xn-IU44p.js";
+import { t as useBlockEnv } from "../../../react-env-Cc7Vf6eb.js";
+//#region src/blocks/entitlements/react/index.ts
+/**
+* Whether the active organization's plan includes `feature`, from the
+* provider session's plan-features claim; `allowed` is `undefined` while
+* the session loads. UX only: RLS enforces the feature. The same hook runs
+* in React DOM and React Native.
+*
+* ```tsx
+* const { allowed } = useFeatureGate("exports");
+* ```
+*/
+function useFeatureGate(feature, options = {}) {
+	const { auth } = useBlockEnv();
+	const { organizationId, claim, tenantClaim } = options;
+	const claimKey = typeof claim === "object" ? JSON.stringify(claim) : claim;
+	return useController(() => createFeatureGateController({
+		auth,
+		feature,
+		...organizationId === void 0 ? {} : { organizationId },
+		...claim === void 0 ? {} : { claim },
+		...tenantClaim === void 0 ? {} : { tenantClaim }
+	}), [
+		auth,
+		feature,
+		organizationId,
+		claimKey,
+		tenantClaim
+	]).view;
+}
+//#endregion
+export { useFeatureGate };

package/dist/blocks/entitlements/react/server.d.ts

@@ -0,0 +1,6 @@
+import { FeatureGateState, UseFeatureGateOptions, useFeatureGate as useFeatureGate$1 } from "./index.js";
+//#region src/blocks/entitlements/react/server.d.ts
+/** The `react-server` build of `useFeatureGate`: call `hasEntitlement(session, organizationId, feature)` instead. */
+export declare const useFeatureGate: typeof useFeatureGate$1;
+//#endregion
+export type { FeatureGateState, UseFeatureGateOptions };

package/dist/blocks/entitlements/react/server.js

@@ -0,0 +1,7 @@
+//#region src/blocks/entitlements/react/server.ts
+/** The `react-server` build of `useFeatureGate`: call `hasEntitlement(session, organizationId, feature)` instead. */
+const useFeatureGate = () => {
+	throw new Error("better-supabase: useFeatureGate() runs in Client Components only. In Server Components call `hasEntitlement(session, organizationId, feature)` instead.");
+};
+//#endregion
+export { useFeatureGate };

package/dist/blocks/entitlements/solid/index.d.ts

@@ -0,0 +1,13 @@
+import { t as BlockOptions } from "../../../block-env-Dxl7rsI0.js";
+import { t as SolidController } from "../../../solid-controller-DqlvYFZa.js";
+import { i as FeatureGateSnapshot, r as FeatureGateControllerOptions, t as FeatureGateActions } from "../../../client-BVZtq_rQ.js";
+//#region src/blocks/entitlements/solid/index.d.ts
+/**
+ * `createFeatureGateController` as a Solid primitive: `state()` reads the
+ * snapshot. Call it in a component; the work starts on mount and the controller
+ * is disposed with the owner. `auth` and `ports` default to the client of
+ * `<BetterSupabaseProvider client={bs}>`.
+ */
+export declare function useFeatureGate(options: BlockOptions<FeatureGateControllerOptions>): SolidController<FeatureGateSnapshot, FeatureGateActions>;
+//#endregion
+export type { BlockOptions, FeatureGateActions, FeatureGateControllerOptions, FeatureGateSnapshot, SolidController };

package/dist/blocks/entitlements/solid/index.js

@@ -0,0 +1,14 @@
+import { t as createFeatureGateController } from "../../../client-Ezlbskjq.js";
+import { t as useBlockController } from "../../../solid-controller-DLsmrczT.js";
+//#region src/blocks/entitlements/solid/index.ts
+/**
+* `createFeatureGateController` as a Solid primitive: `state()` reads the
+* snapshot. Call it in a component; the work starts on mount and the controller
+* is disposed with the owner. `auth` and `ports` default to the client of
+* `<BetterSupabaseProvider client={bs}>`.
+*/
+function useFeatureGate(options) {
+	return useBlockController(createFeatureGateController, options);
+}
+//#endregion
+export { useFeatureGate };

package/dist/blocks/entitlements/svelte/index.d.ts

@@ -0,0 +1,13 @@
+import { t as BlockOptions } from "../../../block-env-Dxl7rsI0.js";
+import { t as SvelteController } from "../../../svelte-controller-DxxHEHxD.js";
+import { i as FeatureGateSnapshot, r as FeatureGateControllerOptions, t as FeatureGateActions } from "../../../client-BVZtq_rQ.js";
+//#region src/blocks/entitlements/svelte/index.d.ts
+/**
+ * `createFeatureGateController` as a Svelte readable store of the snapshot,
+ * with the actions on `.actions`. Call it in a component's script; the work
+ * starts on mount and the controller is disposed with the component. `auth` and
+ * `ports` default to the client of `setBetterSupabase(bs)`.
+ */
+export declare function useFeatureGate(options: BlockOptions<FeatureGateControllerOptions>): SvelteController<FeatureGateSnapshot, FeatureGateActions>;
+//#endregion
+export type { BlockOptions, FeatureGateActions, FeatureGateControllerOptions, FeatureGateSnapshot, SvelteController };

package/dist/blocks/entitlements/svelte/index.js

@@ -0,0 +1,14 @@
+import { t as createFeatureGateController } from "../../../client-Ezlbskjq.js";
+import { t as useBlockController } from "../../../svelte-controller-CDAujo-_.js";
+//#region src/blocks/entitlements/svelte/index.ts
+/**
+* `createFeatureGateController` as a Svelte readable store of the snapshot,
+* with the actions on `.actions`. Call it in a component's script; the work
+* starts on mount and the controller is disposed with the component. `auth` and
+* `ports` default to the client of `setBetterSupabase(bs)`.
+*/
+function useFeatureGate(options) {
+	return useBlockController(createFeatureGateController, options);
+}
+//#endregion
+export { useFeatureGate };

package/dist/blocks/entitlements/vue/index.d.ts

@@ -0,0 +1,13 @@
+import { t as BlockOptions } from "../../../block-env-Dxl7rsI0.js";
+import { t as VueController } from "../../../vue-controller-HPfMTDa2.js";
+import { i as FeatureGateSnapshot, r as FeatureGateControllerOptions, t as FeatureGateActions } from "../../../client-BVZtq_rQ.js";
+//#region src/blocks/entitlements/vue/index.d.ts
+/**
+ * `createFeatureGateController` as a Vue composable: `state` is a shallow ref
+ * of the snapshot. Call it in `setup` or an effect scope; the work starts on
+ * mount and the controller is disposed with the scope. `auth` and `ports`
+ * default to the client of `app.use(betterSupabase(bs))`.
+ */
+export declare function useFeatureGate(options: BlockOptions<FeatureGateControllerOptions>): VueController<FeatureGateSnapshot, FeatureGateActions>;
+//#endregion
+export type { BlockOptions, FeatureGateActions, FeatureGateControllerOptions, FeatureGateSnapshot, VueController };

package/dist/blocks/entitlements/vue/index.js

@@ -0,0 +1,14 @@
+import { t as createFeatureGateController } from "../../../client-Ezlbskjq.js";
+import { t as useBlockController } from "../../../vue-controller-C9tFzqAc.js";
+//#region src/blocks/entitlements/vue/index.ts
+/**
+* `createFeatureGateController` as a Vue composable: `state` is a shallow ref
+* of the snapshot. Call it in `setup` or an effect scope; the work starts on
+* mount and the controller is disposed with the scope. `auth` and `ports`
+* default to the client of `app.use(betterSupabase(bs))`.
+*/
+function useFeatureGate(options) {
+	return useBlockController(createFeatureGateController, options);
+}
+//#endregion
+export { useFeatureGate };

package/dist/blocks/flags/index.d.ts

@@ -1,219 +1,79 @@
-import { t as AsyncResult, w as ErrorMapper } from "../../result-BchM1XZn.js";
-import { a as dbTransport, o as rpcTransport, s as sqlTransport, t as BlockTransport } from "../../block-transport-inD4fFq-.js";
-import { r as BlockTemporalOptions } from "../../block-helpers-C0Xj8War.js";
-//#region src/blocks/flags/flags.d.ts
-type FlagType = "boolean" | "string" | "number" | "object";
-type FlagValue = boolean | string | number | null | FlagValue[] | {
-  [key: string]: FlagValue;
-};
-/** A targeting rule: every list that is set must contain the caller's value. */
-interface FlagRule {
-  readonly variant: string;
-  readonly tenants?: readonly string[];
-  readonly users?: readonly string[];
-  /** Entitlement lookup keys; one match is enough. */
-  readonly plans?: readonly string[];
-  readonly roles?: readonly string[];
-}
-interface FlagOverride {
-  readonly organizationId: string | undefined;
-  readonly userId: string | undefined;
-  readonly variant: string;
-}
-/** A row of the `flags` table with its overrides (`flag_definitions()`). */
-interface FlagDefinition {
-  readonly key: string;
-  readonly type: FlagType;
-  readonly variants: Readonly<Record<string, FlagValue>>;
-  readonly defaultVariant: string;
-  readonly enabled: boolean;
-  readonly rules: readonly FlagRule[];
-  /** 0 to 100, in steps of 0.01. */
-  readonly rolloutPercentage: number;
-  readonly rolloutVariant: string | undefined;
-  readonly overrides: readonly FlagOverride[];
-}
-/**
- * The OpenFeature evaluation context the provider reads. `targetingKey` is
- * the user id; without one, the rollout buckets by `tenant`.
- */
-interface FlagContext {
-  readonly targetingKey?: string;
-  readonly tenant?: string;
-  readonly plans?: readonly string[];
-  readonly role?: string;
-  /** Every role the caller holds in the tenant; a `roles` rule matches any of them. */
-  readonly roles?: readonly string[];
-  readonly [attribute: string]: unknown;
-}
-/**
- * What `flagContext()` returns; an OpenFeature `EvaluationContext`. It is a
- * type alias because an interface has no implicit index signature.
- */
-type RequestFlagContext = {
-  targetingKey?: string;
-  tenant?: string;
-  plans?: string[];
-  role?: string;
-  roles?: string[];
-};
-type FlagReason = "DISABLED" | "TARGETING_MATCH" | "SPLIT" | "DEFAULT" | "ERROR";
-type FlagErrorCode = "FLAG_NOT_FOUND" | "TYPE_MISMATCH" | "PROVIDER_NOT_READY" | "GENERAL";
-/**
- * The shape of an OpenFeature `ResolutionDetails`. `Code` is the type of
- * `errorCode`: OpenFeature's `ErrorCode` when `errorCodes: ErrorCode` is
- * passed to the provider, the matching string literals otherwise.
- */
-interface FlagResolution<T, Code extends string = FlagErrorCode> {
-  readonly value: T;
-  readonly variant?: string;
-  readonly reason: FlagReason;
-  readonly errorCode?: Code;
-  readonly errorMessage?: string;
-}
-/** The shape of an OpenFeature `EvaluationDetails`. */
-interface FlagDetails<T, Code extends string = FlagErrorCode> extends FlagResolution<T, Code> {
-  readonly flagKey: string;
-  readonly flagMetadata: Readonly<Record<string, string | number | boolean>>;
-}
-/**
- * The rollout bucket of `target` for `flag`, 0 to 9999: the first 32 bits
- * of SHA-256(`flag.target`) modulo 10000. `better_supabase.flag_bucket()`
- * computes the same number, so SQL and TypeScript agree on who is in.
- */
-export declare function flagBucket(flag: string, target: string): Promise<number>;
-/** The result of `evaluateFlag()`, which never fails. */
-interface FlagEvaluation {
-  readonly value: FlagValue;
-  readonly variant: string;
-  readonly reason: FlagReason;
-}
-/** Evaluates one flag as `better_supabase.flag_evaluation()` does. */
-export declare function evaluateFlag(flag: FlagDefinition, context?: FlagContext): Promise<FlagEvaluation>;
-/** Parses the rows of `flag_definitions()`. */
-export declare function flagDefinitionsOf(value: unknown): readonly FlagDefinition[];
-interface FlagsProviderOptions<Code extends string = FlagErrorCode> extends BlockTemporalOptions {
-  /**
-   * A service-role transport: `flag_definitions()` is granted to
-   * `service_role` only, as it lists every override.
-   */
-  readonly transport?: BlockTransport;
-  /** The module schema (`sql.modules.flags.schema`), default `better_supabase`. */
-  readonly schema?: string;
-  /** How long the definitions are cached, in milliseconds. Default 30000. */
-  readonly ttl?: number;
-  /** Fixed definitions instead of a transport, for tests and static flags. */
-  readonly definitions?: readonly FlagDefinition[];
-  /**
-   * OpenFeature's `ErrorCode` enum (from `@openfeature/core` or
-   * `@openfeature/server-sdk`), so the provider's types match `Provider`.
-   */
-  readonly errorCodes?: Readonly<Record<FlagErrorCode, Code>>;
-  readonly now?: () => number;
-}
-/**
- * The shape of an OpenFeature server `Provider`. Pass it to
- * `OpenFeature.setProviderAndWait()`; this package never imports OpenFeature.
- */
-interface FlagsProvider<Code extends string = FlagErrorCode> {
-  readonly metadata: {
-    readonly name: string;
-  };
-  readonly runsOn: "server";
-  initialize(context?: FlagContext): Promise<void>;
-  resolveBooleanEvaluation(flagKey: string, defaultValue: boolean, context: FlagContext): Promise<FlagResolution<boolean, Code>>;
-  resolveStringEvaluation(flagKey: string, defaultValue: string, context: FlagContext): Promise<FlagResolution<string, Code>>;
-  resolveNumberEvaluation(flagKey: string, defaultValue: number, context: FlagContext): Promise<FlagResolution<number, Code>>;
-  resolveObjectEvaluation<T extends FlagValue>(flagKey: string, defaultValue: T, context: FlagContext): Promise<FlagResolution<T, Code>>;
-  /** Drops the cache, so the next evaluation reloads the definitions. */
-  refresh(): void;
-}
-/** Feature flags from the `flags` module, as an OpenFeature provider. */
-export declare function createFlagsProvider<Code extends string = FlagErrorCode>(options: FlagsProviderOptions<Code>): FlagsProvider<Code>;
-/**
- * The four `get*Details` methods that the OpenFeature server `Client` and
- * the `FlagClient` of `@supabase-labs/middleware-openfeature` share.
- */
-interface FlagClient<Code extends string = FlagErrorCode> {
-  getBooleanDetails(flagKey: string, defaultValue: boolean, context?: FlagContext): Promise<FlagDetails<boolean, Code>>;
-  getStringDetails(flagKey: string, defaultValue: string, context?: FlagContext): Promise<FlagDetails<string, Code>>;
-  getNumberDetails(flagKey: string, defaultValue: number, context?: FlagContext): Promise<FlagDetails<number, Code>>;
-  getObjectDetails<T extends FlagValue>(flagKey: string, defaultValue: T, context?: FlagContext): Promise<FlagDetails<T, Code>>;
-}
-/**
- * A flag client without the OpenFeature SDK: `withOpenFeature({ client })`
- * from `@supabase-labs/middleware-openfeature` accepts it.
- */
-export declare function createFlagClient<Code extends string = FlagErrorCode>(source: FlagsProvider<Code> | FlagsProviderOptions<Code>): FlagClient<Code>;
-interface FlagContextSource {
-  /** `ctx.jwtClaims` from `withBetterSupabase`, or verified claims. */
-  readonly jwtClaims?: Readonly<Record<string, unknown>> | null | undefined;
-  /** The active tenant; default the `tenant_id` claim. */
-  readonly tenant?: string | null | undefined;
-}
-interface FlagContextOptions {
-  /** `config.claims.tenant`, default `tenant_id`. */
-  readonly tenantClaim?: string;
-  /** `config.claims.features`, default `features`. */
-  readonly featuresClaim?: string;
-  /** The claim the memberships hook writes, default `memberships`. */
-  readonly membershipsClaim?: string;
-  /**
-   * The scope of tenant memberships when the claim is a list of entries, as
-   * an authorization provider's hook may write it (`{ scope, id, roles }`). Without it, the entry
-   * for the tenant id that has no `within` (a root scope) is read.
-   */
-  readonly membershipScope?: string;
-  /** Reads the caller's roles in `tenant` from claims of another shape. */
-  readonly roles?: (claims: Readonly<Record<string, unknown>>, tenant: string) => string | readonly string[] | undefined;
-}
-/**
- * The evaluation context of a request: the user id as `targetingKey`, the
- * tenant, its plan features (`features` claim) and the caller's roles in it
- * (`memberships` claim, in the `tenant` module's or the list shape, or
- * `options.roles`). Pass it as `context` to `withOpenFeature`.
- */
-export declare function flagContext(source: FlagContextSource, options?: FlagContextOptions): RequestFlagContext;
-//#endregion
+import { t as AsyncResult, w as ErrorMapper } from "../../result-Cj3yWhjH.js";
+import { wt as Events, z as FlagEventData } from "../../events-CTreRrgP.js";
+import { n as Logger } from "../../logger-DWVYUmwi.js";
+import { t as StandardSchemaV1 } from "../../standard-C3_AAF3g.js";
+import { a as dbTransport, o as rpcTransport, s as sqlTransport, t as BlockTransport } from "../../block-transport-DaGGXjIw.js";
+import { n as BlockHooks } from "../../block-hooks-BLPWD3Jt.js";
+import { r as FieldsOf } from "../../block-fields-5UA84ZUg.js";
+import { s as BlockOf } from "../../define-block-CLZMEFeK.js";
+import { C as flagDefinitionsOf, S as flagContext, _ as RequestFlagContext, a as FlagDefinition, b as evaluateFlag, c as FlagEvaluation, d as FlagResolution, f as FlagRule, g as FlagsProviderOptions, h as FlagsProvider, i as FlagContextSource, l as FlagOverride, m as FlagValue, n as FlagContext, o as FlagDetails, p as FlagType, r as FlagContextOptions, s as FlagErrorCode, t as FlagClient, u as FlagReason, v as createFlagClient, x as flagBucket, y as createFlagsProvider } from "../../flags-D_D1jAHB.js";
 //#region src/blocks/flags/admin.d.ts
-interface FlagAdminOptions {
+interface FlagsOptions<S extends StandardSchemaV1 | undefined = undefined> {
   /**
    * The caller's transport: `rpcTransport(supabase, { schema: "api" })` for
    * platform staff over the Data API, or a service-role transport.
    */
   readonly transport: BlockTransport;
-  /** The module schema (`sql.modules.flags.schema`), default `better_supabase`. */
+  /** The module schema, or its API schema: `defineBlocks` passes it from `blocks.generated.ts`. Default `better_supabase`. */
   readonly schema?: string;
   readonly mappers?: readonly ErrorMapper[];
+  /**
+   * A Standard Schema for the flag's extra columns
+   * (`blocks.flags.options.extraColumns`), keyed by column name. It types
+   * and parses `fields` on `list` and `save`, and validates them on `save`.
+   */
+  readonly fields?: S;
+  /** `withBlockHooks` hooks around the methods, such as a review rule on `save`. */
+  readonly hooks?: NoInfer<BlockHooks<Flags<FieldsOf<S>>>>;
+  /** Receives the errors `after` hooks throw. */
+  readonly logger?: Logger;
 }
 /** The fields `save` writes; the ones left out keep their value. */
-interface FlagInput {
+interface FlagInput<F extends object = Record<never, never>> {
   readonly type?: FlagType;
   readonly description?: string | null;
   readonly variants?: Readonly<Record<string, FlagValue>>;
   readonly defaultVariant?: string;
   readonly enabled?: boolean;
+  /** Archives the flag: it serves its default variant and leaves Flags Explorer. */
+  readonly archived?: boolean;
   readonly rules?: readonly FlagRule[];
   /** 0 to 100. */
   readonly rolloutPercentage?: number;
   readonly rolloutVariant?: string | null;
+  /** Values for the extra columns, by column name. */
+  readonly fields?: Partial<F> & Readonly<Record<string, unknown>>;
 }
-/** The override target: one tenant or one user. */
+/** A flag as staff manage it: its definition and its extra columns. */
+type FlagRecord<F extends object = Record<never, never>> = FlagDefinition & {
+  /** The extra columns (`options.extraColumns`), by column name. */
+  readonly fields: Readonly<Record<string, unknown>> & F;
+};
+/** The override target: one tenant, one user or one custom context value. */
 type FlagOverrideTarget = {
   readonly organizationId: string;
   readonly userId?: never;
+  readonly context?: never;
 } | {
   readonly userId: string;
   readonly organizationId?: never;
+  readonly context?: never;
+} | {
+  /** A custom context, such as `brand`, and its value, such as `acme`. */
+  readonly context: string;
+  readonly contextKey: string;
+  readonly organizationId?: never;
+  readonly userId?: never;
 };
-interface FlagAdmin {
+/** `F` types the extra columns the `fields` schema describes. */
+interface Flags<F extends object = Record<never, never>> {
   /** Every flag with its overrides. */
-  list(): AsyncResult<readonly FlagDefinition[]>;
+  list(): AsyncResult<readonly FlagRecord<F>[]>;
   /** Creates or updates a flag; returns it as stored. */
-  save(key: string, input: FlagInput): AsyncResult<FlagDefinition | undefined>;
+  save(key: string, input: FlagInput<F>): AsyncResult<FlagRecord<F> | undefined>;
   /** `false` when there was no such flag. */
   remove(key: string): AsyncResult<boolean>;
-  /** Sets a tenant's or a user's variant; `null` removes the override. */
+  /** Sets the variant of a tenant, a user or a context value; `null` removes the override. */
   override(key: string, target: FlagOverrideTarget, variant: string | null): AsyncResult<boolean>;
 }
 /**
@@ -221,6 +81,20 @@ interface FlagAdmin {
  * role, through the `flags` module's `list_flags`, `save_flag`,
  * `delete_flag` and `set_flag_override`.
  */
-export declare function createFlagAdmin(options: FlagAdminOptions): FlagAdmin;
+export declare function createFlags<S extends StandardSchemaV1 | undefined = undefined>(options: FlagsOptions<S>): Flags<FieldsOf<S>>;
+//#endregion
+//#region src/blocks/flags/events.d.ts
+/** The events of the `flags` block: type to data. */
+type FlagsEvents = {
+  readonly "flag.saved": FlagEventData;
+  readonly "flag.deleted": FlagEventData;
+  readonly "flag.override_set": FlagEventData;
+};
+/** The `flags` block's event types, for its manifest and `onBlockEvent`. */
+export declare const flagsEvents: Events<FlagsEvents>;
+//#endregion
+//#region src/blocks/flags/manifest.d.ts
+/** The `flags` block's manifest (ADR 0029). */
+export declare const flagsBlock: BlockOf<"flags", typeof createFlags, FlagsEvents>;
 //#endregion
-export { type BlockTransport, type FlagAdmin, type FlagAdminOptions, type FlagClient, type FlagContext, type FlagContextOptions, type FlagContextSource, type FlagDefinition, type FlagDetails, type FlagErrorCode, type FlagEvaluation, type FlagInput, type FlagOverride, type FlagOverrideTarget, type FlagReason, type FlagResolution, type FlagRule, type FlagType, type FlagValue, type FlagsProvider, type FlagsProviderOptions, type RequestFlagContext, dbTransport, rpcTransport, sqlTransport };
+export { type BlockTransport, type FlagClient, type FlagContext, type FlagContextOptions, type FlagContextSource, type FlagDefinition, type FlagDetails, type FlagErrorCode, type FlagEvaluation, type FlagInput, type FlagOverride, type FlagOverrideTarget, type FlagReason, type FlagRecord, type FlagResolution, type FlagRule, type FlagType, type FlagValue, type Flags, type FlagsEvents, type FlagsOptions, type FlagsProvider, type FlagsProviderOptions, type RequestFlagContext, createFlagClient, createFlagsProvider, dbTransport, evaluateFlag, flagBucket, flagContext, flagDefinitionsOf, rpcTransport, sqlTransport };