paykitjs 0.0.1-alpha.1

package/dist/subscription/subscription.types.d.ts

@@ -0,0 +1,18 @@
+//#region src/subscription/subscription.types.d.ts
+interface SubscribeResult {
+  invoice?: {
+    currency: string;
+    hostedUrl: string | null;
+    providerInvoiceId: string;
+    status: string | null;
+    totalAmount: number;
+  };
+  paymentUrl: string | null;
+  requiredAction?: {
+    clientSecret?: string;
+    paymentIntentId?: string;
+    type: string;
+  } | null;
+}
+//#endregion
+export { SubscribeResult };

package/dist/subscription/subscription.types.js

@@ -0,0 +1,11 @@
+import { returnUrl } from "../api/define-route.js";
+import * as z from "zod";
+//#region src/subscription/subscription.types.ts
+const subscribeBodySchema = z.object({
+	planId: z.string(),
+	forceCheckout: z.boolean().optional(),
+	successUrl: returnUrl(),
+	cancelUrl: returnUrl().optional()
+});
+//#endregion
+export { subscribeBodySchema };

package/dist/testing/testing.api.js

@@ -0,0 +1,29 @@
+import { definePayKitMethod } from "../api/define-route.js";
+import { advanceCustomerTestClock, getCustomerTestClock } from "./testing.service.js";
+import * as z from "zod";
+//#region src/testing/testing.api.ts
+const customerTestClockSchema = z.object({});
+const advanceCustomerTestClockSchema = z.object({ frozenTime: z.coerce.date() });
+const getTestClock = definePayKitMethod({
+	input: customerTestClockSchema,
+	requireCustomer: true,
+	route: {
+		client: true,
+		method: "POST",
+		path: "/get-test-clock"
+	}
+}, async (ctx) => getCustomerTestClock(ctx.paykit, ctx.customer.id));
+const advanceTestClock = definePayKitMethod({
+	input: advanceCustomerTestClockSchema,
+	requireCustomer: true,
+	route: {
+		client: true,
+		method: "POST",
+		path: "/advance-test-clock"
+	}
+}, async (ctx) => advanceCustomerTestClock(ctx.paykit, {
+	customerId: ctx.customer.id,
+	frozenTime: ctx.input.frozenTime
+}));
+//#endregion
+export { advanceTestClock, getTestClock };

package/dist/testing/testing.service.js

@@ -0,0 +1,49 @@
+import { PAYKIT_ERROR_CODES, PayKitError } from "../core/errors.js";
+import { getCustomerByIdOrThrow, getProviderCustomer, setProviderCustomer } from "../customer/customer.service.js";
+//#region src/testing/testing.service.ts
+function assertTestingEnabled(ctx) {
+	if (ctx.options.testing?.enabled !== true) throw PayKitError.from("BAD_REQUEST", PAYKIT_ERROR_CODES.TESTING_NOT_ENABLED);
+}
+async function getCustomerTestClock(ctx, customerId) {
+	assertTestingEnabled(ctx);
+	const providerCustomer = getProviderCustomer(await getCustomerByIdOrThrow(ctx.database, customerId), ctx.provider.id);
+	if (!providerCustomer) throw PayKitError.from("NOT_FOUND", PAYKIT_ERROR_CODES.PROVIDER_CUSTOMER_NOT_FOUND);
+	if (!providerCustomer.testClockId) throw PayKitError.from("NOT_FOUND", PAYKIT_ERROR_CODES.TEST_CLOCK_NOT_FOUND);
+	const testClock = await ctx.stripe.getTestClock({ testClockId: providerCustomer.testClockId });
+	await setProviderCustomer(ctx.database, {
+		customerId,
+		providerCustomer: {
+			...providerCustomer,
+			frozenTime: testClock.frozenTime.toISOString()
+		},
+		providerId: ctx.provider.id
+	});
+	return testClock;
+}
+function getCustomerCurrentTime(ctx, customer) {
+	if (ctx.options.testing?.enabled !== true) return /* @__PURE__ */ new Date();
+	const providerCustomer = getProviderCustomer(customer, ctx.provider.id);
+	if (!providerCustomer?.frozenTime) return /* @__PURE__ */ new Date();
+	return new Date(providerCustomer.frozenTime);
+}
+async function advanceCustomerTestClock(ctx, input) {
+	assertTestingEnabled(ctx);
+	const providerCustomer = getProviderCustomer(await getCustomerByIdOrThrow(ctx.database, input.customerId), ctx.provider.id);
+	if (!providerCustomer) throw PayKitError.from("NOT_FOUND", PAYKIT_ERROR_CODES.PROVIDER_CUSTOMER_NOT_FOUND);
+	if (!providerCustomer.testClockId) throw PayKitError.from("NOT_FOUND", PAYKIT_ERROR_CODES.TEST_CLOCK_NOT_FOUND);
+	const testClock = await ctx.stripe.advanceTestClock({
+		frozenTime: input.frozenTime,
+		testClockId: providerCustomer.testClockId
+	});
+	await setProviderCustomer(ctx.database, {
+		customerId: input.customerId,
+		providerCustomer: {
+			...providerCustomer,
+			frozenTime: testClock.frozenTime.toISOString()
+		},
+		providerId: ctx.provider.id
+	});
+	return testClock;
+}
+//#endregion
+export { advanceCustomerTestClock, getCustomerCurrentTime, getCustomerTestClock };

