@wildo-ai/saas-models 1.0.1 → 1.1.0

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

@@ -0,0 +1,319 @@
+import { z } from 'zod';
+export { FrontendProviderEntrySchema, FrontendProvidersBlockSchema, type FrontendProviderEntry, type FrontendProvidersBlock, } from './frontend-provider-entry.shared.schemas';
+export declare const FrontendAppBootstrapPayloadSchema: z.ZodObject<{
+    frontendProviders: z.ZodObject<{
+        providers: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodObject<{
+            metadata: z.ZodObject<{
+                ref: z.ZodString;
+                displayNameLabelKey: z.ZodOptional<z.ZodString>;
+                displayName: z.ZodOptional<z.ZodString>;
+                iconRef: z.ZodOptional<z.ZodString>;
+            }, z.core.$strip>;
+            providerCapabilities: z.ZodArray<z.ZodString>;
+            protocols: z.ZodArray<z.ZodString>;
+            publicConfig: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+        }, z.core.$strip>>>;
+    }, z.core.$strip>;
+}, z.core.$strip>;
+export type FrontendAppBootstrapPayload = z.infer<typeof FrontendAppBootstrapPayloadSchema>;
+/**
+ * Existing `/application-config` response extended with frontend provider
+ * bootstrap data. Parsing through `AppConfiguration_Shared_Schema` later still
+ * strips `frontendProviders`, so frontend startup can keep the shared config
+ * contract intact while hydrating the registry alongside it.
+ */
+export declare const AppConfiguration_FrontendBootstrapResponse_Schema: z.ZodObject<{
+    appIdentity: z.ZodObject<{
+        appName: z.ZodString;
+        displayName: z.ZodOptional<z.ZodString>;
+        description: z.ZodOptional<z.ZodString>;
+        version: z.ZodString;
+    }, z.core.$strip>;
+    brandAssets: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        composition: z.ZodEnum<typeof import("..").BrandAssetComposition>;
+        theme: z.ZodEnum<typeof import("..").BrandAssetTheme>;
+        purpose: z.ZodEnum<typeof import("..").BrandAssetPurpose>;
+        url: z.ZodString;
+        format: z.ZodEnum<typeof import("..").BrandAssetFormat>;
+        width: z.ZodOptional<z.ZodNumber>;
+        height: z.ZodOptional<z.ZodNumber>;
+    }, z.core.$strip>>>;
+    appPreferences: z.ZodObject<{
+        languages: z.ZodObject<{
+            defaultLanguage: z.ZodDefault<import("@wildo-ai/zod-decorators").DecoratedPrimitiveZodType<z.ZodEnum<typeof import("@wildo-ai/presets-components-models").AvailableLanguage>>>;
+            enabledLanguages: z.ZodDefault<z.ZodArray<import("@wildo-ai/zod-decorators").DecoratedPrimitiveZodType<z.ZodEnum<typeof import("@wildo-ai/presets-components-models").AvailableLanguage>>>>;
+            fallbackLanguage: z.ZodDefault<import("@wildo-ai/zod-decorators").DecoratedPrimitiveZodType<z.ZodEnum<typeof import("@wildo-ai/presets-components-models").AvailableLanguage>>>;
+            autoDetectFromBrowser: z.ZodDefault<z.ZodBoolean>;
+            allowUserOverride: z.ZodDefault<z.ZodBoolean>;
+            allowOrganizationOverride: z.ZodDefault<z.ZodBoolean>;
+            enableLanguageSwitcher: z.ZodDefault<z.ZodBoolean>;
+        }, z.core.$strip>;
+    }, z.core.$strip>;
+    apiJwtPublicKey: z.ZodString;
+    runtime: z.ZodObject<{
+        endPoints: z.ZodRecord<z.ZodString, z.ZodObject<{
+            publicUrl: z.ZodOptional<z.ZodString>;
+            internalUrl: z.ZodOptional<z.ZodString>;
+        }, z.core.$strip>>;
+    }, z.core.$strip>;
+    auth: z.ZodObject<{
+        passkeyConfig: z.ZodObject<{
+            rpName: z.ZodString;
+            rpId: z.ZodString;
+            maxPasskeysPerUser: z.ZodDefault<z.ZodNumber>;
+        }, z.core.$strip>;
+        socialOAuth2Providers: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodObject<{
+            displayName: z.ZodOptional<z.ZodString>;
+        }, z.core.$strip>>>;
+        orgAuthMethodPolicy: z.ZodDefault<z.ZodEnum<typeof import("..").OrgAuthMethodPolicy>>;
+        expandableOrgMethods: z.ZodOptional<z.ZodArray<z.ZodEnum<typeof import("..").AuthMethod>>>;
+        crossOrgSSOAccess: z.ZodDefault<z.ZodBoolean>;
+    }, z.core.$strip>;
+    userTypes: z.ZodRecord<z.ZodString, z.ZodObject<{
+        auth: z.ZodObject<{
+            authMethodsEnabled: z.ZodDefault<z.ZodRecord<z.ZodEnum<typeof import("..").AuthMethod> & z.core.$partial, z.ZodUnion<readonly [z.ZodBoolean, z.ZodObject<{
+                enabled: z.ZodBoolean;
+            }, z.core.$strip>]>>>;
+            mfaPolicy: z.ZodDefault<z.ZodObject<{
+                requireMFA: z.ZodDefault<z.ZodBoolean>;
+                requireStrongMFA: z.ZodDefault<z.ZodBoolean>;
+                acceptableMFAMethods: z.ZodOptional<z.ZodArray<z.ZodEnum<typeof import("..").AuthMethod>>>;
+                enrollmentGracePeriodDays: z.ZodDefault<z.ZodNumber>;
+                passkeyExemptFromMFA: z.ZodDefault<z.ZodBoolean>;
+            }, z.core.$strip>>;
+            registration: z.ZodObject<{
+                mode: z.ZodEnum<typeof import("..").RegistrationMode>;
+                allowedMethods: z.ZodDefault<z.ZodArray<z.ZodEnum<typeof import("..").AuthMethod>>>;
+                emailVerification: z.ZodDefault<z.ZodEnum<typeof import("..").EmailVerificationMode>>;
+                blockForSSODomains: z.ZodDefault<z.ZodBoolean>;
+            }, z.core.$strict>;
+            passwordPolicy: z.ZodDefault<z.ZodObject<{
+                minLength: z.ZodDefault<z.ZodNumber>;
+                maxLength: z.ZodDefault<z.ZodNumber>;
+                requireUppercase: z.ZodDefault<z.ZodBoolean>;
+                requireLowercase: z.ZodDefault<z.ZodBoolean>;
+                requireNumbers: z.ZodDefault<z.ZodBoolean>;
+                requireSpecialChars: z.ZodDefault<z.ZodBoolean>;
+                expiryDays: z.ZodDefault<z.ZodNumber>;
+            }, z.core.$strip>>;
+            sessionDurationMinutes: z.ZodDefault<z.ZodNumber>;
+            maxConcurrentSessions: z.ZodOptional<z.ZodNumber>;
+            lockoutPolicy: z.ZodDefault<z.ZodObject<{
+                maxLoginAttempts: z.ZodDefault<z.ZodNumber>;
+                lockoutDurationMinutes: z.ZodDefault<z.ZodNumber>;
+                progressiveLockout: z.ZodDefault<z.ZodBoolean>;
+                maxProgressiveLockoutHours: z.ZodDefault<z.ZodNumber>;
+            }, z.core.$strip>>;
+            autoLinkByEmail: z.ZodDefault<z.ZodBoolean>;
+            stepUpAuth: z.ZodOptional<z.ZodObject<{
+                enabled: z.ZodDefault<z.ZodBoolean>;
+                maxAgeSeconds: z.ZodDefault<z.ZodNumber>;
+                methods: z.ZodDefault<z.ZodArray<z.ZodEnum<typeof import("..").AuthMethod>>>;
+            }, z.core.$strip>>;
+            methodManagement: z.ZodDefault<z.ZodObject<{
+                allowUserMethodRemoval: z.ZodDefault<z.ZodBoolean>;
+                requireReauthForMethodChanges: z.ZodDefault<z.ZodBoolean>;
+            }, z.core.$strip>>;
+            anonymousSessionsEnabled: z.ZodOptional<z.ZodBoolean>;
+            oneOffSessionAllowed: z.ZodOptional<z.ZodBoolean>;
+            oneOffSessionMaxDurationMinutes: z.ZodOptional<z.ZodNumber>;
+        }, z.core.$strip>;
+        uniqueIdentifier: z.ZodDefault<z.ZodString>;
+        defaultAppRoles: z.ZodDefault<z.ZodArray<z.ZodUnion<readonly [z.ZodEnum<typeof import("..").CORE_APP_ROLES>, z.ZodString]>>>;
+        requiresOrgMembership: z.ZodOptional<z.ZodObject<{
+            orgTypes: z.ZodArray<z.ZodString>;
+        }, z.core.$strip>>;
+    }, z.core.$strip>>;
+    frontendServices: z.ZodRecord<z.ZodString, z.ZodObject<{
+        usersManagement: z.ZodRecord<z.ZodString, z.ZodObject<{
+            register: z.ZodBoolean;
+            auth: z.ZodBoolean;
+            isDefault: z.ZodOptional<z.ZodBoolean>;
+        }, z.core.$strip>>;
+        frontendType: z.ZodOptional<z.ZodEnum<typeof import("..").AppFrontendType>>;
+    }, z.core.$strip>>;
+    organizationTypes: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodObject<{
+        userTypes: z.ZodArray<z.ZodString>;
+        availableOrgRoles: z.ZodDefault<z.ZodArray<z.ZodUnion<readonly [z.ZodUnion<readonly [z.ZodEnum<typeof import("..").CORE_ORG_ROLES>, z.ZodString]>, z.ZodString]>>>;
+        defaultMemberRole: z.ZodDefault<z.ZodUnion<readonly [z.ZodUnion<readonly [z.ZodEnum<typeof import("..").CORE_ORG_ROLES>, z.ZodString]>, z.ZodString]>>;
+        authOverrides: z.ZodOptional<z.ZodObject<{
+            authMethodsEnabled: z.ZodOptional<z.ZodRecord<z.ZodEnum<typeof import("..").AuthMethod> & z.core.$partial, z.ZodUnion<readonly [z.ZodBoolean, z.ZodObject<{
+                enabled: z.ZodBoolean;
+            }, z.core.$strip>]>>>;
+            mfaPolicy: z.ZodOptional<z.ZodObject<{
+                requireMFA: z.ZodOptional<z.ZodDefault<z.ZodBoolean>>;
+                requireStrongMFA: z.ZodOptional<z.ZodDefault<z.ZodBoolean>>;
+                acceptableMFAMethods: z.ZodOptional<z.ZodOptional<z.ZodArray<z.ZodEnum<typeof import("..").AuthMethod>>>>;
+                enrollmentGracePeriodDays: z.ZodOptional<z.ZodDefault<z.ZodNumber>>;
+                passkeyExemptFromMFA: z.ZodOptional<z.ZodDefault<z.ZodBoolean>>;
+            }, z.core.$strip>>;
+            passwordPolicy: z.ZodOptional<z.ZodObject<{
+                minLength: z.ZodOptional<z.ZodDefault<z.ZodNumber>>;
+                maxLength: z.ZodOptional<z.ZodDefault<z.ZodNumber>>;
+                requireUppercase: z.ZodOptional<z.ZodDefault<z.ZodBoolean>>;
+                requireLowercase: z.ZodOptional<z.ZodDefault<z.ZodBoolean>>;
+                requireNumbers: z.ZodOptional<z.ZodDefault<z.ZodBoolean>>;
+                requireSpecialChars: z.ZodOptional<z.ZodDefault<z.ZodBoolean>>;
+                expiryDays: z.ZodOptional<z.ZodDefault<z.ZodNumber>>;
+            }, z.core.$strip>>;
+        }, z.core.$strip>>;
+        scimProvisioning: z.ZodOptional<z.ZodObject<{
+            enabled: z.ZodDefault<z.ZodBoolean>;
+            syncFrequencyHours: z.ZodDefault<z.ZodNumber>;
+        }, z.core.$strip>>;
+        creationPolicy: z.ZodOptional<z.ZodObject<{
+            createOnUserTypeRegistration: z.ZodArray<z.ZodString>;
+            orgNameSource: z.ZodEnum<typeof import("..").OrganizationNameSource>;
+            defaultOwnerRole: z.ZodDefault<z.ZodString>;
+        }, z.core.$strip>>;
+    }, z.core.$strip>>>;
+    compliance: z.ZodObject<{
+        userProfileVisibility: z.ZodDefault<z.ZodEnum<typeof import("..").UserProfileVisibility>>;
+        organizationProfileVisibility: z.ZodDefault<z.ZodEnum<typeof import("..").OrganizationProfileVisibility>>;
+        clientInstanceIdScope: z.ZodDefault<z.ZodEnum<typeof import("..").ClientInstanceIdScope>>;
+    }, z.core.$strip>;
+    billing: z.ZodOptional<z.ZodObject<{
+        enabled: z.ZodDefault<z.ZodBoolean>;
+        providerRef: z.ZodOptional<z.ZodString>;
+        webhooks: z.ZodOptional<z.ZodObject<{
+            path: z.ZodDefault<z.ZodString>;
+            signingSecretRef: z.ZodOptional<z.ZodString>;
+        }, z.core.$strip>>;
+        defaultCurrency: z.ZodDefault<z.ZodUnion<[z.ZodEnum<typeof import("@wildo-ai/zod-decorators").AvailableCurrency>, z.ZodString]>>;
+        supportedCurrencies: z.ZodDefault<z.ZodArray<z.ZodUnion<[z.ZodEnum<typeof import("@wildo-ai/zod-decorators").AvailableCurrency>, z.ZodString]>>>;
+        tax: z.ZodDefault<z.ZodObject<{
+            calculationMode: z.ZodDefault<z.ZodEnum<typeof import("..").TaxCalculationMode>>;
+            defaultDisplayMode: z.ZodDefault<z.ZodEnum<typeof import("@wildo-ai/external-connectors-models").TaxDisplayMode>>;
+        }, z.core.$strip>>;
+        enabledScopes: z.ZodDefault<z.ZodArray<z.ZodEnum<typeof import("..").ResourcePrimaryScope>>>;
+        promotions: z.ZodDefault<z.ZodObject<{
+            enabled: z.ZodDefault<z.ZodBoolean>;
+        }, z.core.$strip>>;
+        creditPools: z.ZodDefault<z.ZodObject<{
+            enabled: z.ZodDefault<z.ZodBoolean>;
+            defaultInitialBalance: z.ZodDefault<z.ZodNumber>;
+        }, z.core.$strip>>;
+        defaultBehaviorPolicy: z.ZodDefault<z.ZodObject<{
+            defaultTrialDays: z.ZodDefault<z.ZodNumber>;
+            paymentGracePeriodDays: z.ZodDefault<z.ZodNumber>;
+            maxPaymentRetries: z.ZodDefault<z.ZodNumber>;
+            defaultProration: z.ZodDefault<z.ZodEnum<typeof import("..").ProrationBehavior>>;
+            defaultCancellation: z.ZodDefault<z.ZodEnum<typeof import("..").BillingTiming>>;
+        }, z.core.$strip>>;
+    }, z.core.$strip>>;
+    analytics: z.ZodOptional<z.ZodObject<{
+        enabled: z.ZodDefault<z.ZodBoolean>;
+        providers: z.ZodDefault<z.ZodArray<z.ZodObject<{
+            providerType: z.ZodEnum<typeof import("..").AnalyticsProviderType>;
+            config: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+        }, z.core.$strip>>>;
+        requiredConsent: z.ZodDefault<z.ZodEnum<typeof import("..").DataProcessingConsent>>;
+        valueMoments: z.ZodOptional<z.ZodArray<z.ZodObject<{
+            identifier: z.ZodString;
+            role: z.ZodEnum<typeof import("..").ValueMomentRole>;
+            scope: z.ZodDefault<z.ZodEnum<typeof import("..").ValueMomentScope>>;
+            signals: z.ZodArray<z.ZodDiscriminatedUnion<[z.ZodObject<{
+                signalType: z.ZodLiteral<import("..").ValueSignalType.RESOURCE_OPERATION>;
+                resourceType: z.ZodString;
+                operation: z.ZodString;
+                filter: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodBoolean, z.ZodNull]>>>;
+                threshold: z.ZodOptional<z.ZodNumber>;
+            }, z.core.$strip>, z.ZodObject<{
+                signalType: z.ZodLiteral<import("..").ValueSignalType.RESOURCE_STATE>;
+                resourceType: z.ZodString;
+                filter: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodBoolean, z.ZodNull]>>>;
+                threshold: z.ZodNumber;
+            }, z.core.$strip>, z.ZodObject<{
+                signalType: z.ZodLiteral<import("..").ValueSignalType.VIEW_VISIT>;
+                contentType: z.ZodEnum<{
+                    custom: "custom";
+                    resource_operation: "resource_operation";
+                    composite_view: "composite_view";
+                    chart_view: "chart_view";
+                    full_custom_view: "full_custom_view";
+                    flows_actors_view: "flows_actors_view";
+                }>;
+                viewRef: z.ZodOptional<z.ZodString>;
+            }, z.core.$strip>, z.ZodObject<{
+                signalType: z.ZodLiteral<import("..").ValueSignalType.FEATURE_ACCESS>;
+                featureId: z.ZodString;
+            }, z.core.$strip>, z.ZodObject<{
+                signalType: z.ZodLiteral<import("..").ValueSignalType.CUSTOM_EVENT>;
+                eventName: z.ZodString;
+                threshold: z.ZodOptional<z.ZodNumber>;
+            }, z.core.$strip>], "signalType">>;
+            mode: z.ZodDefault<z.ZodEnum<typeof import("..").ValueMomentMode>>;
+            requires: z.ZodOptional<z.ZodArray<z.ZodString>>;
+            beforeStage: z.ZodOptional<z.ZodArray<z.ZodString>>;
+            cooldownMs: z.ZodOptional<z.ZodNumber>;
+            onAchieved: z.ZodOptional<z.ZodObject<{
+                frontendEvent: z.ZodDefault<z.ZodBoolean>;
+                backendHandler: z.ZodOptional<z.ZodString>;
+            }, z.core.$strip>>;
+        }, z.core.$strip>>>;
+        persistence: z.ZodDefault<z.ZodObject<{
+            localStorage: z.ZodDefault<z.ZodBoolean>;
+            backendSync: z.ZodDefault<z.ZodBoolean>;
+            backendEvaluation: z.ZodDefault<z.ZodBoolean>;
+        }, z.core.$strip>>;
+        autoInstrumentation: z.ZodDefault<z.ZodObject<{
+            pageViews: z.ZodDefault<z.ZodBoolean>;
+            resourceOperations: z.ZodDefault<z.ZodBoolean>;
+            trackErrors: z.ZodDefault<z.ZodBoolean>;
+            featureGate: z.ZodDefault<z.ZodBoolean>;
+            userLifecycle: z.ZodDefault<z.ZodBoolean>;
+            notifications: z.ZodDefault<z.ZodBoolean>;
+            hotkeys: z.ZodDefault<z.ZodBoolean>;
+        }, z.core.$strip>>;
+    }, z.core.$strip>>;
+    lifecycle: z.ZodOptional<z.ZodObject<{
+        enabled: z.ZodDefault<z.ZodBoolean>;
+        activationCriteria: z.ZodOptional<z.ZodObject<{
+            mode: z.ZodDefault<z.ZodEnum<{
+                ALL: "ALL";
+                ANY: "ANY";
+            }>>;
+            criteria: z.ZodArray<z.ZodDiscriminatedUnion<[z.ZodObject<{
+                criterionType: z.ZodLiteral<import("..").ActivationCriterionType.MILESTONE>;
+                milestoneRef: z.ZodString;
+            }, z.core.$strip>, z.ZodObject<{
+                criterionType: z.ZodLiteral<import("..").ActivationCriterionType.GUIDANCE_COMPLETED>;
+                guidanceFlowRef: z.ZodString;
+            }, z.core.$strip>], "criterionType">>;
+        }, z.core.$strip>>;
+        engagementThreshold: z.ZodOptional<z.ZodObject<{
+            minOperations: z.ZodDefault<z.ZodNumber>;
+            withinDays: z.ZodDefault<z.ZodNumber>;
+        }, z.core.$strip>>;
+        dormancyThresholdDays: z.ZodDefault<z.ZodNumber>;
+        activityDebounceMinutes: z.ZodDefault<z.ZodNumber>;
+        dormancyCronSchedule: z.ZodDefault<z.ZodString>;
+    }, z.core.$strip>>;
+    tenantTeardown: z.ZodOptional<z.ZodObject<{
+        retentionWindowDays: z.ZodDefault<z.ZodNumber>;
+        purgeCronSchedule: z.ZodDefault<z.ZodString>;
+        purgeBatchSize: z.ZodDefault<z.ZodNumber>;
+    }, z.core.$strip>>;
+    dataSeeding: z.ZodOptional<z.ZodObject<{
+        scheduledRerunCronSchedule: z.ZodDefault<z.ZodString>;
+        runRetentionDays: z.ZodDefault<z.ZodNumber>;
+    }, z.core.$strip>>;
+    auditTrail: z.ZodOptional<z.ZodObject<{
+        archiveAfterDays: z.ZodOptional<z.ZodNumber>;
+    }, z.core.$strip>>;
+    frontendProviders: z.ZodObject<{
+        providers: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodObject<{
+            metadata: z.ZodObject<{
+                ref: z.ZodString;
+                displayNameLabelKey: z.ZodOptional<z.ZodString>;
+                displayName: z.ZodOptional<z.ZodString>;
+                iconRef: z.ZodOptional<z.ZodString>;
+            }, z.core.$strip>;
+            providerCapabilities: z.ZodArray<z.ZodString>;
+            protocols: z.ZodArray<z.ZodString>;
+            publicConfig: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+        }, z.core.$strip>>>;
+    }, z.core.$strip>;
+}, z.core.$strip>;
+export type AppConfiguration_FrontendBootstrapResponse = z.infer<typeof AppConfiguration_FrontendBootstrapResponse_Schema>;
+//# sourceMappingURL=frontend-bootstrap.shared.schemas.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"frontend-bootstrap.shared.schemas.d.ts","sourceRoot":"","sources":["../../../../src/external-providers/frontend-bootstrap.shared.schemas.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAExB,OAAO,EACL,2BAA2B,EAC3B,4BAA4B,EAC5B,KAAK,qBAAqB,EAC1B,KAAK,sBAAsB,GAC5B,MAAM,0CAA0C,CAAC;AAGlD,eAAO,MAAM,iCAAiC;;;;;;;;;;;;;;iBAE5C,CAAC;AACH,MAAM,MAAM,2BAA2B,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,iCAAiC,CAAC,CAAC;AAE5F;;;;;GAKG;AACH,eAAO,MAAM,iDAAiD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAG1D,CAAC;AACL,MAAM,MAAM,0CAA0C,GAAG,CAAC,CAAC,KAAK,CAC9D,OAAO,iDAAiD,CACzD,CAAC"}

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

