@wildo-ai/saas-models 1.0.1

package/dist/esm/external-providers/external-providers.shared.schemas.d.ts

@@ -0,0 +1,248 @@
+/**
+ * External Providers Shared Schemas
+ *
+ * Provides application-level registry schemas for external providers.
+ * OAuth2 configurations are defined per-provider in @wildo-ai/external-connectors.
+ */
+import { ExternalProvider_ExchangeProtocol_Kind, OAuth2_Purpose } from "@wildo-ai/external-connectors-models";
+import { z } from "zod";
+import { EngineCapability } from "./wildo-features.shared.schemas.js";
+/**
+ * External Providers Registry Item
+ * Defines what protocols and capabilities a provider supports
+ *
+ * Note: This is a COMPUTED structure populated from:
+ * - ExternalProvider_Definition.capabilities (what provider actually supports)
+ * - CapabilityBindingsPolicy (what capabilities are assigned to this provider)
+ * - Capability requirements validation
+ */
+export declare const External_Providers_RegistryItemSchema: z.ZodObject<{
+    providerRef: z.ZodString;
+    protocols: z.ZodArray<z.ZodEnum<typeof ExternalProvider_ExchangeProtocol_Kind>>;
+    engineCapabilities: z.ZodDefault<z.ZodArray<z.ZodEnum<typeof EngineCapability>>>;
+    supportsOAuth2: z.ZodOptional<z.ZodBoolean>;
+    customOAuth2Config: z.ZodOptional<z.ZodObject<{
+        providerId: z.ZodOptional<z.ZodString>;
+        displayName: z.ZodOptional<z.ZodString>;
+        iconUrl: z.ZodOptional<z.ZodOptional<z.ZodURL>>;
+        brandColor: z.ZodOptional<z.ZodOptional<z.ZodString>>;
+        purpose: z.ZodOptional<z.ZodDefault<z.ZodEnum<typeof OAuth2_Purpose>>>;
+        enabled: z.ZodOptional<z.ZodDefault<z.ZodBoolean>>;
+        endpoints: z.ZodOptional<z.ZodObject<{
+            authorizationUrl: z.ZodURL;
+            tokenUrl: z.ZodURL;
+            refreshUrl: z.ZodOptional<z.ZodURL>;
+            revocationUrl: z.ZodOptional<z.ZodURL>;
+            introspectionUrl: z.ZodOptional<z.ZodURL>;
+            deviceAuthorizationUrl: z.ZodOptional<z.ZodURL>;
+            userInfoUrl: z.ZodOptional<z.ZodURL>;
+            jwksUrl: z.ZodOptional<z.ZodURL>;
+            discoveryUrl: z.ZodOptional<z.ZodURL>;
+            endSessionUrl: z.ZodOptional<z.ZodURL>;
+            apiBaseUrl: z.ZodOptional<z.ZodURL>;
+        }, z.core.$strip, core.$ZodObjectExtra>>;
+        capabilities: z.ZodOptional<z.ZodOptional<z.ZodObject<{
+            supportsAuthorizationCode: z.ZodOptional<z.ZodBoolean>;
+            supportsClientCredentials: z.ZodOptional<z.ZodBoolean>;
+            supportsDeviceCode: z.ZodOptional<z.ZodBoolean>;
+            supportsJwtBearer: z.ZodOptional<z.ZodBoolean>;
+            supportsRefreshToken: z.ZodOptional<z.ZodBoolean>;
+            rotatesRefreshToken: z.ZodOptional<z.ZodBoolean>;
+            supportsTokenRevocation: z.ZodOptional<z.ZodBoolean>;
+            supportsTokenIntrospection: z.ZodOptional<z.ZodBoolean>;
+            supportsPKCE: z.ZodOptional<z.ZodBoolean>;
+            requiresPKCE: z.ZodOptional<z.ZodBoolean>;
+            preferredPKCEMethod: z.ZodOptional<z.ZodEnum<typeof import("@wildo-ai/external-connectors-models").OAuth2_PKCE_Method>>;
+            supportsOIDC: z.ZodOptional<z.ZodBoolean>;
+            supportsOIDCDiscovery: z.ZodOptional<z.ZodBoolean>;
+            supportsUserInfo: z.ZodOptional<z.ZodBoolean>;
+            supportsIdToken: z.ZodOptional<z.ZodBoolean>;
+            supportsIncrementalAuth: z.ZodOptional<z.ZodBoolean>;
+            supportsScopeReduction: z.ZodOptional<z.ZodBoolean>;
+            supportsCustomDomains: z.ZodOptional<z.ZodBoolean>;
+            supportsMultiTenancy: z.ZodOptional<z.ZodBoolean>;
+        }, z.core.$strip, core.$ZodObjectExtra>>>;
+        scopes: z.ZodOptional<z.ZodOptional<z.ZodObject<{
+            available: z.ZodOptional<z.ZodArray<z.ZodObject<{
+                scope: z.ZodString;
+                description: z.ZodOptional<z.ZodString>;
+                required: z.ZodOptional<z.ZodBoolean>;
+                category: z.ZodOptional<z.ZodString>;
+                isOIDC: z.ZodOptional<z.ZodBoolean>;
+                grantsOfflineAccess: z.ZodOptional<z.ZodBoolean>;
+                resources: z.ZodOptional<z.ZodArray<z.ZodString>>;
+            }, z.core.$strip>>>;
+            defaultForSSO: z.ZodOptional<z.ZodArray<z.ZodString>>;
+            defaultForAPI: z.ZodOptional<z.ZodArray<z.ZodString>>;
+            minimum: z.ZodOptional<z.ZodArray<z.ZodString>>;
+            offlineAccessScope: z.ZodOptional<z.ZodString>;
+        }, z.core.$strip, core.$ZodObjectExtra>>>;
+        tokenConfig: z.ZodOptional<z.ZodOptional<z.ZodObject<{
+            tokenType: z.ZodOptional<z.ZodString>;
+            accessTokenLifetime: z.ZodOptional<z.ZodNumber>;
+            refreshTokenLifetime: z.ZodOptional<z.ZodNumber>;
+            idTokenLifetime: z.ZodOptional<z.ZodNumber>;
+            tokenEndpointAuthMethod: z.ZodOptional<z.ZodEnum<typeof import("@wildo-ai/external-connectors-models").OAuth2_TokenEndpoint_AuthMethod>>;
+            tokenRequestHeaders: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+            refreshBufferSeconds: z.ZodOptional<z.ZodNumber>;
+        }, z.core.$strip, core.$ZodObjectExtra>>>;
+        preferredGrantType: z.ZodOptional<z.ZodDefault<z.ZodEnum<typeof import("@wildo-ai/external-connectors-models").OAuth2_GrantType>>>;
+        responseType: z.ZodOptional<z.ZodDefault<z.ZodEnum<typeof import("@wildo-ai/external-connectors-models").OAuth2_ResponseType>>>;
+        prompt: z.ZodOptional<z.ZodOptional<z.ZodEnum<typeof import("@wildo-ai/external-connectors-models").OAuth2_Prompt>>>;
+        accessType: z.ZodOptional<z.ZodDefault<z.ZodEnum<typeof import("@wildo-ai/external-connectors-models").OAuth2_AccessType>>>;
+        templateVariables: z.ZodOptional<z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodObject<{
+            displayName: z.ZodString;
+            description: z.ZodOptional<z.ZodString>;
+            required: z.ZodOptional<z.ZodBoolean>;
+            defaultValue: z.ZodOptional<z.ZodString>;
+            options: z.ZodOptional<z.ZodArray<z.ZodObject<{
+                value: z.ZodString;
+                label: z.ZodString;
+            }, z.core.$strip>>>;
+        }, z.core.$strip, core.$ZodObjectExtra>>>>;
+        extraAuthParams: z.ZodOptional<z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>>;
+        extraTokenParams: z.ZodOptional<z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>>;
+        userProfileMapping: z.ZodOptional<z.ZodOptional<z.ZodObject<{
+            id: z.ZodDefault<z.ZodString>;
+            email: z.ZodDefault<z.ZodString>;
+            name: z.ZodDefault<z.ZodString>;
+            image: z.ZodDefault<z.ZodString>;
+            emailVerified: z.ZodDefault<z.ZodString>;
+        }, z.core.$strip, core.$ZodObjectExtra>>>;
+        extensions: z.ZodOptional<z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>>;
+    }, z.core.$strip, core.$ZodObjectExtra>>;
+}, z.core.$strip, core.$ZodObjectExtra>;
+export type External_Providers_RegistryItem = z.infer<typeof External_Providers_RegistryItemSchema>;
+/**
+ * External Providers Registry
+ * Maps provider references to their configurations
+ */
+export declare const External_Providers_Registry_Schema: z.ZodRecord<z.ZodString, z.ZodObject<{
+    providerRef: z.ZodString;
+    protocols: z.ZodArray<z.ZodEnum<typeof ExternalProvider_ExchangeProtocol_Kind>>;
+    engineCapabilities: z.ZodDefault<z.ZodArray<z.ZodEnum<typeof EngineCapability>>>;
+    supportsOAuth2: z.ZodOptional<z.ZodBoolean>;
+    customOAuth2Config: z.ZodOptional<z.ZodObject<{
+        providerId: z.ZodOptional<z.ZodString>;
+        displayName: z.ZodOptional<z.ZodString>;
+        iconUrl: z.ZodOptional<z.ZodOptional<z.ZodURL>>;
+        brandColor: z.ZodOptional<z.ZodOptional<z.ZodString>>;
+        purpose: z.ZodOptional<z.ZodDefault<z.ZodEnum<typeof OAuth2_Purpose>>>;
+        enabled: z.ZodOptional<z.ZodDefault<z.ZodBoolean>>;
+        endpoints: z.ZodOptional<z.ZodObject<{
+            authorizationUrl: z.ZodURL;
+            tokenUrl: z.ZodURL;
+            refreshUrl: z.ZodOptional<z.ZodURL>;
+            revocationUrl: z.ZodOptional<z.ZodURL>;
+            introspectionUrl: z.ZodOptional<z.ZodURL>;
+            deviceAuthorizationUrl: z.ZodOptional<z.ZodURL>;
+            userInfoUrl: z.ZodOptional<z.ZodURL>;
+            jwksUrl: z.ZodOptional<z.ZodURL>;
+            discoveryUrl: z.ZodOptional<z.ZodURL>;
+            endSessionUrl: z.ZodOptional<z.ZodURL>;
+            apiBaseUrl: z.ZodOptional<z.ZodURL>;
+        }, z.core.$strip, core.$ZodObjectExtra>>;
+        capabilities: z.ZodOptional<z.ZodOptional<z.ZodObject<{
+            supportsAuthorizationCode: z.ZodOptional<z.ZodBoolean>;
+            supportsClientCredentials: z.ZodOptional<z.ZodBoolean>;
+            supportsDeviceCode: z.ZodOptional<z.ZodBoolean>;
+            supportsJwtBearer: z.ZodOptional<z.ZodBoolean>;
+            supportsRefreshToken: z.ZodOptional<z.ZodBoolean>;
+            rotatesRefreshToken: z.ZodOptional<z.ZodBoolean>;
+            supportsTokenRevocation: z.ZodOptional<z.ZodBoolean>;
+            supportsTokenIntrospection: z.ZodOptional<z.ZodBoolean>;
+            supportsPKCE: z.ZodOptional<z.ZodBoolean>;
+            requiresPKCE: z.ZodOptional<z.ZodBoolean>;
+            preferredPKCEMethod: z.ZodOptional<z.ZodEnum<typeof import("@wildo-ai/external-connectors-models").OAuth2_PKCE_Method>>;
+            supportsOIDC: z.ZodOptional<z.ZodBoolean>;
+            supportsOIDCDiscovery: z.ZodOptional<z.ZodBoolean>;
+            supportsUserInfo: z.ZodOptional<z.ZodBoolean>;
+            supportsIdToken: z.ZodOptional<z.ZodBoolean>;
+            supportsIncrementalAuth: z.ZodOptional<z.ZodBoolean>;
+            supportsScopeReduction: z.ZodOptional<z.ZodBoolean>;
+            supportsCustomDomains: z.ZodOptional<z.ZodBoolean>;
+            supportsMultiTenancy: z.ZodOptional<z.ZodBoolean>;
+        }, z.core.$strip, core.$ZodObjectExtra>>>;
+        scopes: z.ZodOptional<z.ZodOptional<z.ZodObject<{
+            available: z.ZodOptional<z.ZodArray<z.ZodObject<{
+                scope: z.ZodString;
+                description: z.ZodOptional<z.ZodString>;
+                required: z.ZodOptional<z.ZodBoolean>;
+                category: z.ZodOptional<z.ZodString>;
+                isOIDC: z.ZodOptional<z.ZodBoolean>;
+                grantsOfflineAccess: z.ZodOptional<z.ZodBoolean>;
+                resources: z.ZodOptional<z.ZodArray<z.ZodString>>;
+            }, z.core.$strip>>>;
+            defaultForSSO: z.ZodOptional<z.ZodArray<z.ZodString>>;
+            defaultForAPI: z.ZodOptional<z.ZodArray<z.ZodString>>;
+            minimum: z.ZodOptional<z.ZodArray<z.ZodString>>;
+            offlineAccessScope: z.ZodOptional<z.ZodString>;
+        }, z.core.$strip, core.$ZodObjectExtra>>>;
+        tokenConfig: z.ZodOptional<z.ZodOptional<z.ZodObject<{
+            tokenType: z.ZodOptional<z.ZodString>;
+            accessTokenLifetime: z.ZodOptional<z.ZodNumber>;
+            refreshTokenLifetime: z.ZodOptional<z.ZodNumber>;
+            idTokenLifetime: z.ZodOptional<z.ZodNumber>;
+            tokenEndpointAuthMethod: z.ZodOptional<z.ZodEnum<typeof import("@wildo-ai/external-connectors-models").OAuth2_TokenEndpoint_AuthMethod>>;
+            tokenRequestHeaders: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+            refreshBufferSeconds: z.ZodOptional<z.ZodNumber>;
+        }, z.core.$strip, core.$ZodObjectExtra>>>;
+        preferredGrantType: z.ZodOptional<z.ZodDefault<z.ZodEnum<typeof import("@wildo-ai/external-connectors-models").OAuth2_GrantType>>>;
+        responseType: z.ZodOptional<z.ZodDefault<z.ZodEnum<typeof import("@wildo-ai/external-connectors-models").OAuth2_ResponseType>>>;
+        prompt: z.ZodOptional<z.ZodOptional<z.ZodEnum<typeof import("@wildo-ai/external-connectors-models").OAuth2_Prompt>>>;
+        accessType: z.ZodOptional<z.ZodDefault<z.ZodEnum<typeof import("@wildo-ai/external-connectors-models").OAuth2_AccessType>>>;
+        templateVariables: z.ZodOptional<z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodObject<{
+            displayName: z.ZodString;
+            description: z.ZodOptional<z.ZodString>;
+            required: z.ZodOptional<z.ZodBoolean>;
+            defaultValue: z.ZodOptional<z.ZodString>;
+            options: z.ZodOptional<z.ZodArray<z.ZodObject<{
+                value: z.ZodString;
+                label: z.ZodString;
+            }, z.core.$strip>>>;
+        }, z.core.$strip, core.$ZodObjectExtra>>>>;
+        extraAuthParams: z.ZodOptional<z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>>;
+        extraTokenParams: z.ZodOptional<z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>>;
+        userProfileMapping: z.ZodOptional<z.ZodOptional<z.ZodObject<{
+            id: z.ZodDefault<z.ZodString>;
+            email: z.ZodDefault<z.ZodString>;
+            name: z.ZodDefault<z.ZodString>;
+            image: z.ZodDefault<z.ZodString>;
+            emailVerified: z.ZodDefault<z.ZodString>;
+        }, z.core.$strip, core.$ZodObjectExtra>>>;
+        extensions: z.ZodOptional<z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>>;
+    }, z.core.$strip, core.$ZodObjectExtra>>;
+}, z.core.$strip, core.$ZodObjectExtra>>;
+export type External_Providers_Registry = z.infer<typeof External_Providers_Registry_Schema>;
+/**
+ * OAuth2 Enabled Provider Configuration
+ * For configuring OAuth2 providers at the application level
+ *
+ * Note: OAuth2 protocol definitions are in each provider folder in external-connectors.
+ * This schema is for application-level enabling/customization of OAuth2 providers.
+ */
+export declare const OAuth2EnabledProviderConfigSchema: z.ZodObject<{
+    provider: z.ZodString;
+    enabled: z.ZodDefault<z.ZodBoolean>;
+    allowedDomains: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    purpose: z.ZodDefault<z.ZodEnum<typeof OAuth2_Purpose>>;
+    displayName: z.ZodOptional<z.ZodString>;
+    iconUrl: z.ZodOptional<z.ZodURL>;
+    additionalScopes: z.ZodOptional<z.ZodArray<z.ZodString>>;
+}, z.core.$strip, core.$ZodObjectExtra>;
+export type OAuth2EnabledProviderConfig = z.infer<typeof OAuth2EnabledProviderConfigSchema>;
+/**
+ * OAuth2 Providers Configuration Map
+ * Application-level configuration for all enabled OAuth2 providers
+ */
+export declare const OAuth2ProvidersConfigSchema: z.ZodRecord<z.ZodString, z.ZodObject<{
+    provider: z.ZodString;
+    enabled: z.ZodDefault<z.ZodBoolean>;
+    allowedDomains: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    purpose: z.ZodDefault<z.ZodEnum<typeof OAuth2_Purpose>>;
+    displayName: z.ZodOptional<z.ZodString>;
+    iconUrl: z.ZodOptional<z.ZodURL>;
+    additionalScopes: z.ZodOptional<z.ZodArray<z.ZodString>>;
+}, z.core.$strip, core.$ZodObjectExtra>>;
+export type OAuth2ProvidersConfig = z.infer<typeof OAuth2ProvidersConfigSchema>;
+//# sourceMappingURL=external-providers.shared.schemas.d.ts.map

