@wildo-ai/saas-models 1.1.4 → 1.1.6

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

@@ -30,6 +30,8 @@ export declare const FrontendAppBootstrapPayloadSchema: z.ZodObject<{
                 imgOrigins: z.ZodDefault<z.ZodArray<z.ZodString>>;
                 styleOrigins: z.ZodDefault<z.ZodArray<z.ZodString>>;
                 fontOrigins: z.ZodDefault<z.ZodArray<z.ZodString>>;
+                workerOrigins: z.ZodDefault<z.ZodArray<z.ZodString>>;
+                mediaOrigins: z.ZodDefault<z.ZodArray<z.ZodString>>;
                 derivedOrigins: z.ZodDefault<z.ZodArray<z.ZodObject<{
                     publicConfigKey: z.ZodString;
                     bucket: z.ZodEnum<typeof import("./provider-frontend-surface.shared.schemas").ProviderFrontendCspOriginBucket>;
@@ -48,9 +50,45 @@ export declare const FrontendAppBootstrapPayloadSchema: z.ZodObject<{
             }, z.core.$strict>>>;
             components: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodObject<{
                 selectionDelivery: z.ZodOptional<z.ZodEnum<typeof import("./provider-frontend-surface.shared.schemas").ProviderFrontendSelectionDelivery>>;
+                placeIdRetention: z.ZodOptional<z.ZodEnum<typeof import("./provider-frontend-surface.shared.schemas").ProviderAddressLookupPlaceIdRetention>>;
+                addressLookup: z.ZodOptional<z.ZodObject<{
+                    suggestOperationId: z.ZodString;
+                    retrieveOperationId: z.ZodString;
+                    sessionTokenInput: z.ZodOptional<z.ZodString>;
+                    attributionMark: z.ZodOptional<z.ZodString>;
+                }, z.core.$strict>>;
             }, z.core.$strict>>>;
             publicConfigKeys: z.ZodOptional<z.ZodArray<z.ZodString>>;
-            fileStorage: z.ZodOptional<z.ZodEnum<typeof import("@wildo-ai/zod-decorators").FileStorageAccepted>>;
+            fileStorage: z.ZodOptional<z.ZodEnum<{
+                readonly WILDO_MANAGED: "wildo_managed";
+                readonly LOCAL_DIRECTORY: "local_directory";
+                readonly ONEDRIVE: "onedrive";
+                readonly GOOGLE_DRIVE: "google_drive";
+                readonly DROPBOX: "dropbox";
+            }>>;
+            complianceProfile: z.ZodOptional<z.ZodUnion<readonly [z.ZodObject<{
+                determination: z.ZodOptional<z.ZodLiteral<import("./provider-compliance-profile.shared.schemas").ProviderComplianceDetermination.ESTABLISHED>>;
+                deploymentModels: z.ZodArray<z.ZodEnum<typeof import("./provider-compliance-profile.shared.schemas").ProviderDeploymentModel>>;
+                processingRegions: z.ZodArray<z.ZodString>;
+                vendorLegalEntityName: z.ZodOptional<z.ZodString>;
+                subprocessorListUrl: z.ZodOptional<z.ZodURL>;
+                dataProcessingAgreementUrl: z.ZodOptional<z.ZodURL>;
+                evidence: z.ZodOptional<z.ZodArray<z.ZodObject<{
+                    facts: z.ZodArray<z.ZodEnum<typeof import("./provider-compliance-profile.shared.schemas").ProviderComplianceFact>>;
+                    source: z.ZodURL;
+                    verifiedAt: z.ZodISODate;
+                }, z.core.$strict>>>;
+                subjectErasure: z.ZodOptional<z.ZodObject<{
+                    stance: z.ZodEnum<{
+                        readonly NO_SUBJECT_DATA: import("..").HttpApiErasureStance.NO_SUBJECT_DATA;
+                        readonly EXTERNAL_ERASURE_OPERATION: import("..").HttpApiErasureStance.EXTERNAL_ERASURE_OPERATION;
+                    }>;
+                }, z.core.$strict>>;
+            }, z.core.$strict>, z.ZodObject<{
+                determination: z.ZodLiteral<import("./provider-compliance-profile.shared.schemas").ProviderComplianceDetermination.UNDETERMINED>;
+                reason: z.ZodString;
+            }, z.core.$strict>]>>;
+            consentPurposes: z.ZodOptional<z.ZodArray<z.ZodString>>;
         }, z.core.$loose>>>;
     }, z.core.$strip>;
 }, z.core.$strip>;
@@ -70,11 +108,11 @@ export declare const AppConfiguration_FrontendBootstrapResponse_Schema: z.ZodObj
         applicationId: z.ZodOptional<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>;
