paykitjs 0.1.0-alpha.2

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Max Katz
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/dist/_virtual/_rolldown/runtime.js

@@ -0,0 +1,13 @@
+//#region \0rolldown/runtime.js
+var __defProp = Object.defineProperty;
+var __exportAll = (all, no_symbols) => {
+	let target = {};
+	for (var name in all) __defProp(target, name, {
+		get: all[name],
+		enumerable: true
+	});
+	if (!no_symbols) __defProp(target, Symbol.toStringTag, { value: "Module" });
+	return target;
+};
+//#endregion
+export { __exportAll };

package/dist/api/define-route.d.ts

@@ -0,0 +1,94 @@
+import { PayKitContext } from "../core/context.js";
+import { Customer } from "../types/models.js";
+import * as better_call0 from "better-call";
+import { EndpointContext, createEndpoint } from "better-call";
+import * as z from "zod";
+
+//#region src/api/define-route.d.ts
+declare const paykitMiddleware: better_call0.Middleware<(inputContext: Record<string, any>) => Promise<PayKitContext>>;
+declare const createPayKitEndpoint: ReturnType<typeof createEndpoint.create<{
+  use: [typeof paykitMiddleware];
+}>>;
+type BetterCallOptions = Parameters<typeof createPayKitEndpoint>[1];
+type OptionalCustomer<TRequireCustomer extends boolean> = TRequireCustomer extends true ? {
+  customer: Customer;
+} : {
+  customer?: undefined;
+};
+type PayKitMethodContext<TInput, TRequireCustomer extends boolean = false, TParams = Record<string, string> | undefined, THeaders = Headers, TRequest = Request | undefined> = {
+  headers: THeaders;
+  input: TInput;
+  params: TParams;
+  paykit: PayKitContext;
+  request: TRequest;
+} & OptionalCustomer<TRequireCustomer>;
+type PayKitMethod<TServerInput, TResult> = ((paykit: PayKitContext, input: TServerInput, request?: Request) => Promise<TResult>) & {
+  client?: boolean;
+  endpoint?: {
+    options: unknown;
+    path: string;
+  } & Record<string, unknown>;
+};
+type PayKitMethodRouteConfig = Omit<BetterCallOptions, "body" | "method"> & {
+  client?: boolean;
+  method: NonNullable<BetterCallOptions["method"]>;
+  path: string;
+  resolveInput?: (ctx: BetterCallEndpointContext) => Promise<unknown> | unknown;
+};
+interface PayKitMethodConfig {
+  input?: BetterCallOptions extends {
+    body?: infer TBody;
+  } ? TBody : never;
+  requireCustomer?: boolean;
+  route?: PayKitMethodRouteConfig;
+  resolveServerCustomerId?: (input: unknown) => string | undefined;
+}
+type InferSchemaInput<TSchema> = TSchema extends {
+  _output: infer TOutput;
+} ? TOutput : never;
+type PayKitReturnUrlSchema = z.ZodURL & {
+  __paykitReturnUrl: true;
+};
+type InferMethodInput<TConfig extends PayKitMethodConfig> = TConfig["input"] extends undefined ? TConfig["route"] extends {
+  resolveInput: (...args: unknown[]) => infer TResolved;
+} ? Awaited<TResolved> : undefined : InferSchemaInput<NonNullable<TConfig["input"]>>;
+type InferRequireCustomer<TConfig extends PayKitMethodConfig> = TConfig["requireCustomer"] extends true ? true : false;
+type ServerMethodInput<TConfig extends PayKitMethodConfig> = InferRequireCustomer<TConfig> extends true ? AddCustomerId<InferMethodInput<TConfig>> : InferMethodInput<TConfig>;
+type AddCustomerId<TInput> = TInput extends undefined ? {
+  customerId: string;
+} : TInput extends object ? TInput & {
+  customerId: string;
+} : TInput;
+type BetterCallEndpointContext = EndpointContext<string, NonNullable<BetterCallOptions["method"]>, object | undefined, undefined, [], boolean, boolean, PayKitContext>;
+type InferRouteContext<TConfig extends PayKitMethodConfig> = TConfig["route"] extends {
+  path: infer TPath extends string;
+  method: infer TMethod extends NonNullable<BetterCallOptions["method"]>;
+  requireHeaders?: infer TRequireHeaders extends boolean;
+  requireRequest?: infer TRequireRequest extends boolean;
+} ? EndpointContext<TPath, TMethod, TConfig["input"] extends object ? TConfig["input"] : undefined, undefined, [], TRequireHeaders, TRequireRequest, PayKitContext> : EndpointContext<never, NonNullable<BetterCallOptions["method"]>, TConfig["input"] extends object ? TConfig["input"] : undefined, undefined, [], false, false, PayKitContext>;
+type InferRoutePath<TConfig extends PayKitMethodConfig> = TConfig["route"] extends {
+  path: infer TPath extends string;
+} ? TPath : never;
+type InferClientRoute<TConfig extends PayKitMethodConfig> = TConfig["route"] extends {
+  client: true;
+} ? true : false;
+type InferMethodMeta<TConfig extends PayKitMethodConfig> = [InferRoutePath<TConfig>] extends [never] ? {
+  client?: boolean;
+  endpoint?: {
+    options: unknown;
+    path: string;
+  } & Record<string, unknown>;
+} : {
+  endpoint: {
+    options: unknown;
+    path: InferRoutePath<TConfig>;
+  } & Record<string, unknown>;
+} & (InferClientRoute<TConfig> extends true ? {
+  client: true;
+} : {
+  client?: false | undefined;
+});
+declare function definePayKitMethod<const TConfig extends PayKitMethodConfig, TResult>(config: TConfig, handler: (ctx: PayKitMethodContext<InferMethodInput<TConfig>, InferRequireCustomer<TConfig>, InferRouteContext<TConfig>["params"], InferRouteContext<TConfig>["headers"], InferRouteContext<TConfig>["request"]>) => Promise<TResult> | TResult): PayKitMethod<ServerMethodInput<TConfig>, TResult> & InferMethodMeta<TConfig>;
+declare function returnUrl(): PayKitReturnUrlSchema;
+//#endregion
+export { PayKitMethod, createPayKitEndpoint, definePayKitMethod, returnUrl };