package/dist/esm/external-providers/external-providers.shared.schemas.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"external-providers.shared.schemas.d.ts","sourceRoot":"","sources":["../../../src/external-providers/external-providers.shared.schemas.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAEH,OAAO,EACL,sCAAsC,EACtC,cAAc,EAEf,MAAM,sCAAsC,CAAC;AAC9C,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AACxB,OAAO,EAAE,gBAAgB,EAAE,MAAM,iCAAiC,CAAC;AAMnE;;;;;;;;GAQG;AACH,eAAO,MAAM,qCAAqC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;uCAehD,CAAC;AACH,MAAM,MAAM,+BAA+B,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,qCAAqC,CAAC,CAAC;AAEpG;;;GAGG;AACH,eAAO,MAAM,kCAAkC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;wCAG9C,CAAC;AACF,MAAM,MAAM,2BAA2B,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,kCAAkC,CAAC,CAAC;AAM7F;;;;;;GAMG;AACH,eAAO,MAAM,iCAAiC;;;;;;;;uCAqB5C,CAAC;AACH,MAAM,MAAM,2BAA2B,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,iCAAiC,CAAC,CAAC;AAE5F;;;GAGG;AACH,eAAO,MAAM,2BAA2B;;;;;;;;wCAGvC,CAAC;AACF,MAAM,MAAM,qBAAqB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,2BAA2B,CAAC,CAAC"}

