@fanvue/builder-sdk 0.3.0 → 0.5.0

package/dist/{index-pS9wR5yg.d.ts → index-cf3ZMnLJ.d.ts}

@@ -1,837 +1,187 @@
-//#region src/core/constants.d.ts
-/** The `Bearer ` token prefix (includes trailing space). */
-declare const BEARER_PREFIX: "Bearer ";
-/** Response header carrying a refreshed session JWT back to the client. */
-declare const HEADER_UPDATED_SESSION: "X-Updated-Session";
-//#endregion
-//#region src/core/defaults.d.ts
-/** Default OAuth scopes requested during authorization. */
-declare const DEFAULT_SCOPES: "openid offline_access offline";
-/** Default OAuth issuer URL for Fanvue authentication. */
-declare const DEFAULT_ISSUER_URL: "https://auth.fanvue.com";
-/** Default base URL for the Fanvue API. */
-declare const DEFAULT_API_BASE_URL: "https://api.fanvue.com";
-/** Default base URL for the Fanvue platform (embedded authorize-on-behalf). */
-declare const DEFAULT_PLATFORM_URL: "https://www.fanvue.com";
-/** The Fanvue API version header value sent with every request. */
-declare const API_VERSION: "2025-06-26";
-/**
- * Validates that a URL belongs to the `fanvue.com` domain.
- *
- * @param url - The URL string to validate.
- * @throws If the URL is malformed or its hostname is not `fanvue.com`
- *   (or a subdomain of it).
- */
-declare function assertFanvueDomain(url: string): void;
+//#region node_modules/.pnpm/zod@4.3.6/node_modules/zod/v4/core/json-schema.d.cts
+type _JSONSchema = boolean | JSONSchema;
+type JSONSchema = {
+  [k: string]: unknown;
+  $schema?: "https://json-schema.org/draft/2020-12/schema" | "http://json-schema.org/draft-07/schema#" | "http://json-schema.org/draft-04/schema#";
+  $id?: string;
+  $anchor?: string;
+  $ref?: string;
+  $dynamicRef?: string;
+  $dynamicAnchor?: string;
+  $vocabulary?: Record<string, boolean>;
+  $comment?: string;
+  $defs?: Record<string, JSONSchema>;
+  type?: "object" | "array" | "string" | "number" | "boolean" | "null" | "integer";
+  additionalItems?: _JSONSchema;
+  unevaluatedItems?: _JSONSchema;
+  prefixItems?: _JSONSchema[];
+  items?: _JSONSchema | _JSONSchema[];
+  contains?: _JSONSchema;
+  additionalProperties?: _JSONSchema;
+  unevaluatedProperties?: _JSONSchema;
+  properties?: Record<string, _JSONSchema>;
+  patternProperties?: Record<string, _JSONSchema>;
+  dependentSchemas?: Record<string, _JSONSchema>;
+  propertyNames?: _JSONSchema;
+  if?: _JSONSchema;
+  then?: _JSONSchema;
+  else?: _JSONSchema;
+  allOf?: JSONSchema[];
+  anyOf?: JSONSchema[];
+  oneOf?: JSONSchema[];
+  not?: _JSONSchema;
+  multipleOf?: number;
+  maximum?: number;
+  exclusiveMaximum?: number | boolean;
+  minimum?: number;
+  exclusiveMinimum?: number | boolean;
+  maxLength?: number;
+  minLength?: number;
+  pattern?: string;
+  maxItems?: number;
+  minItems?: number;
+  uniqueItems?: boolean;
+  maxContains?: number;
+  minContains?: number;
+  maxProperties?: number;
+  minProperties?: number;
+  required?: string[];
+  dependentRequired?: Record<string, string[]>;
+  enum?: Array<string | number | boolean | null>;
+  const?: string | number | boolean | null;
+  id?: string;
+  title?: string;
+  description?: string;
+  default?: unknown;
+  deprecated?: boolean;
+  readOnly?: boolean;
+  writeOnly?: boolean;
+  nullable?: boolean;
+  examples?: unknown[];
+  format?: string;
+  contentMediaType?: string;
+  contentEncoding?: string;
+  contentSchema?: JSONSchema;
+  _prefault?: unknown;
+};
+type BaseSchema = JSONSchema;
 //#endregion
