@wildo-ai/external-connectors-models 1.0.1

package/dist/esm/core/commons.external-connectors-models.schemas.d.ts

@@ -0,0 +1,195 @@
+import { z } from "zod";
+import { ExternalProvider_Auth_Kind } from "./security.external-connectors-models.schemas.js";
+export declare enum ExternalProvider_ExchangeProtocol_Kind {
+    REST_API = "rest_api",
+    WEBHOOK_ORIGINATOR = "webhook_originator",
+    LLM_PROVIDER = "llm_provider",
+    CLI_RUNTIME = "cli_runtime",
+    MCP_CONNECTOR = "mcp_connector",
+    A2A_CONNECTOR = "a2a_connector",
+    EMAIL_PROVIDER = "email_provider",
+    GIT_PROVIDER = "git_provider",
+    GRPC = "grpc",
+    SSO_OAUTH2 = "sso_oauth2",
+    SSO_SAML = "sso_saml",
+    BILLING_PROVIDER = "billing_provider",
+    SMS_PROVIDER = "sms_provider",
+    FRONTEND_INTEGRATION = "frontend_integration"
+}
+export declare enum APPLICATION_ENVIRONMENT {
+    DEVELOPMENT = "development",
+    STAGING = "staging",
+    PRODUCTION = "production"
+}
+export declare enum ExternalProvider_Status {
+    ACTIVE = "active",
+    INACTIVE = "inactive",
+    BUZY = "busy",
+    OFFLINE = "offline",
+    DEPRECATED = "deprecated"
+}
+export declare enum API_HttpMethod {
+    GET = "GET",
+    POST = "POST",
+    PUT = "PUT",
+    PATCH = "PATCH",
+    DELETE = "DELETE",
+    HEAD = "HEAD",
+    OPTIONS = "OPTIONS"
+}
+/**
+ * Shared protocol profile fields.
+ *
+ * These fields are transport-oriented hints that many protocols use, but they
+ * are not universally meaningful. Execution-oriented protocols such as a local
+ * CLI runtime should not need to invent fake HTTP endpoints or auth profiles
+ * just to satisfy the shared contract.
+ */
+export declare const ExternalProvider_ExchangeProtocol_Profile_BaseSchema: z.ZodObject<{
+    endpoints: z.ZodOptional<z.ZodRecord<z.ZodEnum<typeof APPLICATION_ENVIRONMENT>, z.ZodString>>;
+    availableAuthMethods: z.ZodOptional<z.ZodArray<z.ZodEnum<typeof ExternalProvider_Auth_Kind>>>;
+    authProfiles: z.ZodOptional<z.ZodArray<z.ZodDiscriminatedUnion<[z.ZodObject<{
+        ref: z.ZodOptional<z.ZodString>;
+        isDefault: z.ZodDefault<z.ZodBoolean>;
+        location: z.ZodDefault<z.ZodEnum<typeof import("./security.external-connectors-models.schemas.js").ExternalProvider_Auth_ApiKey_Location>>;
+        kind: z.ZodLiteral<ExternalProvider_Auth_Kind.API_KEY>;
+        locationField: z.ZodDefault<z.ZodString>;
+        prefix: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>, z.ZodObject<{
+        ref: z.ZodOptional<z.ZodString>;
+        isDefault: z.ZodDefault<z.ZodBoolean>;
+        location: z.ZodDefault<z.ZodEnum<typeof import("./security.external-connectors-models.schemas.js").ExternalProvider_Auth_ApiKey_Location>>;
+        kind: z.ZodLiteral<ExternalProvider_Auth_Kind.HMAC_SIGNATURE>;
+        locationField: z.ZodDefault<z.ZodString>;
+        algorithm: z.ZodDefault<z.ZodEnum<typeof import("./security.external-connectors-models.schemas.js").ExternalProvider_Auth_HMAC_Signature_Algorithm>>;
+        signaturePayload: z.ZodOptional<z.ZodEnum<{
+            custom: "custom";
+            body: "body";
+            timestamp: "timestamp";
+        }>>;
+        timestampHeader: z.ZodOptional<z.ZodString>;
+        nonceHeader: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>, z.ZodObject<{
+        ref: z.ZodOptional<z.ZodString>;
+        isDefault: z.ZodDefault<z.ZodBoolean>;
+        kind: z.ZodLiteral<ExternalProvider_Auth_Kind.BEARER>;
+        location: z.ZodDefault<z.ZodEnum<typeof import("./security.external-connectors-models.schemas.js").ExternalProvider_Auth_ApiKey_Location>>;
+        locationField: z.ZodDefault<z.ZodString>;
+        prefix: z.ZodDefault<z.ZodString>;
+        format: z.ZodDefault<z.ZodEnum<typeof import("./security.external-connectors-models.schemas.js").ExternalProvider_Auth_Bearer_Format>>;
+    }, z.core.$strip>, z.ZodObject<{
+        ref: z.ZodOptional<z.ZodString>;
+        isDefault: z.ZodDefault<z.ZodBoolean>;
+        location: z.ZodDefault<z.ZodEnum<typeof import("./security.external-connectors-models.schemas.js").ExternalProvider_Auth_ApiKey_Location>>;
+        locationField: z.ZodDefault<z.ZodString>;
+        kind: z.ZodLiteral<ExternalProvider_Auth_Kind.OPENID_CONNECT>;
+        discoveryUrl: z.ZodOptional<z.ZodURL>;
+        issuer: z.ZodOptional<z.ZodString>;
+        audience: z.ZodOptional<z.ZodString>;
+        validationMode: z.ZodOptional<z.ZodEnum<{
+            jwks: "jwks";
+            introspection: "introspection";
+            local: "local";
+        }>>;
+    }, z.core.$strip>, z.ZodObject<{
+        ref: z.ZodOptional<z.ZodString>;
+        isDefault: z.ZodDefault<z.ZodBoolean>;
+        location: z.ZodDefault<z.ZodEnum<typeof import("./security.external-connectors-models.schemas.js").ExternalProvider_Auth_ApiKey_Location>>;
+        locationField: z.ZodDefault<z.ZodString>;
+        kind: z.ZodLiteral<ExternalProvider_Auth_Kind.OAUTH2>;
+        oauth2ProviderRef: z.ZodOptional<z.ZodString>;
+        authUrl: z.ZodOptional<z.ZodURL>;
+        tokenUrl: z.ZodOptional<z.ZodURL>;
+        refreshUrl: z.ZodOptional<z.ZodURL>;
+        scopes: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        grantType: z.ZodOptional<z.ZodEnum<typeof import("./oauth2.enums.js").OAuth2_GrantType>>;
+        tokenEndpointAuthMethod: z.ZodOptional<z.ZodEnum<typeof import("./oauth2.enums.js").OAuth2_TokenEndpoint_AuthMethod>>;
+        pkce: z.ZodOptional<z.ZodBoolean>;
+        pkceMethod: z.ZodOptional<z.ZodEnum<typeof import("./oauth2.enums.js").OAuth2_PKCE_Method>>;
+        prompt: z.ZodOptional<z.ZodEnum<typeof import("./oauth2.enums.js").OAuth2_Prompt>>;
+        accessType: z.ZodOptional<z.ZodEnum<typeof import("./oauth2.enums.js").OAuth2_AccessType>>;
+        extraAuthParams: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+        extraTokenParams: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+        tokenFormat: z.ZodDefault<z.ZodEnum<{
+            token: "token";
+            bearer: "bearer";
+            oauth: "oauth";
+            custom: "custom";
+        }>>;
+        customTokenPrefix: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>, z.ZodObject<{
+        ref: z.ZodOptional<z.ZodString>;
+        isDefault: z.ZodDefault<z.ZodBoolean>;
+        location: z.ZodDefault<z.ZodEnum<typeof import("./security.external-connectors-models.schemas.js").ExternalProvider_Auth_ApiKey_Location>>;
+        locationField: z.ZodDefault<z.ZodString>;
+        kind: z.ZodLiteral<ExternalProvider_Auth_Kind.BASIC>;
+        usernameRef: z.ZodOptional<z.ZodString>;
+        passwordRef: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>, z.ZodObject<{
+        ref: z.ZodOptional<z.ZodString>;
+        isDefault: z.ZodDefault<z.ZodBoolean>;
+        location: z.ZodDefault<z.ZodEnum<typeof import("./security.external-connectors-models.schemas.js").ExternalProvider_Auth_ApiKey_Location>>;
+        locationField: z.ZodDefault<z.ZodString>;
+        kind: z.ZodLiteral<ExternalProvider_Auth_Kind.NONE>;
+    }, z.core.$strip>, z.ZodObject<{
+        ref: z.ZodOptional<z.ZodString>;
+        isDefault: z.ZodDefault<z.ZodBoolean>;
+        location: z.ZodDefault<z.ZodEnum<typeof import("./security.external-connectors-models.schemas.js").ExternalProvider_Auth_ApiKey_Location>>;
+        locationField: z.ZodDefault<z.ZodString>;
+        kind: z.ZodLiteral<ExternalProvider_Auth_Kind.FRONTEND_SECRET>;
+        frontendOnly: z.ZodDefault<z.ZodBoolean>;
+    }, z.core.$strip>, z.ZodObject<{
+        ref: z.ZodOptional<z.ZodString>;
+        isDefault: z.ZodDefault<z.ZodBoolean>;
+        location: z.ZodDefault<z.ZodEnum<typeof import("./security.external-connectors-models.schemas.js").ExternalProvider_Auth_ApiKey_Location>>;
+        locationField: z.ZodDefault<z.ZodString>;
+        kind: z.ZodLiteral<ExternalProvider_Auth_Kind.MUTUAL_TLS>;
+        certificateRef: z.ZodOptional<z.ZodString>;
+        privateKeyRef: z.ZodOptional<z.ZodString>;
+        caRef: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>], "kind">>>;
+}, z.core.$strip>;
+/**
+ * Shared protocol configuration fields.
+ *
+ * `authConfig` remains available for protocols that resolve secrets through the
+ * generic provider auth model, but it is optional because execution-oriented
+ * protocols can own their own auth/runtime policy contract.
+ */
+export declare const ExternalProvider_ExchangeProtocol_Configuration_BaseSchema: z.ZodObject<{
+    enabled: z.ZodBoolean;
+    authConfig: z.ZodOptional<z.ZodObject<{
+        authKind: z.ZodEnum<typeof ExternalProvider_Auth_Kind>;
+        profileRefs: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        isDefault: z.ZodOptional<z.ZodBoolean>;
+        secretRef: z.ZodString;
+    }, z.core.$strip>>;
+    rateLimitConfig: z.ZodOptional<z.ZodObject<{
+        maxConcurrent: z.ZodDefault<z.ZodOptional<z.ZodNumber>>;
+        minTime: z.ZodOptional<z.ZodNumber>;
+        reservoir: z.ZodOptional<z.ZodNumber>;
+        reservoirRefreshInterval: z.ZodOptional<z.ZodNumber>;
+        reservoirRefreshAmount: z.ZodOptional<z.ZodNumber>;
+        priority: z.ZodDefault<z.ZodOptional<z.ZodNumber>>;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+export declare const ExternalProvider_ExchangeProtocol_Status_BaseSchema: z.ZodObject<{
+    protocolKind: z.ZodEnum<typeof ExternalProvider_ExchangeProtocol_Kind>;
+    status: z.ZodEnum<typeof ExternalProvider_Status>;
+    lastCheckedAt: z.ZodString;
+    errorReason: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+export type ExternalProvider_ExchangeProtocol_Profile_Base = z.infer<typeof ExternalProvider_ExchangeProtocol_Profile_BaseSchema>;
+export type ExternalProvider_ExchangeProtocol_Configuration_Base = z.infer<typeof ExternalProvider_ExchangeProtocol_Configuration_BaseSchema>;
+export type ExternalProvider_ExchangeProtocol_Status_Base = z.infer<typeof ExternalProvider_ExchangeProtocol_Status_BaseSchema>;
+export declare enum ExternalProvider_IO_Direction {
+    INBOUND = "inbound",
+    OUTBOUND = "outbound",
+    BIDIRECTIONAL = "bidirectional"
+}
+export declare enum ExternalProvider_IO_InteractionPattern {
+    REQUEST_RESPONSE = "request_response",
+    EVENT_BASED = "event_based",
+    STREAMING = "stream"
+}
+//# sourceMappingURL=commons.external-connectors-models.schemas.d.ts.map

package/dist/esm/core/commons.external-connectors-models.schemas.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"commons.external-connectors-models.schemas.d.ts","sourceRoot":"","sources":["../../../src/core/commons.external-connectors-models.schemas.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AACxB,OAAO,EAA6C,0BAA0B,EAAsF,MAAM,+CAA+C,CAAC;AAG1N,oBAAY,sCAAsC;IAEhD,QAAQ,aAAa;IACrB,kBAAkB,uBAAuB;IAIzC,YAAY,iBAAiB;IAC7B,WAAW,gBAAgB;IAC3B,aAAa,kBAAkB;IAC/B,aAAa,kBAAkB;IAG/B,cAAc,mBAAmB;IACjC,YAAY,iBAAiB;IAC7B,IAAI,SAAS;IAGb,UAAU,eAAe;IACzB,QAAQ,aAAa;IAIrB,gBAAgB,qBAAqB;IAGrC,YAAY,iBAAiB;IAG7B,oBAAoB,yBAAyB;CAC9C;AAED,oBAAY,uBAAuB;IACjC,WAAW,gBAAgB;IAC3B,OAAO,YAAY;IACnB,UAAU,eAAe;CAC1B;AAED,oBAAY,uBAAuB;IACjC,MAAM,WAAW;IACjB,QAAQ,aAAa;IACrB,IAAI,SAAS;IACb,OAAO,YAAY;IACnB,UAAU,eAAe;CAC1B;AAGD,oBAAY,cAAc;IACxB,GAAG,QAAQ;IACX,IAAI,SAAS;IACb,GAAG,QAAQ;IACX,KAAK,UAAU;IACf,MAAM,WAAW;IACjB,IAAI,SAAS;IACb,OAAO,YAAY;CACpB;AAED;;;;;;;GAOG;AACH,eAAO,MAAM,oDAAoD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAI/D,CAAC;AAEH;;;;;;GAMG;AACH,eAAO,MAAM,0DAA0D;;;;;;;;;;;;;;;;iBAIrE,CAAC;AAEH,eAAO,MAAM,mDAAmD;;;;;iBAK9D,CAAC;AAEH,MAAM,MAAM,8CAA8C,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,oDAAoD,CAAC,CAAC;AAClI,MAAM,MAAM,oDAAoD,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,0DAA0D,CAAC,CAAC;AAC9I,MAAM,MAAM,6CAA6C,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,mDAAmD,CAAC,CAAC;AAEhI,oBAAY,6BAA6B;IACvC,OAAO,YAAY;IACnB,QAAQ,aAAa;IACrB,aAAa,kBAAkB;CAChC;AAED,oBAAY,sCAAsC;IAChD,gBAAgB,qBAAqB;IACrC,WAAW,gBAAgB;IAC3B,SAAS,WAAW;CACrB"}

package/dist/esm/core/commons.external-connectors-models.schemas.js

@@ -0,0 +1,96 @@
+import { z } from "zod";
+import { ExternalProvider_Auth_ConfigurationSchema, ExternalProvider_Auth_Kind, ExternalProvider_AuthProfile_Schema, ExternalProvider_RateLimitConfigurationSchema } from "./security.external-connectors-models.schemas.js";
+export var ExternalProvider_ExchangeProtocol_Kind;
+(function (ExternalProvider_ExchangeProtocol_Kind) {
+    // WEB
+    ExternalProvider_ExchangeProtocol_Kind["REST_API"] = "rest_api";
+    ExternalProvider_ExchangeProtocol_Kind["WEBHOOK_ORIGINATOR"] = "webhook_originator";
+    // SOAP ?
+    // AI
+    ExternalProvider_ExchangeProtocol_Kind["LLM_PROVIDER"] = "llm_provider";
+    ExternalProvider_ExchangeProtocol_Kind["CLI_RUNTIME"] = "cli_runtime";
+    ExternalProvider_ExchangeProtocol_Kind["MCP_CONNECTOR"] = "mcp_connector";
+    ExternalProvider_ExchangeProtocol_Kind["A2A_CONNECTOR"] = "a2a_connector";
+    // INFRA
+    ExternalProvider_ExchangeProtocol_Kind["EMAIL_PROVIDER"] = "email_provider";
+    ExternalProvider_ExchangeProtocol_Kind["GIT_PROVIDER"] = "git_provider";
+    ExternalProvider_ExchangeProtocol_Kind["GRPC"] = "grpc";
+    // AUTH
+    ExternalProvider_ExchangeProtocol_Kind["SSO_OAUTH2"] = "sso_oauth2";
+    ExternalProvider_ExchangeProtocol_Kind["SSO_SAML"] = "sso_saml";
+    // OPENID_CONNECT ?
+    // BILLING
+    ExternalProvider_ExchangeProtocol_Kind["BILLING_PROVIDER"] = "billing_provider";
+    // SMS (Phase G2)
+    ExternalProvider_ExchangeProtocol_Kind["SMS_PROVIDER"] = "sms_provider";
+    // FRONTEND
+    ExternalProvider_ExchangeProtocol_Kind["FRONTEND_INTEGRATION"] = "frontend_integration";
+})(ExternalProvider_ExchangeProtocol_Kind || (ExternalProvider_ExchangeProtocol_Kind = {}));
+export var APPLICATION_ENVIRONMENT;
+(function (APPLICATION_ENVIRONMENT) {
+    APPLICATION_ENVIRONMENT["DEVELOPMENT"] = "development";
+    APPLICATION_ENVIRONMENT["STAGING"] = "staging";
+    APPLICATION_ENVIRONMENT["PRODUCTION"] = "production";
+})(APPLICATION_ENVIRONMENT || (APPLICATION_ENVIRONMENT = {}));
+export var ExternalProvider_Status;
+(function (ExternalProvider_Status) {
+    ExternalProvider_Status["ACTIVE"] = "active";
+    ExternalProvider_Status["INACTIVE"] = "inactive";
+    ExternalProvider_Status["BUZY"] = "busy";
+    ExternalProvider_Status["OFFLINE"] = "offline";
+    ExternalProvider_Status["DEPRECATED"] = "deprecated";
+})(ExternalProvider_Status || (ExternalProvider_Status = {}));
+export var API_HttpMethod;
+(function (API_HttpMethod) {
+    API_HttpMethod["GET"] = "GET";
+    API_HttpMethod["POST"] = "POST";
+    API_HttpMethod["PUT"] = "PUT";
+    API_HttpMethod["PATCH"] = "PATCH";
+    API_HttpMethod["DELETE"] = "DELETE";
+    API_HttpMethod["HEAD"] = "HEAD";
+    API_HttpMethod["OPTIONS"] = "OPTIONS";
+})(API_HttpMethod || (API_HttpMethod = {}));
+/**
+ * Shared protocol profile fields.
+ *
+ * These fields are transport-oriented hints that many protocols use, but they
+ * are not universally meaningful. Execution-oriented protocols such as a local
+ * CLI runtime should not need to invent fake HTTP endpoints or auth profiles
+ * just to satisfy the shared contract.
+ */
+export const ExternalProvider_ExchangeProtocol_Profile_BaseSchema = z.object({
+    endpoints: z.record(z.enum(APPLICATION_ENVIRONMENT), z.string()).optional(),
+    availableAuthMethods: z.array(z.enum(ExternalProvider_Auth_Kind)).optional(),
+    authProfiles: z.array(ExternalProvider_AuthProfile_Schema).optional(),
+});
+/**
+ * Shared protocol configuration fields.
+ *
+ * `authConfig` remains available for protocols that resolve secrets through the
+ * generic provider auth model, but it is optional because execution-oriented
+ * protocols can own their own auth/runtime policy contract.
+ */
+export const ExternalProvider_ExchangeProtocol_Configuration_BaseSchema = z.object({
+    enabled: z.boolean(),
+    authConfig: ExternalProvider_Auth_ConfigurationSchema.optional(),
+    rateLimitConfig: ExternalProvider_RateLimitConfigurationSchema.optional(),
+});
+export const ExternalProvider_ExchangeProtocol_Status_BaseSchema = z.object({
+    protocolKind: z.enum(ExternalProvider_ExchangeProtocol_Kind),
+    status: z.enum(ExternalProvider_Status),
+    lastCheckedAt: z.string(),
+    errorReason: z.string().optional(),
+});
+export var ExternalProvider_IO_Direction;
+(function (ExternalProvider_IO_Direction) {
+    ExternalProvider_IO_Direction["INBOUND"] = "inbound";
+    ExternalProvider_IO_Direction["OUTBOUND"] = "outbound";
+    ExternalProvider_IO_Direction["BIDIRECTIONAL"] = "bidirectional";
+})(ExternalProvider_IO_Direction || (ExternalProvider_IO_Direction = {}));
+export var ExternalProvider_IO_InteractionPattern;
+(function (ExternalProvider_IO_InteractionPattern) {
+    ExternalProvider_IO_InteractionPattern["REQUEST_RESPONSE"] = "request_response";
+    ExternalProvider_IO_InteractionPattern["EVENT_BASED"] = "event_based";
+    ExternalProvider_IO_InteractionPattern["STREAMING"] = "stream";
+})(ExternalProvider_IO_InteractionPattern || (ExternalProvider_IO_InteractionPattern = {}));
+//# sourceMappingURL=commons.external-connectors-models.schemas.js.map

package/dist/esm/core/commons.external-connectors-models.schemas.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"commons.external-connectors-models.schemas.js","sourceRoot":"","sources":["../../../src/core/commons.external-connectors-models.schemas.ts"],"names":[],"mappings":"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"}

package/dist/esm/core/lazy-loading.external-connectors-models.schemas.d.ts

@@ -0,0 +1,127 @@
+/**
+ * Lazy Loading Types for External Connectors
+ *
+ * Enables on-demand loading of provider definitions at:
+ * - Protocol level (REST_API, WEBHOOK, LLM, etc.)
+ * - Domain level (customers, invoices, etc.)
+ *
+ * This dramatically reduces memory usage from 1GB+ to ~100KB at startup.
+ */
+import { ExternalProvider_ExchangeProtocol_Kind } from "./commons.external-connectors-models.schemas.js";
+import { ExternalProvider_OperationDefinition_Base } from "./operations.external-connectors-models.schemas.js";
+import { ExternalProvider_ExchangeProtocol_Base } from "./protocols.external-connectors-models.schemas.js";
+import { ExternalProvider_Capability } from "../features/core.external-connectors-models.schemas.js";
+/**
+ * Map of operation key to operation definition
+ */
+export type OperationsMap = Record<string, ExternalProvider_OperationDefinition_Base>;
+/**
+ * Lazy loader for operations within a protocol
+ * @param domain - Optional domain name (required for REST_API with domains)
+ */
+export type OperationsLoader = (domain?: string) => Promise<OperationsMap>;
+/**
+ * Lazy loader for a protocol definition (without operations)
+ */
+export type ProtocolLoader = () => Promise<Omit<ExternalProvider_ExchangeProtocol_Base, 'operations'>>;
+/**
+ * Catalog entry for a single protocol within a provider
+ * Contains metadata and lazy loaders for the protocol and its operations
+ */
+export interface ProtocolCatalogEntry {
+    /** Protocol kind (REST_API, LLM_PROVIDER, etc.) */
+    kind: ExternalProvider_ExchangeProtocol_Kind;
+    /**
+     * Available domains within this protocol (for REST_API)
+     * undefined for protocols without domain-level splitting
+     */
+    domains?: string[];
+    /**
+     * Load the protocol definition (profile, config, status schema)
+     * Does NOT include operations - those are loaded separately
+     */
+    loadProtocol: ProtocolLoader;
+    /**
+     * Load operations for this protocol
+     * @param domain - Domain name (required if domains is defined)
+     */
+    loadOperations: OperationsLoader;
+}
+/**
+ * Catalog entry for a provider
+ * Contains lightweight metadata and protocol loaders
+ *
+ * Total size: ~200-500 bytes per provider
+ * For 400 providers: ~100-200 KB (vs 1GB+ for full definitions)
+ */
+export interface ProviderCatalogEntry {
+    /** Provider reference (e.g., "stripe", "google", "openai") */
+    ref: string;
+    /** Human-readable name */
+    displayName: string;
+    /** Provider description */
+    description?: string;
+    /** Default base URL */
+    baseUrl?: string;
+    /** Available protocols with their loaders */
+    protocols: ProtocolCatalogEntry[];
+    /**
+     * Capabilities this provider implements (with transformers available).
+     * Lightweight array of capability enums - used for transformer availability checking.
+     * If a capability is listed here, its transformer is guaranteed to exist.
+     */
+    capabilities?: ExternalProvider_Capability[];
+    /**
+     * NPM packages required at runtime by this provider's transformers.
+     *
+     * Copied from `ExternalProvider_Definition.requiredPackages` during catalog building.
+     * The engine uses this to check SDK availability at startup before attempting
+     * to use the provider, avoiding cryptic MODULE_NOT_FOUND errors at runtime.
+     *
+     * @example ['stripe'] for the Stripe billing provider
+     */
+    requiredPackages?: string[];
+}
+/**
+ * Complete catalog of all providers
+ * Loaded at startup (~100-200 KB)
+ *
+ * Individual providers/protocols/domains loaded on demand
+ */
+export type ProviderCatalog = Record<string, ProviderCatalogEntry>;
+/**
+ * A provider definition with lazy-loadable protocols
+ * Used as the return type when loading a provider from catalog
+ */
+export interface LazyProviderDefinition {
+    ref: string;
+    displayName: string;
+    description?: string;
+    baseUrl?: string;
+    /** Loaded protocols (populated as they're accessed) */
+    protocols: Map<ExternalProvider_ExchangeProtocol_Kind, ExternalProvider_ExchangeProtocol_Base>;
+    /** Protocol catalog entries for lazy loading */
+    protocolCatalog: ProtocolCatalogEntry[];
+    /**
+     * NPM packages required at runtime by this provider's transformers.
+     * Copied from the catalog entry for convenience when working with loaded definitions.
+     */
+    requiredPackages?: string[];
+}
+/**
+ * Cache key for protocol cache
+ */
+export type ProtocolCacheKey = `${string}:${ExternalProvider_ExchangeProtocol_Kind}`;
+/**
+ * Cache key for operations cache
+ */
+export type OperationsCacheKey = `${string}:${ExternalProvider_ExchangeProtocol_Kind}:${string}`;
+/**
+ * Build protocol cache key
+ */
+export declare function buildProtocolCacheKey(providerRef: string, protocolKind: ExternalProvider_ExchangeProtocol_Kind): ProtocolCacheKey;
+/**
+ * Build operations cache key
+ */
+export declare function buildOperationsCacheKey(providerRef: string, protocolKind: ExternalProvider_ExchangeProtocol_Kind, domain?: string): OperationsCacheKey;
+//# sourceMappingURL=lazy-loading.external-connectors-models.schemas.d.ts.map

package/dist/esm/core/lazy-loading.external-connectors-models.schemas.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"lazy-loading.external-connectors-models.schemas.d.ts","sourceRoot":"","sources":["../../../src/core/lazy-loading.external-connectors-models.schemas.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AAEH,OAAO,EAAE,sCAAsC,EAAE,MAAM,8CAA8C,CAAC;AACtG,OAAO,EAAE,yCAAyC,EAAE,MAAM,iDAAiD,CAAC;AAC5G,OAAO,EAAE,sCAAsC,EAAE,MAAM,gDAAgD,CAAC;AACxG,OAAO,EAAE,2BAA2B,EAAE,MAAM,2EAA2E,CAAC;AAIxH;;GAEG;AACH,MAAM,MAAM,aAAa,GAAG,MAAM,CAAC,MAAM,EAAE,yCAAyC,CAAC,CAAC;AAEtF;;;GAGG;AACH,MAAM,MAAM,gBAAgB,GAAG,CAAC,MAAM,CAAC,EAAE,MAAM,KAAK,OAAO,CAAC,aAAa,CAAC,CAAC;AAE3E;;GAEG;AACH,MAAM,MAAM,cAAc,GAAG,MAAM,OAAO,CAAC,IAAI,CAAC,sCAAsC,EAAE,YAAY,CAAC,CAAC,CAAC;AAIvG;;;GAGG;AACH,MAAM,WAAW,oBAAoB;IACnC,mDAAmD;IACnD,IAAI,EAAE,sCAAsC,CAAC;IAE7C;;;OAGG;IACH,OAAO,CAAC,EAAE,MAAM,EAAE,CAAC;IAEnB;;;OAGG;IACH,YAAY,EAAE,cAAc,CAAC;IAE7B;;;OAGG;IACH,cAAc,EAAE,gBAAgB,CAAC;CAClC;AAID;;;;;;GAMG;AACH,MAAM,WAAW,oBAAoB;IACnC,8DAA8D;IAC9D,GAAG,EAAE,MAAM,CAAC;IAEZ,0BAA0B;IAC1B,WAAW,EAAE,MAAM,CAAC;IAEpB,2BAA2B;IAC3B,WAAW,CAAC,EAAE,MAAM,CAAC;IAErB,uBAAuB;IACvB,OAAO,CAAC,EAAE,MAAM,CAAC;IAEjB,6CAA6C;IAC7C,SAAS,EAAE,oBAAoB,EAAE,CAAC;IAElC;;;;OAIG;IACH,YAAY,CAAC,EAAE,2BAA2B,EAAE,CAAC;IAE7C;;;;;;;;OAQG;IACH,gBAAgB,CAAC,EAAE,MAAM,EAAE,CAAC;CAC7B;AAID;;;;;GAKG;AACH,MAAM,MAAM,eAAe,GAAG,MAAM,CAAC,MAAM,EAAE,oBAAoB,CAAC,CAAC;AAInE;;;GAGG;AACH,MAAM,WAAW,sBAAsB;IACrC,GAAG,EAAE,MAAM,CAAC;IACZ,WAAW,EAAE,MAAM,CAAC;IACpB,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,OAAO,CAAC,EAAE,MAAM,CAAC;IAEjB,uDAAuD;IACvD,SAAS,EAAE,GAAG,CAAC,sCAAsC,EAAE,sCAAsC,CAAC,CAAC;IAE/F,gDAAgD;IAChD,eAAe,EAAE,oBAAoB,EAAE,CAAC;IAExC;;;OAGG;IACH,gBAAgB,CAAC,EAAE,MAAM,EAAE,CAAC;CAC7B;AAID;;GAEG;AACH,MAAM,MAAM,gBAAgB,GAAG,GAAG,MAAM,IAAI,sCAAsC,EAAE,CAAC;AAErF;;GAEG;AACH,MAAM,MAAM,kBAAkB,GAAG,GAAG,MAAM,IAAI,sCAAsC,IAAI,MAAM,EAAE,CAAC;AAEjG;;GAEG;AACH,wBAAgB,qBAAqB,CACnC,WAAW,EAAE,MAAM,EACnB,YAAY,EAAE,sCAAsC,GACnD,gBAAgB,CAElB;AAED;;GAEG;AACH,wBAAgB,uBAAuB,CACrC,WAAW,EAAE,MAAM,EACnB,YAAY,EAAE,sCAAsC,EACpD,MAAM,CAAC,EAAE,MAAM,GACd,kBAAkB,CAEpB"}

package/dist/esm/core/lazy-loading.external-connectors-models.schemas.js

@@ -0,0 +1,22 @@
+/**
+ * Lazy Loading Types for External Connectors
+ *
+ * Enables on-demand loading of provider definitions at:
+ * - Protocol level (REST_API, WEBHOOK, LLM, etc.)
+ * - Domain level (customers, invoices, etc.)
+ *
+ * This dramatically reduces memory usage from 1GB+ to ~100KB at startup.
+ */
+/**
+ * Build protocol cache key
+ */
+export function buildProtocolCacheKey(providerRef, protocolKind) {
+    return `${providerRef}:${protocolKind}`;
+}
+/**
+ * Build operations cache key
+ */
+export function buildOperationsCacheKey(providerRef, protocolKind, domain) {
+    return `${providerRef}:${protocolKind}:${domain ?? '_all'}`;
+}
+//# sourceMappingURL=lazy-loading.external-connectors-models.schemas.js.map

package/dist/esm/core/lazy-loading.external-connectors-models.schemas.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"lazy-loading.external-connectors-models.schemas.js","sourceRoot":"","sources":["../../../src/core/lazy-loading.external-connectors-models.schemas.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AAiJH;;GAEG;AACH,MAAM,UAAU,qBAAqB,CACnC,WAAmB,EACnB,YAAoD;IAEpD,OAAO,GAAG,WAAW,IAAI,YAAY,EAAE,CAAC;AAC1C,CAAC;AAED;;GAEG;AACH,MAAM,UAAU,uBAAuB,CACrC,WAAmB,EACnB,YAAoD,EACpD,MAAe;IAEf,OAAO,GAAG,WAAW,IAAI,YAAY,IAAI,MAAM,IAAI,MAAM,EAAE,CAAC;AAC9D,CAAC"}

package/dist/esm/core/oauth2.enums.d.ts

@@ -0,0 +1,125 @@
+/**
+ * OAuth2 Enums - Shared OAuth2 type definitions
+ *
+ * These enums are extracted to avoid circular dependencies between
+ * security schemas and oauth2 protocol schemas.
+ *
+ * Based on:
+ * - RFC 6749: The OAuth 2.0 Authorization Framework
+ * - RFC 7636: Proof Key for Code Exchange (PKCE)
+ * - OpenID Connect Core 1.0
+ */
+/**
+ * OAuth2 Grant Types as defined in RFC 6749
+ * @see https://datatracker.ietf.org/doc/html/rfc6749#section-4
+ */
+export declare enum OAuth2_GrantType {
+    /** Authorization Code Grant (RFC 6749 §4.1) - For server-side apps with secure client secrets */
+    AUTHORIZATION_CODE = "authorization_code",
+    /** Client Credentials Grant (RFC 6749 §4.4) - For machine-to-machine / S2S authentication */
+    CLIENT_CREDENTIALS = "client_credentials",
+    /** Refresh Token Grant (RFC 6749 §6) - For obtaining new access tokens */
+    REFRESH_TOKEN = "refresh_token",
+    /** Implicit Grant (RFC 6749 §4.2) - DEPRECATED, use PKCE instead */
+    IMPLICIT = "implicit",
+    /** Resource Owner Password Credentials (RFC 6749 §4.3) - DEPRECATED */
+    PASSWORD = "password",
+    /** Device Authorization Grant (RFC 8628) - For input-constrained devices */
+    DEVICE_CODE = "urn:ietf:params:oauth:grant-type:device_code",
+    /** JWT Bearer Assertion (RFC 7523) - For service accounts */
+    JWT_BEARER = "urn:ietf:params:oauth:grant-type:jwt-bearer"
+}
+/**
+ * OAuth2 Response Types for Authorization Endpoint
+ */
+export declare enum OAuth2_ResponseType {
+    CODE = "code",
+    TOKEN = "token",
+    ID_TOKEN = "id_token",
+    CODE_ID_TOKEN = "code id_token",
+    CODE_TOKEN = "code token",
+    ID_TOKEN_TOKEN = "id_token token",
+    CODE_ID_TOKEN_TOKEN = "code id_token token"
+}
+/**
+ * PKCE Code Challenge Methods (RFC 7636)
+ */
+export declare enum OAuth2_PKCE_Method {
+    PLAIN = "plain",
+    S256 = "S256"
+}
+/**
+ * Token Endpoint Authentication Methods
+ * How credentials are sent to the token endpoint
+ */
+export declare enum OAuth2_TokenEndpoint_AuthMethod {
+    /** Credentials in Authorization header as Basic auth */
+    CLIENT_SECRET_BASIC = "client_secret_basic",
+    /** Credentials in request body */
+    CLIENT_SECRET_POST = "client_secret_post",
+    /** JWT assertion signed with client secret (HMAC) */
+    CLIENT_SECRET_JWT = "client_secret_jwt",
+    /** JWT assertion signed with private key (RSA/EC) */
+    PRIVATE_KEY_JWT = "private_key_jwt",
+    /** No authentication (public clients) */
+    NONE = "none"
+}
+/**
+ * OpenID Connect Prompt Values
+ * Controls how the authorization server prompts the user
+ */
+export declare enum OAuth2_Prompt {
+    /** No prompt - silent auth only */
+    NONE = "none",
+    /** Force login even if session exists */
+    LOGIN = "login",
+    /** Require user consent even if previously granted */
+    CONSENT = "consent",
+    /** Prompt for account selection */
+    SELECT_ACCOUNT = "select_account"
+}
+/**
+ * Access Type - whether to request refresh tokens
+ */
+export declare enum OAuth2_AccessType {
+    /** Only access token, no refresh capability */
+    ONLINE = "online",
+    /** Request refresh token for offline access */
+    OFFLINE = "offline"
+}
+/**
+ * OAuth2 Provider Purpose - what the OAuth2 is used for
+ */
+export declare enum OAuth2_Purpose {
+    /** API access only - for making API calls to the provider */
+    API_ACCESS = "api_access",
+    /** User SSO - for authenticating users into our application */
+    USER_SSO = "user_sso",
+    /** Both API access and user SSO */
+    HYBRID = "hybrid"
+}
+/**
+ * OAuth2 Token Format - How to format the token for API calls
+ */
+export declare enum OAuth2_TokenFormat {
+    /** Authorization: Bearer <token> */
+    BEARER = "bearer",
+    /** Authorization: token <token> */
+    TOKEN = "token",
+    /** Authorization: OAuth <token> */
+    OAUTH = "oauth",
+    /** Custom header specified separately */
+    CUSTOM_HEADER = "custom_header",
+    /** Token in query parameter */
+    QUERY_PARAM = "query_param"
+}
+/**
+ * OAuth2 Token Location - Where to send the access token
+ */
+export declare enum OAuth2_TokenLocation {
+    /** In Authorization header */
+    HEADER = "header",
+    /** As query parameter */
+    QUERY = "query"
+}
+//# sourceMappingURL=oauth2.enums.d.ts.map

package/dist/esm/core/oauth2.enums.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"oauth2.enums.d.ts","sourceRoot":"","sources":["../../../src/core/oauth2.enums.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;GAUG;AAEH;;;GAGG;AACH,oBAAY,gBAAgB;IAC1B,iGAAiG;IACjG,kBAAkB,uBAAuB;IAEzC,6FAA6F;IAC7F,kBAAkB,uBAAuB;IAEzC,0EAA0E;IAC1E,aAAa,kBAAkB;IAE/B,oEAAoE;IACpE,QAAQ,aAAa;IAErB,uEAAuE;IACvE,QAAQ,aAAa;IAErB,4EAA4E;IAC5E,WAAW,iDAAiD;IAE5D,6DAA6D;IAC7D,UAAU,gDAAgD;CAC3D;AAED;;GAEG;AACH,oBAAY,mBAAmB;IAC7B,IAAI,SAAS;IACb,KAAK,UAAU;IACf,QAAQ,aAAa;IACrB,aAAa,kBAAkB;IAC/B,UAAU,eAAe;IACzB,cAAc,mBAAmB;IACjC,mBAAmB,wBAAwB;CAC5C;AAED;;GAEG;AACH,oBAAY,kBAAkB;IAC5B,KAAK,UAAU;IACf,IAAI,SAAS;CACd;AAED;;;GAGG;AACH,oBAAY,+BAA+B;IACzC,wDAAwD;IACxD,mBAAmB,wBAAwB;IAE3C,kCAAkC;IAClC,kBAAkB,uBAAuB;IAEzC,qDAAqD;IACrD,iBAAiB,sBAAsB;IAEvC,qDAAqD;IACrD,eAAe,oBAAoB;IAEnC,yCAAyC;IACzC,IAAI,SAAS;CACd;AAED;;;GAGG;AACH,oBAAY,aAAa;IACvB,mCAAmC;IACnC,IAAI,SAAS;IAEb,yCAAyC;IACzC,KAAK,UAAU;IAEf,sDAAsD;IACtD,OAAO,YAAY;IAEnB,mCAAmC;IACnC,cAAc,mBAAmB;CAClC;AAED;;GAEG;AACH,oBAAY,iBAAiB;IAC3B,+CAA+C;IAC/C,MAAM,WAAW;IAEjB,+CAA+C;IAC/C,OAAO,YAAY;CACpB;AAED;;GAEG;AACH,oBAAY,cAAc;IACxB,6DAA6D;IAC7D,UAAU,eAAe;IAEzB,+DAA+D;IAC/D,QAAQ,aAAa;IAErB,mCAAmC;IACnC,MAAM,WAAW;CAClB;AAED;;GAEG;AACH,oBAAY,kBAAkB;IAC5B,oCAAoC;IACpC,MAAM,WAAW;IACjB,mCAAmC;IACnC,KAAK,UAAU;IACf,mCAAmC;IACnC,KAAK,UAAU;IACf,yCAAyC;IACzC,aAAa,kBAAkB;IAC/B,+BAA+B;IAC/B,WAAW,gBAAgB;CAC5B;AAED;;GAEG;AACH,oBAAY,oBAAoB;IAC9B,8BAA8B;IAC9B,MAAM,WAAW;IACjB,yBAAyB;IACzB,KAAK,UAAU;CAChB"}