package/dist/esm/external-providers/external-providers.shared.schemas.js

@@ -0,0 +1,70 @@
+/**
+ * External Providers Shared Schemas
+ *
+ * Provides application-level registry schemas for external providers.
+ * OAuth2 configurations are defined per-provider in @wildo-ai/external-connectors.
+ */
+import { ExternalProvider_ExchangeProtocol_Kind, OAuth2_Purpose, OAuth2_ProviderDefinitionSchema, } from "@wildo-ai/external-connectors-models";
+import { z } from "zod";
+import { EngineCapability } from "./wildo-features.shared.schemas.js";
+// =============================================================================
+// EXTERNAL PROVIDERS REGISTRY
+// =============================================================================
+/**
+ * External Providers Registry Item
+ * Defines what protocols and capabilities a provider supports
+ *
+ * Note: This is a COMPUTED structure populated from:
+ * - ExternalProvider_Definition.capabilities (what provider actually supports)
+ * - CapabilityBindingsPolicy (what capabilities are assigned to this provider)
+ * - Capability requirements validation
+ */
+export const External_Providers_RegistryItemSchema = z.object({
+    /** Reference to the provider (string identifier) */
+    providerRef: z.string(),
+    /** Protocols this provider supports */
+    protocols: z.array(z.enum(ExternalProvider_ExchangeProtocol_Kind)),
+    /** Engine capabilities enabled for this provider */
+    engineCapabilities: z.array(z.enum(EngineCapability)).default([]),
+    /** Does this provider support OAuth2? */
+    supportsOAuth2: z.boolean().optional(),
+    /** Custom OAuth2 configuration (if needed to override provider defaults) */
+    customOAuth2Config: OAuth2_ProviderDefinitionSchema.partial().optional(),
+});
+/**
+ * External Providers Registry
+ * Maps provider references to their configurations
+ */
+export const External_Providers_Registry_Schema = z.record(z.string(), External_Providers_RegistryItemSchema);
+// =============================================================================
+// OAUTH2 ENABLED PROVIDERS CONFIGURATION
+// =============================================================================
+/**
+ * OAuth2 Enabled Provider Configuration
+ * For configuring OAuth2 providers at the application level
+ *
+ * Note: OAuth2 protocol definitions are in each provider folder in external-connectors.
+ * This schema is for application-level enabling/customization of OAuth2 providers.
+ */
+export const OAuth2EnabledProviderConfigSchema = z.object({
+    /** Provider reference (string identifier) */
+    provider: z.string(),
+    /** Is this provider enabled? */
+    enabled: z.boolean().default(true),
+    /** Allowed email domains for this provider */
+    allowedDomains: z.array(z.string()).optional(),
+    /** Purpose: SSO only, API only, or both */
+    purpose: z.enum(OAuth2_Purpose).default(OAuth2_Purpose.HYBRID),
+    /** Custom display name (overrides default) */
+    displayName: z.string().optional(),
+    /** Custom icon URL (overrides default) */
+    iconUrl: z.url().optional(),
+    /** Additional scopes to request */
+    additionalScopes: z.array(z.string()).optional(),
+});
+/**
+ * OAuth2 Providers Configuration Map
+ * Application-level configuration for all enabled OAuth2 providers
+ */
+export const OAuth2ProvidersConfigSchema = z.record(z.string(), OAuth2EnabledProviderConfigSchema);
+//# sourceMappingURL=external-providers.shared.schemas.js.map