+        composition: import("@wildo-ai/zod-decorators").DecoratedPrimitiveZodType<z.ZodEnum<typeof import("..").BrandAssetComposition>>;
+        theme: import("@wildo-ai/zod-decorators").DecoratedPrimitiveZodType<z.ZodEnum<typeof import("..").BrandAssetTheme>>;
+        purpose: import("@wildo-ai/zod-decorators").DecoratedPrimitiveZodType<z.ZodEnum<typeof import("..").BrandAssetPurpose>>;
         url: z.ZodString;
-        format: z.ZodEnum<typeof import("..").BrandAssetFormat>;
+        format: import("@wildo-ai/zod-decorators").DecoratedPrimitiveZodType<z.ZodEnum<typeof import("..").BrandAssetFormat>>;
         width: z.ZodOptional<z.ZodNumber>;
         height: z.ZodOptional<z.ZodNumber>;
     }, z.core.$strip>>>;
@@ -115,6 +153,7 @@ export declare const AppConfiguration_FrontendBootstrapResponse_Schema: z.ZodObj
                 enabled: z.ZodBoolean;
             }, z.core.$strip>]>>>;
             mfaPolicy: z.ZodDefault<z.ZodObject<{
+                externalAssuranceEnforcement: z.ZodOptional<z.ZodEnum<typeof import("./provider-authentication-assurance.shared.schemas").ExternalAssuranceEnforcement>>;
                 requireMFA: z.ZodDefault<z.ZodBoolean>;
                 requireStrongMFA: z.ZodDefault<z.ZodBoolean>;
                 acceptableMFAMethods: z.ZodOptional<z.ZodArray<z.ZodEnum<typeof import("..").AuthMethod>>>;
@@ -126,6 +165,18 @@ export declare const AppConfiguration_FrontendBootstrapResponse_Schema: z.ZodObj
                 allowedMethods: z.ZodDefault<z.ZodArray<z.ZodEnum<typeof import("..").AuthMethod>>>;
                 emailVerification: z.ZodDefault<z.ZodEnum<typeof import("..").EmailVerificationMode>>;
                 blockForSSODomains: z.ZodDefault<z.ZodBoolean>;
+                allowedEmailDomains: z.ZodOptional<z.ZodArray<z.ZodString>>;
+                additionalProfileQuestions: z.ZodOptional<z.ZodArray<z.ZodObject<{
+                    id: z.ZodString;
+                    ref: z.ZodOptional<z.ZodString>;
+                    type: z.ZodEnum<typeof import("..").OnboardingSurveyQuestionType>;
+                    options: z.ZodOptional<z.ZodArray<z.ZodObject<{
+                        ref: z.ZodString;
+                    }, z.core.$strip>>>;
+                    required: z.ZodDefault<z.ZodBoolean>;
+                    bindToField: z.ZodOptional<z.ZodString>;
+                }, z.core.$strip>>>;
+                profileNamesCollectedAt: z.ZodOptional<z.ZodEnum<typeof import("..").ProfileNamesCollectionMoment>>;
             }, z.core.$strict>;
             passwordPolicy: z.ZodDefault<z.ZodObject<{
                 minLength: z.ZodDefault<z.ZodNumber>;
@@ -158,7 +209,6 @@ export declare const AppConfiguration_FrontendBootstrapResponse_Schema: z.ZodObj
             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>;
@@ -181,6 +231,7 @@ export declare const AppConfiguration_FrontendBootstrapResponse_Schema: z.ZodObj
                 enabled: z.ZodBoolean;
             }, z.core.$strip>]>>>;
             mfaPolicy: z.ZodOptional<z.ZodObject<{
+                externalAssuranceEnforcement: z.ZodOptional<z.ZodOptional<z.ZodEnum<typeof import("./provider-authentication-assurance.shared.schemas").ExternalAssuranceEnforcement>>>;
                 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>>>>;
@@ -204,18 +255,165 @@ export declare const AppConfiguration_FrontendBootstrapResponse_Schema: z.ZodObj
         }, 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>>;