package/dist/api/define-route.js

@@ -0,0 +1,153 @@
+import { PAYKIT_ERROR_CODES, PayKitError } from "../core/errors.js";
+import { getCustomerByIdOrThrow, syncCustomerWithDefaults } from "../customer/customer.service.js";
+import { createEndpoint, createMiddleware } from "better-call";
+import * as z from "zod";
+//#region src/api/define-route.ts
+const paykitMiddleware = createMiddleware(async () => {
+	return {};
+});
+const createPayKitEndpoint = createEndpoint.create({ use: [paykitMiddleware] });
+const returnUrlBrand = "__paykitReturnUrl";
+function definePayKitMethod(config, handler) {
+	const call = async (paykit, input, request) => {
+		const normalizedInput = normalizeMethodInput(config.input, stripCustomerId(input), request, request?.headers);
+		const customer = config.requireCustomer ? await resolveCustomer(paykit, request, config.resolveServerCustomerId?.(input) ?? getInputCustomerId(input)) : void 0;
+		return handler({
+			headers: request?.headers ?? new Headers(),
+			input: normalizedInput,
+			params: {},
+			paykit,
+			request,
+			...customer ? { customer } : {}
+		});
+	};
+	if (config.route) {
+		const endpoint = createPayKitEndpoint(config.route.path, {
+			body: createRouteInputSchema(config.input),
+			...config.route,
+			client: void 0,
+			path: void 0,
+			resolveInput: void 0
+		}, async (ctx) => {
+			const routeInput = normalizeMethodInput(config.input, config.route?.resolveInput ? await config.route.resolveInput(ctx) : ctx.body, ctx.request, ctx.headers);
+			const customer = config.requireCustomer ? await resolveCustomer(ctx.context, ctx.request) : void 0;
+			return handler({
+				headers: ctx.headers,
+				input: routeInput,
+				params: ctx.params,
+				paykit: ctx.context,
+				request: ctx.request,
+				...customer ? { customer } : {}
+			});
+		});
+		call.client = config.route.client === true;
+		call.endpoint = endpoint;
+	}
+	return call;
+}
+function returnUrl() {
+	const schema = z.url();
+	Object.defineProperty(schema, returnUrlBrand, {
+		configurable: false,
+		enumerable: false,
+		value: true,
+		writable: false
+	});
+	return schema;
+}
+function getInputCustomerId(input) {
+	if (!input || typeof input !== "object") return;
+	return "customerId" in input && typeof input.customerId === "string" ? input.customerId : void 0;
+}
+function stripCustomerId(input) {
+	if (!input || typeof input !== "object" || !("customerId" in input)) return input;
+	const { customerId: _customerId, ...rest } = input;
+	return rest;
+}
+function normalizeMethodInput(schema, input, request, headers) {
+	if (!(schema instanceof z.ZodObject) || !input || typeof input !== "object") return input;
+	const fields = getReturnUrlFields(schema);
+	if (fields.length === 0) return input;
+	const normalized = { ...input };
+	for (const field of fields) {
+		const value = normalized[field];
+		if (typeof value === "string") {
+			normalized[field] = normalizeReturnUrlValue(field, value, request, headers);
+			continue;
+		}
+		if (value == null && shouldDefaultReturnUrlField(field)) normalized[field] = resolveAbsoluteUrl("/", request, headers, field);
+	}
+	return normalized;
+}
+function createRouteInputSchema(schema) {
+	if (!(schema instanceof z.ZodObject)) return schema;
+	const shape = schema.shape;
+	const overrides = {};
+	for (const [key, fieldSchema] of Object.entries(shape)) {
+		if (!isReturnUrlSchema(fieldSchema)) continue;
+		overrides[key] = createRoutedReturnUrlSchema(key, fieldSchema);
+	}
+	return Object.keys(overrides).length > 0 ? schema.extend(overrides) : schema;
+}
+function createRoutedReturnUrlSchema(field, schema) {
+	const typedSchema = schema;
+	if (typedSchema instanceof z.ZodOptional) return createRoutedReturnUrlSchema(field, typedSchema.unwrap()).optional();
+	const routedSchema = z.string().refine((value) => isAbsoluteUrl(value) || isAbsolutePath(value), { message: "Invalid URL" });
+	return shouldDefaultReturnUrlField(field) ? routedSchema.optional() : routedSchema;
+}
+function getReturnUrlFields(schema) {
+	return Object.entries(schema.shape).filter(([, fieldSchema]) => isReturnUrlSchema(fieldSchema)).map(([field]) => field);
+}
+function isReturnUrlSchema(schema) {
+	const typedSchema = schema;
+	if (typedSchema instanceof z.ZodOptional) return isReturnUrlSchema(typedSchema.unwrap());
+	return typedSchema[returnUrlBrand] === true;
+}
+function normalizeReturnUrlValue(field, value, request, headers) {
+	if (isAbsolutePath(value)) return resolveAbsoluteUrl(value, request, headers, field);
+	return value;
+}
+function shouldDefaultReturnUrlField(field) {
+	return field !== "cancelUrl";
+}
+function resolveAbsoluteUrl(value, request, headers, field) {
+	const origin = resolveOrigin(request, headers);
+	if (!origin) throw PayKitError.from("BAD_REQUEST", PAYKIT_ERROR_CODES.SUCCESS_URL_REQUIRED, `A ${field} is required when this method is called without a request context`);
+	return new URL(value, origin).toString();
+}
+function resolveOrigin(request, headers) {
+	if (request?.url) return new URL("/", request.url).toString();
+	const explicitOrigin = headers?.get("origin");
+	if (explicitOrigin && isAbsoluteUrl(explicitOrigin)) return explicitOrigin.endsWith("/") ? explicitOrigin : `${explicitOrigin}/`;
+	const host = headers?.get("x-forwarded-host") ?? headers?.get("host");
+	if (!host) return null;
+	return `${headers?.get("x-forwarded-proto") ?? "https"}://${host}/`;
+}
+function isAbsoluteUrl(value) {
+	try {
+		new URL(value);
+		return true;
+	} catch {
+		return false;
+	}
+}
+function isAbsolutePath(value) {
+	return /^\/(?!\/)/u.test(value);
+}
+async function resolveCustomer(ctx, request, explicitCustomerId) {
+	if (ctx.options.identify && request) {
+		const identity = await ctx.options.identify(request);
+		if (!identity) throw PayKitError.from("UNAUTHORIZED", PAYKIT_ERROR_CODES.IDENTIFY_REQUIRED);
+		if (explicitCustomerId && explicitCustomerId !== identity.customerId) throw PayKitError.from("FORBIDDEN", PAYKIT_ERROR_CODES.CUSTOMER_ID_MISMATCH);
+		return syncCustomerWithDefaults(ctx, {
+			id: identity.customerId,
+			email: identity.email,
+			name: identity.name
+		});
+	}
+	if (request) throw PayKitError.from("UNAUTHORIZED", PAYKIT_ERROR_CODES.IDENTIFY_REQUIRED);
+	if (explicitCustomerId) return getCustomerByIdOrThrow(ctx.database, explicitCustomerId);
+	throw PayKitError.from("UNAUTHORIZED", PAYKIT_ERROR_CODES.CUSTOMER_ID_REQUIRED);
+}
+//#endregion
+export { createPayKitEndpoint, definePayKitMethod, returnUrl };