package/dist/types/events.d.ts

@@ -0,0 +1,181 @@
+//#region src/types/events.d.ts
+interface NormalizedPaymentMethod {
+  expiryMonth?: number;
+  expiryYear?: number;
+  isDefault?: boolean;
+  last4?: string;
+  providerMethodId: string;
+  type: string;
+}
+interface NormalizedPayment {
+  amount: number;
+  createdAt: Date;
+  currency: string;
+  description?: string | null;
+  metadata?: Record<string, string>;
+  providerMethodId?: string | null;
+  providerPaymentId: string;
+  status: string;
+}
+interface NormalizedSubscription {
+  cancelAtPeriodEnd: boolean;
+  canceledAt?: Date | null;
+  currentPeriodEndAt?: Date | null;
+  currentPeriodStartAt?: Date | null;
+  endedAt?: Date | null;
+  providerPriceId?: string | null;
+  providerSubscriptionId: string;
+  providerSubscriptionScheduleId?: string | null;
+  status: string;
+}
+interface NormalizedInvoice {
+  currency: string;
+  hostedUrl?: string | null;
+  periodEndAt?: Date | null;
+  periodStartAt?: Date | null;
+  providerInvoiceId: string;
+  status: string | null;
+  totalAmount: number;
+}
+interface CheckoutCompletedSubscription extends NormalizedSubscription {}
+interface CheckoutCompletedInvoice extends NormalizedInvoice {}
+interface UpsertCustomerAction {
+  type: "customer.upsert";
+  data: {
+    id: string;
+    email?: string;
+    name?: string;
+    metadata?: Record<string, string>;
+  };
+}
+interface DeleteCustomerAction {
+  type: "customer.delete";
+  data: {
+    id: string;
+  };
+}
+interface UpsertPaymentMethodAction {
+  type: "payment_method.upsert";
+  data: {
+    paymentMethod: NormalizedPaymentMethod;
+    providerCustomerId: string;
+  };
+}
+interface DeletePaymentMethodAction {
+  type: "payment_method.delete";
+  data: {
+    providerMethodId: string;
+  };
+}
+interface UpsertPaymentAction {
+  type: "payment.upsert";
+  data: {
+    payment: NormalizedPayment;
+    providerCustomerId: string;
+  };
+}
+interface UpsertSubscriptionAction {
+  type: "subscription.upsert";
+  data: {
+    providerCustomerId: string;
+    subscription: NormalizedSubscription;
+  };
+}
+interface DeleteSubscriptionAction {
+  type: "subscription.delete";
+  data: {
+    providerCustomerId: string;
+    providerSubscriptionId: string;
+  };
+}
+interface UpsertInvoiceAction {
+  type: "invoice.upsert";
+  data: {
+    invoice: NormalizedInvoice;
+    providerCustomerId: string;
+    providerSubscriptionId?: string | null;
+  };
+}
+type WebhookApplyAction = UpsertCustomerAction | DeleteCustomerAction | UpsertPaymentMethodAction | DeletePaymentMethodAction | UpsertPaymentAction | UpsertSubscriptionAction | DeleteSubscriptionAction | UpsertInvoiceAction;
+type EventByName<TEventMap extends object, TName extends keyof TEventMap> = {
+  name: TName;
+  payload: TEventMap[TName];
+};
+interface NormalizedWebhookEventMap {
+  "checkout.completed": {
+    checkoutSessionId: string;
+    invoice?: CheckoutCompletedInvoice;
+    metadata?: Record<string, string>;
+    mode?: "payment" | "setup" | "subscription";
+    providerInvoiceId?: string;
+    providerSubscriptionId?: string;
+    paymentStatus: string | null;
+    providerCustomerId: string;
+    providerEventId?: string;
+    status: string | null;
+    subscription?: CheckoutCompletedSubscription;
+  };
+  "payment_method.attached": {
+    paymentMethod: NormalizedPaymentMethod;
+    providerCustomerId: string;
+    providerEventId?: string;
+  };
+  "payment.succeeded": {
+    payment: NormalizedPayment;
+    providerCustomerId: string;
+    providerEventId?: string;
+  };
+  "subscription.updated": {
+    providerCustomerId: string;
+    providerEventId?: string;
+    subscription: NormalizedSubscription;
+  };
+  "subscription.deleted": {
+    providerCustomerId: string;
+    providerEventId?: string;
+    providerSubscriptionId: string;
+  };
+  "invoice.updated": {
+    invoice: NormalizedInvoice;
+    providerCustomerId: string;
+    providerEventId?: string;
+    providerSubscriptionId?: string | null;
+  };
+  "payment_method.detached": {
+    providerEventId?: string;
+    providerMethodId: string;
+  };
+}
+type NormalizedWebhookEventName = keyof NormalizedWebhookEventMap;
+type AnyNormalizedWebhookEvent = { [TName in NormalizedWebhookEventName]: EventByName<NormalizedWebhookEventMap, TName> & {
+  actions?: WebhookApplyAction[];
+} }[NormalizedWebhookEventName];
+type NormalizedWebhookEvent<TName extends NormalizedWebhookEventName = NormalizedWebhookEventName> = Extract<AnyNormalizedWebhookEvent, {
+  name: TName;
+}>;
+interface PayKitEventMap {
+  "customer.updated": {
+    customerId: string;
+    subscriptions: readonly {
+      currentPeriodEndAt: Date | null;
+      endedAt: Date | null;
+      id: string;
+      startedAt: Date | null;
+      status: string;
+    }[];
+  };
+}
+type PayKitEventName = keyof PayKitEventMap;
+type PayKitEventHandlers = { [TName in PayKitEventName]?: (event: {
+  name: TName;
+  payload: PayKitEventMap[TName];
+}) => Promise<void> | void } & {
+  "*"?: (input: {
+    event: {
+      name: PayKitEventName;
+      payload: PayKitEventMap[PayKitEventName];
+    };
+  }) => Promise<void> | void;
+};
+//#endregion
+export { NormalizedInvoice, NormalizedPayment, NormalizedPaymentMethod, NormalizedSubscription, NormalizedWebhookEvent, NormalizedWebhookEventMap, NormalizedWebhookEventName, PayKitEventHandlers, PayKitEventMap, PayKitEventName, WebhookApplyAction };

