@xylex-group/athena 2.14.0 → 3.0.2

package/dist/{model-form-DcH3R7WD.d.ts → model-form-Dh0sisdL.d.ts}

@@ -1,5 +1,5 @@
-import { d as AthenaGatewayErrorCode, q as AthenaGatewayEndpointPath, r as AthenaGatewayMethod, e as AthenaGatewayErrorDetails, s as AthenaGatewayResponse } from './types-YQUR7wu0.js';
-import { r as AnyModelDef, a as InsertOf, n as RowOf, U as UpdateOf } from './types-CD6K05JQ.js';
+import { d as AthenaGatewayErrorCode, q as AthenaGatewayEndpointPath, r as AthenaGatewayMethod, e as AthenaGatewayErrorDetails, s as AthenaGatewayResponse } from './types-Bltx6iL6.js';
+import { s as AnyModelDef, a as InsertOf, n as RowOf, U as UpdateOf } from './types-B75PdABb.js';
 
 interface AthenaGatewayErrorInput {
     code: AthenaGatewayErrorCode;

package/dist/{model-form-BE1_Bmdd.d.cts → model-form-oOAJUVd4.d.cts}

@@ -1,5 +1,5 @@
-import { d as AthenaGatewayErrorCode, q as AthenaGatewayEndpointPath, r as AthenaGatewayMethod, e as AthenaGatewayErrorDetails, s as AthenaGatewayResponse } from './types-YQUR7wu0.cjs';
-import { r as AnyModelDef, a as InsertOf, n as RowOf, U as UpdateOf } from './types-6H575ITc.cjs';
+import { d as AthenaGatewayErrorCode, q as AthenaGatewayEndpointPath, r as AthenaGatewayMethod, e as AthenaGatewayErrorDetails, s as AthenaGatewayResponse } from './types-Bltx6iL6.cjs';
+import { s as AnyModelDef, a as InsertOf, n as RowOf, U as UpdateOf } from './types-CgCv5o6R.cjs';
 
 interface AthenaGatewayErrorInput {
     code: AthenaGatewayErrorCode;

package/dist/{module-DFGZXCtt.d.cts → module-CB25egcO.d.cts}

@@ -1,11 +1,22 @@
-import { o as SchemaDef, r as AnyModelDef, D as DatabaseDef, k as ModelMetadata, j as ModelDef, R as RegistryDef, h as ModelColumnKind, q as TenantKeyMap, T as TenantContext, A as AthenaModelTarget, n as RowOf, a as InsertOf, U as UpdateOf, M as ModelAt, S as SchemaIntrospectionProvider, b as IntrospectionColumn, I as IntrospectionSnapshot } from './types-6H575ITc.cjs';
-import { b as ModelFormNullishMode, c as ModelFormValues } from './model-form-BE1_Bmdd.cjs';
+import { o as SchemaDef, s as AnyModelDef, D as DatabaseDef, k as ModelMetadata, j as ModelDef, R as RegistryDef, h as ModelColumnKind, S as SchemaIntrospectionProvider, b as IntrospectionColumn, I as IntrospectionSnapshot } from './types-CgCv5o6R.cjs';
+import { b as ModelFormNullishMode, c as ModelFormValues } from './model-form-oOAJUVd4.cjs';
 import { ZodType } from 'zod';
-import { aV as AthenaSdkClient, d5 as TableQueryBuilder, aH as AthenaFromOptions, ae as AthenaClientContextOptions, al as AthenaClientSessionLike, am as AthenaClientSessionOptions, an as AthenaCreateClientAuthOptions, af as AthenaClientExperimentalOptions, o as AthenaChatMessageCreatedResponse, n as AthenaChatMessage, C as AthenaChatRoomCreatedResponse, B as AthenaChatRoom } from './client-wU2J9yqb.cjs';
-import { a as AthenaGatewayCallOptions } from './types-YQUR7wu0.cjs';
-import { o as GeneratorSchemaSelection, b as GeneratorProviderConfig, r as NormalizedGeneratorFilterConfig, p as GeneratorTableSelection } from './types-dHnjluBC.cjs';
-import { F as AthenaAuthClientConfig, ac as AthenaAuthSdkClient, aS as AuthSocialProvider, a4 as AthenaAuthReactEmailProps, a1 as AthenaAuthReactEmailComponent, a6 as AthenaAuthReactEmailRenderInput, L as AthenaAuthEmailTemplateDefinition, J as AthenaAuthEmailTemplateBuilder, a7 as AthenaAuthReactEmailRenderOptions, a5 as AthenaAuthReactEmailRenderEvent, a2 as AthenaAuthReactEmailConfig } from './types-eAKAh71s.cjs';
+import { o as GeneratorSchemaSelection, b as GeneratorProviderConfig, r as NormalizedGeneratorFilterConfig, p as GeneratorTableSelection } from './types-BBm-kEBL.cjs';
 import { A as AthenaCookiesOptions, a as AthenaSessionPair, b as AthenaCookieOptions, c as AthenaAuthCookies, g as getCookieCache, d as getSessionCookie, e as AthenaCookieContextRuntime } from './index-CFL9xbFR.cjs';
+import { aQ as AuthSocialProvider, a4 as AthenaAuthReactEmailProps, a1 as AthenaAuthReactEmailComponent, a6 as AthenaAuthReactEmailRenderInput, L as AthenaAuthEmailTemplateDefinition, J as AthenaAuthEmailTemplateBuilder, a7 as AthenaAuthReactEmailRenderOptions, a5 as AthenaAuthReactEmailRenderEvent, a2 as AthenaAuthReactEmailConfig } from './types-AOY-GLu8.cjs';
+import { r as AthenaChatMessageCreatedResponse, q as AthenaChatMessage, F as AthenaChatRoomCreatedResponse, E as AthenaChatRoom } from './v3-client-CWfZHcKL.cjs';
+
+type AthenaService = 'db' | 'auth' | 'chat' | 'storage' | 'billing';
+type AthenaConfigurationErrorCode = 'ATHENA_NO_SERVICE_CONFIGURED' | 'ATHENA_SERVICE_NOT_CONFIGURED' | 'ATHENA_API_KEY_REQUIRED' | 'ATHENA_INVALID_URL' | 'ATHENA_NEXT_SERVER_RUNTIME_REQUIRED';
+/**
+ * Structured configuration failure raised during client construction or
+ * unavailable-service access. Distinct from transport/auth/gateway errors.
+ */
+declare class AthenaConfigurationError extends Error {
+    readonly code: AthenaConfigurationErrorCode;
+    readonly service?: AthenaService;
+    constructor(code: AthenaConfigurationErrorCode, message: string, service?: AthenaService);
+}
 
 interface NormalizeAthenaGatewayBaseUrlOptions {
     defaultBaseUrl?: string;
@@ -156,46 +167,6 @@ interface AthenaTableColumnsBuilder<TName extends string, TMappedName extends st
 }
 declare function table<TName extends string>(name: TName): AthenaTableBuilder<TName, undefined>;
 
-type RegistryConstraint = RegistryDef<Record<string, DatabaseDef<Record<string, SchemaDef<Record<string, AnyModelDef>>>>>>;
-/**
- * Options for creating typed Athena clients.
- */
-interface TypedClientOptions<TMap extends TenantKeyMap = TenantKeyMap> extends Pick<AthenaGatewayCallOptions, 'backend' | 'client' | 'headers' | 'forceNoCache' | 'userId' | 'organizationId'> {
-    auth?: Omit<AthenaCreateClientAuthOptions, 'url' | 'baseUrl' | 'apiKey'>;
-    tenantKeyMap?: TMap;
-    tenantContext?: TenantContext<TMap>;
-    experimental?: AthenaClientExperimentalOptions;
-}
-interface TypedClientOptionsWithTypecheckedColumns<TMap extends TenantKeyMap = TenantKeyMap> extends TypedClientOptions<TMap> {
-    experimental: AthenaClientExperimentalOptions & {
-        typecheckColumns: true;
-    };
-}
-/**
- * Typed Athena client with registry-driven model resolution and tenant-context propagation.
- */
-interface TypedAthenaClient<TRegistry extends RegistryConstraint, TTenantMap extends TenantKeyMap = Record<never, string>, TStrict extends boolean = false> extends Omit<AthenaSdkClient<TStrict>, 'from' | 'withContext' | 'withSession'> {
-    readonly registry: TRegistry;
-    readonly tenantKeyMap: Readonly<TTenantMap>;
-    readonly tenantContext: TenantContext<TTenantMap>;
-    from<TModel extends AthenaModelTarget>(model: TModel): TableQueryBuilder<RowOf<TModel>, InsertOf<TModel>, UpdateOf<TModel>, unknown, TStrict>;
-    from<Row = Record<string, unknown>, Insert = Partial<Row>, Update = Partial<Insert>>(table: string, options?: AthenaFromOptions): TableQueryBuilder<Row, Insert, Update, unknown, TStrict>;
-    withContext(context?: AthenaClientContextOptions): TypedAthenaClient<TRegistry, TTenantMap, TStrict>;
-    withSession(session?: AthenaClientSessionLike | null, options?: AthenaClientSessionOptions): TypedAthenaClient<TRegistry, TTenantMap, TStrict>;
-    withTenantContext(context: TenantContext<TTenantMap>): TypedAthenaClient<TRegistry, TTenantMap, TStrict>;
-    fromModel<TDatabase extends keyof TRegistry & string, TSchema extends keyof TRegistry[TDatabase]['schemas'] & string, TModel extends keyof TRegistry[TDatabase]['schemas'][TSchema]['models'] & string>(database: TDatabase, schema: TSchema, model: TModel): TableQueryBuilder<RowOf<ModelAt<TRegistry, TDatabase, TSchema, TModel>>, InsertOf<ModelAt<TRegistry, TDatabase, TSchema, TModel>>, UpdateOf<ModelAt<TRegistry, TDatabase, TSchema, TModel>>, {
-        registry: TRegistry;
-        database: TDatabase;
-        schema: TSchema;
-        model: ModelAt<TRegistry, TDatabase, TSchema, TModel>;
-    }, TStrict>;
-}
-/**
- * Creates a typed client bound to a registry contract and optional tenant header mapping.
- */
-declare function createTypedClient<TRegistry extends RegistryConstraint, TTenantMap extends TenantKeyMap = Record<never, string>>(registry: TRegistry, url: string, apiKey: string, options: TypedClientOptionsWithTypecheckedColumns<TTenantMap>): TypedAthenaClient<TRegistry, TTenantMap, true>;
-declare function createTypedClient<TRegistry extends RegistryConstraint, TTenantMap extends TenantKeyMap = Record<never, string>>(registry: TRegistry, url: string, apiKey: string, options?: TypedClientOptions<TTenantMap>): TypedAthenaClient<TRegistry, TTenantMap, false>;
-
 /**
  * Constructor options for the PostgreSQL introspection provider.
  */
@@ -265,11 +236,6 @@ declare function resolveProviderSchemas(providerConfig: GeneratorProviderConfig)
 declare function normalizeTableSelection(value: GeneratorTableSelection | undefined): string[];
 declare function filterIntrospectionSnapshot(snapshot: IntrospectionSnapshot, filter: NormalizedGeneratorFilterConfig): IntrospectionSnapshot;
 
-/**
- * @deprecated Prefer `createClient(...).auth` from `@xylex-group/athena`.
- */
-declare function createAuthClient(config?: AthenaAuthClientConfig): AthenaAuthSdkClient;
-
 interface AthenaAuthAdminLimits {
     maxAdminJsonBytes: number;
     maxAdminJsonDepth: number;
@@ -541,4 +507,4 @@ declare const chatSdkManifest: {
 declare function unwrapChatRoom(payload: AthenaChatRoomCreatedResponse): AthenaChatRoom;
 declare function unwrapChatMessage(payload: AthenaChatMessageCreatedResponse): AthenaChatMessage;
 
-export { type AthenaAuthDatabaseFactory as $, ATHENA_AUTH_ADMIN_LIMITS as A, filterIntrospectionSnapshot as B, type ColumnRuntimeConfig as C, DEFAULT_POSTGRES_SCHEMAS as D, generatorEnv as E, type FormValuesFromColumns as F, identifier as G, json as H, type InsertFromColumns as I, normalizeAthenaGatewayBaseUrl as J, normalizeSchemaSelection as K, normalizeTableSelection as L, number as M, renderAthenaReactEmail as N, resolvePostgresColumnType as O, type PostgresIntrospectionProviderOptions as P, resolveProviderSchemas as Q, type RowFromColumns as R, string as S, type TypedAthenaClient as T, type UpdateFromColumns as U, table as V, unwrapChatMessage as W, unwrapChatRoom as X, type AthenaAuthBaseURLConfig as Y, type AthenaAuthContext as Z, type AthenaAuthCookieRuntimeInput as _, ATHENA_AUTH_BASE_ERROR_CODES as a, type AthenaAuthHandlerResult as a0, type AthenaAuthPlugin as a1, type AthenaAuthPluginContext as a2, type AthenaAuthPluginHandlerContext as a3, type AthenaAuthRequestContext as a4, type AthenaAuthServer as a5, type AthenaAuthServerApi as a6, type AthenaAuthServerConfig as a7, type AthenaAuthServerRuntimeOptions as a8, type AthenaAuthSocialProviderConfig as a9, type AthenaAuthTrustedOrigins as aa, type AthenaAuthTrustedProviders as ab, type GeneratorEnvBooleanOptions as ac, type GeneratorEnvJsonOptions as ad, type GeneratorEnvListOptions as ae, type GeneratorEnvOneOfOptions as af, type GeneratorEnvStringOptions as ag, createPostgresIntrospectionProvider as ah, ATHENA_AUTH_MAX_ADMIN_JSON_BYTES as b, ATHENA_AUTH_MAX_ADMIN_JSON_DEPTH as c, ATHENA_AUTH_MAX_TEMPLATE_VARIABLES as d, ATHENA_AUTH_MAX_TEMPLATE_VARIABLE_LENGTH as e, type AnyColumnBuilder as f, type AthenaAuthAdminLimits as g, AthenaChatError as h, type AthenaColumnBuilder as i, type AthenaTableDef as j, type AthenaTableSchemaBundle as k, type TypedClientOptions as l, type TypedClientOptionsWithTypecheckedColumns as m, athenaAuth as n, boolean as o, chatSdkManifest as p, createAuthClient as q, createAuthReactEmailInput as r, createTypedClient as s, defineAthenaAuthConfig as t, defineAuthEmailTemplate as u, defineDatabase as v, defineModel as w, defineRegistry as x, defineSchema as y, enumeration as z };
+export { type AthenaAuthPlugin as $, ATHENA_AUTH_ADMIN_LIMITS as A, generatorEnv as B, type ColumnRuntimeConfig as C, DEFAULT_POSTGRES_SCHEMAS as D, identifier as E, type FormValuesFromColumns as F, json as G, normalizeAthenaGatewayBaseUrl as H, type InsertFromColumns as I, normalizeSchemaSelection as J, normalizeTableSelection as K, number as L, renderAthenaReactEmail as M, resolvePostgresColumnType as N, resolveProviderSchemas as O, type PostgresIntrospectionProviderOptions as P, string as Q, type RowFromColumns as R, table as S, unwrapChatMessage as T, type UpdateFromColumns as U, unwrapChatRoom as V, type AthenaAuthBaseURLConfig as W, type AthenaAuthContext as X, type AthenaAuthCookieRuntimeInput as Y, type AthenaAuthDatabaseFactory as Z, type AthenaAuthHandlerResult as _, ATHENA_AUTH_BASE_ERROR_CODES as a, type AthenaAuthPluginContext as a0, type AthenaAuthPluginHandlerContext as a1, type AthenaAuthRequestContext as a2, type AthenaAuthServer as a3, type AthenaAuthServerApi as a4, type AthenaAuthServerConfig as a5, type AthenaAuthServerRuntimeOptions as a6, type AthenaAuthSocialProviderConfig as a7, type AthenaAuthTrustedOrigins as a8, type AthenaAuthTrustedProviders as a9, type GeneratorEnvBooleanOptions as aa, type GeneratorEnvJsonOptions as ab, type GeneratorEnvListOptions as ac, type GeneratorEnvOneOfOptions as ad, type GeneratorEnvStringOptions as ae, createPostgresIntrospectionProvider as af, ATHENA_AUTH_MAX_ADMIN_JSON_BYTES as b, ATHENA_AUTH_MAX_ADMIN_JSON_DEPTH as c, ATHENA_AUTH_MAX_TEMPLATE_VARIABLES as d, ATHENA_AUTH_MAX_TEMPLATE_VARIABLE_LENGTH as e, type AnyColumnBuilder as f, type AthenaAuthAdminLimits as g, AthenaChatError as h, type AthenaColumnBuilder as i, AthenaConfigurationError as j, type AthenaConfigurationErrorCode as k, type AthenaService as l, type AthenaTableDef as m, type AthenaTableSchemaBundle as n, athenaAuth as o, boolean as p, chatSdkManifest as q, createAuthReactEmailInput as r, defineAthenaAuthConfig as s, defineAuthEmailTemplate as t, defineDatabase as u, defineModel as v, defineRegistry as w, defineSchema as x, enumeration as y, filterIntrospectionSnapshot as z };

package/dist/module-C_ab-MM1.d.cts

@@ -0,0 +1,360 @@
+/**
+ * Athena billing HTTP client for live `/billing/v1/*`, `/admin/billing/*`,
+ * provider webhook, and `/debug/billing` routes.
+ *
+ * Methods map 1:1 onto the registered Actix handlers. Auth uses the static
+ * Athena admin key (`X-Athena-Key` / configured API key) matching the server
+ * `authorize_static_admin_key` gate.
+ *
+ * Contract spine: `billingSdkManifest` METHOD+path entries must match the
+ * permanent Rust inventory `athena_billing::LIVE_HTTP_ROUTES`
+ * (exported as `./live-http-routes.json`). Export with
+ * `cargo run -p athena-billing --bin billing-contract-spine -- --write`.
+ */
+type AthenaBillingHttpMethod = 'GET' | 'POST' | 'PATCH' | 'DELETE';
+type AthenaBillingJson = null | boolean | number | string | AthenaBillingJson[] | {
+    [key: string]: AthenaBillingJson;
+};
+interface AthenaBillingCallOptions {
+    headers?: Record<string, string>;
+    signal?: AbortSignal;
+    apiKey?: string | null;
+}
+interface AthenaBillingClientConfig {
+    baseUrl: string;
+    apiKey: string;
+    client?: string | null;
+    headers?: Record<string, string>;
+    fetchImpl?: typeof fetch;
+}
+interface AthenaBillingEnvelope<T = unknown> {
+    status?: string;
+    message?: string;
+    data: T;
+}
+declare class AthenaBillingError extends Error {
+    status: number;
+    endpoint: string;
+    method: string;
+    body: unknown;
+    constructor(input: {
+        message: string;
+        status: number;
+        endpoint: string;
+        method: string;
+        body: unknown;
+    });
+}
+interface BillingConnectionRefInput {
+    connectionId: string;
+    clientName?: string;
+}
+interface BillingListQuery extends BillingConnectionRefInput {
+    cursor?: string;
+    source?: 'provider' | 'persistence' | string;
+    limit?: number;
+    offset?: number;
+}
+interface BillingEnsureCustomerInput extends BillingConnectionRefInput {
+    email?: string | null;
+    name?: string | null;
+    metadata?: Record<string, AthenaBillingJson>;
+    idempotencyKey: string;
+}
+interface BillingUpdateCustomerInput extends BillingConnectionRefInput {
+    email?: string | null;
+    name?: string | null;
+}
+interface BillingCreateConnectionInput {
+    ownerKind: string;
+    ownerId: string;
+    provider: string;
+    mode?: string;
+    status?: string;
+    credentialKind?: string;
+    providerAccountId: string;
+    providerProfileId?: string | null;
+    scopes?: string[];
+    config?: Record<string, AthenaBillingJson>;
+    metadata?: Record<string, AthenaBillingJson>;
+}
+interface BillingUpdateConnectionInput {
+    status?: string;
+    mode?: string;
+    credentialKind?: string;
+    providerAccountId?: string;
+    providerProfileId?: string | null;
+    scopes?: string[];
+    config?: Record<string, AthenaBillingJson>;
+    metadata?: Record<string, AthenaBillingJson>;
+}
+interface BillingReconcileInput {
+    resourceKind: string;
+    resourceId: string;
+    customerId?: string | null;
+}
+interface BillingProvisionSinksInput {
+    targetSchema?: string;
+    instance?: string;
+}
+declare const billingSdkManifest: {
+    readonly namespace: "billing";
+    readonly envelopeKind: "athena";
+    readonly methods: readonly [{
+        readonly name: "getCapabilities";
+        readonly method: "GET";
+        readonly path: "/billing/v1/capabilities";
+    }, {
+        readonly name: "createCheckout";
+        readonly method: "POST";
+        readonly path: "/billing/v1/checkouts";
+    }, {
+        readonly name: "listProducts";
+        readonly method: "GET";
+        readonly path: "/billing/v1/products";
+    }, {
+        readonly name: "listPrices";
+        readonly method: "GET";
+        readonly path: "/billing/v1/prices";
+    }, {
+        readonly name: "listCustomers";
+        readonly method: "GET";
+        readonly path: "/billing/v1/customers";
+    }, {
+        readonly name: "createCustomer";
+        readonly method: "POST";
+        readonly path: "/billing/v1/customers";
+    }, {
+        readonly name: "getCustomer";
+        readonly method: "GET";
+        readonly path: "/billing/v1/customers/{id}";
+    }, {
+        readonly name: "updateCustomer";
+        readonly method: "PATCH";
+        readonly path: "/billing/v1/customers/{id}";
+    }, {
+        readonly name: "deleteCustomer";
+        readonly method: "DELETE";
+        readonly path: "/billing/v1/customers/{id}";
+    }, {
+        readonly name: "listPayments";
+        readonly method: "GET";
+        readonly path: "/billing/v1/payments";
+    }, {
+        readonly name: "createPayment";
+        readonly method: "POST";
+        readonly path: "/billing/v1/payments";
+    }, {
+        readonly name: "getPayment";
+        readonly method: "GET";
+        readonly path: "/billing/v1/payments/{id}";
+    }, {
+        readonly name: "cancelPayment";
+        readonly method: "POST";
+        readonly path: "/billing/v1/payments/{id}/cancel";
+    }, {
+        readonly name: "listPaymentLinks";
+        readonly method: "GET";
+        readonly path: "/billing/v1/payment-links";
+    }, {
+        readonly name: "createPaymentLink";
+        readonly method: "POST";
+        readonly path: "/billing/v1/payment-links";
+    }, {
+        readonly name: "getPaymentLink";
+        readonly method: "GET";
+        readonly path: "/billing/v1/payment-links/{id}";
+    }, {
+        readonly name: "updatePaymentLink";
+        readonly method: "PATCH";
+        readonly path: "/billing/v1/payment-links/{id}";
+    }, {
+        readonly name: "deletePaymentLink";
+        readonly method: "DELETE";
+        readonly path: "/billing/v1/payment-links/{id}";
+    }, {
+        readonly name: "listRefunds";
+        readonly method: "GET";
+        readonly path: "/billing/v1/refunds";
+    }, {
+        readonly name: "createRefund";
+        readonly method: "POST";
+        readonly path: "/billing/v1/refunds";
+    }, {
+        readonly name: "getRefund";
+        readonly method: "GET";
+        readonly path: "/billing/v1/refunds/{id}";
+    }, {
+        readonly name: "cancelRefund";
+        readonly method: "POST";
+        readonly path: "/billing/v1/refunds/{id}/cancel";
+    }, {
+        readonly name: "listSubscriptions";
+        readonly method: "GET";
+        readonly path: "/billing/v1/subscriptions";
+    }, {
+        readonly name: "createSubscription";
+        readonly method: "POST";
+        readonly path: "/billing/v1/subscriptions";
+    }, {
+        readonly name: "getSubscription";
+        readonly method: "GET";
+        readonly path: "/billing/v1/subscriptions/{id}";
+    }, {
+        readonly name: "updateSubscription";
+        readonly method: "PATCH";
+        readonly path: "/billing/v1/subscriptions/{id}";
+    }, {
+        readonly name: "cancelSubscription";
+        readonly method: "POST";
+        readonly path: "/billing/v1/subscriptions/{id}/cancel";
+    }, {
+        readonly name: "listInvoices";
+        readonly method: "GET";
+        readonly path: "/billing/v1/invoices";
+    }, {
+        readonly name: "getInvoice";
+        readonly method: "GET";
+        readonly path: "/billing/v1/invoices/{id}";
+    }, {
+        readonly name: "listWebhooks";
+        readonly method: "GET";
+        readonly path: "/billing/v1/webhooks";
+    }, {
+        readonly name: "createWebhook";
+        readonly method: "POST";
+        readonly path: "/billing/v1/webhooks";
+    }, {
+        readonly name: "getWebhook";
+        readonly method: "GET";
+        readonly path: "/billing/v1/webhooks/{id}";
+    }, {
+        readonly name: "updateWebhook";
+        readonly method: "PATCH";
+        readonly path: "/billing/v1/webhooks/{id}";
+    }, {
+        readonly name: "deleteWebhook";
+        readonly method: "DELETE";
+        readonly path: "/billing/v1/webhooks/{id}";
+    }, {
+        readonly name: "testWebhook";
+        readonly method: "POST";
+        readonly path: "/billing/v1/webhooks/{id}/test";
+    }, {
+        readonly name: "listConnections";
+        readonly method: "GET";
+        readonly path: "/admin/billing/clients/{client_name}/connections";
+    }, {
+        readonly name: "createConnection";
+        readonly method: "POST";
+        readonly path: "/admin/billing/clients/{client_name}/connections";
+    }, {
+        readonly name: "getConnection";
+        readonly method: "GET";
+        readonly path: "/admin/billing/clients/{client_name}/connections/{connection_id}";
+    }, {
+        readonly name: "updateConnection";
+        readonly method: "PATCH";
+        readonly path: "/admin/billing/clients/{client_name}/connections/{connection_id}";
+    }, {
+        readonly name: "deleteConnection";
+        readonly method: "DELETE";
+        readonly path: "/admin/billing/clients/{client_name}/connections/{connection_id}";
+    }, {
+        readonly name: "reconcileDocument";
+        readonly method: "POST";
+        readonly path: "/admin/billing/clients/{client_name}/connections/{connection_id}/reconcile";
+    }, {
+        readonly name: "listWebhookEvents";
+        readonly method: "GET";
+        readonly path: "/admin/billing/clients/{client_name}/webhook-events";
+    }, {
+        readonly name: "provisionWebhookSinks";
+        readonly method: "POST";
+        readonly path: "/admin/billing/clients/{client_name}/webhook-sinks/provision";
+    }, {
+        readonly name: "listGrants";
+        readonly method: "GET";
+        readonly path: "/admin/billing/grants";
+    }, {
+        readonly name: "listProviders";
+        readonly method: "GET";
+        readonly path: "/admin/billing/providers";
+    }, {
+        readonly name: "listSinkHelpers";
+        readonly method: "GET";
+        readonly path: "/admin/webhook-sinks/helpers/billing";
+    }, {
+        readonly name: "ingestProviderWebhook";
+        readonly method: "POST";
+        readonly path: "/billing/providers/{provider}/clients/{client_name}/connections/{connection_id}/webhook";
+    }, {
+        readonly name: "getDebugBilling";
+        readonly method: "GET";
+        readonly path: "/debug/billing";
+    }];
+};
+interface AthenaBillingModule {
+    getCapabilities(input: BillingConnectionRefInput, options?: AthenaBillingCallOptions): Promise<unknown>;
+    createCheckout(body: Record<string, unknown>, options?: AthenaBillingCallOptions): Promise<unknown>;
+    listProducts(input: BillingConnectionRefInput, options?: AthenaBillingCallOptions): Promise<unknown>;
+    listPrices(input: BillingConnectionRefInput & {
+        productId?: string;
+    }, options?: AthenaBillingCallOptions): Promise<unknown>;
+    listCustomers(input: BillingListQuery, options?: AthenaBillingCallOptions): Promise<unknown>;
+    createCustomer(input: BillingEnsureCustomerInput, options?: AthenaBillingCallOptions): Promise<unknown>;
+    getCustomer(id: string, input: BillingConnectionRefInput, options?: AthenaBillingCallOptions): Promise<unknown>;
+    updateCustomer(id: string, input: BillingUpdateCustomerInput, options?: AthenaBillingCallOptions): Promise<unknown>;
+    deleteCustomer(id: string, input: BillingConnectionRefInput, options?: AthenaBillingCallOptions): Promise<unknown>;
+    listPayments(input: BillingListQuery, options?: AthenaBillingCallOptions): Promise<unknown>;
+    createPayment(body: Record<string, unknown>, options?: AthenaBillingCallOptions): Promise<unknown>;
+    getPayment(id: string, input: BillingConnectionRefInput, options?: AthenaBillingCallOptions): Promise<unknown>;
+    cancelPayment(id: string, input: BillingConnectionRefInput, options?: AthenaBillingCallOptions): Promise<unknown>;
+    listPaymentLinks(input: BillingListQuery, options?: AthenaBillingCallOptions): Promise<unknown>;
+    createPaymentLink(body: Record<string, unknown>, options?: AthenaBillingCallOptions): Promise<unknown>;
+    getPaymentLink(id: string, input: BillingConnectionRefInput, options?: AthenaBillingCallOptions): Promise<unknown>;
+    updatePaymentLink(id: string, body: Record<string, unknown>, options?: AthenaBillingCallOptions): Promise<unknown>;
+    deletePaymentLink(id: string, input: BillingConnectionRefInput, options?: AthenaBillingCallOptions): Promise<unknown>;
+    listRefunds(input: BillingListQuery, options?: AthenaBillingCallOptions): Promise<unknown>;
+    createRefund(body: Record<string, unknown>, options?: AthenaBillingCallOptions): Promise<unknown>;
+    getRefund(id: string, input: BillingConnectionRefInput, options?: AthenaBillingCallOptions): Promise<unknown>;
+    cancelRefund(id: string, input: BillingConnectionRefInput, options?: AthenaBillingCallOptions): Promise<unknown>;
+    listSubscriptions(input: BillingListQuery, options?: AthenaBillingCallOptions): Promise<unknown>;
+    createSubscription(body: Record<string, unknown>, options?: AthenaBillingCallOptions): Promise<unknown>;
+    getSubscription(id: string, input: BillingConnectionRefInput, options?: AthenaBillingCallOptions): Promise<unknown>;
+    updateSubscription(id: string, body: Record<string, unknown>, options?: AthenaBillingCallOptions): Promise<unknown>;
+    cancelSubscription(id: string, input: BillingConnectionRefInput, options?: AthenaBillingCallOptions): Promise<unknown>;
+    listInvoices(input: BillingListQuery, options?: AthenaBillingCallOptions): Promise<unknown>;
+    getInvoice(id: string, input: BillingConnectionRefInput, options?: AthenaBillingCallOptions): Promise<unknown>;
+    listWebhooks(input: BillingListQuery, options?: AthenaBillingCallOptions): Promise<unknown>;
+    createWebhook(input: BillingConnectionRefInput, body: Record<string, unknown>, options?: AthenaBillingCallOptions): Promise<unknown>;
+    getWebhook(id: string, input: BillingConnectionRefInput, options?: AthenaBillingCallOptions): Promise<unknown>;
+    updateWebhook(id: string, input: BillingConnectionRefInput, body: Record<string, unknown>, options?: AthenaBillingCallOptions): Promise<unknown>;
+    deleteWebhook(id: string, input: BillingConnectionRefInput, options?: AthenaBillingCallOptions): Promise<unknown>;
+    testWebhook(id: string, input: BillingConnectionRefInput, options?: AthenaBillingCallOptions): Promise<unknown>;
+    listConnections(clientName: string, options?: AthenaBillingCallOptions): Promise<unknown>;
+    createConnection(clientName: string, input: BillingCreateConnectionInput, options?: AthenaBillingCallOptions): Promise<unknown>;
+    getConnection(clientName: string, connectionId: string, options?: AthenaBillingCallOptions): Promise<unknown>;
+    updateConnection(clientName: string, connectionId: string, input: BillingUpdateConnectionInput, options?: AthenaBillingCallOptions): Promise<unknown>;
+    deleteConnection(clientName: string, connectionId: string, options?: AthenaBillingCallOptions): Promise<unknown>;
+    reconcileDocument(clientName: string, connectionId: string, input: BillingReconcileInput, options?: AthenaBillingCallOptions): Promise<unknown>;
+    listWebhookEvents(clientName: string, options?: AthenaBillingCallOptions): Promise<unknown>;
+    provisionWebhookSinks(clientName: string, input?: BillingProvisionSinksInput, options?: AthenaBillingCallOptions): Promise<unknown>;
+    listGrants(options?: AthenaBillingCallOptions): Promise<unknown>;
+    listProviders(options?: AthenaBillingCallOptions): Promise<unknown>;
+    listSinkHelpers(query?: {
+        targetSchema?: string;
+        instance?: string;
+    }, options?: AthenaBillingCallOptions): Promise<unknown>;
+    ingestProviderWebhook(input: {
+        provider: string;
+        clientName: string;
+        connectionId: string;
+        body: BodyInit | Record<string, unknown> | string;
+        signatureHeaders?: Record<string, string>;
+    }, options?: AthenaBillingCallOptions): Promise<unknown>;
+    getDebugBilling(jwtSecret: string, options?: AthenaBillingCallOptions): Promise<string>;
+}
+declare function createBillingModule(config: AthenaBillingClientConfig): AthenaBillingModule;
+
+export { type AthenaBillingCallOptions as A, type BillingConnectionRefInput as B, type AthenaBillingClientConfig as a, AthenaBillingError as b, type AthenaBillingModule as c, billingSdkManifest as d, createBillingModule as e, type AthenaBillingEnvelope as f, type AthenaBillingHttpMethod as g, type AthenaBillingJson as h, type BillingCreateConnectionInput as i, type BillingEnsureCustomerInput as j, type BillingListQuery as k, type BillingProvisionSinksInput as l, type BillingReconcileInput as m, type BillingUpdateConnectionInput as n, type BillingUpdateCustomerInput as o };