-//#region src/core/types.d.ts
-/**
- * Configuration for the OAuth client.
- *
- * @property clientId - The OAuth client ID.
- * @property clientSecret - The OAuth client secret.
- * @property redirectUri - The URI to redirect to after authentication.
- * @property issuerUrl - The OAuth issuer URL, or `null` to use the default.
- * @property apiBaseUrl - The Fanvue API base URL, or `null` to use the default.
- * @property scopes - Additional OAuth scopes to request beyond the defaults, or `null` for defaults only.
- * @property responseMode - The OAuth response mode (e.g., `fragment`), or `null` to omit.
- * @property prompt - The OAuth prompt parameter (e.g., `consent`), or `null` to omit.
- */
-interface OAuthConfig {
-  clientId: string;
-  clientSecret: string;
-  redirectUri: string;
-  issuerUrl: string | null;
-  apiBaseUrl: string | null;
-  scopes: string | null;
-  responseMode: string | null;
-  prompt: string | null;
+//#region node_modules/.pnpm/zod@4.3.6/node_modules/zod/v4/core/standard-schema.d.cts
+/** The Standard interface. */
+interface StandardTypedV1<Input = unknown, Output = Input> {
+  /** The Standard properties. */
+  readonly "~standard": StandardTypedV1.Props<Input, Output>;
 }
-/**
- * The raw token response returned by the OAuth token endpoint.
- *
- * @property access_token - The access token issued by the authorization server.
- * @property refresh_token - The refresh token, or `null` if not provided.
- * @property expires_in - The lifetime in seconds of the access token.
- * @property token_type - The type of the token (e.g., `Bearer`).
- * @property scope - The scope of the access token, or `null` if not provided.
- * @property id_token - The ID token, or `null` if not provided.
- */
-interface TokenResponse {
-  access_token: string;
-  refresh_token: string | null;
-  expires_in: number;
-  token_type: string;
-  scope: string | null;
-  id_token: string | null;
+declare namespace StandardTypedV1 {
+  /** The Standard properties interface. */
+  interface Props<Input = unknown, Output = Input> {
+    /** The version number of the standard. */
+    readonly version: 1;
+    /** The vendor name of the schema library. */
+    readonly vendor: string;
+    /** Inferred types associated with the schema. */
+    readonly types?: Types<Input, Output> | undefined;
+  }
+  /** The Standard types interface. */
+  interface Types<Input = unknown, Output = Input> {
+    /** The input type of the schema. */
+    readonly input: Input;
+    /** The output type of the schema. */
+    readonly output: Output;
+  }
+  /** Infers the input type of a Standard. */
+  type InferInput<Schema extends StandardTypedV1> = NonNullable<Schema["~standard"]["types"]>["input"];
+  /** Infers the output type of a Standard. */
+  type InferOutput<Schema extends StandardTypedV1> = NonNullable<Schema["~standard"]["types"]>["output"];
 }
-/**
- * The payload stored inside the encrypted session JWT.
- *
- * @property accessToken - The OAuth access token.
- * @property refreshToken - The OAuth refresh token, or `null` if unavailable.
- * @property expiresAt - The timestamp (in milliseconds) when the access token expires.
- * @property tokenType - The type of the token (e.g., `Bearer`), or `null` if unavailable.
- * @property scope - The granted scope, or `null` if unavailable.
- * @property idToken - The ID token, or `null` if unavailable.
- * @property userUuid - The unique identifier of the authenticated user.
- * @property handle - The user's handle/username.
- * @property displayName - The user's display name.
- * @property isCreator - Whether the user is a creator.
- * @property avatarUrl - The URL of the user's avatar, or `null` if not set.
- */
-interface SessionPayload {
-  accessToken: string;
-  refreshToken: string | null;
-  expiresAt: number;
-  tokenType: string | null;
-  scope: string | null;
-  idToken: string | null;
-  userUuid: string;
-  handle: string;
-  displayName: string;
-  isCreator: boolean;
-  avatarUrl: string | null;
+/** The Standard Schema interface. */
+interface StandardSchemaV1<Input = unknown, Output = Input> {
+  /** The Standard Schema properties. */
+  readonly "~standard": StandardSchemaV1.Props<Input, Output>;
 }
-/**
- * A Fanvue user profile as returned by the API.
- *
- * @property uuid - The unique identifier of the user.
- * @property email - The user's email address.
- * @property handle - The user's handle/username.
- * @property displayName - The user's display name.
- * @property isCreator - Whether the user is a creator.
- * @property avatarUrl - The URL of the user's avatar, or `null` if not set.
- * @property bannerUrl - The URL of the user's banner, or `null` if not set.
- * @property createdAt - The ISO 8601 timestamp of when the user was created.
- * @property updatedAt - The ISO 8601 timestamp of when the user was last updated, or `null`.
- */
-interface FanvueUser {
-  uuid: string;
-  email: string;
-  handle: string;
-  displayName: string;
-  isCreator: boolean;
-  avatarUrl: string | null;
-  bannerUrl: string | null;
-  createdAt: string;
-  updatedAt: string | null;
+declare namespace StandardSchemaV1 {
+  /** The Standard Schema properties interface. */
+  interface Props<Input = unknown, Output = Input> extends StandardTypedV1.Props<Input, Output> {
+    /** Validates unknown input values. */
+    readonly validate: (value: unknown, options?: StandardSchemaV1.Options | undefined) => Result<Output> | Promise<Result<Output>>;
+  }
+  /** The result interface of the validate function. */
+  type Result<Output> = SuccessResult<Output> | FailureResult;
+  /** The result interface if validation succeeds. */
+  interface SuccessResult<Output> {
+    /** The typed output value. */
+    readonly value: Output;
+    /** The absence of issues indicates success. */
+    readonly issues?: undefined;
+  }
+  interface Options {
+    /** Implicit support for additional vendor-specific parameters, if needed. */
+    readonly libraryOptions?: Record<string, unknown> | undefined;
+  }
+  /** The result interface if validation fails. */
+  interface FailureResult {
+    /** The issues of failed validation. */
+    readonly issues: ReadonlyArray<Issue>;
+  }
+  /** The issue interface of the failure output. */
+  interface Issue {
+    /** The error message of the issue. */
+    readonly message: string;
+    /** The path of the issue, if any. */
+    readonly path?: ReadonlyArray<PropertyKey | PathSegment> | undefined;
+  }
+  /** The path segment interface of the issue. */
+  interface PathSegment {
+    /** The key representing a path segment. */
+    readonly key: PropertyKey;
+  }
+  /** The Standard types interface. */
+  interface Types<Input = unknown, Output = Input> extends StandardTypedV1.Types<Input, Output> {}
+  /** Infers the input type of a Standard. */
+  type InferInput<Schema extends StandardTypedV1> = StandardTypedV1.InferInput<Schema>;
+  /** Infers the output type of a Standard. */
+  type InferOutput<Schema extends StandardTypedV1> = StandardTypedV1.InferOutput<Schema>;
 }
-/**
- * Configuration for the embedded-app (delegated authorize-on-behalf) flow.
- *
- * Extends {@link OAuthConfig} with the Fanvue platform base URL that hosts
- * the `authorize-on-behalf` endpoint.
- *
- * @property platformUrl - The Fanvue platform base URL, or `null` to use the default.
- */
-interface EmbeddedAuthConfig extends OAuthConfig {
-  platformUrl: string | null;
-}
-/** Error type for JSON parsing failures. */
-type JsonParseError = {
-  code: 'JSON_PARSE_ERROR';
-  rawText: string;
-  message: string;
-};
-/** Error type for OAuth operations (token exchange, refresh). */
-type OAuthError = {
-  code: 'TOKEN_EXCHANGE_FAILED';
-  statusCode: number;
-  message: string;
-} | {
-  code: 'TOKEN_REFRESH_FAILED';
-  statusCode: number;
-  message: string;
-} | {
-  code: 'OAUTH_JSON_PARSE_ERROR';
-  rawText: string;
-  message: string;
-} | {
-  code: 'OAUTH_VALIDATION_ERROR';
-  message: string;
-};
-/** Error type for Fanvue API requests. */
-type ApiError = {
-  code: 'API_REQUEST_FAILED';
-  statusCode: number;
-  message: string;
-} | {
-  code: 'API_JSON_PARSE_ERROR';
-  rawText: string;
-  message: string;
-} | {
-  code: 'API_VALIDATION_ERROR';
-  message: string;
-};
-/** Error type for session JWT verification. */
-type SessionVerifyError = {
-  code: 'JWT_VERIFY_FAILED';
-  message: string;
-} | {
-  code: 'SESSION_VALIDATION_ERROR';
-  message: string;
-};
-/**
- * Error type for the embedded authorize-on-behalf step.
- *
- * - `SESSION_TOKEN_REJECTED` — the platform rejected the session token
- *   (missing, malformed, or expired — they live ~60 seconds). The user must
- *   reopen the embedded surface to receive a fresh one.
- * - `CONSENT_REQUIRED` — the creator has not approved (or has revoked) the
- *   in-platform consent for this app. Consent is granted in the Fanvue UI;
- *   the app cannot create it.
- * - `AUTHORIZE_ON_BEHALF_FAILED` — any other failure (network error,
- *   unexpected status). `statusCode` is `0` for network errors.
- * - `AUTHORIZE_STATE_MISMATCH` — the returned `state` did not match the one
- *   sent; the response must not be trusted.
- */
-type EmbeddedAuthError = {
-  code: 'SESSION_TOKEN_REJECTED';
-  statusCode: number;
-  message: string;
-} | {
-  code: 'CONSENT_REQUIRED';
-  statusCode: number;
-  message: string;
-} | {
-  code: 'AUTHORIZE_ON_BEHALF_FAILED';
-  statusCode: number;
-  message: string;
-} | {
-  code: 'AUTHORIZE_STATE_MISMATCH';
-  message: string;
-} | {
-  code: 'EMBEDDED_JSON_PARSE_ERROR';
-  rawText: string;
-  message: string;
-} | {
-  code: 'EMBEDDED_VALIDATION_ERROR';
-  message: string;
-};
-//#endregion
-//#region node_modules/.pnpm/neverthrow@8.2.0/node_modules/neverthrow/dist/index.d.ts
-interface ErrorConfig {
-  withStackTrace: boolean;
+/** The Standard JSON Schema interface. */
+interface StandardJSONSchemaV1<Input = unknown, Output = Input> {
+  /** The Standard JSON Schema properties. */
+  readonly "~standard": StandardJSONSchemaV1.Props<Input, Output>;
 }
-declare class ResultAsync<T, E> implements PromiseLike<Result$1<T, E>> {
-  private _promise;
-  constructor(res: Promise<Result$1<T, E>>);
-  static fromSafePromise<T, E = never>(promise: PromiseLike<T>): ResultAsync<T, E>;
-  static fromPromise<T, E>(promise: PromiseLike<T>, errorFn: (e: unknown) => E): ResultAsync<T, E>;
-  static fromThrowable<A extends readonly any[], R, E>(fn: (...args: A) => Promise<R>, errorFn?: (err: unknown) => E): (...args: A) => ResultAsync<R, E>;
-  static combine<T extends readonly [ResultAsync<unknown, unknown>, ...ResultAsync<unknown, unknown>[]]>(asyncResultList: T): CombineResultAsyncs<T>;
-  static combine<T extends readonly ResultAsync<unknown, unknown>[]>(asyncResultList: T): CombineResultAsyncs<T>;
-  static combineWithAllErrors<T extends readonly [ResultAsync<unknown, unknown>, ...ResultAsync<unknown, unknown>[]]>(asyncResultList: T): CombineResultsWithAllErrorsArrayAsync<T>;
-  static combineWithAllErrors<T extends readonly ResultAsync<unknown, unknown>[]>(asyncResultList: T): CombineResultsWithAllErrorsArrayAsync<T>;
-  map<A>(f: (t: T) => A | Promise<A>): ResultAsync<A, E>;
-  andThrough<F>(f: (t: T) => Result$1<unknown, F> | ResultAsync<unknown, F>): ResultAsync<T, E | F>;
-  andTee(f: (t: T) => unknown): ResultAsync<T, E>;
-  orTee(f: (t: E) => unknown): ResultAsync<T, E>;
-  mapErr<U>(f: (e: E) => U | Promise<U>): ResultAsync<T, U>;
-  andThen<R extends Result$1<unknown, unknown>>(f: (t: T) => R): ResultAsync<InferOkTypes<R>, InferErrTypes<R> | E>;
-  andThen<R extends ResultAsync<unknown, unknown>>(f: (t: T) => R): ResultAsync<InferAsyncOkTypes<R>, InferAsyncErrTypes<R> | E>;
-  andThen<U, F>(f: (t: T) => Result$1<U, F> | ResultAsync<U, F>): ResultAsync<U, E | F>;
-  orElse<R extends Result$1<unknown, unknown>>(f: (e: E) => R): ResultAsync<InferOkTypes<R> | T, InferErrTypes<R>>;
-  orElse<R extends ResultAsync<unknown, unknown>>(f: (e: E) => R): ResultAsync<InferAsyncOkTypes<R> | T, InferAsyncErrTypes<R>>;
-  orElse<U, A>(f: (e: E) => Result$1<U, A> | ResultAsync<U, A>): ResultAsync<U | T, A>;
-  match<A, B = A>(ok: (t: T) => A, _err: (e: E) => B): Promise<A | B>;
-  unwrapOr<A>(t: A): Promise<T | A>;
-  /**
-   * @deprecated will be removed in 9.0.0.
-   *
-   * You can use `safeTry` without this method.
-   * @example
-   * ```typescript
-   * safeTry(async function* () {
-   *   const okValue = yield* yourResult
-   * })
-   * ```
-   * Emulates Rust's `?` operator in `safeTry`'s body. See also `safeTry`.
+declare namespace StandardJSONSchemaV1 {
+  /** The Standard JSON Schema properties interface. */
+  interface Props<Input = unknown, Output = Input> extends StandardTypedV1.Props<Input, Output> {
+    /** Methods for generating the input/output JSON Schema. */
+    readonly jsonSchema: Converter;
+  }
+  /** The Standard JSON Schema converter interface. */
+  interface Converter {
+    /** Converts the input type to JSON Schema. May throw if conversion is not supported. */
+    readonly input: (options: StandardJSONSchemaV1.Options) => Record<string, unknown>;
+    /** Converts the output type to JSON Schema. May throw if conversion is not supported. */
+    readonly output: (options: StandardJSONSchemaV1.Options) => Record<string, unknown>;
+  }
+  /** The target version of the generated JSON Schema.
+   *
+   * It is *strongly recommended* that implementers support `"draft-2020-12"` and `"draft-07"`, as they are both in wide use.
+   *
+   * The `"openapi-3.0"` target is intended as a standardized specifier for OpenAPI 3.0 which is a superset of JSON Schema `"draft-04"`.
+   *
+   * All other targets can be implemented on a best-effort basis. Libraries should throw if they don't support a specified target.
    */
-  safeUnwrap(): AsyncGenerator<Err<never, E>, T>;
-  then<A, B>(successCallback?: (res: Result$1<T, E>) => A | PromiseLike<A>, failureCallback?: (reason: unknown) => B | PromiseLike<B>): PromiseLike<A | B>;
-  [Symbol.asyncIterator](): AsyncGenerator<Err<never, E>, T>;
-}
-declare type CombineResultAsyncs<T extends readonly ResultAsync<unknown, unknown>[]> = IsLiteralArray<T> extends 1 ? TraverseAsync<UnwrapAsync<T>> : ResultAsync<ExtractOkAsyncTypes<T>, ExtractErrAsyncTypes<T>[number]>;
-declare type CombineResultsWithAllErrorsArrayAsync<T extends readonly ResultAsync<unknown, unknown>[]> = IsLiteralArray<T> extends 1 ? TraverseWithAllErrorsAsync<UnwrapAsync<T>> : ResultAsync<ExtractOkAsyncTypes<T>, ExtractErrAsyncTypes<T>[number][]>;
-declare type UnwrapAsync<T> = IsLiteralArray<T> extends 1 ? Writable<T> extends [infer H, ...infer Rest] ? H extends PromiseLike<infer HI> ? HI extends Result$1<unknown, unknown> ? [Dedup<HI>, ...UnwrapAsync<Rest>] : never : never : [] : T extends Array<infer A> ? A extends PromiseLike<infer HI> ? HI extends Result$1<infer L, infer R> ? Ok<L, R>[] : never : never : never;
-declare type TraverseAsync<T, Depth extends number = 5> = IsLiteralArray<T> extends 1 ? Combine<T, Depth> extends [infer Oks, infer Errs] ? ResultAsync<EmptyArrayToNever<Oks>, MembersToUnion<Errs>> : never : T extends Array<infer I> ? Combine<MemberListOf<I>, Depth> extends [infer Oks, infer Errs] ? Oks extends unknown[] ? Errs extends unknown[] ? ResultAsync<EmptyArrayToNever<Oks[number][]>, MembersToUnion<Errs[number][]>> : ResultAsync<EmptyArrayToNever<Oks[number][]>, Errs> : Errs extends unknown[] ? ResultAsync<Oks, MembersToUnion<Errs[number][]>> : ResultAsync<Oks, Errs> : never : never;
-declare type TraverseWithAllErrorsAsync<T, Depth extends number = 5> = TraverseAsync<T, Depth> extends ResultAsync<infer Oks, infer Errs> ? ResultAsync<Oks, Errs[]> : never;
-declare type Writable<T> = T extends ReadonlyArray<unknown> ? [...T] : T;
-declare type ExtractOkTypes<T extends readonly Result$1<unknown, unknown>[]> = { [idx in keyof T]: T[idx] extends Result$1<infer U, unknown> ? U : never };
-declare type ExtractOkAsyncTypes<T extends readonly ResultAsync<unknown, unknown>[]> = { [idx in keyof T]: T[idx] extends ResultAsync<infer U, unknown> ? U : never };
-declare type ExtractErrTypes<T extends readonly Result$1<unknown, unknown>[]> = { [idx in keyof T]: T[idx] extends Result$1<unknown, infer E> ? E : never };
-declare type ExtractErrAsyncTypes<T extends readonly ResultAsync<unknown, unknown>[]> = { [idx in keyof T]: T[idx] extends ResultAsync<unknown, infer E> ? E : never };
-declare type InferOkTypes<R> = R extends Result$1<infer T, unknown> ? T : never;
-declare type InferErrTypes<R> = R extends Result$1<unknown, infer E> ? E : never;
-declare type InferAsyncOkTypes<R> = R extends ResultAsync<infer T, unknown> ? T : never;
-declare type InferAsyncErrTypes<R> = R extends ResultAsync<unknown, infer E> ? E : never;
-declare namespace Result$1 {
-  /**
-   * Wraps a function with a try catch, creating a new function with the same
-   * arguments but returning `Ok` if successful, `Err` if the function throws
-   *
-   * @param fn function to wrap with ok on success or err on failure
-   * @param errorFn when an error is thrown, this will wrap the error result if provided
-   */
-  function fromThrowable<Fn extends (...args: readonly any[]) => any, E>(fn: Fn, errorFn?: (e: unknown) => E): (...args: Parameters<Fn>) => Result$1<ReturnType<Fn>, E>;
-  function combine<T extends readonly [Result$1<unknown, unknown>, ...Result$1<unknown, unknown>[]]>(resultList: T): CombineResults<T>;
-  function combine<T extends readonly Result$1<unknown, unknown>[]>(resultList: T): CombineResults<T>;
-  function combineWithAllErrors<T extends readonly [Result$1<unknown, unknown>, ...Result$1<unknown, unknown>[]]>(resultList: T): CombineResultsWithAllErrorsArray<T>;
-  function combineWithAllErrors<T extends readonly Result$1<unknown, unknown>[]>(resultList: T): CombineResultsWithAllErrorsArray<T>;
-}
-declare type Result$1<T, E> = Ok<T, E> | Err<T, E>;
-interface IResult<T, E> {
-  /**
-   * Used to check if a `Result` is an `OK`
-   *
-   * @returns `true` if the result is an `OK` variant of Result
-   */
-  isOk(): this is Ok<T, E>;
-  /**
-   * Used to check if a `Result` is an `Err`
-   *
-   * @returns `true` if the result is an `Err` variant of Result
-   */
-  isErr(): this is Err<T, E>;
-  /**
-   * Maps a `Result<T, E>` to `Result<U, E>`
-   * by applying a function to a contained `Ok` value, leaving an `Err` value
-   * untouched.
-   *
-   * @param f The function to apply an `OK` value
-   * @returns the result of applying `f` or an `Err` untouched
-   */
-  map<A>(f: (t: T) => A): Result$1<A, E>;
-  /**
-   * Maps a `Result<T, E>` to `Result<T, F>` by applying a function to a
-   * contained `Err` value, leaving an `Ok` value untouched.
-   *
-   * This function can be used to pass through a successful result while
-   * handling an error.
-   *
-   * @param f a function to apply to the error `Err` value
-   */
-  mapErr<U>(f: (e: E) => U): Result$1<T, U>;
-  /**
-   * Similar to `map` Except you must return a new `Result`.
-   *
-   * This is useful for when you need to do a subsequent computation using the
-   * inner `T` value, but that computation might fail.
-   * Additionally, `andThen` is really useful as a tool to flatten a
-   * `Result<Result<A, E2>, E1>` into a `Result<A, E2>` (see example below).
-   *
-   * @param f The function to apply to the current value
-   */
-  andThen<R extends Result$1<unknown, unknown>>(f: (t: T) => R): Result$1<InferOkTypes<R>, InferErrTypes<R> | E>;
-  andThen<U, F>(f: (t: T) => Result$1<U, F>): Result$1<U, E | F>;
-  /**
-   * This "tee"s the current value to an passed-in computation such as side
-   * effect functions but still returns the same current value as the result.
-   *
-   * This is useful when you want to pass the current result to your side-track
-   * work such as logging but want to continue main-track work after that.
-   * This method does not care about the result of the passed in computation.
-   *
-   * @param f The function to apply to the current value
-   */
-  andTee(f: (t: T) => unknown): Result$1<T, E>;
-  /**
-   * This "tee"s the current `Err` value to an passed-in computation such as side
-   * effect functions but still returns the same `Err` value as the result.
-   *
-   * This is useful when you want to pass the current `Err` value to your side-track
-   * work such as logging but want to continue error-track work after that.
-   * This method does not care about the result of the passed in computation.
-   *
-   * @param f The function to apply to the current `Err` value
-   */
-  orTee(f: (t: E) => unknown): Result$1<T, E>;
-  /**
-   * Similar to `andTee` except error result of the computation will be passed
-   * to the downstream in case of an error.
-   *
-   * This version is useful when you want to make side-effects but in case of an
-   * error, you want to pass the error to the downstream.
-   *
-   * @param f The function to apply to the current value
-   */
-  andThrough<R extends Result$1<unknown, unknown>>(f: (t: T) => R): Result$1<T, InferErrTypes<R> | E>;
-  andThrough<F>(f: (t: T) => Result$1<unknown, F>): Result$1<T, E | F>;
-  /**
-   * Takes an `Err` value and maps it to a `Result<T, SomeNewType>`.
-   *
-   * This is useful for error recovery.
-   *
-   *
-   * @param f  A function to apply to an `Err` value, leaving `Ok` values
-   * untouched.
-   */
-  orElse<R extends Result$1<unknown, unknown>>(f: (e: E) => R): Result$1<InferOkTypes<R> | T, InferErrTypes<R>>;
-  orElse<U, A>(f: (e: E) => Result$1<U, A>): Result$1<U | T, A>;
-  /**
-   * Similar to `map` Except you must return a new `Result`.
-   *
-   * This is useful for when you need to do a subsequent async computation using
-   * the inner `T` value, but that computation might fail. Must return a ResultAsync
-   *
-   * @param f The function that returns a `ResultAsync` to apply to the current
-   * value
-   */
-  asyncAndThen<U, F>(f: (t: T) => ResultAsync<U, F>): ResultAsync<U, E | F>;
-  /**
-   * Maps a `Result<T, E>` to `ResultAsync<U, E>`
-   * by applying an async function to a contained `Ok` value, leaving an `Err`
-   * value untouched.
-   *
-   * @param f An async function to apply an `OK` value
-   */
-  asyncMap<U>(f: (t: T) => Promise<U>): ResultAsync<U, E>;
-  /**
-   * Unwrap the `Ok` value, or return the default if there is an `Err`
-   *
-   * @param v the default value to return if there is an `Err`
-   */
-  unwrapOr<A>(v: A): T | A;
-  /**
-   *
-   * Given 2 functions (one for the `Ok` variant and one for the `Err` variant)
-   * execute the function that matches the `Result` variant.
-   *
-   * Match callbacks do not necessitate to return a `Result`, however you can
-   * return a `Result` if you want to.
-   *
-   * `match` is like chaining `map` and `mapErr`, with the distinction that
-   * with `match` both functions must have the same return type.
-   *
-   * @param ok
-   * @param err
-   */
-  match<A, B = A>(ok: (t: T) => A, err: (e: E) => B): A | B;
-  /**
-   * @deprecated will be removed in 9.0.0.
-   *
-   * You can use `safeTry` without this method.
-   * @example
-   * ```typescript
-   * safeTry(function* () {
-   *   const okValue = yield* yourResult
-   * })
-   * ```
-   * Emulates Rust's `?` operator in `safeTry`'s body. See also `safeTry`.
-   */
-  safeUnwrap(): Generator<Err<never, E>, T>;
-  /**
-   * **This method is unsafe, and should only be used in a test environments**
-   *
-   * Takes a `Result<T, E>` and returns a `T` when the result is an `Ok`, otherwise it throws a custom object.
-   *
-   * @param config
-   */
-  _unsafeUnwrap(config?: ErrorConfig): T;
-  /**
-   * **This method is unsafe, and should only be used in a test environments**
-   *
-   * takes a `Result<T, E>` and returns a `E` when the result is an `Err`,
-   * otherwise it throws a custom object.
-   *
-   * @param config
-   */
-  _unsafeUnwrapErr(config?: ErrorConfig): E;
-}
-declare class Ok<T, E> implements IResult<T, E> {
-  readonly value: T;
-  constructor(value: T);
-  isOk(): this is Ok<T, E>;
-  isErr(): this is Err<T, E>;
-  map<A>(f: (t: T) => A): Result$1<A, E>;
-  mapErr<U>(_f: (e: E) => U): Result$1<T, U>;
-  andThen<R extends Result$1<unknown, unknown>>(f: (t: T) => R): Result$1<InferOkTypes<R>, InferErrTypes<R> | E>;
-  andThen<U, F>(f: (t: T) => Result$1<U, F>): Result$1<U, E | F>;
-  andThrough<R extends Result$1<unknown, unknown>>(f: (t: T) => R): Result$1<T, InferErrTypes<R> | E>;
-  andThrough<F>(f: (t: T) => Result$1<unknown, F>): Result$1<T, E | F>;
-  andTee(f: (t: T) => unknown): Result$1<T, E>;
-  orTee(_f: (t: E) => unknown): Result$1<T, E>;
-  orElse<R extends Result$1<unknown, unknown>>(_f: (e: E) => R): Result$1<InferOkTypes<R> | T, InferErrTypes<R>>;
-  orElse<U, A>(_f: (e: E) => Result$1<U, A>): Result$1<U | T, A>;
-  asyncAndThen<U, F>(f: (t: T) => ResultAsync<U, F>): ResultAsync<U, E | F>;
-  asyncAndThrough<R extends ResultAsync<unknown, unknown>>(f: (t: T) => R): ResultAsync<T, InferAsyncErrTypes<R> | E>;
-  asyncAndThrough<F>(f: (t: T) => ResultAsync<unknown, F>): ResultAsync<T, E | F>;
-  asyncMap<U>(f: (t: T) => Promise<U>): ResultAsync<U, E>;
-  unwrapOr<A>(_v: A): T | A;
-  match<A, B = A>(ok: (t: T) => A, _err: (e: E) => B): A | B;
-  safeUnwrap(): Generator<Err<never, E>, T>;
-  _unsafeUnwrap(_?: ErrorConfig): T;
-  _unsafeUnwrapErr(config?: ErrorConfig): E;
-  [Symbol.iterator](): Generator<Err<never, E>, T>;
-}
-declare class Err<T, E> implements IResult<T, E> {
-  readonly error: E;
-  constructor(error: E);
-  isOk(): this is Ok<T, E>;
-  isErr(): this is Err<T, E>;
-  map<A>(_f: (t: T) => A): Result$1<A, E>;
-  mapErr<U>(f: (e: E) => U): Result$1<T, U>;
-  andThrough<F>(_f: (t: T) => Result$1<unknown, F>): Result$1<T, E | F>;
-  andTee(_f: (t: T) => unknown): Result$1<T, E>;
-  orTee(f: (t: E) => unknown): Result$1<T, E>;
-  andThen<R extends Result$1<unknown, unknown>>(_f: (t: T) => R): Result$1<InferOkTypes<R>, InferErrTypes<R> | E>;
-  andThen<U, F>(_f: (t: T) => Result$1<U, F>): Result$1<U, E | F>;
-  orElse<R extends Result$1<unknown, unknown>>(f: (e: E) => R): Result$1<InferOkTypes<R> | T, InferErrTypes<R>>;
-  orElse<U, A>(f: (e: E) => Result$1<U, A>): Result$1<U | T, A>;
-  asyncAndThen<U, F>(_f: (t: T) => ResultAsync<U, F>): ResultAsync<U, E | F>;
-  asyncAndThrough<F>(_f: (t: T) => ResultAsync<unknown, F>): ResultAsync<T, E | F>;
-  asyncMap<U>(_f: (t: T) => Promise<U>): ResultAsync<U, E>;
-  unwrapOr<A>(v: A): T | A;
-  match<A, B = A>(_ok: (t: T) => A, err: (e: E) => B): A | B;
-  safeUnwrap(): Generator<Err<never, E>, T>;
-  _unsafeUnwrap(config?: ErrorConfig): T;
-  _unsafeUnwrapErr(_?: ErrorConfig): E;
-  [Symbol.iterator](): Generator<Err<never, E>, T>;
-}
-declare type Prev = [never, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, ...0[]];
-declare type CollectResults<T, Collected extends unknown[] = [], Depth extends number = 50> = [Depth] extends [never] ? [] : T extends [infer H, ...infer Rest] ? H extends Result$1<infer L, infer R> ? CollectResults<Rest, [...Collected, [L, R]], Prev[Depth]> : never : Collected;
-declare type Transpose<A, Transposed extends unknown[][] = [], Depth extends number = 10> = A extends [infer T, ...infer Rest] ? T extends [infer L, infer R] ? Transposed extends [infer PL, infer PR] ? PL extends unknown[] ? PR extends unknown[] ? Transpose<Rest, [[...PL, L], [...PR, R]], Prev[Depth]> : never : never : Transpose<Rest, [[L], [R]], Prev[Depth]> : Transposed : Transposed;
-declare type Combine<T, Depth extends number = 5> = Transpose<CollectResults<T>, [], Depth> extends [infer L, infer R] ? [UnknownMembersToNever<L>, UnknownMembersToNever<R>] : Transpose<CollectResults<T>, [], Depth> extends [] ? [[], []] : never;
-declare type Dedup<T> = T extends Result$1<infer RL, infer RR> ? [unknown] extends [RL] ? Err<RL, RR> : Ok<RL, RR> : T;
-declare type MemberListOf<T> = ((T extends unknown ? (t: T) => T : never) extends infer U ? (U extends unknown ? (u: U) => unknown : never) extends ((v: infer V) => unknown) ? V : never : never) extends ((_: unknown) => infer W) ? [...MemberListOf<Exclude<T, W>>, W] : [];
-declare type EmptyArrayToNever<T, NeverArrayToNever extends number = 0> = T extends [] ? never : NeverArrayToNever extends 1 ? T extends [never, ...infer Rest] ? [EmptyArrayToNever<Rest>] extends [never] ? never : T : T : T;
-declare type UnknownMembersToNever<T> = T extends [infer H, ...infer R] ? [[unknown] extends [H] ? never : H, ...UnknownMembersToNever<R>] : T;
-declare type MembersToUnion<T> = T extends unknown[] ? T[number] : never;
-declare type IsLiteralArray<T> = T extends {
-  length: infer L;
-} ? L extends number ? number extends L ? 0 : 1 : 0 : 0;
-declare type Traverse<T, Depth extends number = 5> = Combine<T, Depth> extends [infer Oks, infer Errs] ? Result$1<EmptyArrayToNever<Oks, 1>, MembersToUnion<Errs>> : never;
-declare type TraverseWithAllErrors<T, Depth extends number = 5> = Traverse<T, Depth> extends Result$1<infer Oks, infer Errs> ? Result$1<Oks, Errs[]> : never;
-declare type CombineResults<T extends readonly Result$1<unknown, unknown>[]> = IsLiteralArray<T> extends 1 ? Traverse<T> : Result$1<ExtractOkTypes<T>, ExtractErrTypes<T>[number]>;
-declare type CombineResultsWithAllErrorsArray<T extends readonly Result$1<unknown, unknown>[]> = IsLiteralArray<T> extends 1 ? TraverseWithAllErrors<T> : Result$1<ExtractOkTypes<T>, ExtractErrTypes<T>[number][]>;
-//#endregion
-//#region src/core/oauth.d.ts
-/**
- * Builds an OAuth 2.0 authorization URL with PKCE parameters.
- *
- * @param config - The OAuth configuration.
- * @param opts - Optional overrides. Pass `state` to use a deterministic state value.
- * @returns The authorization URL, the PKCE code verifier, and the state parameter.
- */
-declare function createAuthorizationUrl(config: OAuthConfig, opts?: {
-  state: string | null;
-} | null): Promise<{
-  url: URL;
-  codeVerifier: string;
-  state: string;
-}>;
-/**
- * Exchanges an authorization code for tokens using the OAuth token endpoint.
- *
- * @param config - The OAuth configuration.
- * @param opts - The authorization code, PKCE code verifier, and optional redirect URI override.
- * @returns A `Result` containing `TokenResponse` on success or `OAuthError` on failure.
- */
-declare function exchangeCodeForToken(config: OAuthConfig, opts: {
-  code: string;
-  codeVerifier: string;
-  redirectUri: string | null;
-}): Promise<Result$1<TokenResponse, OAuthError>>;
-/**
- * Refreshes an access token using a refresh token.
- *
- * @param config - The OAuth configuration.
- * @param refreshToken - The refresh token to use.
- * @returns A `Result` containing `TokenResponse` on success or `OAuthError` on failure.
- */
-declare function refreshAccessToken(config: OAuthConfig, refreshToken: string): Promise<Result$1<TokenResponse, OAuthError>>;
-//#endregion
-//#region src/core/session.d.ts
-/**
- * Creates a signed JWT containing the given session payload.
- *
- * @param secret - The secret key used to sign the JWT.
- * @param payload - The session data to embed in the token.
- * @param expiresIn - How long until the token expires (e.g., `"30d"`), or `null` for the default (`"30d"`).
- * @returns The signed JWT string.
- */
-declare function createSessionJwt(secret: string, payload: SessionPayload, expiresIn?: string | null): Promise<string>;
-/**
- * Verifies a session JWT and returns the validated session payload.
- *
- * @param secret - The secret key used to verify the JWT signature.
- * @param token - The JWT string to verify.
- * @returns A {@link Result} containing the validated {@link SessionPayload}, or a {@link SessionVerifyError}.
- */
-declare function verifySessionJwt(secret: string, token: string): Promise<Result$1<SessionPayload, SessionVerifyError>>;
-//#endregion
-//#region src/core/embedded.d.ts
-/**
- * The creator's active colour scheme, as resolved by Fanvue.
- *
- * Fanvue resolves a creator's "system" preference to the scheme actually being
- * rendered, so this is always a definite value — never `'system'`.
- */
-type FanvueTheme = 'light' | 'dark';
-/**
- * Extracts the embedded session token from a URL.
- *
- * When Fanvue opens an embedded app, it loads the app's embed URL with a
- * short-lived session token appended as a `?token=` query parameter.
- *
- * @param url - The URL to read the token from (e.g. `window.location.href`).
- * @returns The session token, or `null` when absent or the URL is malformed.
- */
-declare function getSessionTokenFromUrl(url: string | URL): string | null;
-/**
- * Extracts the creator's active colour scheme from a URL.
- *
- * When Fanvue opens an embedded app, it appends the creator's resolved colour
- * scheme as a `?theme=` query parameter (`light` or `dark`), letting the app
- * theme-match Fanvue.
- *
- * @param url - The URL to read the theme from (e.g. `window.location.href`).
- * @returns The {@link FanvueTheme}, or `null` when absent, unrecognised, or the
- *   URL is malformed (e.g. the app was opened outside Fanvue).
- */
-declare function getThemeFromUrl(url: string | URL): FanvueTheme | null;
-/**
- * Requests an authorization code from the Fanvue platform on behalf of the
- * creator currently using the embedded app.
- *
- * This is the "authorize" half of the delegated flow: the platform verifies
- * the session token, runs the OAuth authorize as the creator, and returns the
- * resulting authorization code. The PKCE verifier and client secret never
- * leave the caller — only the challenge is sent.
- *
- * Most apps should use {@link exchangeSessionToken}, which composes this with
- * the code exchange.
- *
- * @param config - The embedded auth configuration.
- * @param sessionToken - The short-lived session token received in the iframe.
- * @param opts - The PKCE code challenge and state to bind the code to.
- * @returns A `Result` containing the authorization code on success or
- *   {@link EmbeddedAuthError} on failure.
- */
-declare function requestAuthorizationCodeOnBehalf(config: EmbeddedAuthConfig, sessionToken: string, opts: {
-  codeChallenge: string;
-  state: string;
-}): Promise<Result$1<{
-  code: string;
-}, EmbeddedAuthError>>;
-/**
- * Exchanges an embedded session token for OAuth access and refresh tokens.
- *
- * Runs the complete delegated authorize-on-behalf flow:
- *
- * 1. Generates a PKCE verifier/challenge pair and a random `state`.
- * 2. Asks the Fanvue platform to authorize as the creator
- *    ({@link requestAuthorizationCodeOnBehalf}).
- * 3. Exchanges the returned code at the token endpoint using the client
- *    secret and PKCE verifier.
- *
- * Must run server-side: it uses the client secret. The session token should
- * be used promptly — it expires after ~60 seconds.
- *
- * @param config - The embedded auth configuration. `redirectUri` must be a
- *   redirect URI registered on the OAuth client (it is never visited; it only
- *   binds the authorization code).
- * @param sessionToken - The short-lived session token received in the iframe.
- * @returns A `Result` containing {@link TokenResponse} on success or an
- *   {@link EmbeddedAuthError} / {@link OAuthError} on failure.
- */
-declare function exchangeSessionToken(config: EmbeddedAuthConfig, sessionToken: string): Promise<Result$1<TokenResponse, EmbeddedAuthError | OAuthError>>;
-//#endregion
-//#region src/core/json.d.ts
-/**
- * Safely parses a JSON string, returning a `Result` instead of throwing.
- *
- * @param text - The raw text to parse as JSON.
- * @returns `ok(parsed)` on success, or `err({ code, rawText, message })` on failure.
- */
-declare function safeJsonParse(text: string): Result$1<unknown, JsonParseError>;
-//#endregion
-//#region node_modules/.pnpm/zod@4.3.6/node_modules/zod/v4/core/json-schema.d.cts
-type _JSONSchema = boolean | JSONSchema;
-type JSONSchema = {
-  [k: string]: unknown;
-  $schema?: "https://json-schema.org/draft/2020-12/schema" | "http://json-schema.org/draft-07/schema#" | "http://json-schema.org/draft-04/schema#";
-  $id?: string;
-  $anchor?: string;
-  $ref?: string;
-  $dynamicRef?: string;
-  $dynamicAnchor?: string;
-  $vocabulary?: Record<string, boolean>;
-  $comment?: string;
-  $defs?: Record<string, JSONSchema>;
-  type?: "object" | "array" | "string" | "number" | "boolean" | "null" | "integer";
-  additionalItems?: _JSONSchema;
-  unevaluatedItems?: _JSONSchema;
-  prefixItems?: _JSONSchema[];
-  items?: _JSONSchema | _JSONSchema[];
-  contains?: _JSONSchema;
-  additionalProperties?: _JSONSchema;
-  unevaluatedProperties?: _JSONSchema;
-  properties?: Record<string, _JSONSchema>;
-  patternProperties?: Record<string, _JSONSchema>;
-  dependentSchemas?: Record<string, _JSONSchema>;
-  propertyNames?: _JSONSchema;
-  if?: _JSONSchema;
-  then?: _JSONSchema;
-  else?: _JSONSchema;
-  allOf?: JSONSchema[];
-  anyOf?: JSONSchema[];
-  oneOf?: JSONSchema[];
-  not?: _JSONSchema;
-  multipleOf?: number;
-  maximum?: number;
-  exclusiveMaximum?: number | boolean;
-  minimum?: number;
-  exclusiveMinimum?: number | boolean;
-  maxLength?: number;
-  minLength?: number;
-  pattern?: string;
-  maxItems?: number;
-  minItems?: number;
-  uniqueItems?: boolean;
-  maxContains?: number;
-  minContains?: number;
-  maxProperties?: number;
-  minProperties?: number;
-  required?: string[];
-  dependentRequired?: Record<string, string[]>;
-  enum?: Array<string | number | boolean | null>;
-  const?: string | number | boolean | null;
-  id?: string;
-  title?: string;
-  description?: string;
-  default?: unknown;
-  deprecated?: boolean;
-  readOnly?: boolean;
-  writeOnly?: boolean;
-  nullable?: boolean;
-  examples?: unknown[];
-  format?: string;
-  contentMediaType?: string;
-  contentEncoding?: string;
-  contentSchema?: JSONSchema;
-  _prefault?: unknown;
-};
-type BaseSchema = JSONSchema;
-//#endregion
-//#region node_modules/.pnpm/zod@4.3.6/node_modules/zod/v4/core/standard-schema.d.cts
-/** The Standard interface. */
-interface StandardTypedV1<Input = unknown, Output = Input> {
-  /** The Standard properties. */
-  readonly "~standard": StandardTypedV1.Props<Input, Output>;
-}
-declare namespace StandardTypedV1 {
-  /** The Standard properties interface. */
-  interface Props<Input = unknown, Output = Input> {
-    /** The version number of the standard. */
-    readonly version: 1;
-    /** The vendor name of the schema library. */
-    readonly vendor: string;
-    /** Inferred types associated with the schema. */
-    readonly types?: Types<Input, Output> | undefined;
-  }
-  /** The Standard types interface. */
-  interface Types<Input = unknown, Output = Input> {
-    /** The input type of the schema. */
-    readonly input: Input;
-    /** The output type of the schema. */
-    readonly output: Output;
-  }
-  /** Infers the input type of a Standard. */
-  type InferInput<Schema extends StandardTypedV1> = NonNullable<Schema["~standard"]["types"]>["input"];
-  /** Infers the output type of a Standard. */
-  type InferOutput<Schema extends StandardTypedV1> = NonNullable<Schema["~standard"]["types"]>["output"];
-}
-/** The Standard Schema interface. */
-interface StandardSchemaV1<Input = unknown, Output = Input> {
-  /** The Standard Schema properties. */
-  readonly "~standard": StandardSchemaV1.Props<Input, Output>;
-}
-declare namespace StandardSchemaV1 {
-  /** The Standard Schema properties interface. */
-  interface Props<Input = unknown, Output = Input> extends StandardTypedV1.Props<Input, Output> {
-    /** Validates unknown input values. */
-    readonly validate: (value: unknown, options?: StandardSchemaV1.Options | undefined) => Result<Output> | Promise<Result<Output>>;
-  }
-  /** The result interface of the validate function. */
-  type Result<Output> = SuccessResult<Output> | FailureResult;
-  /** The result interface if validation succeeds. */
-  interface SuccessResult<Output> {
-    /** The typed output value. */
-    readonly value: Output;
-    /** The absence of issues indicates success. */
-    readonly issues?: undefined;
-  }
-  interface Options {
-    /** Implicit support for additional vendor-specific parameters, if needed. */
-    readonly libraryOptions?: Record<string, unknown> | undefined;
-  }
-  /** The result interface if validation fails. */
-  interface FailureResult {
-    /** The issues of failed validation. */
-    readonly issues: ReadonlyArray<Issue>;
-  }
-  /** The issue interface of the failure output. */
-  interface Issue {
-    /** The error message of the issue. */
-    readonly message: string;
-    /** The path of the issue, if any. */
-    readonly path?: ReadonlyArray<PropertyKey | PathSegment> | undefined;
-  }
-  /** The path segment interface of the issue. */
-  interface PathSegment {
-    /** The key representing a path segment. */
-    readonly key: PropertyKey;
-  }
-  /** The Standard types interface. */
-  interface Types<Input = unknown, Output = Input> extends StandardTypedV1.Types<Input, Output> {}
-  /** Infers the input type of a Standard. */
-  type InferInput<Schema extends StandardTypedV1> = StandardTypedV1.InferInput<Schema>;
-  /** Infers the output type of a Standard. */
-  type InferOutput<Schema extends StandardTypedV1> = StandardTypedV1.InferOutput<Schema>;
-}
-/** The Standard JSON Schema interface. */
-interface StandardJSONSchemaV1<Input = unknown, Output = Input> {
-  /** The Standard JSON Schema properties. */
-  readonly "~standard": StandardJSONSchemaV1.Props<Input, Output>;
-}
-declare namespace StandardJSONSchemaV1 {
-  /** The Standard JSON Schema properties interface. */
-  interface Props<Input = unknown, Output = Input> extends StandardTypedV1.Props<Input, Output> {
-    /** Methods for generating the input/output JSON Schema. */
-    readonly jsonSchema: Converter;
-  }
-  /** The Standard JSON Schema converter interface. */
-  interface Converter {
-    /** Converts the input type to JSON Schema. May throw if conversion is not supported. */
-    readonly input: (options: StandardJSONSchemaV1.Options) => Record<string, unknown>;
-    /** Converts the output type to JSON Schema. May throw if conversion is not supported. */
-    readonly output: (options: StandardJSONSchemaV1.Options) => Record<string, unknown>;
-  }
-  /** The target version of the generated JSON Schema.
-   *
-   * It is *strongly recommended* that implementers support `"draft-2020-12"` and `"draft-07"`, as they are both in wide use.
-   *
-   * The `"openapi-3.0"` target is intended as a standardized specifier for OpenAPI 3.0 which is a superset of JSON Schema `"draft-04"`.
-   *
-   * All other targets can be implemented on a best-effort basis. Libraries should throw if they don't support a specified target.
-   */
-  type Target = "draft-2020-12" | "draft-07" | "openapi-3.0" | ({} & string);
-  /** The options for the input/output methods. */
-  interface Options {
-    /** Specifies the target version of the generated JSON Schema. Support for all versions is on a best-effort basis. If a given version is not supported, the library should throw. */
-    readonly target: Target;
-    /** Implicit support for additional vendor-specific parameters, if needed. */
-    readonly libraryOptions?: Record<string, unknown> | undefined;
-  }
-  /** The Standard types interface. */
-  interface Types<Input = unknown, Output = Input> extends StandardTypedV1.Types<Input, Output> {}
-  /** Infers the input type of a Standard. */
-  type InferInput<Schema extends StandardTypedV1> = StandardTypedV1.InferInput<Schema>;
-  /** Infers the output type of a Standard. */
-  type InferOutput<Schema extends StandardTypedV1> = StandardTypedV1.InferOutput<Schema>;
+  type Target = "draft-2020-12" | "draft-07" | "openapi-3.0" | ({} & string);
+  /** The options for the input/output methods. */
+  interface Options {
+    /** Specifies the target version of the generated JSON Schema. Support for all versions is on a best-effort basis. If a given version is not supported, the library should throw. */
+    readonly target: Target;
+    /** Implicit support for additional vendor-specific parameters, if needed. */
+    readonly libraryOptions?: Record<string, unknown> | undefined;
+  }
+  /** The Standard types interface. */
+  interface Types<Input = unknown, Output = Input> extends StandardTypedV1.Types<Input, Output> {}
+  /** Infers the input type of a Standard. */
+  type InferInput<Schema extends StandardTypedV1> = StandardTypedV1.InferInput<Schema>;
+  /** Infers the output type of a Standard. */
+  type InferOutput<Schema extends StandardTypedV1> = StandardTypedV1.InferOutput<Schema>;
 }
 interface StandardSchemaWithJSONProps<Input = unknown, Output = Input> extends StandardSchemaV1.Props<Input, Output>, StandardJSONSchemaV1.Props<Input, Output> {}
 //#endregion
@@ -1527,6 +877,18 @@ interface $ZodUnion<T extends readonly SomeType[] = readonly $ZodType[]> extends
   _zod: $ZodUnionInternals<T>;
 }
 declare const $ZodUnion: $constructor<$ZodUnion>;
+interface $ZodDiscriminatedUnionDef<Options extends readonly SomeType[] = readonly $ZodType[], Disc extends string = string> extends $ZodUnionDef<Options> {
+  discriminator: Disc;
+  unionFallback?: boolean;
+}
+interface $ZodDiscriminatedUnionInternals<Options extends readonly SomeType[] = readonly $ZodType[], Disc extends string = string> extends $ZodUnionInternals<Options> {
+  def: $ZodDiscriminatedUnionDef<Options, Disc>;
+  propValues: PropValues;
+}
+interface $ZodDiscriminatedUnion<Options extends readonly SomeType[] = readonly $ZodType[], Disc extends string = string> extends $ZodType {
+  _zod: $ZodDiscriminatedUnionInternals<Options, Disc>;
+}
+declare const $ZodDiscriminatedUnion: $constructor<$ZodDiscriminatedUnion>;
 interface $ZodIntersectionDef<Left extends SomeType = $ZodType, Right extends SomeType = $ZodType> extends $ZodTypeDef {
   type: "intersection";
   left: Left;
@@ -2563,6 +1925,12 @@ interface ZodString extends _ZodString<$ZodStringInternals<string>> {
   duration(params?: string | $ZodCheckISODurationParams): this;
 }
 declare const ZodString: $constructor<ZodString>;
+interface ZodStringFormat<Format extends string = string> extends _ZodString<$ZodStringFormatInternals<Format>> {}
+declare const ZodStringFormat: $constructor<ZodStringFormat>;
+interface ZodURL extends ZodStringFormat<"url"> {
+  _zod: $ZodURLInternals;
+}
+declare const ZodURL: $constructor<ZodURL>;
 interface _ZodNumber<Internals extends $ZodNumberInternals = $ZodNumberInternals> extends _ZodType<Internals> {
   gt(value: number, params?: string | $ZodCheckGreaterThanParams): this;
   /** Identical to .min() */
@@ -2598,6 +1966,8 @@ declare const ZodNumber: $constructor<ZodNumber>;
 interface _ZodBoolean<T extends $ZodBooleanInternals = $ZodBooleanInternals> extends _ZodType<T> {}
 interface ZodBoolean extends _ZodBoolean<$ZodBooleanInternals<boolean>> {}
 declare const ZodBoolean: $constructor<ZodBoolean>;
+interface ZodUnknown extends _ZodType<$ZodUnknownInternals> {}
+declare const ZodUnknown: $constructor<ZodUnknown>;
 interface ZodArray<T extends SomeType = $ZodType> extends _ZodType<$ZodArrayInternals<T>>, $ZodArray<T> {
   element: T;
   min(minLength: number, params?: string | $ZodCheckMinLengthParams): this;
@@ -2642,10 +2012,22 @@ interface ZodUnion<T extends readonly SomeType[] = readonly $ZodType[]> extends
   options: T;
 }
 declare const ZodUnion: $constructor<ZodUnion>;
+interface ZodDiscriminatedUnion<Options extends readonly SomeType[] = readonly $ZodType[], Disc extends string = string> extends ZodUnion<Options>, $ZodDiscriminatedUnion<Options, Disc> {
+  "~standard": ZodStandardSchemaWithJSON<this>;
+  _zod: $ZodDiscriminatedUnionInternals<Options, Disc>;
+  def: $ZodDiscriminatedUnionDef<Options, Disc>;
+}
+declare const ZodDiscriminatedUnion: $constructor<ZodDiscriminatedUnion>;
 interface ZodIntersection<A extends SomeType = $ZodType, B extends SomeType = $ZodType> extends _ZodType<$ZodIntersectionInternals<A, B>>, $ZodIntersection<A, B> {
   "~standard": ZodStandardSchemaWithJSON<this>;
 }
 declare const ZodIntersection: $constructor<ZodIntersection>;
+interface ZodRecord<Key extends $ZodRecordKey = $ZodRecordKey, Value extends SomeType = $ZodType> extends _ZodType<$ZodRecordInternals<Key, Value>>, $ZodRecord<Key, Value> {
+  "~standard": ZodStandardSchemaWithJSON<this>;
+  keyType: Key;
+  valueType: Value;
+}
+declare const ZodRecord: $constructor<ZodRecord>;
 interface ZodEnum< /** @ts-ignore Cast variance */out T extends EnumLike = EnumLike> extends _ZodType<$ZodEnumInternals<T>>, $ZodEnum<T> {
   "~standard": ZodStandardSchemaWithJSON<this>;
   enum: T;
@@ -2654,6 +2036,13 @@ interface ZodEnum< /** @ts-ignore Cast variance */out T extends EnumLike = EnumL
   exclude<const U extends readonly (keyof T)[]>(values: U, params?: string | $ZodEnumParams): ZodEnum<Flatten<Omit<T, U[number]>>>;
 }
 declare const ZodEnum: $constructor<ZodEnum>;
+interface ZodLiteral<T extends Literal = Literal> extends _ZodType<$ZodLiteralInternals<T>>, $ZodLiteral<T> {
+  "~standard": ZodStandardSchemaWithJSON<this>;
+  values: Set<T>;
+  /** @legacy Use `.values` instead. Accessing this property will throw an error if the literal accepts multiple values. */
+  value: T;
+}
+declare const ZodLiteral: $constructor<ZodLiteral>;
 interface ZodTransform<O = unknown, I = unknown> extends _ZodType<$ZodTransformInternals<O, I>>, $ZodTransform<O, I> {
   "~standard": ZodStandardSchemaWithJSON<this>;
 }
@@ -2696,81 +2085,315 @@ interface ZodCatch<T extends SomeType = $ZodType> extends _ZodType<$ZodCatchInte
   /** @deprecated Use `.unwrap()` instead. */
   removeCatch(): T;
 }
-declare const ZodCatch: $constructor<ZodCatch>;
-interface ZodPipe<A extends SomeType = $ZodType, B extends SomeType = $ZodType> extends _ZodType<$ZodPipeInternals<A, B>>, $ZodPipe<A, B> {
-  "~standard": ZodStandardSchemaWithJSON<this>;
-  in: A;
-  out: B;
+declare const ZodCatch: $constructor<ZodCatch>;
+interface ZodPipe<A extends SomeType = $ZodType, B extends SomeType = $ZodType> extends _ZodType<$ZodPipeInternals<A, B>>, $ZodPipe<A, B> {
+  "~standard": ZodStandardSchemaWithJSON<this>;
+  in: A;
+  out: B;
+}
+declare const ZodPipe: $constructor<ZodPipe>;
+interface ZodReadonly<T extends SomeType = $ZodType> extends _ZodType<$ZodReadonlyInternals<T>>, $ZodReadonly<T> {
+  "~standard": ZodStandardSchemaWithJSON<this>;
+  unwrap(): T;
+}
+declare const ZodReadonly: $constructor<ZodReadonly>;
+//#endregion
+//#region node_modules/.pnpm/neverthrow@8.2.0/node_modules/neverthrow/dist/index.d.ts
+interface ErrorConfig {
+  withStackTrace: boolean;
+}
+declare class ResultAsync<T, E> implements PromiseLike<Result$1<T, E>> {
+  private _promise;
+  constructor(res: Promise<Result$1<T, E>>);
+  static fromSafePromise<T, E = never>(promise: PromiseLike<T>): ResultAsync<T, E>;
+  static fromPromise<T, E>(promise: PromiseLike<T>, errorFn: (e: unknown) => E): ResultAsync<T, E>;
+  static fromThrowable<A extends readonly any[], R, E>(fn: (...args: A) => Promise<R>, errorFn?: (err: unknown) => E): (...args: A) => ResultAsync<R, E>;
+  static combine<T extends readonly [ResultAsync<unknown, unknown>, ...ResultAsync<unknown, unknown>[]]>(asyncResultList: T): CombineResultAsyncs<T>;
+  static combine<T extends readonly ResultAsync<unknown, unknown>[]>(asyncResultList: T): CombineResultAsyncs<T>;
+  static combineWithAllErrors<T extends readonly [ResultAsync<unknown, unknown>, ...ResultAsync<unknown, unknown>[]]>(asyncResultList: T): CombineResultsWithAllErrorsArrayAsync<T>;
+  static combineWithAllErrors<T extends readonly ResultAsync<unknown, unknown>[]>(asyncResultList: T): CombineResultsWithAllErrorsArrayAsync<T>;
+  map<A>(f: (t: T) => A | Promise<A>): ResultAsync<A, E>;
+  andThrough<F>(f: (t: T) => Result$1<unknown, F> | ResultAsync<unknown, F>): ResultAsync<T, E | F>;
+  andTee(f: (t: T) => unknown): ResultAsync<T, E>;
+  orTee(f: (t: E) => unknown): ResultAsync<T, E>;
+  mapErr<U>(f: (e: E) => U | Promise<U>): ResultAsync<T, U>;
+  andThen<R extends Result$1<unknown, unknown>>(f: (t: T) => R): ResultAsync<InferOkTypes<R>, InferErrTypes<R> | E>;
+  andThen<R extends ResultAsync<unknown, unknown>>(f: (t: T) => R): ResultAsync<InferAsyncOkTypes<R>, InferAsyncErrTypes<R> | E>;
+  andThen<U, F>(f: (t: T) => Result$1<U, F> | ResultAsync<U, F>): ResultAsync<U, E | F>;
+  orElse<R extends Result$1<unknown, unknown>>(f: (e: E) => R): ResultAsync<InferOkTypes<R> | T, InferErrTypes<R>>;
+  orElse<R extends ResultAsync<unknown, unknown>>(f: (e: E) => R): ResultAsync<InferAsyncOkTypes<R> | T, InferAsyncErrTypes<R>>;
+  orElse<U, A>(f: (e: E) => Result$1<U, A> | ResultAsync<U, A>): ResultAsync<U | T, A>;
+  match<A, B = A>(ok: (t: T) => A, _err: (e: E) => B): Promise<A | B>;
+  unwrapOr<A>(t: A): Promise<T | A>;
+  /**
+   * @deprecated will be removed in 9.0.0.
+   *
+   * You can use `safeTry` without this method.
+   * @example
+   * ```typescript
+   * safeTry(async function* () {
+   *   const okValue = yield* yourResult
+   * })
+   * ```
+   * Emulates Rust's `?` operator in `safeTry`'s body. See also `safeTry`.
+   */
+  safeUnwrap(): AsyncGenerator<Err<never, E>, T>;
+  then<A, B>(successCallback?: (res: Result$1<T, E>) => A | PromiseLike<A>, failureCallback?: (reason: unknown) => B | PromiseLike<B>): PromiseLike<A | B>;
+  [Symbol.asyncIterator](): AsyncGenerator<Err<never, E>, T>;
+}
+declare type CombineResultAsyncs<T extends readonly ResultAsync<unknown, unknown>[]> = IsLiteralArray<T> extends 1 ? TraverseAsync<UnwrapAsync<T>> : ResultAsync<ExtractOkAsyncTypes<T>, ExtractErrAsyncTypes<T>[number]>;
+declare type CombineResultsWithAllErrorsArrayAsync<T extends readonly ResultAsync<unknown, unknown>[]> = IsLiteralArray<T> extends 1 ? TraverseWithAllErrorsAsync<UnwrapAsync<T>> : ResultAsync<ExtractOkAsyncTypes<T>, ExtractErrAsyncTypes<T>[number][]>;
+declare type UnwrapAsync<T> = IsLiteralArray<T> extends 1 ? Writable<T> extends [infer H, ...infer Rest] ? H extends PromiseLike<infer HI> ? HI extends Result$1<unknown, unknown> ? [Dedup<HI>, ...UnwrapAsync<Rest>] : never : never : [] : T extends Array<infer A> ? A extends PromiseLike<infer HI> ? HI extends Result$1<infer L, infer R> ? Ok<L, R>[] : never : never : never;
+declare type TraverseAsync<T, Depth extends number = 5> = IsLiteralArray<T> extends 1 ? Combine<T, Depth> extends [infer Oks, infer Errs] ? ResultAsync<EmptyArrayToNever<Oks>, MembersToUnion<Errs>> : never : T extends Array<infer I> ? Combine<MemberListOf<I>, Depth> extends [infer Oks, infer Errs] ? Oks extends unknown[] ? Errs extends unknown[] ? ResultAsync<EmptyArrayToNever<Oks[number][]>, MembersToUnion<Errs[number][]>> : ResultAsync<EmptyArrayToNever<Oks[number][]>, Errs> : Errs extends unknown[] ? ResultAsync<Oks, MembersToUnion<Errs[number][]>> : ResultAsync<Oks, Errs> : never : never;
+declare type TraverseWithAllErrorsAsync<T, Depth extends number = 5> = TraverseAsync<T, Depth> extends ResultAsync<infer Oks, infer Errs> ? ResultAsync<Oks, Errs[]> : never;
+declare type Writable<T> = T extends ReadonlyArray<unknown> ? [...T] : T;
+declare type ExtractOkTypes<T extends readonly Result$1<unknown, unknown>[]> = { [idx in keyof T]: T[idx] extends Result$1<infer U, unknown> ? U : never };
+declare type ExtractOkAsyncTypes<T extends readonly ResultAsync<unknown, unknown>[]> = { [idx in keyof T]: T[idx] extends ResultAsync<infer U, unknown> ? U : never };
+declare type ExtractErrTypes<T extends readonly Result$1<unknown, unknown>[]> = { [idx in keyof T]: T[idx] extends Result$1<unknown, infer E> ? E : never };
+declare type ExtractErrAsyncTypes<T extends readonly ResultAsync<unknown, unknown>[]> = { [idx in keyof T]: T[idx] extends ResultAsync<unknown, infer E> ? E : never };
+declare type InferOkTypes<R> = R extends Result$1<infer T, unknown> ? T : never;
+declare type InferErrTypes<R> = R extends Result$1<unknown, infer E> ? E : never;
+declare type InferAsyncOkTypes<R> = R extends ResultAsync<infer T, unknown> ? T : never;
+declare type InferAsyncErrTypes<R> = R extends ResultAsync<unknown, infer E> ? E : never;
+declare namespace Result$1 {
+  /**
+   * Wraps a function with a try catch, creating a new function with the same
+   * arguments but returning `Ok` if successful, `Err` if the function throws
+   *
+   * @param fn function to wrap with ok on success or err on failure
+   * @param errorFn when an error is thrown, this will wrap the error result if provided
+   */
+  function fromThrowable<Fn extends (...args: readonly any[]) => any, E>(fn: Fn, errorFn?: (e: unknown) => E): (...args: Parameters<Fn>) => Result$1<ReturnType<Fn>, E>;
+  function combine<T extends readonly [Result$1<unknown, unknown>, ...Result$1<unknown, unknown>[]]>(resultList: T): CombineResults<T>;
+  function combine<T extends readonly Result$1<unknown, unknown>[]>(resultList: T): CombineResults<T>;
+  function combineWithAllErrors<T extends readonly [Result$1<unknown, unknown>, ...Result$1<unknown, unknown>[]]>(resultList: T): CombineResultsWithAllErrorsArray<T>;
+  function combineWithAllErrors<T extends readonly Result$1<unknown, unknown>[]>(resultList: T): CombineResultsWithAllErrorsArray<T>;
+}
+declare type Result$1<T, E> = Ok<T, E> | Err<T, E>;
+interface IResult<T, E> {
+  /**
+   * Used to check if a `Result` is an `OK`
+   *
+   * @returns `true` if the result is an `OK` variant of Result
+   */
+  isOk(): this is Ok<T, E>;
+  /**
+   * Used to check if a `Result` is an `Err`
+   *
+   * @returns `true` if the result is an `Err` variant of Result
+   */
+  isErr(): this is Err<T, E>;
+  /**
+   * Maps a `Result<T, E>` to `Result<U, E>`
+   * by applying a function to a contained `Ok` value, leaving an `Err` value
+   * untouched.
+   *
+   * @param f The function to apply an `OK` value
+   * @returns the result of applying `f` or an `Err` untouched
+   */
+  map<A>(f: (t: T) => A): Result$1<A, E>;
+  /**
+   * Maps a `Result<T, E>` to `Result<T, F>` by applying a function to a
+   * contained `Err` value, leaving an `Ok` value untouched.
+   *
+   * This function can be used to pass through a successful result while
+   * handling an error.
+   *
+   * @param f a function to apply to the error `Err` value
+   */
+  mapErr<U>(f: (e: E) => U): Result$1<T, U>;
+  /**
+   * Similar to `map` Except you must return a new `Result`.
+   *
+   * This is useful for when you need to do a subsequent computation using the
+   * inner `T` value, but that computation might fail.
+   * Additionally, `andThen` is really useful as a tool to flatten a
+   * `Result<Result<A, E2>, E1>` into a `Result<A, E2>` (see example below).
+   *
+   * @param f The function to apply to the current value
+   */
+  andThen<R extends Result$1<unknown, unknown>>(f: (t: T) => R): Result$1<InferOkTypes<R>, InferErrTypes<R> | E>;
+  andThen<U, F>(f: (t: T) => Result$1<U, F>): Result$1<U, E | F>;
+  /**
+   * This "tee"s the current value to an passed-in computation such as side
+   * effect functions but still returns the same current value as the result.
+   *
+   * This is useful when you want to pass the current result to your side-track
+   * work such as logging but want to continue main-track work after that.
+   * This method does not care about the result of the passed in computation.
+   *
+   * @param f The function to apply to the current value
+   */
+  andTee(f: (t: T) => unknown): Result$1<T, E>;
+  /**
+   * This "tee"s the current `Err` value to an passed-in computation such as side
+   * effect functions but still returns the same `Err` value as the result.
+   *
+   * This is useful when you want to pass the current `Err` value to your side-track
+   * work such as logging but want to continue error-track work after that.
+   * This method does not care about the result of the passed in computation.
+   *
+   * @param f The function to apply to the current `Err` value
+   */
+  orTee(f: (t: E) => unknown): Result$1<T, E>;
+  /**
+   * Similar to `andTee` except error result of the computation will be passed
+   * to the downstream in case of an error.
+   *
+   * This version is useful when you want to make side-effects but in case of an
+   * error, you want to pass the error to the downstream.
+   *
+   * @param f The function to apply to the current value
+   */
+  andThrough<R extends Result$1<unknown, unknown>>(f: (t: T) => R): Result$1<T, InferErrTypes<R> | E>;
+  andThrough<F>(f: (t: T) => Result$1<unknown, F>): Result$1<T, E | F>;
+  /**
+   * Takes an `Err` value and maps it to a `Result<T, SomeNewType>`.
+   *
+   * This is useful for error recovery.
+   *
+   *
+   * @param f  A function to apply to an `Err` value, leaving `Ok` values
+   * untouched.
+   */
+  orElse<R extends Result$1<unknown, unknown>>(f: (e: E) => R): Result$1<InferOkTypes<R> | T, InferErrTypes<R>>;
+  orElse<U, A>(f: (e: E) => Result$1<U, A>): Result$1<U | T, A>;
+  /**
+   * Similar to `map` Except you must return a new `Result`.
+   *
+   * This is useful for when you need to do a subsequent async computation using
+   * the inner `T` value, but that computation might fail. Must return a ResultAsync
+   *
+   * @param f The function that returns a `ResultAsync` to apply to the current
+   * value
+   */
+  asyncAndThen<U, F>(f: (t: T) => ResultAsync<U, F>): ResultAsync<U, E | F>;
+  /**
+   * Maps a `Result<T, E>` to `ResultAsync<U, E>`
+   * by applying an async function to a contained `Ok` value, leaving an `Err`
+   * value untouched.
+   *
+   * @param f An async function to apply an `OK` value
+   */
+  asyncMap<U>(f: (t: T) => Promise<U>): ResultAsync<U, E>;
+  /**
+   * Unwrap the `Ok` value, or return the default if there is an `Err`
+   *
+   * @param v the default value to return if there is an `Err`
+   */
+  unwrapOr<A>(v: A): T | A;
+  /**
+   *
+   * Given 2 functions (one for the `Ok` variant and one for the `Err` variant)
+   * execute the function that matches the `Result` variant.
+   *
+   * Match callbacks do not necessitate to return a `Result`, however you can
+   * return a `Result` if you want to.
+   *
+   * `match` is like chaining `map` and `mapErr`, with the distinction that
+   * with `match` both functions must have the same return type.
+   *
+   * @param ok
+   * @param err
+   */
+  match<A, B = A>(ok: (t: T) => A, err: (e: E) => B): A | B;
+  /**
+   * @deprecated will be removed in 9.0.0.
+   *
+   * You can use `safeTry` without this method.
+   * @example
+   * ```typescript
+   * safeTry(function* () {
+   *   const okValue = yield* yourResult
+   * })
+   * ```
+   * Emulates Rust's `?` operator in `safeTry`'s body. See also `safeTry`.
+   */
+  safeUnwrap(): Generator<Err<never, E>, T>;
+  /**
+   * **This method is unsafe, and should only be used in a test environments**
+   *
+   * Takes a `Result<T, E>` and returns a `T` when the result is an `Ok`, otherwise it throws a custom object.
+   *
+   * @param config
+   */
+  _unsafeUnwrap(config?: ErrorConfig): T;
+  /**
+   * **This method is unsafe, and should only be used in a test environments**
+   *
+   * takes a `Result<T, E>` and returns a `E` when the result is an `Err`,
+   * otherwise it throws a custom object.
+   *
+   * @param config
+   */
+  _unsafeUnwrapErr(config?: ErrorConfig): E;
 }
-declare const ZodPipe: $constructor<ZodPipe>;
-interface ZodReadonly<T extends SomeType = $ZodType> extends _ZodType<$ZodReadonlyInternals<T>>, $ZodReadonly<T> {
-  "~standard": ZodStandardSchemaWithJSON<this>;
-  unwrap(): T;
+declare class Ok<T, E> implements IResult<T, E> {
+  readonly value: T;
+  constructor(value: T);
+  isOk(): this is Ok<T, E>;
+  isErr(): this is Err<T, E>;
+  map<A>(f: (t: T) => A): Result$1<A, E>;
+  mapErr<U>(_f: (e: E) => U): Result$1<T, U>;
+  andThen<R extends Result$1<unknown, unknown>>(f: (t: T) => R): Result$1<InferOkTypes<R>, InferErrTypes<R> | E>;
+  andThen<U, F>(f: (t: T) => Result$1<U, F>): Result$1<U, E | F>;
+  andThrough<R extends Result$1<unknown, unknown>>(f: (t: T) => R): Result$1<T, InferErrTypes<R> | E>;
+  andThrough<F>(f: (t: T) => Result$1<unknown, F>): Result$1<T, E | F>;
+  andTee(f: (t: T) => unknown): Result$1<T, E>;
+  orTee(_f: (t: E) => unknown): Result$1<T, E>;
+  orElse<R extends Result$1<unknown, unknown>>(_f: (e: E) => R): Result$1<InferOkTypes<R> | T, InferErrTypes<R>>;
+  orElse<U, A>(_f: (e: E) => Result$1<U, A>): Result$1<U | T, A>;
+  asyncAndThen<U, F>(f: (t: T) => ResultAsync<U, F>): ResultAsync<U, E | F>;
+  asyncAndThrough<R extends ResultAsync<unknown, unknown>>(f: (t: T) => R): ResultAsync<T, InferAsyncErrTypes<R> | E>;
+  asyncAndThrough<F>(f: (t: T) => ResultAsync<unknown, F>): ResultAsync<T, E | F>;
+  asyncMap<U>(f: (t: T) => Promise<U>): ResultAsync<U, E>;
+  unwrapOr<A>(_v: A): T | A;
+  match<A, B = A>(ok: (t: T) => A, _err: (e: E) => B): A | B;
+  safeUnwrap(): Generator<Err<never, E>, T>;
+  _unsafeUnwrap(_?: ErrorConfig): T;
+  _unsafeUnwrapErr(config?: ErrorConfig): E;
+  [Symbol.iterator](): Generator<Err<never, E>, T>;
 }
-declare const ZodReadonly: $constructor<ZodReadonly>;
-//#endregion
-//#region src/core/schemas.d.ts
-/** Zod schema for the raw token response from the OAuth token endpoint. */
-declare const TokenResponseSchema: ZodObject<{
-  access_token: ZodString;
-  refresh_token: ZodDefault<ZodOptional<ZodNullable<ZodString>>>;
-  expires_in: ZodNumber;
-  token_type: ZodString;
-  scope: ZodDefault<ZodOptional<ZodNullable<ZodString>>>;
-  id_token: ZodDefault<ZodOptional<ZodNullable<ZodString>>>;
-}, $strip>;
-/** Zod schema for a Fanvue user profile. */
-declare const FanvueUserSchema: ZodObject<{
-  uuid: ZodString;
-  email: ZodString;
-  handle: ZodString;
-  displayName: ZodString;
-  isCreator: ZodBoolean;
-  avatarUrl: ZodNullable<ZodString>;
-  bannerUrl: ZodNullable<ZodString>;
-  createdAt: ZodString;
-  updatedAt: ZodNullable<ZodString>;
-}, $strip>;
-/** Zod schema for the authorize-on-behalf response from the Fanvue platform. */
-declare const AuthorizeOnBehalfResponseSchema: ZodObject<{
-  code: ZodString;
-  state: ZodString;
-}, $strip>;
-/** Zod schema for the session JWT payload. */
-declare const SessionPayloadSchema: ZodObject<{
-  accessToken: ZodString;
-  refreshToken: ZodNullable<ZodString>;
-  expiresAt: ZodNumber;
-  tokenType: ZodNullable<ZodString>;
-  scope: ZodNullable<ZodString>;
-  idToken: ZodNullable<ZodString>;
-  userUuid: ZodString;
-  handle: ZodString;
-  displayName: ZodString;
-  isCreator: ZodBoolean;
-  avatarUrl: ZodNullable<ZodString>;
-}, $loose>;
-//#endregion
-//#region src/core/client.d.ts
-/**
- * A client for making authenticated requests to the Fanvue API.
- */
-interface FanvueClient {
-  /**
-   * Fetches the currently authenticated user's profile.
-   *
-   * @returns A `Result` containing the {@link FanvueUser} on success or `ApiError` on failure.
-   */
-  getCurrentUser(): Promise<Result$1<FanvueUser, ApiError>>;
+declare class Err<T, E> implements IResult<T, E> {
+  readonly error: E;
+  constructor(error: E);
+  isOk(): this is Ok<T, E>;
+  isErr(): this is Err<T, E>;
+  map<A>(_f: (t: T) => A): Result$1<A, E>;
+  mapErr<U>(f: (e: E) => U): Result$1<T, U>;
+  andThrough<F>(_f: (t: T) => Result$1<unknown, F>): Result$1<T, E | F>;
+  andTee(_f: (t: T) => unknown): Result$1<T, E>;
+  orTee(f: (t: E) => unknown): Result$1<T, E>;
+  andThen<R extends Result$1<unknown, unknown>>(_f: (t: T) => R): Result$1<InferOkTypes<R>, InferErrTypes<R> | E>;
+  andThen<U, F>(_f: (t: T) => Result$1<U, F>): Result$1<U, E | F>;
+  orElse<R extends Result$1<unknown, unknown>>(f: (e: E) => R): Result$1<InferOkTypes<R> | T, InferErrTypes<R>>;
+  orElse<U, A>(f: (e: E) => Result$1<U, A>): Result$1<U | T, A>;
+  asyncAndThen<U, F>(_f: (t: T) => ResultAsync<U, F>): ResultAsync<U, E | F>;
+  asyncAndThrough<F>(_f: (t: T) => ResultAsync<unknown, F>): ResultAsync<T, E | F>;
+  asyncMap<U>(_f: (t: T) => Promise<U>): ResultAsync<U, E>;
+  unwrapOr<A>(v: A): T | A;
+  match<A, B = A>(_ok: (t: T) => A, err: (e: E) => B): A | B;
+  safeUnwrap(): Generator<Err<never, E>, T>;
+  _unsafeUnwrap(config?: ErrorConfig): T;
+  _unsafeUnwrapErr(_?: ErrorConfig): E;
+  [Symbol.iterator](): Generator<Err<never, E>, T>;
 }
-/**
- * Creates a new {@link FanvueClient} for making authenticated requests to the Fanvue API.
- *
- * @param accessToken - The OAuth access token to authenticate requests.
- * @param apiBaseUrl - The base URL for the Fanvue API, or `null` to use the default.
- * @returns A {@link FanvueClient} instance.
- */
-declare function createFanvueClient(accessToken: string, apiBaseUrl: string | null): FanvueClient;
+declare type Prev = [never, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, ...0[]];
+declare type CollectResults<T, Collected extends unknown[] = [], Depth extends number = 50> = [Depth] extends [never] ? [] : T extends [infer H, ...infer Rest] ? H extends Result$1<infer L, infer R> ? CollectResults<Rest, [...Collected, [L, R]], Prev[Depth]> : never : Collected;
+declare type Transpose<A, Transposed extends unknown[][] = [], Depth extends number = 10> = A extends [infer T, ...infer Rest] ? T extends [infer L, infer R] ? Transposed extends [infer PL, infer PR] ? PL extends unknown[] ? PR extends unknown[] ? Transpose<Rest, [[...PL, L], [...PR, R]], Prev[Depth]> : never : never : Transpose<Rest, [[L], [R]], Prev[Depth]> : Transposed : Transposed;
+declare type Combine<T, Depth extends number = 5> = Transpose<CollectResults<T>, [], Depth> extends [infer L, infer R] ? [UnknownMembersToNever<L>, UnknownMembersToNever<R>] : Transpose<CollectResults<T>, [], Depth> extends [] ? [[], []] : never;
+declare type Dedup<T> = T extends Result$1<infer RL, infer RR> ? [unknown] extends [RL] ? Err<RL, RR> : Ok<RL, RR> : T;
+declare type MemberListOf<T> = ((T extends unknown ? (t: T) => T : never) extends infer U ? (U extends unknown ? (u: U) => unknown : never) extends ((v: infer V) => unknown) ? V : never : never) extends ((_: unknown) => infer W) ? [...MemberListOf<Exclude<T, W>>, W] : [];
+declare type EmptyArrayToNever<T, NeverArrayToNever extends number = 0> = T extends [] ? never : NeverArrayToNever extends 1 ? T extends [never, ...infer Rest] ? [EmptyArrayToNever<Rest>] extends [never] ? never : T : T : T;
+declare type UnknownMembersToNever<T> = T extends [infer H, ...infer R] ? [[unknown] extends [H] ? never : H, ...UnknownMembersToNever<R>] : T;
+declare type MembersToUnion<T> = T extends unknown[] ? T[number] : never;
+declare type IsLiteralArray<T> = T extends {
+  length: infer L;
+} ? L extends number ? number extends L ? 0 : 1 : 0 : 0;
+declare type Traverse<T, Depth extends number = 5> = Combine<T, Depth> extends [infer Oks, infer Errs] ? Result$1<EmptyArrayToNever<Oks, 1>, MembersToUnion<Errs>> : never;
+declare type TraverseWithAllErrors<T, Depth extends number = 5> = Traverse<T, Depth> extends Result$1<infer Oks, infer Errs> ? Result$1<Oks, Errs[]> : never;
+declare type CombineResults<T extends readonly Result$1<unknown, unknown>[]> = IsLiteralArray<T> extends 1 ? Traverse<T> : Result$1<ExtractOkTypes<T>, ExtractErrTypes<T>[number]>;
+declare type CombineResultsWithAllErrorsArray<T extends readonly Result$1<unknown, unknown>[]> = IsLiteralArray<T> extends 1 ? TraverseWithAllErrors<T> : Result$1<ExtractOkTypes<T>, ExtractErrTypes<T>[number][]>;
 //#endregion
-export { DEFAULT_ISSUER_URL as A, OAuthConfig as C, TokenResponse as D, SessionVerifyError as E, HEADER_UPDATED_SESSION as F, DEFAULT_SCOPES as M, assertFanvueDomain as N, API_VERSION as O, BEARER_PREFIX as P, JsonParseError as S, SessionPayload as T, refreshAccessToken as _, SessionPayloadSchema as a, EmbeddedAuthError as b, FanvueTheme as c, getThemeFromUrl as d, requestAuthorizationCodeOnBehalf as f, exchangeCodeForToken as g, createAuthorizationUrl as h, FanvueUserSchema as i, DEFAULT_PLATFORM_URL as j, DEFAULT_API_BASE_URL as k, exchangeSessionToken as l, verifySessionJwt as m, createFanvueClient as n, TokenResponseSchema as o, createSessionJwt as p, AuthorizeOnBehalfResponseSchema as r, safeJsonParse as s, FanvueClient as t, getSessionTokenFromUrl as u, ApiError as v, OAuthError as w, FanvueUser as x, EmbeddedAuthConfig as y };
-//# sourceMappingURL=index-pS9wR5yg.d.ts.map
+export { $strip as C, $loose as S, ZodType as _, ZodDefault as a, ZodUnknown as b, ZodLiteral as c, ZodObject as d, ZodOptional as f, ZodTransform as g, ZodString as h, ZodCatch as i, ZodNullable as l, ZodRecord as m, ZodArray as n, ZodDiscriminatedUnion as o, ZodPipe as p, ZodBoolean as r, ZodEnum as s, Result$1 as t, ZodNumber as u, ZodURL as v, output as x, ZodUnion as y };
+//# sourceMappingURL=index-cf3ZMnLJ.d.ts.map