package/dist/types/instance.d.ts

@@ -0,0 +1,88 @@
+import { FeatureIdFromPlans, PlanIdFromPlans } from "./schema.js";
+import { PayKitOptions } from "./options.js";
+import { PayKitContext } from "../core/context.js";
+import { PayKitMethod as PayKitMethod$1 } from "../api/define-route.js";
+import { CustomerEntitlement, CustomerSubscription, CustomerWithDetails, ListCustomersResult } from "../customer/customer.types.js";
+import { methods, testingMethods } from "../api/methods.js";
+
+//#region src/types/instance.d.ts
+type RegisteredMethods = typeof methods;
+type RegisteredMethodKey = keyof RegisteredMethods;
+type RegisteredTestingMethodKey = keyof typeof testingMethods;
+type PlanIdFromOptions<TOptions extends PayKitOptions> = [PlanIdFromPlans<TOptions["plans"]>] extends [never] ? string : PlanIdFromPlans<TOptions["plans"]>;
+type FeatureIdFromOptions<TOptions extends PayKitOptions> = [FeatureIdFromPlans<TOptions["plans"]>] extends [never] ? string : FeatureIdFromPlans<TOptions["plans"]>;
+type InferMethodInput<TMethod> = TMethod extends PayKitMethod$1<infer TInput, unknown> ? TInput : never;
+type InferMethodResult<TMethod> = TMethod extends PayKitMethod$1<infer _TInput, infer TResult> ? TResult : never;
+type InferMethodPath<TMethod> = TMethod extends {
+  endpoint: {
+    path: infer TPath extends string;
+  };
+} ? TPath : never;
+type OmitCustomerId<TInput> = TInput extends undefined ? undefined : TInput extends object ? Omit<TInput, "customerId"> : TInput;
+type RefineServerMethodInput<TOptions extends PayKitOptions, TKey extends RegisteredMethodKey, TInput> = TKey extends "subscribe" ? TInput extends {
+  cancelUrl?: string;
+  forceCheckout?: boolean;
+  successUrl?: string;
+} ? TInput & {
+  customerId: string;
+  planId: PlanIdFromOptions<TOptions>;
+  successUrl: string;
+} : TInput : TKey extends "check" | "report" ? TInput extends {
+  featureId: string;
+} ? Omit<TInput, "featureId"> & {
+  featureId: FeatureIdFromOptions<TOptions>;
+} : TInput : TInput;
+type RefineClientMethodInput<TOptions extends PayKitOptions, TKey extends RegisteredMethodKey, TInput> = TKey extends "subscribe" ? OmitCustomerId<TInput> extends {
+  cancelUrl?: string;
+  forceCheckout?: boolean;
+  successUrl?: string;
+} ? Omit<OmitCustomerId<TInput>, "planId"> & {
+  planId: PlanIdFromOptions<TOptions>;
+} : OmitCustomerId<TInput> : TKey extends "customerPortal" ? OmitCustomerId<TInput> extends {
+  returnUrl: string;
+} ? Omit<OmitCustomerId<TInput>, "returnUrl"> & {
+  returnUrl?: string;
+} : OmitCustomerId<TInput> : OmitCustomerId<TInput>;
+type PayKitClientSubscribeInput<TOptions extends PayKitOptions = PayKitOptions> = RefineClientMethodInput<TOptions, "subscribe", InferMethodInput<RegisteredMethods["subscribe"]>>;
+type PayKitSubscribeInput<TOptions extends PayKitOptions = PayKitOptions> = RefineServerMethodInput<TOptions, "subscribe", InferMethodInput<RegisteredMethods["subscribe"]>>;
+type PayKitSubscribeResult = InferMethodResult<RegisteredMethods["subscribe"]>;
+type PayKitClientCustomerPortalInput = RefineClientMethodInput<PayKitOptions, "customerPortal", InferMethodInput<RegisteredMethods["customerPortal"]>>;
+type PayKitCustomerPortalInput = RefineServerMethodInput<PayKitOptions, "customerPortal", InferMethodInput<RegisteredMethods["customerPortal"]>>;
+type PayKitClientGetTestClockInput = RefineClientMethodInput<PayKitOptions, "getTestClock", InferMethodInput<RegisteredMethods["getTestClock"]>>;
+type PayKitGetTestClockInput = RefineServerMethodInput<PayKitOptions, "getTestClock", InferMethodInput<RegisteredMethods["getTestClock"]>>;
+type PayKitClientAdvanceTestClockInput = RefineClientMethodInput<PayKitOptions, "advanceTestClock", InferMethodInput<RegisteredMethods["advanceTestClock"]>>;
+type PayKitAdvanceTestClockInput = RefineServerMethodInput<PayKitOptions, "advanceTestClock", InferMethodInput<RegisteredMethods["advanceTestClock"]>>;
+type PayKitCheckInput<TOptions extends PayKitOptions = PayKitOptions> = RefineServerMethodInput<TOptions, "check", InferMethodInput<RegisteredMethods["check"]>>;
+type PayKitReportInput<TOptions extends PayKitOptions = PayKitOptions> = RefineServerMethodInput<TOptions, "report", InferMethodInput<RegisteredMethods["report"]>>;
+declare const payKitClientApiBrand: unique symbol;
+type PayKitMethod<TInput, TResult> = (input: TInput) => Promise<TResult>;
+type PayKitClientMethod<TPath extends string, TInput, TResult> = ((input: TInput) => Promise<TResult>) & {
+  path: TPath;
+  options: unknown;
+};
+type TestingEnabled<TOptions extends PayKitOptions> = TOptions["testing"] extends {
+  enabled: true;
+} ? true : false;
+type EnabledMethodKeys<TOptions extends PayKitOptions> = TestingEnabled<TOptions> extends true ? RegisteredMethodKey : Exclude<RegisteredMethodKey, RegisteredTestingMethodKey>;
+type ClientMethodKeys = { [K in RegisteredMethodKey]-?: RegisteredMethods[K] extends {
+  client: true;
+} ? K : never }[RegisteredMethodKey];
+type EnabledClientMethodKeys<TOptions extends PayKitOptions> = TestingEnabled<TOptions> extends true ? ClientMethodKeys : Exclude<ClientMethodKeys, RegisteredTestingMethodKey>;
+type GeneratePayKitAPI<TOptions extends PayKitOptions> = { [K in EnabledMethodKeys<TOptions>]: PayKitMethod<RefineServerMethodInput<TOptions, K, InferMethodInput<RegisteredMethods[K]>>, InferMethodResult<RegisteredMethods[K]>> };
+type GeneratePayKitClientAPI<TOptions extends PayKitOptions> = { [K in EnabledClientMethodKeys<TOptions>]: PayKitClientMethod<InferMethodPath<RegisteredMethods[K]>, RefineClientMethodInput<TOptions, K, InferMethodInput<RegisteredMethods[K]>>, InferMethodResult<RegisteredMethods[K]>> };
+interface PayKitClientApiCarrier<TClientApi> {
+  readonly [payKitClientApiBrand]?: TClientApi;
+}
+type PayKitClientAPI<TOptions extends PayKitOptions = PayKitOptions> = GeneratePayKitClientAPI<TOptions>;
+type PayKitAPI<TOptions extends PayKitOptions = PayKitOptions> = GeneratePayKitAPI<TOptions>;
+type PayKitInstance<TOptions extends PayKitOptions = PayKitOptions> = PayKitAPI<TOptions> & PayKitClientApiCarrier<PayKitClientAPI<TOptions>> & {
+  options: TOptions;
+  handler: (request: Request) => Promise<Response>;
+  $context: Promise<PayKitContext>;
+  $infer: {
+    planId: PlanIdFromOptions<TOptions>;
+    featureId: FeatureIdFromOptions<TOptions>;
+  };
+};
+//#endregion
+export { PayKitAdvanceTestClockInput, PayKitCheckInput, PayKitClientAdvanceTestClockInput, PayKitClientApiCarrier, PayKitClientCustomerPortalInput, PayKitClientGetTestClockInput, PayKitClientSubscribeInput, PayKitCustomerPortalInput, PayKitGetTestClockInput, PayKitInstance, PayKitReportInput, PayKitSubscribeInput, PayKitSubscribeResult };