package/dist/esm/external-providers/external-providers.shared.schemas.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"external-providers.shared.schemas.js","sourceRoot":"","sources":["../../../src/external-providers/external-providers.shared.schemas.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAEH,OAAO,EACL,sCAAsC,EACtC,cAAc,EACd,+BAA+B,GAChC,MAAM,sCAAsC,CAAC;AAC9C,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AACxB,OAAO,EAAE,gBAAgB,EAAE,MAAM,iCAAiC,CAAC;AAEnE,gFAAgF;AAChF,8BAA8B;AAC9B,gFAAgF;AAEhF;;;;;;;;GAQG;AACH,MAAM,CAAC,MAAM,qCAAqC,GAAG,CAAC,CAAC,MAAM,CAAC;IAC5D,oDAAoD;IACpD,WAAW,EAAE,CAAC,CAAC,MAAM,EAAE;IAEvB,uCAAuC;IACvC,SAAS,EAAE,CAAC,CAAC,KAAK,CAAC,CAAC,CAAC,IAAI,CAAC,sCAAsC,CAAC,CAAC;IAElE,oDAAoD;IACpD,kBAAkB,EAAE,CAAC,CAAC,KAAK,CAAC,CAAC,CAAC,IAAI,CAAC,gBAAgB,CAAC,CAAC,CAAC,OAAO,CAAC,EAAE,CAAC;IAEjE,yCAAyC;IACzC,cAAc,EAAE,CAAC,CAAC,OAAO,EAAE,CAAC,QAAQ,EAAE;IAEtC,4EAA4E;IAC5E,kBAAkB,EAAE,+BAA+B,CAAC,OAAO,EAAE,CAAC,QAAQ,EAAE;CACzE,CAAC,CAAC;AAGH;;;GAGG;AACH,MAAM,CAAC,MAAM,kCAAkC,GAAG,CAAC,CAAC,MAAM,CACxD,CAAC,CAAC,MAAM,EAAE,EACV,qCAAqC,CACtC,CAAC;AAGF,gFAAgF;AAChF,yCAAyC;AACzC,gFAAgF;AAEhF;;;;;;GAMG;AACH,MAAM,CAAC,MAAM,iCAAiC,GAAG,CAAC,CAAC,MAAM,CAAC;IACxD,6CAA6C;IAC7C,QAAQ,EAAE,CAAC,CAAC,MAAM,EAAE;IAEpB,gCAAgC;IAChC,OAAO,EAAE,CAAC,CAAC,OAAO,EAAE,CAAC,OAAO,CAAC,IAAI,CAAC;IAElC,8CAA8C;IAC9C,cAAc,EAAE,CAAC,CAAC,KAAK,CAAC,CAAC,CAAC,MAAM,EAAE,CAAC,CAAC,QAAQ,EAAE;IAE9C,2CAA2C;IAC3C,OAAO,EAAE,CAAC,CAAC,IAAI,CAAC,cAAc,CAAC,CAAC,OAAO,CAAC,cAAc,CAAC,MAAM,CAAC;IAE9D,8CAA8C;IAC9C,WAAW,EAAE,CAAC,CAAC,MAAM,EAAE,CAAC,QAAQ,EAAE;IAElC,0CAA0C;IAC1C,OAAO,EAAE,CAAC,CAAC,GAAG,EAAE,CAAC,QAAQ,EAAE;IAE3B,mCAAmC;IACnC,gBAAgB,EAAE,CAAC,CAAC,KAAK,CAAC,CAAC,CAAC,MAAM,EAAE,CAAC,CAAC,QAAQ,EAAE;CACjD,CAAC,CAAC;AAGH;;;GAGG;AACH,MAAM,CAAC,MAAM,2BAA2B,GAAG,CAAC,CAAC,MAAM,CACjD,CAAC,CAAC,MAAM,EAAE,EACV,iCAAiC,CAClC,CAAC"}