+        ownsApplication: z.ZodOptional<z.ZodLiteral<true>>;
+        servesAsProvider: z.ZodOptional<z.ZodObject<{
+            clientOrganizationTypes: z.ZodArray<z.ZodString>;
+            providerRoles: z.ZodArray<z.ZodString>;
+            defaultProviderRole: z.ZodString;
+        }, z.core.$strip>>;
+        acceptsServiceProviders: z.ZodOptional<z.ZodObject<{
+            defaultExpertAdmissionPolicy: z.ZodOptional<z.ZodEnum<typeof import("..").ServiceProviderExpertAdmissionPolicy>>;
+            securityCriticalCapabilityMaxDays: z.ZodOptional<z.ZodNumber>;
+            expertApprovalDeadlines: z.ZodOptional<z.ZodObject<{
+                lapseAfter: z.ZodOptional<z.ZodString>;
+                claim: z.ZodOptional<z.ZodObject<{
+                    at: z.ZodUnion<readonly [z.ZodString, z.ZodObject<{
+                        fractionOfLapse: z.ZodNumber;
+                    }, z.core.$strip>]>;
+                    basis: z.ZodOptional<z.ZodEnum<typeof import("..").ReviewClockBasis>>;
+                    warnBefore: z.ZodOptional<z.ZodString>;
+                }, z.core.$strip>>;
+                decision: z.ZodOptional<z.ZodObject<{
+                    at: z.ZodUnion<readonly [z.ZodString, z.ZodObject<{
+                        fractionOfLapse: z.ZodNumber;
+                    }, z.core.$strip>]>;
+                    basis: z.ZodOptional<z.ZodEnum<typeof import("..").ReviewClockBasis>>;
+                    warnBefore: z.ZodOptional<z.ZodString>;
+                }, z.core.$strip>>;
+                rules: z.ZodOptional<z.ZodArray<z.ZodObject<{
+                    stage: z.ZodEnum<typeof import("..").ReviewDeadlineStage>;
+                    action: z.ZodEnum<typeof import("..").ReviewEscalationActionKind>;
+                }, z.core.$strip>>>;
+                pauseStates: z.ZodOptional<z.ZodArray<z.ZodString>>;
+            }, z.core.$strip>>;
+        }, z.core.$strip>>;
     }, z.core.$strip>>>;
+    organizationRoles: z.ZodOptional<z.ZodArray<z.ZodString>>;
     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>>;