@@ -0,0 +1,17 @@
+import { z } from 'zod';
+import { AppConfiguration_Shared_Schema } from '../config/app-configuration-shared.shared.schemas.js';
+export { FrontendProviderEntrySchema, FrontendProvidersBlockSchema, } from './frontend-provider-entry.shared.schemas.js';
+import { FrontendProvidersBlockSchema } from './frontend-provider-entry.shared.schemas.js';
+export const FrontendAppBootstrapPayloadSchema = z.object({
+    frontendProviders: FrontendProvidersBlockSchema,
+});
+/**
+ * Existing `/application-config` response extended with frontend provider
+ * bootstrap data. Parsing through `AppConfiguration_Shared_Schema` later still
+ * strips `frontendProviders`, so frontend startup can keep the shared config
+ * contract intact while hydrating the registry alongside it.
+ */
+export const AppConfiguration_FrontendBootstrapResponse_Schema = AppConfiguration_Shared_Schema.extend({
+    frontendProviders: FrontendProvidersBlockSchema,
+});
+//# sourceMappingURL=frontend-bootstrap.shared.schemas.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"frontend-bootstrap.shared.schemas.js","sourceRoot":"","sources":["../../../../src/external-providers/frontend-bootstrap.shared.schemas.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AACxB,OAAO,EAAE,8BAA8B,EAAE,MAAM,mDAAmD,CAAC;AACnG,OAAO,EACL,2BAA2B,EAC3B,4BAA4B,GAG7B,MAAM,0CAA0C,CAAC;AAClD,OAAO,EAAE,4BAA4B,EAAE,MAAM,0CAA0C,CAAC;AAExF,MAAM,CAAC,MAAM,iCAAiC,GAAG,CAAC,CAAC,MAAM,CAAC;IACxD,iBAAiB,EAAE,4BAA4B;CAChD,CAAC,CAAC;AAGH;;;;;GAKG;AACH,MAAM,CAAC,MAAM,iDAAiD,GAC5D,8BAA8B,CAAC,MAAM,CAAC;IACpC,iBAAiB,EAAE,4BAA4B;CAChD,CAAC,CAAC","sourcesContent":["import { z } from 'zod';\nimport { AppConfiguration_Shared_Schema } from '../config/app-configuration-shared.shared.schemas';\nexport {\n  FrontendProviderEntrySchema,\n  FrontendProvidersBlockSchema,\n  type FrontendProviderEntry,\n  type FrontendProvidersBlock,\n} from './frontend-provider-entry.shared.schemas';\nimport { FrontendProvidersBlockSchema } from './frontend-provider-entry.shared.schemas';\n\nexport const FrontendAppBootstrapPayloadSchema = z.object({\n  frontendProviders: FrontendProvidersBlockSchema,\n});\nexport type FrontendAppBootstrapPayload = z.infer<typeof FrontendAppBootstrapPayloadSchema>;\n\n/**\n * Existing `/application-config` response extended with frontend provider\n * bootstrap data. Parsing through `AppConfiguration_Shared_Schema` later still\n * strips `frontendProviders`, so frontend startup can keep the shared config\n * contract intact while hydrating the registry alongside it.\n */\nexport const AppConfiguration_FrontendBootstrapResponse_Schema =\n  AppConfiguration_Shared_Schema.extend({\n    frontendProviders: FrontendProvidersBlockSchema,\n  });\nexport type AppConfiguration_FrontendBootstrapResponse = z.infer<\n  typeof AppConfiguration_FrontendBootstrapResponse_Schema\n>;\n"]}

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