package/dist/esm/external-providers/feature-bindings-policy.shared.schemas.d.ts

@@ -0,0 +1,27 @@
+/**
+ * Capability Bindings Policy Schemas
+ *
+ * POLICY = Manual configuration declaring which providers to use for which capabilities.
+ * The External_Providers_Registry is then COMPUTED from this policy + provider definitions.
+ *
+ * Policy is configured in AppConfig.capabilities
+ */
+import { z } from "zod";
+import { EngineCapability } from "./wildo-features.shared.schemas.js";
+/**
+ * Capability Bindings Policy for AppConfig
+ *
+ * This is the POLICY (manual configuration).
+ * The External_Providers_Registry is COMPUTED from this policy.
+ *
+ * Simple map: EngineCapability → providerRef (string) or providerRef[] (string[])
+ */
+export declare const CapabilityBindingsPolicySchema: z.ZodObject<{
+    capabilities: z.ZodDefault<z.ZodRecord<z.ZodEnum<typeof EngineCapability> & z.core.$partial, z.ZodUnion<readonly [z.ZodString, z.ZodArray<z.ZodString>]>>>;
+}, z.core.$strip, core.$ZodObjectExtra>;
+export type CapabilityBindingsPolicy = z.infer<typeof CapabilityBindingsPolicySchema>;
+/**
+ * Default empty capability bindings policy
+ */
+export declare const DefaultCapabilityBindingsPolicy: CapabilityBindingsPolicy;
+//# sourceMappingURL=feature-bindings-policy.shared.schemas.d.ts.map

package/dist/esm/external-providers/feature-bindings-policy.shared.schemas.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"feature-bindings-policy.shared.schemas.d.ts","sourceRoot":"","sources":["../../../src/external-providers/feature-bindings-policy.shared.schemas.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAEH,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AACxB,OAAO,EAAE,gBAAgB,EAAE,MAAM,iCAAiC,CAAC;AAMnE;;;;;;;GAOG;AACH,eAAO,MAAM,8BAA8B;;uCAMzC,CAAC;AACH,MAAM,MAAM,wBAAwB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,8BAA8B,CAAC,CAAC;AAMtF;;GAEG;AACH,eAAO,MAAM,+BAA+B,EAAE,wBAE7C,CAAC"}