+        governedDocumentReleases: z.ZodDefault<z.ZodArray<z.ZodObject<{
+            schemaVersion: z.ZodLiteral<1>;
+            identity: z.ZodObject<{
+                document: z.ZodObject<{
+                    documentRef: z.core.$ZodBranded<z.ZodString, "GovernedDocumentRef", "out">;
+                    documentVersion: z.ZodNumber;
+                }, z.core.$strict>;
+                releaseId: z.core.$ZodBranded<z.ZodString, "GovernedDocumentRef", "out">;
+                releaseVersion: z.ZodNumber;
+            }, z.core.$strict>;
+            documentClass: z.ZodEnum<typeof import("..").GovernedDocumentClass>;
+            locale: z.ZodString;
+            jurisdictionRefs: z.ZodArray<z.core.$ZodBranded<z.ZodString, "GovernedDocumentRef", "out">>;
+            allowedInteractionKinds: z.ZodArray<z.ZodEnum<typeof import("..").GovernedDocumentInteractionKind>>;
+            approvalState: z.ZodEnum<typeof import("..").GovernedDocumentReleaseApprovalState>;
+            effectiveAt: z.ZodISODateTime;
+            expiresAt: z.ZodOptional<z.ZodISODateTime>;
+            renewedInteractionKinds: z.ZodDefault<z.ZodArray<z.ZodEnum<typeof import("..").GovernedDocumentInteractionKind>>>;
+        }, z.core.$strict>>>;
+        publicDocuments: z.ZodDefault<z.ZodArray<z.ZodDiscriminatedUnion<[z.ZodObject<{
+            schemaVersion: z.ZodLiteral<1>;
+            kind: z.ZodLiteral<import("..").GovernedDocumentPublicDocumentKind.RELEASED>;
+            release: z.ZodObject<{
+                schemaVersion: z.ZodLiteral<1>;
+                identity: z.ZodObject<{
+                    document: z.ZodObject<{
+                        documentRef: z.core.$ZodBranded<z.ZodString, "GovernedDocumentRef", "out">;
+                        documentVersion: z.ZodNumber;
+                    }, z.core.$strict>;
+                    releaseId: z.core.$ZodBranded<z.ZodString, "GovernedDocumentRef", "out">;
+                    releaseVersion: z.ZodNumber;
+                }, z.core.$strict>;
+                definition: z.ZodObject<{
+                    definitionRef: z.core.$ZodBranded<z.ZodString, "GovernedDocumentRef", "out">;
+                    definitionVersion: z.ZodNumber;
+                }, z.core.$strict>;
+                documentClass: z.ZodEnum<typeof import("..").GovernedDocumentClass>;
+                locale: z.ZodString;
+                jurisdictionRefs: z.ZodArray<z.core.$ZodBranded<z.ZodString, "GovernedDocumentRef", "out">>;
+                contentMediaType: z.ZodLiteral<"application/vnd.wildo.governed-document.public+json;version=1">;
+                issuedAt: z.ZodISODateTime;
+                effectiveAt: z.ZodISODateTime;
+                expiresAt: z.ZodOptional<z.ZodISODateTime>;
+                allowedInteractionKinds: z.ZodArray<z.ZodEnum<typeof import("..").GovernedDocumentInteractionKind>>;
+            }, z.core.$strict>;
+            content: z.ZodObject<{
+                schemaVersion: z.ZodLiteral<1>;
+                title: z.ZodString;
+                locale: z.ZodString;
+                jurisdictionRefs: z.ZodArray<z.core.$ZodBranded<z.ZodString, "GovernedDocumentRef", "out">>;
+                sections: z.ZodArray<z.ZodObject<{
+                    sectionRef: z.core.$ZodBranded<z.ZodString, "GovernedDocumentRef", "out">;
+                    order: z.ZodNumber;
+                    title: z.ZodString;
+                    clauses: z.ZodArray<z.ZodObject<{
+                        clauseRef: z.core.$ZodBranded<z.ZodString, "GovernedDocumentRef", "out">;
+                        order: z.ZodNumber;
+                        bodyMarkdown: z.ZodString;
+                        standing: z.ZodEnum<typeof import("..").GovernedDocumentPublicClauseStanding>;
+                        missingInformation: z.ZodOptional<z.ZodString>;
+                    }, z.core.$strict>>;
+                }, z.core.$strict>>;
+            }, z.core.$strict>;
+            approvalState: z.ZodEnum<typeof import("..").GovernedDocumentReleaseApprovalState>;
+        }, z.core.$strict>, z.ZodObject<{
+            schemaVersion: z.ZodLiteral<1>;
+            kind: z.ZodLiteral<import("..").GovernedDocumentPublicDocumentKind.UNRELEASED_DRAFT>;
+            documentRef: z.core.$ZodBranded<z.ZodString, "GovernedDocumentRef", "out">;
+            content: z.ZodObject<{
+                schemaVersion: z.ZodLiteral<1>;
+                title: z.ZodString;
+                locale: z.ZodString;
+                jurisdictionRefs: z.ZodArray<z.core.$ZodBranded<z.ZodString, "GovernedDocumentRef", "out">>;
+                sections: z.ZodArray<z.ZodObject<{
+                    sectionRef: z.core.$ZodBranded<z.ZodString, "GovernedDocumentRef", "out">;
+                    order: z.ZodNumber;
+                    title: z.ZodString;
+                    clauses: z.ZodArray<z.ZodObject<{
+                        clauseRef: z.core.$ZodBranded<z.ZodString, "GovernedDocumentRef", "out">;
+                        order: z.ZodNumber;
+                        bodyMarkdown: z.ZodString;
+                        standing: z.ZodEnum<typeof import("..").GovernedDocumentPublicClauseStanding>;
+                        missingInformation: z.ZodOptional<z.ZodString>;
+                    }, z.core.$strict>>;
+                }, z.core.$strict>>;
+            }, z.core.$strict>;
+        }, z.core.$strict>], "kind">>>;
+        governedDocumentAcceptanceMode: z.ZodDefault<z.ZodEnum<typeof import("..").GovernedDocumentAcceptanceMode>>;
+        governedDocumentApprovalGate: z.ZodDefault<z.ZodEnum<typeof import("..").GovernedDocumentApprovalGate>>;
+        serviceConsentRequirement: z.ZodOptional<z.ZodObject<{
+            requiredPurposes: z.ZodArray<z.ZodEnum<typeof import("..").ConsentPurpose>>;
+            gatedProcessing: z.ZodOptional<z.ZodString>;
+        }, z.core.$strict>>;
+        capabilityDeclaredConsentPurposes: z.ZodDefault<z.ZodArray<z.ZodEnum<typeof import("..").ConsentPurpose>>>;
+        dataRetention: z.ZodOptional<z.ZodRecord<z.ZodEnum<typeof import("..").DataRetentionClass> & z.core.$partial, z.ZodObject<{
+            retentionDays: z.ZodNumber;
+            rationale: z.ZodString;
+        }, z.core.$strict>>>;
+        subjectDataRecipients: z.ZodOptional<z.ZodObject<{
+            recipients: z.ZodArray<z.ZodObject<{
+                ref: z.ZodString;
+                legalEntityName: z.ZodNullable<z.ZodString>;
+                processingRegions: z.ZodArray<z.ZodString>;
+                reach: z.ZodEnum<typeof import("..").SubjectDataRecipientReach>;
+                categories: z.ZodArray<z.ZodEnum<typeof import("..").PersonalDataCategory>>;
+                categoriesNotDerivable: z.ZodArray<z.ZodEnum<typeof import("..").RecipientCategoriesNotDerivableReason>>;
+                categoriesAreAFloor: z.ZodBoolean;
+                derivedFrom: z.ZodArray<z.ZodString>;
+                erasureStance: z.ZodNullable<z.ZodEnum<typeof import("..").HttpApiErasureStance>>;
+            }, z.core.$strict>>;
+            roleAllocations: z.ZodArray<z.ZodObject<{
+                role: z.ZodEnum<typeof import("..").OperatorProcessingRole>;
+                resourceTypes: z.ZodArray<z.ZodString>;
+            }, z.core.$strict>>;
+        }, z.core.$strict>>;
     }, z.core.$strip>;
     billing: z.ZodOptional<z.ZodObject<{
         enabled: z.ZodDefault<z.ZodBoolean>;
@@ -234,6 +432,31 @@ export declare const AppConfiguration_FrontendBootstrapResponse_Schema: z.ZodObj
             enabled: z.ZodDefault<z.ZodBoolean>;
             defaultInitialBalance: z.ZodDefault<z.ZodNumber>;
         }, z.core.$strip>>;