package/dist/api/methods.d.ts

@@ -0,0 +1,422 @@
+import { ProviderCustomerMap, ProviderTestClock } from "../providers/provider.js";
+import { PayKitContext } from "../core/context.js";
+import { PayKitMethod } from "./define-route.js";
+import { SubscribeResult } from "../subscription/subscription.types.js";
+import { CustomerWithDetails, ListCustomersResult } from "../customer/customer.types.js";
+import { CheckResult, ReportResult } from "../entitlement/entitlement.service.js";
+//#region src/api/methods.d.ts
+declare const testingMethods: {
+  readonly getTestClock: ((paykit: PayKitContext, input: Record<string, never> & {
+    customerId: string;
+  }, request?: Request) => Promise<ProviderTestClock>) & {
+    client?: boolean;
+    endpoint?: {
+      options: unknown;
+      path: string;
+    } & Record<string, unknown>;
+  } & {
+    endpoint: {
+      options: unknown;
+      path: "/get-test-clock";
+    } & Record<string, unknown>;
+  } & {
+    client: true;
+  };
+  readonly advanceTestClock: ((paykit: PayKitContext, input: {
+    frozenTime: Date;
+  } & {
+    customerId: string;
+  }, request?: Request) => Promise<ProviderTestClock>) & {
+    client?: boolean;
+    endpoint?: {
+      options: unknown;
+      path: string;
+    } & Record<string, unknown>;
+  } & {
+    endpoint: {
+      options: unknown;
+      path: "/advance-test-clock";
+    } & Record<string, unknown>;
+  } & {
+    client: true;
+  };
+};
+declare const methods: {
+  readonly getTestClock: ((paykit: PayKitContext, input: Record<string, never> & {
+    customerId: string;
+  }, request?: Request) => Promise<ProviderTestClock>) & {
+    client?: boolean;
+    endpoint?: {
+      options: unknown;
+      path: string;
+    } & Record<string, unknown>;
+  } & {
+    endpoint: {
+      options: unknown;
+      path: "/get-test-clock";
+    } & Record<string, unknown>;
+  } & {
+    client: true;
+  };
+  readonly advanceTestClock: ((paykit: PayKitContext, input: {
+    frozenTime: Date;
+  } & {
+    customerId: string;
+  }, request?: Request) => Promise<ProviderTestClock>) & {
+    client?: boolean;
+    endpoint?: {
+      options: unknown;
+      path: string;
+    } & Record<string, unknown>;
+  } & {
+    endpoint: {
+      options: unknown;
+      path: "/advance-test-clock";
+    } & Record<string, unknown>;
+  } & {
+    client: true;
+  };
+  readonly subscribe: ((paykit: PayKitContext, input: {
+    planId: string;
+    successUrl: string;
+    forceCheckout?: boolean | undefined;
+    cancelUrl?: string | undefined;
+  } & {
+    customerId: string;
+  }, request?: Request) => Promise<SubscribeResult>) & {
+    client?: boolean;
+    endpoint?: {
+      options: unknown;
+      path: string;
+    } & Record<string, unknown>;
+  } & {
+    endpoint: {
+      options: unknown;
+      path: "/subscribe";
+    } & Record<string, unknown>;
+  } & {
+    client: true;
+  };
+  readonly customerPortal: ((paykit: PayKitContext, input: {
+    returnUrl: string;
+  } & {
+    customerId: string;
+  }, request?: Request) => Promise<{
+    url: string;
+  }>) & {
+    client?: boolean;
+    endpoint?: {
+      options: unknown;
+      path: string;
+    } & Record<string, unknown>;
+  } & {
+    endpoint: {
+      options: unknown;
+      path: "/customer-portal";
+    } & Record<string, unknown>;
+  } & {
+    client: true;
+  };
+  readonly upsertCustomer: ((paykit: PayKitContext, input: {
+    id: string;
+    email?: string | undefined;
+    name?: string | undefined;
+    metadata?: Record<string, string> | undefined;
+  }, request?: Request) => Promise<{
+    metadata: Record<string, string> | null;
+    id: string;
+    email: string | null;
+    name: string | null;
+    provider: ProviderCustomerMap;
+    deletedAt: Date | null;
+    createdAt: Date;
+    updatedAt: Date;
+  }>) & {
+    client?: boolean;
+    endpoint?: {
+      options: unknown;
+      path: string;
+    } & Record<string, unknown>;
+  } & {
+    client?: boolean;
+    endpoint?: {
+      options: unknown;
+      path: string;
+    } & Record<string, unknown>;
+  };
+  readonly getCustomer: ((paykit: PayKitContext, input: {
+    id: string;
+  }, request?: Request) => Promise<CustomerWithDetails | null>) & {
+    client?: boolean;
+    endpoint?: {
+      options: unknown;
+      path: string;
+    } & Record<string, unknown>;
+  } & {
+    client?: boolean;
+    endpoint?: {
+      options: unknown;
+      path: string;
+    } & Record<string, unknown>;
+  };
+  readonly deleteCustomer: ((paykit: PayKitContext, input: {
+    id: string;
+  }, request?: Request) => Promise<{
+    success: boolean;
+  }>) & {
+    client?: boolean;
+    endpoint?: {
+      options: unknown;
+      path: string;
+    } & Record<string, unknown>;
+  } & {
+    client?: boolean;
+    endpoint?: {
+      options: unknown;
+      path: string;
+    } & Record<string, unknown>;
+  };
+  readonly listCustomers: ((paykit: PayKitContext, input: {
+    limit?: number | undefined;
+    offset?: number | undefined;
+    planIds?: string[] | undefined;
+  } | undefined, request?: Request) => Promise<ListCustomersResult>) & {
+    client?: boolean;
+    endpoint?: {
+      options: unknown;
+      path: string;
+    } & Record<string, unknown>;
+  } & {
+    client?: boolean;
+    endpoint?: {
+      options: unknown;
+      path: string;
+    } & Record<string, unknown>;
+  };
+  readonly check: ((paykit: PayKitContext, input: {
+    featureId: string;
+    required?: number | undefined;
+  } & {
+    customerId: string;
+  }, request?: Request) => Promise<CheckResult>) & {
+    client?: boolean;
+    endpoint?: {
+      options: unknown;
+      path: string;
+    } & Record<string, unknown>;
+  } & {
+    client?: boolean;
+    endpoint?: {
+      options: unknown;
+      path: string;
+    } & Record<string, unknown>;
+  };
+  readonly report: ((paykit: PayKitContext, input: {
+    featureId: string;
+    amount?: number | undefined;
+  } & {
+    customerId: string;
+  }, request?: Request) => Promise<ReportResult>) & {
+    client?: boolean;
+    endpoint?: {
+      options: unknown;
+      path: string;
+    } & Record<string, unknown>;
+  } & {
+    client?: boolean;
+    endpoint?: {
+      options: unknown;
+      path: string;
+    } & Record<string, unknown>;
+  };
+  readonly handleWebhook: ((paykit: PayKitContext, input: never, request?: Request) => Promise<{
+    received: true;
+  }>) & {
+    client?: boolean;
+    endpoint?: {
+      options: unknown;
+      path: string;
+    } & Record<string, unknown>;
+  } & {
+    endpoint: {
+      options: unknown;
+      path: "/webhook/:providerId";
+    } & Record<string, unknown>;
+  } & {
+    client?: false | undefined;
+  };
+};
+type MethodMap = Record<string, PayKitMethod<never, unknown>>;
+declare const clientMethods: Pick<{
+  readonly subscribe: ((paykit: PayKitContext, input: {
+    planId: string;
+    successUrl: string;
+    forceCheckout?: boolean | undefined;
+    cancelUrl?: string | undefined;
+  } & {
+    customerId: string;
+  }, request?: Request) => Promise<SubscribeResult>) & {
+    client?: boolean;
+    endpoint?: {
+      options: unknown;
+      path: string;
+    } & Record<string, unknown>;
+  } & {
+    endpoint: {
+      options: unknown;
+      path: "/subscribe";
+    } & Record<string, unknown>;
+  } & {
+    client: true;
+  };
+  readonly customerPortal: ((paykit: PayKitContext, input: {
+    returnUrl: string;
+  } & {
+    customerId: string;
+  }, request?: Request) => Promise<{
+    url: string;
+  }>) & {
+    client?: boolean;
+    endpoint?: {
+      options: unknown;
+      path: string;
+    } & Record<string, unknown>;
+  } & {
+    endpoint: {
+      options: unknown;
+      path: "/customer-portal";
+    } & Record<string, unknown>;
+  } & {
+    client: true;
+  };
+  readonly upsertCustomer: ((paykit: PayKitContext, input: {
+    id: string;
+    email?: string | undefined;
+    name?: string | undefined;
+    metadata?: Record<string, string> | undefined;
+  }, request?: Request) => Promise<{
+    metadata: Record<string, string> | null;
+    id: string;
+    email: string | null;
+    name: string | null;
+    provider: ProviderCustomerMap;
+    deletedAt: Date | null;
+    createdAt: Date;
+    updatedAt: Date;
+  }>) & {
+    client?: boolean;
+    endpoint?: {
+      options: unknown;
+      path: string;
+    } & Record<string, unknown>;
+  } & {
+    client?: boolean;
+    endpoint?: {
+      options: unknown;
+      path: string;
+    } & Record<string, unknown>;
+  };
+  readonly getCustomer: ((paykit: PayKitContext, input: {
+    id: string;
+  }, request?: Request) => Promise<CustomerWithDetails | null>) & {
+    client?: boolean;
+    endpoint?: {
+      options: unknown;
+      path: string;
+    } & Record<string, unknown>;
+  } & {
+    client?: boolean;
+    endpoint?: {
+      options: unknown;
+      path: string;
+    } & Record<string, unknown>;
+  };
+  readonly deleteCustomer: ((paykit: PayKitContext, input: {
+    id: string;
+  }, request?: Request) => Promise<{
+    success: boolean;
+  }>) & {
+    client?: boolean;
+    endpoint?: {
+      options: unknown;
+      path: string;
+    } & Record<string, unknown>;
+  } & {
+    client?: boolean;
+    endpoint?: {
+      options: unknown;
+      path: string;
+    } & Record<string, unknown>;
+  };
+  readonly listCustomers: ((paykit: PayKitContext, input: {
+    limit?: number | undefined;
+    offset?: number | undefined;
+    planIds?: string[] | undefined;
+  } | undefined, request?: Request) => Promise<ListCustomersResult>) & {
+    client?: boolean;
+    endpoint?: {
+      options: unknown;
+      path: string;
+    } & Record<string, unknown>;
+  } & {
+    client?: boolean;
+    endpoint?: {
+      options: unknown;
+      path: string;
+    } & Record<string, unknown>;
+  };
+  readonly check: ((paykit: PayKitContext, input: {
+    featureId: string;
+    required?: number | undefined;
+  } & {
+    customerId: string;
+  }, request?: Request) => Promise<CheckResult>) & {
+    client?: boolean;
+    endpoint?: {
+      options: unknown;
+      path: string;
+    } & Record<string, unknown>;
+  } & {
+    client?: boolean;
+    endpoint?: {
+      options: unknown;
+      path: string;
+    } & Record<string, unknown>;
+  };
+  readonly report: ((paykit: PayKitContext, input: {
+    featureId: string;
+    amount?: number | undefined;
+  } & {
+    customerId: string;
+  }, request?: Request) => Promise<ReportResult>) & {
+    client?: boolean;
+    endpoint?: {
+      options: unknown;
+      path: string;
+    } & Record<string, unknown>;
+  } & {
+    client?: boolean;
+    endpoint?: {
+      options: unknown;
+      path: string;
+    } & Record<string, unknown>;
+  };
+  readonly handleWebhook: ((paykit: PayKitContext, input: never, request?: Request) => Promise<{
+    received: true;
+  }>) & {
+    client?: boolean;
+    endpoint?: {
+      options: unknown;
+      path: string;
+    } & Record<string, unknown>;
+  } & {
+    endpoint: {
+      options: unknown;
+      path: "/webhook/:providerId";
+    } & Record<string, unknown>;
+  } & {
+    client?: false | undefined;
+  };
+} & MethodMap, never>;
+//#endregion
+export { clientMethods, methods, testingMethods };