package/dist/esm/external-providers/feature-bindings-policy.shared.schemas.js

@@ -0,0 +1,35 @@
+/**
+ * Capability Bindings Policy Schemas
+ *
+ * POLICY = Manual configuration declaring which providers to use for which capabilities.
+ * The External_Providers_Registry is then COMPUTED from this policy + provider definitions.
+ *
+ * Policy is configured in AppConfig.capabilities
+ */
+import { z } from "zod";
+import { EngineCapability } from "./wildo-features.shared.schemas.js";
+// =====================================================
+// Capability Bindings Policy Schema
+// =====================================================
+/**
+ * Capability Bindings Policy for AppConfig
+ *
+ * This is the POLICY (manual configuration).
+ * The External_Providers_Registry is COMPUTED from this policy.
+ *
+ * Simple map: EngineCapability → providerRef (string) or providerRef[] (string[])
+ */
+export const CapabilityBindingsPolicySchema = z.object({
+    /** EngineCapability → Provider policy mappings (single providerRef or array) */
+    capabilities: z.partialRecord(z.enum(EngineCapability), z.union([z.string(), z.array(z.string())])).default({}),
+});
+// =====================================================
+// Default Capability Bindings Policy
+// =====================================================
+/**
+ * Default empty capability bindings policy
+ */
+export const DefaultCapabilityBindingsPolicy = {
+    capabilities: {},
+};
+//# sourceMappingURL=feature-bindings-policy.shared.schemas.js.map

package/dist/esm/external-providers/feature-bindings-policy.shared.schemas.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"feature-bindings-policy.shared.schemas.js","sourceRoot":"","sources":["../../../src/external-providers/feature-bindings-policy.shared.schemas.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAEH,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AACxB,OAAO,EAAE,gBAAgB,EAAE,MAAM,iCAAiC,CAAC;AAEnE,wDAAwD;AACxD,oCAAoC;AACpC,wDAAwD;AAExD;;;;;;;GAOG;AACH,MAAM,CAAC,MAAM,8BAA8B,GAAG,CAAC,CAAC,MAAM,CAAC;IACrD,gFAAgF;IAChF,YAAY,EAAE,CAAC,CAAC,aAAa,CAC3B,CAAC,CAAC,IAAI,CAAC,gBAAgB,CAAC,EACxB,CAAC,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC,MAAM,EAAE,EAAE,CAAC,CAAC,KAAK,CAAC,CAAC,CAAC,MAAM,EAAE,CAAC,CAAC,CAAC,CAC3C,CAAC,OAAO,CAAC,EAAE,CAAC;CACd,CAAC,CAAC;AAGH,wDAAwD;AACxD,qCAAqC;AACrC,wDAAwD;AAExD;;GAEG;AACH,MAAM,CAAC,MAAM,+BAA+B,GAA6B;IACvE,YAAY,EAAE,EAAE;CACjB,CAAC"}

package/dist/esm/external-providers/feature-mapping.shared.schemas.d.ts

@@ -0,0 +1,80 @@
+/**
+ * Engine Capability Definition Schemas
+ *
+ * Defines the mapping from ExternalProvider_Capability to EngineCapability.
+ * Each definition includes:
+ * - How the capability can be fulfilled (one or more of EXTERNAL_PROVIDER / PLATFORM_SERVICE)
+ * - Whether the capability is managed (engine provides abstraction) or unmanaged
+ * - Requirements that providers must meet (for EXTERNAL_PROVIDER fulfillment)
+ */
+import { z } from "zod";
+import { ExternalProvider_Capability, ExternalProvider_ExchangeProtocol_Kind } from "@wildo-ai/external-connectors-models";
+import { EngineCapability, EngineCapabilityFulfillmentKind } from "./wildo-features.shared.schemas.js";
+/**
+ * Capability Requirements Schema
+ *
+ * Defines what an external provider needs to satisfy a capability.
+ * Only applicable for EXTERNAL_PROVIDER fulfillment kind.
+ */
+export declare const CapabilityRequirementSchema: z.ZodObject<{
+    requiredProtocols: z.ZodOptional<z.ZodArray<z.ZodEnum<typeof ExternalProvider_ExchangeProtocol_Kind>>>;
+    requiresTransformer: z.ZodDefault<z.ZodBoolean>;
+}, z.core.$strip, core.$ZodObjectExtra>;
+export type CapabilityRequirement = z.infer<typeof CapabilityRequirementSchema>;
+/**
+ * EngineCapability Definition
+ *
+ * Defines an engine capability, how it can be fulfilled, and its requirements.
+ *
+ * A capability may support multiple fulfillment kinds simultaneously.
+ * For example, DOCUMENT_GENERATION can be backed by a platform service (Gotenberg)
+ * or by an external API (Adobe PDF Services). The actual fulfillment depends on
+ * the app's `capabilities` configuration.
+ *
+ * - `externalProviderCapabilityRef` is set when EXTERNAL_PROVIDER is in fulfillmentKinds
+ * - `platformServiceRef` is set when PLATFORM_SERVICE is in fulfillmentKinds
+ * - Both can coexist when the capability supports dual fulfillment
+ */
+export declare const EngineCapabilityDefinitionSchema: z.ZodObject<{
+    capability: z.ZodEnum<typeof EngineCapability>;
+    fulfillmentKinds: z.ZodArray<z.ZodEnum<typeof EngineCapabilityFulfillmentKind>>;
+    externalProviderCapabilityRef: z.ZodOptional<z.ZodEnum<typeof ExternalProvider_Capability>>;
+    platformServiceRef: z.ZodOptional<z.ZodString>;
+    managed: z.ZodDefault<z.ZodBoolean>;
+    providerMode: z.ZodDefault<z.ZodEnum<{
+        SINGLE: "SINGLE";
+        MULTIPLE: "MULTIPLE";
+    }>>;
+    requirements: z.ZodOptional<z.ZodObject<{
+        requiredProtocols: z.ZodOptional<z.ZodArray<z.ZodEnum<typeof ExternalProvider_ExchangeProtocol_Kind>>>;
+        requiresTransformer: z.ZodDefault<z.ZodBoolean>;
+    }, z.core.$strip, core.$ZodObjectExtra>>;
+}, z.core.$strip, core.$ZodObjectExtra>;
+export type EngineCapabilityDefinition = z.infer<typeof EngineCapabilityDefinitionSchema>;
+/**
+ * EngineCapability Definitions
+ *
+ * Maps EngineCapability → definition with supported fulfillment kinds and requirements.
+ * Unified registry for both external-provider and platform-service capabilities.
+ *
+ * A capability can support multiple fulfillment kinds. The actual fulfillment used
+ * at runtime depends on the app's `capabilities` configuration (whether it binds
+ * an external provider or relies on a platform service).
+ */
+export declare const EngineCapability_Definitions: Partial<Record<EngineCapability, EngineCapabilityDefinition>>;
+/**
+ * @deprecated Use `EngineCapability_Definitions` instead.
+ */
+export declare const PlatformCapability_Definitions: Partial<Record<EngineCapability, {
+    capability: EngineCapability;
+    fulfillmentKinds: EngineCapabilityFulfillmentKind[];
+    managed: boolean;
+    providerMode: "SINGLE" | "MULTIPLE";
+    externalProviderCapabilityRef?: ExternalProvider_Capability;
+    platformServiceRef?: string;
+    requirements?: {
+        requiresTransformer: boolean;
+        requiredProtocols?: ExternalProvider_ExchangeProtocol_Kind[];
+    };
+}>>;
+//# sourceMappingURL=feature-mapping.shared.schemas.d.ts.map