+        referrals: z.ZodDefault<z.ZodObject<{
+            enabled: z.ZodDefault<z.ZodBoolean>;
+            referrerReward: z.ZodOptional<z.ZodObject<{
+                credits: z.ZodOptional<z.ZodNumber>;
+                creditPoolKey: z.ZodOptional<z.ZodString>;
+                featureKey: z.ZodOptional<z.ZodString>;
+                durationDays: z.ZodOptional<z.ZodNumber>;
+                percentOff: z.ZodOptional<z.ZodNumber>;
+                discountDuration: z.ZodOptional<z.ZodEnum<typeof import("..").PromotionDuration>>;
+                discountDurationInMonths: z.ZodOptional<z.ZodNumber>;
+                type: import("@wildo-ai/zod-decorators").DecoratedPrimitiveZodType<z.ZodEnum<typeof import("..").ReferrerRewardType>>;
+            }, z.core.$strip>>;
+            referredReward: z.ZodOptional<z.ZodObject<{
+                trialExtensionDays: z.ZodOptional<z.ZodNumber>;
+                credits: z.ZodOptional<z.ZodNumber>;
+                creditPoolKey: z.ZodOptional<z.ZodString>;
+                featureKey: z.ZodOptional<z.ZodString>;
+                durationDays: z.ZodOptional<z.ZodNumber>;
+                percentOff: z.ZodOptional<z.ZodNumber>;
+                discountDuration: z.ZodOptional<z.ZodEnum<typeof import("..").PromotionDuration>>;
+                discountDurationInMonths: z.ZodOptional<z.ZodNumber>;
+                type: import("@wildo-ai/zod-decorators").DecoratedPrimitiveZodType<z.ZodEnum<typeof import("..").ReferredRewardType>>;
+            }, z.core.$strip>>;
+            codeValidityDays: z.ZodDefault<z.ZodNumber>;
+        }, z.core.$strip>>;
         defaultBehaviorPolicy: z.ZodDefault<z.ZodObject<{
             defaultTrialDays: z.ZodDefault<z.ZodNumber>;
             paymentGracePeriodDays: z.ZodDefault<z.ZodNumber>;
@@ -248,7 +471,7 @@ export declare const AppConfiguration_FrontendBootstrapResponse_Schema: z.ZodObj
             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>>;
+        requiresConsent: z.ZodDefault<z.ZodBoolean>;
         valueMoments: z.ZodOptional<z.ZodArray<z.ZodObject<{
             identifier: z.ZodString;
             role: z.ZodEnum<typeof import("..").ValueMomentRole>;
@@ -331,15 +554,25 @@ export declare const AppConfiguration_FrontendBootstrapResponse_Schema: z.ZodObj
         dormancyCronSchedule: z.ZodDefault<z.ZodString>;
     }, z.core.$strip>>;
     tenantTeardown: z.ZodOptional<z.ZodObject<{
-        retentionWindowDays: z.ZodDefault<z.ZodNumber>;
+        retentionWindowDays: z.ZodOptional<z.ZodNumber>;
         purgeCronSchedule: z.ZodDefault<z.ZodString>;
         purgeBatchSize: z.ZodDefault<z.ZodNumber>;
     }, z.core.$strip>>;
+    reviewCalendar: z.ZodOptional<z.ZodObject<{
+        timeZone: z.ZodString;
+        workingDays: z.ZodDefault<z.ZodArray<z.ZodEnum<typeof import("..").CalendarWeekday>>>;
+        workingHours: z.ZodDefault<z.ZodObject<{
+            start: z.ZodString;
+            end: z.ZodString;
+        }, z.core.$strip>>;
+        holidays: z.ZodDefault<z.ZodArray<z.ZodString>>;
+    }, 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<{
+        applicationReadAccess: z.ZodOptional<z.ZodEnum<typeof import("..").AuditApplicationReadAccess>>;
         archiveAfterDays: z.ZodOptional<z.ZodNumber>;
         allowPrivateNetworkSiemCollectors: z.ZodOptional<z.ZodBoolean>;
     }, z.core.$strip>>;
@@ -372,6 +605,8 @@ export declare const AppConfiguration_FrontendBootstrapResponse_Schema: z.ZodObj
                 imgOrigins: z.ZodDefault<z.ZodArray<z.ZodString>>;
                 styleOrigins: z.ZodDefault<z.ZodArray<z.ZodString>>;
                 fontOrigins: z.ZodDefault<z.ZodArray<z.ZodString>>;
+                workerOrigins: z.ZodDefault<z.ZodArray<z.ZodString>>;
+                mediaOrigins: z.ZodDefault<z.ZodArray<z.ZodString>>;
                 derivedOrigins: z.ZodDefault<z.ZodArray<z.ZodObject<{
                     publicConfigKey: z.ZodString;
                     bucket: z.ZodEnum<typeof import("./provider-frontend-surface.shared.schemas").ProviderFrontendCspOriginBucket>;
@@ -390,9 +625,45 @@ export declare const AppConfiguration_FrontendBootstrapResponse_Schema: z.ZodObj
             }, z.core.$strict>>>;
             components: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodObject<{
                 selectionDelivery: z.ZodOptional<z.ZodEnum<typeof import("./provider-frontend-surface.shared.schemas").ProviderFrontendSelectionDelivery>>;
+                placeIdRetention: z.ZodOptional<z.ZodEnum<typeof import("./provider-frontend-surface.shared.schemas").ProviderAddressLookupPlaceIdRetention>>;
+                addressLookup: z.ZodOptional<z.ZodObject<{
+                    suggestOperationId: z.ZodString;
+                    retrieveOperationId: z.ZodString;
+                    sessionTokenInput: z.ZodOptional<z.ZodString>;
+                    attributionMark: z.ZodOptional<z.ZodString>;
+                }, z.core.$strict>>;
             }, z.core.$strict>>>;
             publicConfigKeys: z.ZodOptional<z.ZodArray<z.ZodString>>;
-            fileStorage: z.ZodOptional<z.ZodEnum<typeof import("@wildo-ai/zod-decorators").FileStorageAccepted>>;
+            fileStorage: z.ZodOptional<z.ZodEnum<{
+                readonly WILDO_MANAGED: "wildo_managed";
+                readonly LOCAL_DIRECTORY: "local_directory";
+                readonly ONEDRIVE: "onedrive";
+                readonly GOOGLE_DRIVE: "google_drive";
+                readonly DROPBOX: "dropbox";
+            }>>;
+            complianceProfile: z.ZodOptional<z.ZodUnion<readonly [z.ZodObject<{
+                determination: z.ZodOptional<z.ZodLiteral<import("./provider-compliance-profile.shared.schemas").ProviderComplianceDetermination.ESTABLISHED>>;
+                deploymentModels: z.ZodArray<z.ZodEnum<typeof import("./provider-compliance-profile.shared.schemas").ProviderDeploymentModel>>;
+                processingRegions: z.ZodArray<z.ZodString>;
+                vendorLegalEntityName: z.ZodOptional<z.ZodString>;
+                subprocessorListUrl: z.ZodOptional<z.ZodURL>;
+                dataProcessingAgreementUrl: z.ZodOptional<z.ZodURL>;
+                evidence: z.ZodOptional<z.ZodArray<z.ZodObject<{
+                    facts: z.ZodArray<z.ZodEnum<typeof import("./provider-compliance-profile.shared.schemas").ProviderComplianceFact>>;
+                    source: z.ZodURL;
+                    verifiedAt: z.ZodISODate;
+                }, z.core.$strict>>>;
+                subjectErasure: z.ZodOptional<z.ZodObject<{
+                    stance: z.ZodEnum<{
+                        readonly NO_SUBJECT_DATA: import("..").HttpApiErasureStance.NO_SUBJECT_DATA;
+                        readonly EXTERNAL_ERASURE_OPERATION: import("..").HttpApiErasureStance.EXTERNAL_ERASURE_OPERATION;
+                    }>;
+                }, z.core.$strict>>;
+            }, z.core.$strict>, z.ZodObject<{
+                determination: z.ZodLiteral<import("./provider-compliance-profile.shared.schemas").ProviderComplianceDetermination.UNDETERMINED>;
+                reason: z.ZodString;
+            }, z.core.$strict>]>>;
+            consentPurposes: z.ZodOptional<z.ZodArray<z.ZodString>>;
         }, z.core.$loose>>>;
     }, z.core.$strip>;
 }, z.core.$strip>;

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