@@ -0,0 +1,35 @@
+import { z } from 'zod';
+/**
+ * Bundle-safe frontend provider atoms shared by every browser-bound runtime.
+ *
+ * This file intentionally stops at the provider-entry/block level so
+ * `@wildo-ai/saas-models/public-runtime` can expose the types without pulling
+ * the heavier application-config bootstrap contract into browser bundles.
+ */
+export declare const FrontendProviderEntrySchema: z.ZodObject<{
+    metadata: z.ZodObject<{
+        ref: z.ZodString;
+        displayNameLabelKey: z.ZodOptional<z.ZodString>;
+        displayName: z.ZodOptional<z.ZodString>;
+        iconRef: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>;
+    providerCapabilities: z.ZodArray<z.ZodString>;
+    protocols: z.ZodArray<z.ZodString>;
+    publicConfig: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+}, z.core.$strip>;
+export type FrontendProviderEntry = z.infer<typeof FrontendProviderEntrySchema>;
+export declare const FrontendProvidersBlockSchema: z.ZodObject<{
+    providers: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodObject<{
+        metadata: z.ZodObject<{
+            ref: z.ZodString;
+            displayNameLabelKey: z.ZodOptional<z.ZodString>;
+            displayName: z.ZodOptional<z.ZodString>;
+            iconRef: z.ZodOptional<z.ZodString>;
+        }, z.core.$strip>;
+        providerCapabilities: z.ZodArray<z.ZodString>;
+        protocols: z.ZodArray<z.ZodString>;
+        publicConfig: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    }, z.core.$strip>>>;
+}, z.core.$strip>;
+export type FrontendProvidersBlock = z.infer<typeof FrontendProvidersBlockSchema>;
+//# sourceMappingURL=frontend-provider-entry.shared.schemas.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"frontend-provider-entry.shared.schemas.d.ts","sourceRoot":"","sources":["../../../../src/external-providers/frontend-provider-entry.shared.schemas.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAGxB;;;;;;GAMG;AACH,eAAO,MAAM,2BAA2B;;;;;;;;;;iBAKtC,CAAC;AACH,MAAM,MAAM,qBAAqB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,2BAA2B,CAAC,CAAC;AAEhF,eAAO,MAAM,4BAA4B;;;;;;;;;;;;iBAEvC,CAAC;AACH,MAAM,MAAM,sBAAsB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,4BAA4B,CAAC,CAAC"}

package/dist/esm/external-providers/frontend-provider-entry.shared.schemas.js

@@ -0,0 +1,19 @@
+import { z } from 'zod';
+import { ProviderMetadataSchema } from './provider-metadata.shared.schemas.js';
+/**
+ * Bundle-safe frontend provider atoms shared by every browser-bound runtime.
+ *
+ * This file intentionally stops at the provider-entry/block level so
+ * `@wildo-ai/saas-models/public-runtime` can expose the types without pulling
+ * the heavier application-config bootstrap contract into browser bundles.
+ */
+export const FrontendProviderEntrySchema = z.object({
+    metadata: ProviderMetadataSchema,
+    providerCapabilities: z.array(z.string().min(1)),
+    protocols: z.array(z.string().min(1)),
+    publicConfig: z.record(z.string(), z.unknown()).optional(),
+});
+export const FrontendProvidersBlockSchema = z.object({
+    providers: z.record(z.string().min(1), FrontendProviderEntrySchema).default({}),
+});
+//# sourceMappingURL=frontend-provider-entry.shared.schemas.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"frontend-provider-entry.shared.schemas.js","sourceRoot":"","sources":["../../../../src/external-providers/frontend-provider-entry.shared.schemas.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AACxB,OAAO,EAAE,sBAAsB,EAAE,MAAM,oCAAoC,CAAC;AAE5E;;;;;;GAMG;AACH,MAAM,CAAC,MAAM,2BAA2B,GAAG,CAAC,CAAC,MAAM,CAAC;IAClD,QAAQ,EAAE,sBAAsB;IAChC,oBAAoB,EAAE,CAAC,CAAC,KAAK,CAAC,CAAC,CAAC,MAAM,EAAE,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC;IAChD,SAAS,EAAE,CAAC,CAAC,KAAK,CAAC,CAAC,CAAC,MAAM,EAAE,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC;IACrC,YAAY,EAAE,CAAC,CAAC,MAAM,CAAC,CAAC,CAAC,MAAM,EAAE,EAAE,CAAC,CAAC,OAAO,EAAE,CAAC,CAAC,QAAQ,EAAE;CAC3D,CAAC,CAAC;AAGH,MAAM,CAAC,MAAM,4BAA4B,GAAG,CAAC,CAAC,MAAM,CAAC;IACnD,SAAS,EAAE,CAAC,CAAC,MAAM,CAAC,CAAC,CAAC,MAAM,EAAE,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,2BAA2B,CAAC,CAAC,OAAO,CAAC,EAAE,CAAC;CAChF,CAAC,CAAC","sourcesContent":["import { z } from 'zod';\nimport { ProviderMetadataSchema } from './provider-metadata.shared.schemas';\n\n/**\n * Bundle-safe frontend provider atoms shared by every browser-bound runtime.\n *\n * This file intentionally stops at the provider-entry/block level so\n * `@wildo-ai/saas-models/public-runtime` can expose the types without pulling\n * the heavier application-config bootstrap contract into browser bundles.\n */\nexport const FrontendProviderEntrySchema = z.object({\n  metadata: ProviderMetadataSchema,\n  providerCapabilities: z.array(z.string().min(1)),\n  protocols: z.array(z.string().min(1)),\n  publicConfig: z.record(z.string(), z.unknown()).optional(),\n});\nexport type FrontendProviderEntry = z.infer<typeof FrontendProviderEntrySchema>;\n\nexport const FrontendProvidersBlockSchema = z.object({\n  providers: z.record(z.string().min(1), FrontendProviderEntrySchema).default({}),\n});\nexport type FrontendProvidersBlock = z.infer<typeof FrontendProvidersBlockSchema>;\n"]}

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

@@ -0,0 +1,135 @@
+/**
+ * `ProviderCapability` — open, app-extensible enum of standardized
+ * behaviors that providers implement.
+ *
+ * Distinct from `EngineCapability` (closed, engine-defined slots that
+ * may require fulfillment). See the analysis glossary in
+ * `.cursor/plans/provider-registration-refactor-draft-analysis.md` §14
+ * for the full naming rationale; this file is the canonical Phase-0
+ * authoring surface called out in §Phase 0.2 of the implementation
+ * plan.
+ *
+ * Built-in values use SCREAMING_SNAKE_CASE; app-augmented values SHOULD
+ * use kebab-case + domain prefix (e.g. `'live-chat-handoff'`,
+ * `'search-index'`). The two namespaces never collide by construction.
+ */
+/** @wildo_source:part:start saas.models.provider-capabilities facet:kind:api facet:audience:app-developer
+ *
+ * Built-in provider capabilities shipped by the framework.
+ *
+ * Authoring rule: keep this list narrow and stable. Adding a new
+ * built-in capability is a framework-level decision (it implies the
+ * engine knows how to consume the capability via a transformer or a
+ * platform binding); apps that need a one-off capability MUST extend
+ * via `AppCustomProviderCapabilities` instead.
+ */
+export declare const BUILTIN_PROVIDER_CAPABILITY: {
+    readonly EMAIL_TRANSACTIONAL: "EMAIL_TRANSACTIONAL";
+    readonly EMAIL_MARKETING: "EMAIL_MARKETING";
+    readonly SMS: "SMS";
+    /**
+     * Single billing-engagement capability covering everything from
+     * Checkout-style hosted flows to first-party PaymentIntent flows.
+     * Webhook delivery is NOT a separate capability — it is modelled at
+     * the protocol layer (e.g. Stripe declares both a `BILLING_PROVIDER`
+     * and a `WEBHOOK_ORIGINATOR` protocol but a single `BILLING`
+     * capability). This 1:1 matches the billing slot from the older
+     * external connector transformer vocabulary.
+     */
+    readonly BILLING: "BILLING";
+    readonly SSO_OAUTH2: "SSO_OAUTH2";
+    /** Reserved for future SAML-based SSO providers (none ship today). */
+    readonly SSO_SAML: "SSO_SAML";
+    readonly LLM_CHAT: "LLM_CHAT";
+    readonly LLM_EMBEDDINGS: "LLM_EMBEDDINGS";
+    /**
+     * Provider turns DOCUMENT BYTES into text — OCR over scans and photographs of pages, not merely
+     * a read of a PDF's existing text layer. Maps to `EngineCapability.AI_DOCUMENT_EXTRACTION`.
+     *
+     * A NEW token was genuinely required rather than convenient: `IMAGE_GENERATION` is an OUTPUT
+     * capability (text → image), and `EngineCapability.DOCUMENT_GENERATION` is PDF *generation*,
+     * which is this capability's exact opposite. Nothing in the existing vocabulary claimed the
+     * document-INPUT slot.
+     *
+     * Distinct from `LLM_CHAT` even where a vendor serves both from one API key: the work is
+     * different (a page-layout model, billed per page, with no sampling parameters), and fusing
+     * them would make the OCR provider unselectable independently of the chat provider — the exact
+     * defect that splitting `AI_EMBEDDINGS` out of `AI_LLM` existed to fix.
+     */
+    readonly DOCUMENT_TEXT_EXTRACTION: "DOCUMENT_TEXT_EXTRACTION";
+    /**
+     * Provider ships an autonomous CODING AGENT: a process that reads and writes
+     * a workspace, runs commands, and requests authorisation, reachable over the
+     * Agent Client Protocol.
+     *
+     * Distinct from `LLM_CHAT` because the WORK is
+     * different, not merely its transport. A chat model returns text for a caller
+     * to act on; a coding agent acts, and the resulting obligations — permission
+     * decisions, mutation scope, change attribution, verification — have no
+     * counterpart in a completion call.
+     */
+    readonly CODING_AGENT: "CODING_AGENT";
+    readonly IMAGE_GENERATION: "IMAGE_GENERATION";
+    readonly FRONTEND_ERROR_MONITORING: "FRONTEND_ERROR_MONITORING";
+    readonly FRONTEND_PRODUCT_ANALYTICS: "FRONTEND_PRODUCT_ANALYTICS";
+    readonly FRONTEND_SEARCH: "FRONTEND_SEARCH";
+    readonly FRONTEND_FILE_PICKER: "FRONTEND_FILE_PICKER";
+    readonly FRONTEND_CAPTCHA: "FRONTEND_CAPTCHA";
+    /**
+     * Backend LLM-call observability — a provider that ingests per-`invokeAgent`
+     * generation traces (model / tokens / cost / latency), e.g. PostHog
+     * `$ai_generation`. Maps to `EngineCapability.LLM_OBSERVABILITY`. The engine
+     * consumes it via the `AgentCallTraceSink` (not a request/response transformer).
+     */
+    readonly LLM_OBSERVABILITY: "LLM_OBSERVABILITY";
+    /**
+     * Operational-telemetry sink — a provider that ingests OpenTelemetry traces,
+     * metrics, and logs over OTLP (e.g. BetterStack). Maps to
+     * `EngineCapability.OBSERVABILITY_TELEMETRY`. Consumed by the OTel SDK preload
+     * (env-var-driven), NOT a request/response transformer or a DI sink.
+     */
+    readonly OBSERVABILITY_TELEMETRY: "OBSERVABILITY_TELEMETRY";
+    /**
+     * Audit-log sink — a provider that stores or forwards compliance audit
+     * events (who-did-what-when), e.g. immudb (tamper-evident) or a SIEM
+     * webhook. Maps to `EngineCapability.COMPLIANCE_AUDIT_TRAIL`, a FAN_OUT
+     * capability: every declared audit provider receives every event (see
+     * `getEngineCapabilityResolutionMode`). The engine consumes it via the
+     * `AuditLogSink` DI fan-out, layered on the always-on database audit store.
+     */
+    readonly COMPLIANCE_AUDIT_TRAIL: "COMPLIANCE_AUDIT_TRAIL";
+};
+/** @wildo_source:part:end saas.models.provider-capabilities */
+export type BuiltinProviderCapability = (typeof BUILTIN_PROVIDER_CAPABILITY)[keyof typeof BUILTIN_PROVIDER_CAPABILITY];
+/**
+ * Open extension point — apps augment via TypeScript module augmentation
+ * inside their `wildo.saas.config.ts`. See analysis §10 Q2 for the
+ * design decision (no `app.d.ts` file; declaration merging happens
+ * inline in the saas config so the surface is co-located with the
+ * authored configuration).
+ *
+ * Example app-side augmentation:
+ *
+ * ```ts
+ * declare module '@wildo-ai/saas-models' {
+ *   interface AppCustomProviderCapabilities {
+ *     'live-chat-handoff': true;
+ *     'search-index': true;
+ *   }
+ * }
+ * ```
+ *
+ * Phase 3.d (per the implementation plan) wires this augmentation point
+ * into `BackendProviderRegistry.getProvidersByProviderCapability()` so
+ * apps can register and resolve custom capabilities in a fully
+ * type-checked way. In Phase 0 the interface is intentionally empty.
+ */
+export interface AppCustomProviderCapabilities {
+}
+/**
+ * Union of every possible provider capability — the closed built-in set
+ * plus any app-side augmentations. Consumers (registries, transformers,
+ * lock-file digests) accept this union.
+ */
+export type ProviderCapability = BuiltinProviderCapability | keyof AppCustomProviderCapabilities;
+//# sourceMappingURL=provider-capability.shared.schemas.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"provider-capability.shared.schemas.d.ts","sourceRoot":"","sources":["../../../../src/external-providers/provider-capability.shared.schemas.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;GAcG;AAEH;;;;;;;;;GASG;AACH,eAAO,MAAM,2BAA2B;;;;IAItC;;;;;;;;OAQG;;;IAGH,sEAAsE;;;;IAItE;;;;;;;;;;;;;OAaG;;IAEH;;;;;;;;;;OAUG;;;;;;;;IAQH;;;;;OAKG;;IAEH;;;;;OAKG;;IAEH;;;;;;;OAOG;;CAEK,CAAC;AACX,+DAA+D;AAE/D,MAAM,MAAM,yBAAyB,GACnC,CAAC,OAAO,2BAA2B,CAAC,CAAC,MAAM,OAAO,2BAA2B,CAAC,CAAC;AAEjF;;;;;;;;;;;;;;;;;;;;;;GAsBG;AACH,MAAM,WAAW,6BAA6B;CAAG;AAEjD;;;;GAIG;AACH,MAAM,MAAM,kBAAkB,GAC1B,yBAAyB,GACzB,MAAM,6BAA6B,CAAC"}