package/dist/esm/external-providers/feature-mapping.shared.schemas.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"feature-mapping.shared.schemas.d.ts","sourceRoot":"","sources":["../../../src/external-providers/feature-mapping.shared.schemas.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AAEH,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AACxB,OAAO,EACL,2BAA2B,EAC3B,sCAAsC,EACvC,MAAM,sCAAsC,CAAC;AAC9C,OAAO,EAAE,gBAAgB,EAAE,+BAA+B,EAAE,MAAM,iCAAiC,CAAC;AAMpG;;;;;GAKG;AACH,eAAO,MAAM,2BAA2B;;;uCAMtC,CAAC;AACH,MAAM,MAAM,qBAAqB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,2BAA2B,CAAC,CAAC;AAMhF;;;;;;;;;;;;;GAaG;AACH,eAAO,MAAM,gCAAgC;;;;;;;;;;;;;;uCAyB3C,CAAC;AACH,MAAM,MAAM,0BAA0B,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,gCAAgC,CAAC,CAAC;AAO1F;;;;;;;;;GASG;AACH,eAAO,MAAM,4BAA4B,EAAE,OAAO,CAAC,MAAM,CAAC,gBAAgB,EAAE,0BAA0B,CAAC,CA+EtG,CAAC;AAEF;;GAEG;AACH,eAAO,MAAM,8BAA8B;;;;;;;;;;;GAA+B,CAAC"}

package/dist/esm/external-providers/feature-mapping.shared.schemas.js