@@ -1 +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"}
+{"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-capability-public-config.shared.schemas.d.ts

@@ -56,4 +56,119 @@ export declare const FrontendFilePickerPublicConfigSchema: z.ZodObject<{
     maxSelectionCount: z.ZodOptional<z.ZodNumber>;
 }, z.core.$loose>;
 export type FrontendFilePickerPublicConfig = z.infer<typeof FrontendFilePickerPublicConfigSchema>;
+/**
+ * Every built-in capability that owns public-config keys, and the schema that
+ * owns them.
+ *
+ * A MAP rather than a list of keys, so the keys are derived from the schema that
+ * validates them and the two cannot disagree. Adding a capability's shape here
+ * is the ONE edit that makes its keys admissible everywhere — the admission,
+ * the refusal message and the validation all read this map.
+ *
+ * A capability absent from this map owns no public-config keys, which is the
+ * common case and needs no entry.
+ */
+export declare const FRONTEND_CAPABILITY_PUBLIC_CONFIG_SCHEMAS: Readonly<Record<string, z.ZodObject>>;
+/**
+ * The public-config keys a provider admits BY VIRTUE OF the capabilities it
+ * claims, beside whatever its own `publicConfigSchema` declares.
+ *
+ * ## Why this exists — measured 2026-09-18 (#380)
+ *
+ * `FrontendFilePickerPublicConfigSchema` declares the constraint vocabulary the
+ * FRAMEWORK reads off a picker (`acceptedMimeTypes`, `maxFileSizeMb`,
+ * `maxSelectionCount`), and `resolveFormFieldFileProviderConstraints` reads it.
+ * Three separate gates refused it, because each asked only what the PROVIDER
+ * declares:
+ *
+ * - the config overlay THREW `UNDECLARED_KEY` — *"a key the provider never reads
+ *   would be served to every browser and used by nothing"*, which is false here:
+ *   the framework reads it, for that provider, because it claims the capability;
+ * - hydration answered `unknown key` and set the provider's code to `undefined`,
+ *   so declaring a size limit DELETED the picker;
+ * - and the resolver then found nothing, because nothing had been allowed through.
+ *
+ * All three engine pickers declare a `publicConfigSchema` (`appId`, `clientId`,
+ * `appKey`), so the capability's whole vocabulary was unusable on every one of
+ * them. It worked only on an application-authored picker that declares NO
+ * schema, where the first gate is skipped — which is why the dogfood never saw it.
+ *
+ * The capability schema's own docstring asked a provider to *"EXTEND the schema
+ * for the capability it claims"*, and no affordance to do that existed. This is
+ * the affordance, DERIVED instead: a provider claiming `FRONTEND_FILE_PICKER`
+ * admits the file-picker keys with no edit to the provider, so a capability
+ * shape added tomorrow reaches every provider claiming it and none that does not.
+ */
+export declare function frontendCapabilityPublicConfigKeys(providerCapabilities: readonly string[] | undefined): readonly string[];
+/**
+ * Splits a public-config bag into the half the CAPABILITIES own and the half the
+ * provider's own schema must answer for, validating the first here.
+ *
+ * Returning the two halves rather than one merged bag is what lets a caller run
+ * the provider's schema over exactly the keys it declared — a strict provider
+ * schema would otherwise refuse the capability's keys, which is the defect this
+ * whole mechanism exists to remove.
+ */
+export declare function partitionFrontendCapabilityPublicConfig(input: {
+    readonly providerCapabilities: readonly string[] | undefined;
+    readonly publicConfig: Readonly<Record<string, unknown>>;
+}): {
+    readonly capabilityConfig: Readonly<Record<string, unknown>>;
+    readonly providerConfig: Readonly<Record<string, unknown>>;
+    readonly issues: ReadonlyArray<{
+        readonly message: string;
+        readonly path: readonly PropertyKey[];
+    }>;
+};
+/**
+ * The full set of public-config keys a provider admits: what its own schema
+ * declares, UNION what the capabilities it claims own.
+ *
+ * `undefined` in, `undefined` out — and that is load-bearing. A provider with no
+ * introspectable schema has no key list, which every gate refuses
+ * (`SCHEMA_NOT_INTROSPECTABLE`, #1705); widening `undefined` to the capability
+ * keys would instead turn that refusal into "declares exactly these" and hide
+ * the missing schema behind a plausible list.
+ *
+ * It lives beside the capability map rather than beside
+ * `readDeclaredPublicConfigKeys`, because that module is deliberately
+ * dependency-free so a provider module can declare a schema without pulling a
+ * validation library in.
+ */
+export declare function admissibleFrontendPublicConfigKeys(input: {
+    readonly declaredKeys: readonly string[] | undefined;
+    readonly providerCapabilities: readonly string[] | undefined;
+}): readonly string[] | undefined;
+/**
+ * Lays ONE provider's declared picker limits under the field's own, for that
+ * provider's picker and no other.
+ *
+ * ## Why this is per-provider and not resolved once (#380)
+ *
+ * The field used to resolve its picker constraints from the FIRST provider the
+ * registry returned for `FRONTEND_FILE_PICKER`, and pass that single object to
+ * whichever picker the person then chose — so a Drive limit governed a Dropbox
+ * pick, and which provider won depended on registry order. `ProviderFilePickerHost`
+ * was built so "a framework that picked one would be making a product decision in
+ * a lookup table"; the constraints were still making exactly that decision, one
+ * layer up, and it became reachable the moment a third picker shipped.
+ *
+ * It also reached the field's OWN native upload, which is wrong at any number of
+ * providers: a vendor's picker limit says nothing about a local file going to the
+ * field's own storage.
+ *
+ * Precedence is unchanged and is the part that must not move: the field's Zod
+ * metadata ALWAYS wins, and a provider only fills the gaps the schema left open.
+ * `maxSelectionCount` applies only to a `multiple` field — a single-file field
+ * never inherits a selection count.
+ */
+export declare function layerProviderFilePickerConstraints<TConstraints extends {
+    readonly allowedMimeTypes?: readonly string[];
+    readonly maxSize?: number;
+    readonly maxFiles?: number;
+}>(input: {
+    readonly base: TConstraints;
+    readonly multiple: boolean;
+    readonly publicConfig: Readonly<Record<string, unknown>> | undefined;
+}): TConstraints;
 //# sourceMappingURL=frontend-capability-public-config.shared.schemas.d.ts.map

package/dist/esm/external-providers/frontend-capability-public-config.shared.schemas.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"frontend-capability-public-config.shared.schemas.d.ts","sourceRoot":"","sources":["../../../src/external-providers/frontend-capability-public-config.shared.schemas.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;GAsBG;AAEH,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAExB;;;;;;;;;GASG;AACH,eAAO,MAAM,oCAAoC;IAC/C;;;;;;;;;OASG;;IAKH;;;;;;OAMG;;IAEH,mFAAmF;;iBAEnF,CAAC;AACH,MAAM,MAAM,8BAA8B,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,oCAAoC,CAAC,CAAC"}
+{"version":3,"file":"frontend-capability-public-config.shared.schemas.d.ts","sourceRoot":"","sources":["../../../../src/external-providers/frontend-capability-public-config.shared.schemas.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;GAsBG;AAEH,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAExB;;;;;;;;;GASG;AACH,eAAO,MAAM,oCAAoC;IAC/C;;;;;;;;;OASG;;IAKH;;;;;;OAMG;;IAEH,mFAAmF;;iBAEnF,CAAC;AACH,MAAM,MAAM,8BAA8B,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,oCAAoC,CAAC,CAAC;AAElG;;;;;;;;;;;GAWG;AACH,eAAO,MAAM,yCAAyC,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,CAAC,CAAC,SAAS,CAAC,CAE1F,CAAC;AAEH;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA6BG;AACH,wBAAgB,kCAAkC,CAChD,oBAAoB,EAAE,SAAS,MAAM,EAAE,GAAG,SAAS,GAClD,SAAS,MAAM,EAAE,CASnB;AAED;;;;;;;;GAQG;AACH,wBAAgB,uCAAuC,CAAC,KAAK,EAAE;IAC7D,QAAQ,CAAC,oBAAoB,EAAE,SAAS,MAAM,EAAE,GAAG,SAAS,CAAC;IAC7D,QAAQ,CAAC,YAAY,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC,CAAC;CAC1D,GAAG;IACF,QAAQ,CAAC,gBAAgB,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC,CAAC;IAC7D,QAAQ,CAAC,cAAc,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC,CAAC;IAC3D,QAAQ,CAAC,MAAM,EAAE,aAAa,CAAC;QAAE,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAC;QAAC,QAAQ,CAAC,IAAI,EAAE,SAAS,WAAW,EAAE,CAAA;KAAE,CAAC,CAAC;CACrG,CA0BA;AAED;;;;;;;;;;;;;;GAcG;AACH,wBAAgB,kCAAkC,CAAC,KAAK,EAAE;IACxD,QAAQ,CAAC,YAAY,EAAE,SAAS,MAAM,EAAE,GAAG,SAAS,CAAC;IACrD,QAAQ,CAAC,oBAAoB,EAAE,SAAS,MAAM,EAAE,GAAG,SAAS,CAAC;CAC9D,GAAG,SAAS,MAAM,EAAE,GAAG,SAAS,CAGhC;AAED;;;;;;;;;;;;;;;;;;;;;;GAsBG;AACH,wBAAgB,kCAAkC,CAChD,YAAY,SAAS;IACnB,QAAQ,CAAC,gBAAgB,CAAC,EAAE,SAAS,MAAM,EAAE,CAAC;IAC9C,QAAQ,CAAC,OAAO,CAAC,EAAE,MAAM,CAAC;IAC1B,QAAQ,CAAC,QAAQ,CAAC,EAAE,MAAM,CAAC;CAC5B,EACD,KAAK,EAAE;IACP,QAAQ,CAAC,IAAI,EAAE,YAAY,CAAC;IAC5B,QAAQ,CAAC,QAAQ,EAAE,OAAO,CAAC;IAC3B,QAAQ,CAAC,YAAY,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC,GAAG,SAAS,CAAC;CACtE,GAAG,YAAY,CAcf"}