package/dist/types/models.d.ts

@@ -0,0 +1,11 @@
+import { customer, feature, invoice, product, productFeature, subscription } from "../database/schema.js";
+
+//#region src/types/models.d.ts
+type Customer = typeof customer.$inferSelect;
+type StoredFeature = typeof feature.$inferSelect;
+type StoredProduct = typeof product.$inferSelect;
+type StoredProductFeature = typeof productFeature.$inferSelect;
+type StoredSubscription = typeof subscription.$inferSelect;
+type StoredInvoice = typeof invoice.$inferSelect;
+//#endregion
+export { Customer, StoredFeature, StoredInvoice, StoredProduct, StoredProductFeature, StoredSubscription };

package/dist/types/options.d.ts

@@ -0,0 +1,32 @@
+import { PayKitEventHandlers } from "./events.js";
+import { StripeProviderConfig } from "../providers/provider.js";
+import { PayKitPlugin } from "./plugin.js";
+import { PayKitPlansModule } from "./schema.js";
+import { Pool } from "pg";
+import { LevelWithSilent, Logger } from "pino";
+
+//#region src/types/options.d.ts
+interface PayKitLoggingOptions {
+  level?: LevelWithSilent;
+  logger?: Logger;
+}
+interface PayKitTestingOptions {
+  enabled: true;
+}
+interface PayKitOptions {
+  database: Pool | string;
+  provider: StripeProviderConfig;
+  plans?: PayKitPlansModule;
+  basePath?: string;
+  identify?: (request: Request) => Promise<{
+    customerId: string;
+    email?: string;
+    name?: string;
+  } | null>;
+  on?: PayKitEventHandlers;
+  plugins?: PayKitPlugin[];
+  logging?: PayKitLoggingOptions;
+  testing?: PayKitTestingOptions;
+}
+//#endregion
+export { PayKitLoggingOptions, PayKitOptions, PayKitTestingOptions };