@@ -0,0 +1,159 @@
+/**
+ * Engine Capability Definition Schemas
+ *
+ * Defines the mapping from ExternalProvider_Capability to EngineCapability.
+ * Each definition includes:
+ * - How the capability can be fulfilled (one or more of EXTERNAL_PROVIDER / PLATFORM_SERVICE)
+ * - Whether the capability is managed (engine provides abstraction) or unmanaged
+ * - Requirements that providers must meet (for EXTERNAL_PROVIDER fulfillment)
+ */
+import { z } from "zod";
+import { ExternalProvider_Capability, ExternalProvider_ExchangeProtocol_Kind, } from "@wildo-ai/external-connectors-models";
+import { EngineCapability, EngineCapabilityFulfillmentKind } from "./wildo-features.shared.schemas.js";
+// =====================================================
+// Capability Requirements Schema
+// =====================================================
+/**
+ * Capability Requirements Schema
+ *
+ * Defines what an external provider needs to satisfy a capability.
+ * Only applicable for EXTERNAL_PROVIDER fulfillment kind.
+ */
+export const CapabilityRequirementSchema = z.object({
+    /** Required protocols (at least one must be present) */
+    requiredProtocols: z.array(z.enum(ExternalProvider_ExchangeProtocol_Kind)).optional(),
+    /** Required capability transformer availability */
+    requiresTransformer: z.boolean().default(false),
+});
+// =====================================================
+// EngineCapability Definition Schema
+// =====================================================
+/**
+ * EngineCapability Definition
+ *
+ * Defines an engine capability, how it can be fulfilled, and its requirements.
+ *
+ * A capability may support multiple fulfillment kinds simultaneously.
+ * For example, DOCUMENT_GENERATION can be backed by a platform service (Gotenberg)
+ * or by an external API (Adobe PDF Services). The actual fulfillment depends on
+ * the app's `capabilities` configuration.
+ *
+ * - `externalProviderCapabilityRef` is set when EXTERNAL_PROVIDER is in fulfillmentKinds
+ * - `platformServiceRef` is set when PLATFORM_SERVICE is in fulfillmentKinds
+ * - Both can coexist when the capability supports dual fulfillment
+ */
+export const EngineCapabilityDefinitionSchema = z.object({
+    /** The EngineCapability this definition is for */
+    capability: z.enum(EngineCapability),
+    /**
+     * How this capability can be fulfilled at runtime.
+     * Array to support capabilities that can be backed by either an external provider
+     * or a platform service (or both), depending on the app's configuration.
+     */
+    fulfillmentKinds: z.array(z.enum(EngineCapabilityFulfillmentKind)).min(1),
+    /** Reference to ExternalProvider_Capability (when EXTERNAL_PROVIDER is a supported fulfillment) */
+    externalProviderCapabilityRef: z.enum(ExternalProvider_Capability).optional(),
+    /** Platform service name (when PLATFORM_SERVICE is a supported fulfillment) */
+    platformServiceRef: z.string().optional(),
+    /** Whether the engine provides standardized interfaces and transformers */
+    managed: z.boolean().default(true),
+    /** Can be enabled by a single provider or requires multiple */
+    providerMode: z.enum(["SINGLE", "MULTIPLE"]).default("SINGLE"),
+    /** Requirements providers must meet (for EXTERNAL_PROVIDER fulfillment) */
+    requirements: CapabilityRequirementSchema.optional(),
+});
+// =====================================================
+// Static Capability Definitions Registry
+// =====================================================
+/**
+ * EngineCapability Definitions
+ *
+ * Maps EngineCapability → definition with supported fulfillment kinds and requirements.
+ * Unified registry for both external-provider and platform-service capabilities.
+ *
+ * A capability can support multiple fulfillment kinds. The actual fulfillment used
+ * at runtime depends on the app's `capabilities` configuration (whether it binds
+ * an external provider or relies on a platform service).
+ */
+export const EngineCapability_Definitions = {
+    // ── EXTERNAL_PROVIDER capabilities ──────────────────────────
+    [EngineCapability.EMAIL_TRANSACTIONAL]: {
+        capability: EngineCapability.EMAIL_TRANSACTIONAL,
+        fulfillmentKinds: [EngineCapabilityFulfillmentKind.EXTERNAL_PROVIDER],
+        externalProviderCapabilityRef: ExternalProvider_Capability.EMAIL_TRANSACTIONAL,
+        managed: true,
+        providerMode: "SINGLE",
+        requirements: {
+            requiredProtocols: [ExternalProvider_ExchangeProtocol_Kind.EMAIL_PROVIDER],
+            requiresTransformer: true,
+        },
+    },
+    [EngineCapability.EMAIL_MARKETING]: {
+        capability: EngineCapability.EMAIL_MARKETING,
+        fulfillmentKinds: [EngineCapabilityFulfillmentKind.EXTERNAL_PROVIDER],
+        externalProviderCapabilityRef: ExternalProvider_Capability.EMAIL_MARKETING,
+        managed: true,
+        providerMode: "SINGLE",
+        requirements: {
+            requiredProtocols: [ExternalProvider_ExchangeProtocol_Kind.EMAIL_PROVIDER],
+            requiresTransformer: true,
+        },
+    },
+    [EngineCapability.SMS]: {
+        capability: EngineCapability.SMS,
+        fulfillmentKinds: [EngineCapabilityFulfillmentKind.EXTERNAL_PROVIDER],
+        externalProviderCapabilityRef: ExternalProvider_Capability.SMS,
+        managed: true,
+        providerMode: "SINGLE",
+        requirements: {
+            requiredProtocols: [ExternalProvider_ExchangeProtocol_Kind.SMS_PROVIDER],
+            requiresTransformer: true,
+        },
+    },
+    [EngineCapability.BILLING]: {
+        capability: EngineCapability.BILLING,
+        fulfillmentKinds: [EngineCapabilityFulfillmentKind.EXTERNAL_PROVIDER],
+        externalProviderCapabilityRef: ExternalProvider_Capability.BILLING,
+        managed: true,
+        providerMode: "SINGLE",
+        requirements: {
+            requiresTransformer: true,
+        },
+    },
+    [EngineCapability.AI_LLM]: {
+        capability: EngineCapability.AI_LLM,
+        fulfillmentKinds: [EngineCapabilityFulfillmentKind.EXTERNAL_PROVIDER],
+        managed: false,
+        providerMode: "MULTIPLE",
+        requirements: {
+            requiredProtocols: [ExternalProvider_ExchangeProtocol_Kind.LLM_PROVIDER],
+            requiresTransformer: false,
+        },
+    },
+    [EngineCapability.MAPS_GEOLOCATION]: {
+        capability: EngineCapability.MAPS_GEOLOCATION,
+        fulfillmentKinds: [EngineCapabilityFulfillmentKind.EXTERNAL_PROVIDER],
+        managed: false,
+        providerMode: "SINGLE",
+    },
+    // ── PLATFORM_SERVICE capabilities (some also support EXTERNAL_PROVIDER) ──
+    [EngineCapability.DOCUMENT_GENERATION]: {
+        capability: EngineCapability.DOCUMENT_GENERATION,
+        fulfillmentKinds: [EngineCapabilityFulfillmentKind.PLATFORM_SERVICE, EngineCapabilityFulfillmentKind.EXTERNAL_PROVIDER],
+        platformServiceRef: 'fileGenerator',
+        managed: true,
+        providerMode: "SINGLE",
+    },
+    [EngineCapability.ANTIVIRUS_SCANNING]: {
+        capability: EngineCapability.ANTIVIRUS_SCANNING,
+        fulfillmentKinds: [EngineCapabilityFulfillmentKind.PLATFORM_SERVICE, EngineCapabilityFulfillmentKind.EXTERNAL_PROVIDER],
+        platformServiceRef: 'clamav',
+        managed: true,
+        providerMode: "SINGLE",
+    },
+};
+/**
+ * @deprecated Use `EngineCapability_Definitions` instead.
+ */
+export const PlatformCapability_Definitions = EngineCapability_Definitions;
+//# sourceMappingURL=feature-mapping.shared.schemas.js.map