@forgezero/providers 0.1.23 → 0.1.25

package/dist/{chain.js → billing.js}

@@ -336,155 +336,270 @@ function createService(definition, methods, options = {}) {
     }
   };
 }
-var VERSION = "0.1.23";
+var VERSION = "0.1.25";
 
-// src/chain.ts
-var hexToNumber = (value) => Number(BigInt(value));
-var TERMINAL_PATTERNS = [
-  "already known",
-  "nonce too low",
-  "already imported",
-  "replacement transaction underpriced",
-  "intrinsic gas too low",
-  "insufficient funds",
-  "exceeds block gas limit",
-  "invalid sender",
-  "execution reverted"
-];
-var evmRpc = defineSingleMethodProvider({
-  id: "evm-rpc",
-  method: "request",
-  label: "EVM JSON-RPC node",
-  multiInstance: true,
-  credentials: {
-    type: "object",
-    properties: {
-      url: { type: "string", writeOnly: true },
-      bearer: { type: "string", writeOnly: true }
+// src/billing.ts
+var PAYMENT_PROVIDER_KEYS = ["stripe:v1", "paypal:v1", "razorpay:v1"];
+var paymentProviderDefinitions = [
+  {
+    id: "stripe",
+    label: "Stripe",
+    multiInstance: true,
+    config: {
+      type: "object",
+      properties: {
+        providerApiVersion: { type: "string", minLength: 4, maxLength: 64 },
+        mode: { type: "string", enum: ["test", "live"] }
+      },
+      required: ["providerApiVersion", "mode"],
+      additionalProperties: false
     },
-    required: ["url"],
-    additionalProperties: false
-  },
-  config: {
-    type: "object",
-    properties: {
-      chainId: { type: "integer" },
-      maxLogRange: { type: "integer" },
-      timeoutMs: { type: "integer" }
+    credentials: {
+      type: "object",
+      properties: {
+        secretKey: { type: "string", minLength: 16, maxLength: 512, writeOnly: true },
+        webhookSecret: { type: "string", minLength: 16, maxLength: 512, writeOnly: true }
+      },
+      required: ["secretKey", "webhookSecret"],
+      additionalProperties: false
     },
-    required: ["chainId"],
-    additionalProperties: false
+    methods: {}
   },
-  async invoke(context, call) {
-    const config = context.config;
-    const url = await context.secret("url");
-    const bearer = await context.secret("bearer").catch(() => {
-      return;
-    });
-    const rpc = async (method, params) => {
-      const response = await fetch(url, {
-        method: "POST",
-        headers: {
-          "content-type": "application/json",
-          ...bearer ? { authorization: `Bearer ${bearer}` } : {}
-        },
-        body: JSON.stringify({ jsonrpc: "2.0", id: 1, method, params }),
-        signal: context.signal ?? AbortSignal.timeout(config.timeoutMs ?? 15000)
-      });
-      if (!response.ok) {
-        throw new ProviderError("RPC_HTTP", `${method}: HTTP ${response.status}`, {
-          status: response.status
-        });
-      }
-      const body = await response.json();
-      if (body.error) {
-        throw new ProviderError("RPC_ERROR", `${method}: ${body.error.message ?? "error"}`, {
-          code: body.error.code
-        });
-      }
-      if (body.result === undefined) {
-        throw new ProviderError("RPC_EMPTY", `${method}: no result`);
-      }
-      return body.result;
-    };
-    switch (call.op) {
-      case "head":
-        return { op: "head", block: hexToNumber(await rpc("eth_blockNumber", [])) };
-      case "balance":
-        return {
-          op: "balance",
-          wei: BigInt(await rpc("eth_getBalance", [call.address, call.block ?? "latest"]))
-        };
-      case "call":
-        return {
-          op: "call",
-          data: await rpc("eth_call", [
-            { to: call.to, data: call.data },
-            call.block ?? "latest"
-          ])
-        };
-      case "logs": {
-        const span = call.toBlock - call.fromBlock + 1;
-        const cap = config.maxLogRange ?? 2000;
-        if (span > cap) {
-          throw new ProviderError("RPC_RANGE_TOO_WIDE", `Asked for ${span} blocks; this node allows ${cap}. Split the range.`);
-        }
-        const logs = await rpc("eth_getLogs", [
-          {
-            fromBlock: `0x${call.fromBlock.toString(16)}`,
-            toBlock: `0x${call.toBlock.toString(16)}`,
-            ...call.address ? { address: call.address } : {},
-            ...call.topics ? { topics: call.topics } : {}
-          }
-        ]);
-        return {
-          op: "logs",
-          logs: logs.map((log) => ({
-            transactionHash: log.transactionHash,
-            logIndex: hexToNumber(log.logIndex),
-            blockNumber: hexToNumber(log.blockNumber),
-            address: log.address,
-            topics: log.topics,
-            data: log.data
-          }))
-        };
-      }
-      case "nonce":
-        return {
-          op: "nonce",
-          nonce: BigInt(await rpc("eth_getTransactionCount", [call.address, call.block ?? "pending"]))
-        };
-      case "send":
-        return { op: "send", hash: await rpc("eth_sendRawTransaction", [call.raw]) };
-      case "receipt": {
-        const receipt = await rpc("eth_getTransactionReceipt", [call.hash]);
-        if (!receipt)
-          return { op: "receipt", receipt: null };
-        return {
-          op: "receipt",
-          receipt: {
-            hash: call.hash,
-            blockNumber: hexToNumber(receipt.blockNumber ?? "0x0"),
-            success: receipt.status === "0x1"
-          }
-        };
-      }
-    }
+  {
+    id: "paypal",
+    label: "PayPal",
+    multiInstance: true,
+    config: {
+      type: "object",
+      properties: {
+        providerApiVersion: { type: "string", minLength: 2, maxLength: 64 },
+        environment: { type: "string", enum: ["sandbox", "live"] }
+      },
+      required: ["providerApiVersion", "environment"],
+      additionalProperties: false
+    },
+    credentials: {
+      type: "object",
+      properties: {
+        clientId: { type: "string", minLength: 10, maxLength: 512, writeOnly: true },
+        clientSecret: { type: "string", minLength: 10, maxLength: 512, writeOnly: true },
+        webhookId: { type: "string", minLength: 4, maxLength: 256, writeOnly: true }
+      },
+      required: ["clientId", "clientSecret", "webhookId"],
+      additionalProperties: false
+    },
+    methods: {}
   },
-  classify(error) {
-    const message = String(error?.message ?? "").toLowerCase();
-    const details = error.details;
-    if (TERMINAL_PATTERNS.some((pattern) => message.includes(pattern)))
-      return "terminal";
-    if (message.includes("split the range"))
-      return "terminal";
-    if (details?.code === -32602)
-      return "terminal";
-    if (details?.status === 429 || message.includes("rate limit") || message.includes("too many"))
-      return "backoff";
-    return "retryable";
+  {
+    id: "razorpay",
+    label: "Razorpay",
+    multiInstance: true,
+    config: {
+      type: "object",
+      properties: {
+        providerApiVersion: { type: "string", minLength: 2, maxLength: 64 },
+        mode: { type: "string", enum: ["test", "live"] }
+      },
+      required: ["providerApiVersion", "mode"],
+      additionalProperties: false
+    },
+    credentials: {
+      type: "object",
+      properties: {
+        keyId: { type: "string", minLength: 8, maxLength: 256, writeOnly: true },
+        keySecret: { type: "string", minLength: 8, maxLength: 512, writeOnly: true },
+        webhookSecret: { type: "string", minLength: 8, maxLength: 512, writeOnly: true }
+      },
+      required: ["keyId", "keySecret", "webhookSecret"],
+      additionalProperties: false
+    },
+    methods: {}
+  }
+];
+var billingService = defineService({
+  key: "billing",
+  methods: {
+    createHostedSetup: serviceMethod(),
+    completeHostedSetup: serviceMethod(),
+    createCustomer: serviceMethod(),
+    charge: serviceMethod(),
+    detachPaymentMethod: serviceMethod(),
+    verifyWebhook: serviceMethod(),
+    reconcile: serviceMethod()
   }
 });
+function required(value, field, maximum = 512) {
+  const result = value.trim();
+  if (!result || result.length > maximum)
+    throw new Error(`PAYMENT_${field.toUpperCase()}_INVALID`);
+  return result;
+}
+function assertHostedInput(input) {
+  required(input.tenantKey, "tenant");
+  required(input.idempotencyKey, "idempotency", 200);
+  for (const [field, value] of [["return_url", input.returnUrl], ["cancel_url", input.cancelUrl]]) {
+    const url = new URL(required(value, field, 2048));
+    if (url.protocol !== "https:")
+      throw new Error(`PAYMENT_${field.toUpperCase()}_INVALID`);
+  }
+}
+function assertChargeInput(input) {
+  required(input.tenantKey, "tenant");
+  required(input.invoiceKey, "invoice");
+  required(input.providerCustomerReference, "customer_reference");
+  required(input.providerPaymentMethodReference, "method_reference");
+  required(input.idempotencyKey, "idempotency", 200);
+  if (!/^[1-9][0-9]*$/.test(input.amountMinor))
+    throw new Error("PAYMENT_AMOUNT_INVALID");
+  if (input.currency !== "USD")
+    throw new Error("PAYMENT_CURRENCY_INVALID");
+}
+function assertSetupCompletion(input) {
+  required(input.tenantKey, "tenant");
+  required(input.setupReference, "setup_reference", 512);
+  required(input.idempotencyKey, "idempotency", 200);
+}
+function assertHostedResult(value) {
+  const hostedUrl = new URL(required(value.hostedUrl, "hosted_url", 2048));
+  if (hostedUrl.protocol !== "https:" || hostedUrl.username || hostedUrl.password)
+    throw new Error("PAYMENT_HOSTED_URL_INVALID");
+  required(value.setupReference, "setup_reference", 512);
+  if (!Number.isSafeInteger(value.expiresAtTs) || value.expiresAtTs <= Date.now())
+    throw new Error("PAYMENT_SETUP_EXPIRY_INVALID");
+  return { ...value, hostedUrl: hostedUrl.toString() };
+}
+function assertCompletionResult(value) {
+  required(value.providerPaymentMethodReference, "method_reference", 512);
+  if (value.providerCustomerReference !== undefined)
+    required(value.providerCustomerReference, "customer_reference", 512);
+  const display = value.display;
+  if (!display || !["card", "bank", "upi", "paypal", "other"].includes(display.type))
+    throw new Error("PAYMENT_DISPLAY_INVALID");
+  for (const [field, item, maximum] of [
+    ["brand", display.brand, 80],
+    ["last4", display.last4, 8],
+    ["label", display.label, 160]
+  ]) {
+    if (item !== undefined)
+      required(item, `display_${field}`, maximum);
+  }
+  if (display.last4 !== undefined && !/^[A-Za-z0-9]{1,8}$/.test(display.last4))
+    throw new Error("PAYMENT_DISPLAY_LAST4_INVALID");
+  for (const value2 of [display.expiresMonth, display.expiresYear]) {
+    if (value2 !== undefined && !Number.isSafeInteger(value2))
+      throw new Error("PAYMENT_DISPLAY_EXPIRY_INVALID");
+  }
+  if (display.expiresMonth !== undefined && (display.expiresMonth < 1 || display.expiresMonth > 12))
+    throw new Error("PAYMENT_DISPLAY_EXPIRY_INVALID");
+  return structuredClone(value);
+}
+function assertCustomerResult(value) {
+  return { providerCustomerReference: required(value.providerCustomerReference, "customer_reference", 512) };
+}
+function assertChargeResult(value) {
+  const providerAttemptReference = required(value.providerAttemptReference, "attempt_reference", 512);
+  if (!["succeeded", "failed", "pending"].includes(value.status))
+    throw new Error("PAYMENT_STATUS_INVALID");
+  const failureCode = value.failureCode === undefined ? undefined : required(value.failureCode, "failure_code", 160);
+  return { providerAttemptReference, status: value.status, ...failureCode ? { failureCode } : {} };
+}
+function assertWebhookResult(value) {
+  const providerEventId = required(value.providerEventId, "event_id", 512);
+  const eventType = required(value.eventType, "event_type", 160);
+  const resourceReference = required(value.resourceReference, "resource_reference", 512);
+  if (!["succeeded", "failed", "pending"].includes(value.status))
+    throw new Error("PAYMENT_STATUS_INVALID");
+  if (!Number.isSafeInteger(value.occurredAtTs) || value.occurredAtTs < 0)
+    throw new Error("PAYMENT_EVENT_TIME_INVALID");
+  const failureCode = value.failureCode === undefined ? undefined : required(value.failureCode, "failure_code", 160);
+  return {
+    providerEventId,
+    eventType,
+    resourceReference,
+    status: value.status,
+    occurredAtTs: value.occurredAtTs,
+    ...failureCode ? { failureCode } : {}
+  };
+}
+function assertReconciliationResult(value) {
+  const providerAttemptReference = required(value.providerAttemptReference, "attempt_reference", 512);
+  if (!["succeeded", "failed", "pending", "not_found"].includes(value.status))
+    throw new Error("PAYMENT_STATUS_INVALID");
+  const failureCode = value.failureCode === undefined ? undefined : required(value.failureCode, "failure_code", 160);
+  return { providerAttemptReference, status: value.status, ...failureCode ? { failureCode } : {} };
+}
+function paymentProviderAdapter(args) {
+  const [provider, contractVersion] = args.key.split(":");
+  const providerApiVersion = required(args.providerApiVersion, "api_version", 100);
+  return Object.freeze({
+    key: args.key,
+    provider,
+    contractVersion,
+    providerApiVersion,
+    async createHostedSetup(input) {
+      assertHostedInput(input);
+      return assertHostedResult(await args.driver.createHostedSetup(input));
+    },
+    async completeHostedSetup(input) {
+      assertSetupCompletion(input);
+      return assertCompletionResult(await args.driver.completeHostedSetup(input));
+    },
+    async createCustomer(input) {
+      required(input.tenantKey, "tenant");
+      required(input.email, "email");
+      required(input.idempotencyKey, "idempotency", 200);
+      return assertCustomerResult(await args.driver.createCustomer(input));
+    },
+    async charge(input) {
+      assertChargeInput(input);
+      return assertChargeResult(await args.driver.charge(input));
+    },
+    async detachPaymentMethod(input) {
+      required(input.tenantKey, "tenant");
+      required(input.providerPaymentMethodReference, "method_reference");
+      required(input.idempotencyKey, "idempotency", 200);
+      return args.driver.detachPaymentMethod(input);
+    },
+    async verifyWebhook(input) {
+      if (!(input.rawBody instanceof Uint8Array) || input.rawBody.byteLength > 1048576) {
+        throw new Error("PAYMENT_WEBHOOK_BODY_INVALID");
+      }
+      return assertWebhookResult(await args.driver.verifyWebhook(input));
+    },
+    async reconcile(input) {
+      required(input.tenantKey, "tenant");
+      required(input.providerAttemptReference, "attempt_reference");
+      return assertReconciliationResult(await args.driver.reconcile(input));
+    }
+  });
+}
+function definePaymentProvider(args) {
+  const classify = args.classify ?? (() => "retryable");
+  const branch = (invoke) => defineProviderMethodBranches({
+    currentVersion: args.version,
+    versions: { [args.version]: { version: args.version, lifecycle: "current", invoke, classify } }
+  });
+  return defineProvider({
+    id: args.id,
+    label: args.label,
+    multiInstance: true,
+    config: args.config,
+    credentials: args.credentials,
+    methods: {
+      createHostedSetup: branch(args.driver.createHostedSetup),
+      completeHostedSetup: branch(args.driver.completeHostedSetup),
+      createCustomer: branch(args.driver.createCustomer),
+      charge: branch(args.driver.charge),
+      detachPaymentMethod: branch(args.driver.detachPaymentMethod),
+      verifyWebhook: branch(args.driver.verifyWebhook),
+      reconcile: branch(args.driver.reconcile)
+    }
+  });
+}
 export {
-  evmRpc
+  paymentProviderDefinitions,
+  paymentProviderAdapter,
+  definePaymentProvider,
+  billingService,
+  PAYMENT_PROVIDER_KEYS
 };

package/dist/database.js

@@ -336,7 +336,7 @@ function createService(definition, methods, options = {}) {
     }
   };
 }
-var VERSION = "0.1.23";
+var VERSION = "0.1.25";
 
 // src/database.ts
 var pools = new Map;

package/dist/email.js

@@ -336,7 +336,7 @@ function createService(definition, methods, options = {}) {
     }
   };
 }
-var VERSION = "0.1.23";
+var VERSION = "0.1.25";
 
 // src/email.ts
 var recipients = (to) => Array.isArray(to) ? [...to] : [to];

package/dist/git.d.ts

@@ -1,8 +1,47 @@
 import { type FailureKind, type InvokeContext, type ProviderDefinition } from './index';
-export interface GitAccount {
+/**
+ * GitHub is one provider authority with two deliberately separate service
+ * bindings. OAuth Server receives only user-authorization methods; Git Connect
+ * receives only installation/repository methods. Both resolve the same
+ * provider instance and therefore the same Vault credential exactly once.
+ */
+export interface GitHubUserAuthorizationRequest {
+    intent: 'signin' | 'signup' | 'invite' | 'recover' | 'session';
+    returnTo: string;
+    state: string;
+    codeChallenge: string;
+}
+export interface GitHubUserAuthorization {
+    url: string;
+    expiresAtTs: number;
+}
+export interface GitHubUserAuthorizationCompletion {
+    code: string;
+    state: string;
+    codeVerifier: string;
+}
+export interface GitHubVerifiedIdentity {
+    providerUserId: string;
+    email: string;
+    displayName?: string;
+}
+export interface GitHubUserGrant {
+    accessToken: string;
+    expiresAtTs?: number;
+    refreshToken?: string;
+    refreshTokenExpiresAtTs?: number;
+}
+export interface GitHubUserGrantRefreshRequest {
+    refreshToken: string;
+}
+export interface GitHubUserGrantRevokeRequest {
+    accessToken: string;
+}
+export interface GitInstallation {
     id: string;
-    label: string;
-    kind: 'user' | 'organization' | 'group' | 'other';
+    accountId: string;
+    accountLabel: string;
+    accountKind: 'user' | 'organization';
 }
 export interface GitRepository {
     id: string;
@@ -20,29 +59,46 @@ export interface GitCloneCredential {
     token: string;
     expiresAtTs: number;
 }
-export interface GitAccountRequest {
-    cursor?: string;
+export interface GitInstallationStartRequest {
+    returnTo: string;
+    state: string;
+}
+export interface GitInstallationStart {
+    url: string;
+    expiresAtTs: number;
+}
+export interface GitInstallationCompletionRequest {
+    installationId: string;
+    setupAction?: 'install' | 'update';
+    state: string;
+}
+export interface GitInstallationRequest {
+    installationId: string;
 }
 export interface GitRepositoryRequest {
-    accountId: string;
+    installationId: string;
     cursor?: string;
 }
 export interface GitBranchRequest {
-    accountId: string;
+    installationId: string;
     repository: string;
     cursor?: string;
 }
-export interface GitWebhookRequest {
-    accountId: string;
-    repository: string;
-    callbackUrl: string;
-    secret: string;
-    events: readonly ['push'];
-}
 export interface GitCloneCredentialRequest {
-    accountId: string;
+    installationId: string;
     repository: string;
 }
+export interface GitWebhookVerificationRequest {
+    rawBody: Uint8Array;
+    signature: string;
+    deliveryId: string;
+    event: string;
+}
+export interface GitWebhookEvent {
+    deliveryId: string;
+    event: string;
+    payload: unknown;
+}
 export declare const githubAppConfigSchema: {
     readonly type: "object";
     readonly properties: {
@@ -59,8 +115,16 @@ export declare const githubAppConfigSchema: {
             readonly type: "string";
             readonly pattern: "^[a-z0-9][a-z0-9-]{0,99}$";
         };
+        readonly providerVersion: {
+            readonly type: "string";
+            readonly pattern: "^github-app:[a-z0-9][a-z0-9.-]{0,31}$";
+        };
+        readonly verifiedAtTs: {
+            readonly type: "integer";
+            readonly minimum: 1;
+        };
     };
-    readonly required: readonly ["clientId", "appId", "slug"];
+    readonly required: readonly ["clientId", "appId", "slug", "providerVersion", "verifiedAtTs"];
     readonly additionalProperties: false;
 };
 export declare const githubAppCredentialSchema: {
@@ -88,37 +152,41 @@ export declare const githubAppCredentialSchema: {
     readonly required: readonly ["clientSecret", "privateKey", "webhookSecret"];
     readonly additionalProperties: false;
 };
+export declare const oauthServerService: import("./index").ServiceDefinition<"oauth-server", {
+    beginUserAuthorization: import("./index").ServiceMethodContract<GitHubUserAuthorizationRequest, GitHubUserAuthorization>;
+    completeUserAuthorization: import("./index").ServiceMethodContract<GitHubUserAuthorizationCompletion, GitHubUserGrant>;
+    readVerifiedIdentity: import("./index").ServiceMethodContract<GitHubUserGrant, GitHubVerifiedIdentity>;
+    refreshUserGrant: import("./index").ServiceMethodContract<GitHubUserGrantRefreshRequest, GitHubUserGrant>;
+    revokeUserGrant: import("./index").ServiceMethodContract<GitHubUserGrantRevokeRequest, void>;
+}>;
 export declare const gitConnectService: import("./index").ServiceDefinition<"git-connect", {
-    listAccounts: import("./index").ServiceMethodContract<GitAccountRequest, readonly GitAccount[]>;
+    beginInstallation: import("./index").ServiceMethodContract<GitInstallationStartRequest, GitInstallationStart>;
+    completeInstallation: import("./index").ServiceMethodContract<GitInstallationCompletionRequest, GitInstallation>;
+    listInstallations: import("./index").ServiceMethodContract<Record<string, never>, readonly GitInstallation[]>;
     listRepositories: import("./index").ServiceMethodContract<GitRepositoryRequest, readonly GitRepository[]>;
     listBranches: import("./index").ServiceMethodContract<GitBranchRequest, readonly GitBranch[]>;
-    ensureWebhook: import("./index").ServiceMethodContract<GitWebhookRequest, {
-        webhookId: string;
-        created: boolean;
-    }>;
-    cloneCredential: import("./index").ServiceMethodContract<GitCloneCredentialRequest, GitCloneCredential>;
+    mintCloneCredential: import("./index").ServiceMethodContract<GitCloneCredentialRequest, GitCloneCredential>;
+    verifyWebhook: import("./index").ServiceMethodContract<GitWebhookVerificationRequest, GitWebhookEvent>;
+    disconnectInstallation: import("./index").ServiceMethodContract<GitInstallationRequest, void>;
 }>;
-export interface GitConnectAdapter {
-    listAccounts(context: InvokeContext, args: GitAccountRequest): Promise<readonly GitAccount[]>;
+export interface GitHubProviderAdapter {
+    beginUserAuthorization(context: InvokeContext, args: GitHubUserAuthorizationRequest): Promise<GitHubUserAuthorization>;
+    completeUserAuthorization(context: InvokeContext, args: GitHubUserAuthorizationCompletion): Promise<GitHubUserGrant>;
+    readVerifiedIdentity(context: InvokeContext, args: GitHubUserGrant): Promise<GitHubVerifiedIdentity>;
+    refreshUserGrant(context: InvokeContext, args: GitHubUserGrantRefreshRequest): Promise<GitHubUserGrant>;
+    revokeUserGrant(context: InvokeContext, args: GitHubUserGrantRevokeRequest): Promise<void>;
+    beginInstallation(context: InvokeContext, args: GitInstallationStartRequest): Promise<GitInstallationStart>;
+    completeInstallation(context: InvokeContext, args: GitInstallationCompletionRequest): Promise<GitInstallation>;
+    listInstallations(context: InvokeContext, args: Record<string, never>): Promise<readonly GitInstallation[]>;
     listRepositories(context: InvokeContext, args: GitRepositoryRequest): Promise<readonly GitRepository[]>;
     listBranches(context: InvokeContext, args: GitBranchRequest): Promise<readonly GitBranch[]>;
-    ensureWebhook(context: InvokeContext, args: GitWebhookRequest): Promise<{
-        webhookId: string;
-        created: boolean;
-    }>;
-    cloneCredential(context: InvokeContext, args: GitCloneCredentialRequest): Promise<GitCloneCredential>;
+    mintCloneCredential(context: InvokeContext, args: GitCloneCredentialRequest): Promise<GitCloneCredential>;
+    verifyWebhook(context: InvokeContext, args: GitWebhookVerificationRequest): Promise<GitWebhookEvent>;
+    disconnectInstallation(context: InvokeContext, args: GitInstallationRequest): Promise<void>;
 }
-/**
- * Define one Git forge without coupling it to ForgeZero Vault or API storage.
- * A GitHub App, GitLab OAuth application, self-hosted forge, or future provider
- * supplies this adapter; the service keeps the same five typed operations.
- */
-export declare function defineGitConnectProvider(args: {
-    id: string;
-    label: string;
+/** Define the single GitHub App provider. No OAuth-App compatibility identity exists. */
+export declare function defineGitHubProvider(args: {
     version: string;
-    adapter: GitConnectAdapter;
-    credentials?: Record<string, unknown>;
-    config?: Record<string, unknown>;
+    adapter: GitHubProviderAdapter;
     classify?: (error: unknown) => FailureKind;
 }): ProviderDefinition;