package/dist/types/plugin.d.ts

@@ -0,0 +1,11 @@
+//#region src/types/plugin.d.ts
+interface PayKitPlugin {
+  id: string;
+  /**
+   * Better-call endpoints to merge into the PayKit router.
+   * Paths are relative to the API base path (e.g. "/dash/stats" → "/paykit/api/dash/stats").
+   */
+  endpoints?: Record<string, unknown>;
+}
+//#endregion
+export { PayKitPlugin };

package/dist/types/schema.d.ts

@@ -0,0 +1,99 @@
+import * as z from "zod";
+
+//#region src/types/schema.d.ts
+declare const priceSchema: z.ZodObject<{
+  amount: z.ZodNumber;
+  interval: z.ZodEnum<{
+    month: "month";
+    year: "year";
+  }>;
+}, z.core.$strip>;
+declare const meteredFeatureConfigSchema: z.ZodObject<{
+  limit: z.ZodNumber;
+  reset: z.ZodEnum<{
+    month: "month";
+    year: "year";
+    day: "day";
+    week: "week";
+  }>;
+}, z.core.$strip>;
+type FeatureType = "boolean" | "metered";
+type PriceInterval = z.infer<typeof priceSchema>["interval"];
+type MeteredResetInterval = z.infer<typeof meteredFeatureConfigSchema>["reset"];
+type PlanPrice = z.infer<typeof priceSchema>;
+type MeteredFeatureConfig = z.infer<typeof meteredFeatureConfigSchema>;
+interface PayKitFeatureDefinition<TId extends string = string, TType extends FeatureType = FeatureType> {
+  id: TId;
+  type: TType;
+}
+type BooleanFeatureDefinition<TId extends string = string> = PayKitFeatureDefinition<TId, "boolean">;
+type MeteredFeatureDefinition<TId extends string = string> = PayKitFeatureDefinition<TId, "metered">;
+type BooleanFeatureInclude<TFeature extends BooleanFeatureDefinition = BooleanFeatureDefinition> = Readonly<{
+  config: undefined;
+  feature: TFeature;
+}>;
+type MeteredFeatureInclude<TFeature extends MeteredFeatureDefinition = MeteredFeatureDefinition> = Readonly<{
+  config: MeteredFeatureConfig;
+  feature: TFeature;
+}>;
+type PayKitFeatureInclude = BooleanFeatureInclude<BooleanFeatureDefinition> | MeteredFeatureInclude<MeteredFeatureDefinition>;
+type BooleanFeatureCallable<TFeature extends BooleanFeatureDefinition> = (() => BooleanFeatureInclude<TFeature>) & Readonly<TFeature>;
+type MeteredFeatureCallable<TFeature extends MeteredFeatureDefinition> = ((config: MeteredFeatureConfig) => MeteredFeatureInclude<TFeature>) & Readonly<TFeature>;
+type PayKitFeature<TFeature extends PayKitFeatureDefinition = PayKitFeatureDefinition> = TFeature extends BooleanFeatureDefinition ? BooleanFeatureCallable<TFeature> : TFeature extends MeteredFeatureDefinition ? MeteredFeatureCallable<TFeature> : never;
+interface PayKitPlanConfig<TId extends string = string> {
+  default?: boolean;
+  group?: string;
+  id: TId;
+  includes?: readonly PayKitFeatureInclude[];
+  name?: string;
+  price?: PlanPrice;
+}
+type PayKitPlan<TConfig extends PayKitPlanConfig = PayKitPlanConfig> = Readonly<Omit<TConfig, "includes"> & {
+  includes: TConfig["includes"] extends readonly PayKitFeatureInclude[] ? TConfig["includes"] : readonly PayKitFeatureInclude[];
+}>;
+interface NormalizedPlanFeature {
+  config: Record<string, unknown> | null;
+  id: string;
+  limit: number | null;
+  resetInterval: MeteredResetInterval | null;
+  type: FeatureType;
+}
+interface NormalizedPlan {
+  group: string;
+  hash: string;
+  id: string;
+  includes: readonly NormalizedPlanFeature[];
+  isDefault: boolean;
+  name: string;
+  priceAmount: number | null;
+  priceInterval: PriceInterval | null;
+  trialDays: number | null;
+}
+interface NormalizedFeature {
+  id: string;
+  type: FeatureType;
+}
+interface NormalizedSchema {
+  features: readonly NormalizedFeature[];
+  plans: readonly NormalizedPlan[];
+  planMap: ReadonlyMap<string, NormalizedPlan>;
+}
+type PayKitPlansModule = readonly PayKitPlan[] | Record<string, unknown>;
+type PlanIdFromPlans<TPlans> = TPlans extends readonly (infer TItem)[] ? TItem extends PayKitPlan<PayKitPlanConfig<infer TId>> ? TId : never : TPlans extends Record<PropertyKey, unknown> ? TPlans[keyof TPlans] extends infer TValue ? TValue extends {
+  id: infer TId extends string;
+} ? TValue extends PayKitPlan ? TId : never : never : never : never;
+type ExtractFeatureIds<TPlan> = TPlan extends {
+  includes: readonly (infer TInclude)[];
+} ? TInclude extends {
+  feature: {
+    id: infer TId extends string;
+  };
+} ? TId : never : never;
+type FeatureIdFromPlans<TPlans> = TPlans extends readonly (infer TItem)[] ? ExtractFeatureIds<TItem> : TPlans extends Record<PropertyKey, unknown> ? ExtractFeatureIds<TPlans[keyof TPlans]> : never;
+declare function feature<const TId extends string, const TType extends FeatureType>(definition: {
+  id: TId;
+  type: TType;
+}): PayKitFeature<PayKitFeatureDefinition<TId, TType>>;
+declare function plan<const TConfig extends PayKitPlanConfig>(config: TConfig): PayKitPlan<TConfig>;
+//#endregion
+export { FeatureIdFromPlans, FeatureType, MeteredFeatureConfig, MeteredResetInterval, NormalizedPlan, NormalizedPlanFeature, NormalizedSchema, PayKitFeature, PayKitFeatureDefinition, PayKitFeatureInclude, PayKitPlan, PayKitPlanConfig, PayKitPlansModule, PlanIdFromPlans, PlanPrice, PriceInterval, feature, plan };