@atlasauth/backend 0.17.0 → 0.19.0

package/dist/client/index.d.ts

@@ -183,7 +183,12 @@ declare function buildNamespaces(request: RequestFn): {
         setCustomData(id: string, customData: Record<string, unknown> | null): Promise<import("./sessions").Session>;
         updateCustomData(id: string, patch: Record<string, unknown>): Promise<import("./sessions").Session>;
         touch(id: string): Promise<import("./sessions").TouchedSession>;
-        getToken(id: string, template: string): Promise<import("./sessions").SessionTemplateToken>;
+        getToken: {
+            (id: string, template: string): Promise<import("./sessions").SessionTemplateToken>;
+            (id: string, options: {
+                for: string;
+            }): Promise<import("./sessions").SessionIntegrationToken>;
+        };
     };
     organizations: {
         list(params?: import("./types").CursorParams): Promise<import("./types").CursorPage<import("./organizations").Organization>>;
@@ -350,7 +355,9 @@ declare function buildNamespaces(request: RequestFn): {
         import(body: {
             clients: import("./oauth-clients").ImportOAuthClientEntry[];
         }, idempotencyKey?: string): Promise<import("./types").ListPage<import("./oauth-clients").ImportedOAuthClient>>;
-        list(): Promise<import("./types").ListPage<import("./oauth-clients").OAuthClient>>;
+        list(params?: {
+            metadata?: import("./compliance").ProvisioningMetadata;
+        }): Promise<import("./types").ListPage<import("./oauth-clients").OAuthClient>>;
         get(id: string): Promise<import("./oauth-clients").OAuthClient>;
         create(body: import("./oauth-clients").CreateOAuthClientBody, idempotencyKey?: string): Promise<import("./oauth-clients").OAuthClientWithSecret>;
         update(id: string, body: import("./oauth-clients").UpdateOAuthClientBody): Promise<import("./oauth-clients").OAuthClient>;
@@ -514,11 +521,27 @@ declare function buildNamespaces(request: RequestFn): {
     };
     webhooks: {
         endpoints: {
-            list(): Promise<import("./webhooks").WebhookEndpointList>;
+            list(opts?: {
+                includeDeprecated?: boolean;
+                metadata?: import("./compliance").ProvisioningMetadata;
+            }): Promise<import("./webhooks").WebhookEndpointList>;
+            get(id: string): Promise<import("./webhooks").WebhookEndpoint>;
+            upsertByUrl(body: import("./webhooks").UpsertWebhookEndpointBody, idempotencyKey?: string): Promise<import("./webhooks").WebhookEndpoint & {
+                secret?: string;
+                created: boolean;
+            }>;
             update(id: string, body: import("./webhooks").UpdateWebhookEndpointBody): Promise<import("./webhooks").WebhookEndpoint>;
             revealSecret(id: string): Promise<import("./webhooks").WebhookSigningSecret>;
             rotateSecret(id: string, body?: import("./webhooks").RotateWebhookSecretBody): Promise<import("./webhooks").WebhookSigningSecret>;
             test(id: string): Promise<import("./webhooks").WebhookDeliveryQueued>;
+            testNow(id: string, wait?: string): Promise<import("./webhooks").WebhookTestResult>;
+            redeliverWindow(id: string, body?: import("./webhooks").WebhookWindow & {
+                status?: "failed" | "success";
+            }, idempotencyKey?: string): Promise<import("./webhooks").WebhookBulkResult>;
+            replay(id: string, body: import("./webhooks").WebhookWindow & {
+                since: number | string;
+                event_type?: string;
+            }, idempotencyKey?: string): Promise<import("./webhooks").WebhookBulkResult>;
             redeliver(id: string, deliveryId: string): Promise<import("./webhooks").WebhookDeliveryQueued>;
             create(body: import("./webhooks").CreateWebhookEndpointBody, idempotencyKey?: string): Promise<import("./webhooks").WebhookEndpointWithSecret>;
             delete(id: string): Promise<{
@@ -532,6 +555,16 @@ declare function buildNamespaces(request: RequestFn): {
             has_more: boolean;
             next_cursor?: string | null;
         }>;
+        egressIps(): Promise<import("./webhooks").EgressIps>;
+        health(params?: {
+            kind?: import("./webhooks").DeliveryTargetKind;
+            state?: "unhealthy" | "all";
+        }): Promise<{
+            data: import("./webhooks").DeliveryHealth[];
+            has_more: boolean;
+            unhealthy_count: number;
+        }>;
+        setAlertContacts(kind: import("./webhooks").DeliveryTargetKind, targetId: string, alertContacts: string[] | null): Promise<import("./webhooks").DeliveryHealth>;
         redeliver(endpointId: string, deliveryId: string): Promise<import("./webhooks").WebhookDeliveryQueued>;
     };
     signInTokens: {
@@ -823,6 +856,40 @@ declare function buildNamespaces(request: RequestFn): {
         }>;
         test(id: string): Promise<import("./log-streams").LogStreamTestResult>;
     };
+    auditExports: {
+        list(): Promise<import("./types").ListPage<import("./compliance").AuditExport> & {
+            mandatory_actions: string[];
+        }>;
+        get(id: string): Promise<import("./compliance").AuditExport>;
+        create(body: import("./compliance").CreateAuditExportBody, idempotencyKey?: string): Promise<import("./compliance").AuditExport>;
+        update(id: string, body: import("./compliance").UpdateAuditExportBody): Promise<import("./compliance").AuditExport>;
+        delete(id: string): Promise<{
+            object: "audit_export";
+            id: string;
+            deleted: true;
+        }>;
+        test(id: string): Promise<import("./compliance").AuditExportTestResult>;
+        rotateSecret(id: string): Promise<import("./compliance").AuditExport>;
+    };
+    notices: {
+        list(params?: {
+            all?: boolean;
+        }): Promise<import("./types").ListPage<import("./compliance").InstanceNotice> & {
+            unacknowledged: number;
+            changelog_url: string;
+        }>;
+        acknowledge(id: string): Promise<import("./compliance").InstanceNotice>;
+    };
+    securityAdvisories: {
+        list(): Promise<import("./types").ListPage<import("./compliance").SecurityAdvisory> & {
+            applying: number;
+        }>;
+        acknowledge(id: string): Promise<import("./compliance").SecurityAdvisory>;
+        catalog(): Promise<import("./types").ListPage<import("./compliance").SecurityAdvisory>>;
+    };
+    subProcessors: {
+        get(): Promise<import("./compliance").SubProcessorList>;
+    };
     branding: {
         get(): Promise<import("./branding").BrandingResponse>;
         update(body: Partial<import("./branding").Branding>): Promise<import("./branding").BrandingResponse>;
@@ -929,6 +996,9 @@ declare function buildNamespaces(request: RequestFn): {
     };
     messaging: {
         get(): Promise<import("./messaging").MessagingProviders>;
+        channel<C extends "email" | "sms">(channel: C): Promise<(C extends "email" ? import("./messaging").EmailProvider : import("./messaging").SmsProvider) | (import("./messaging").NotConfigured<"messaging_provider"> & {
+            channel: C;
+        })>;
         setEmail: {
             (body: import("./messaging").EmailProviderInput): Promise<import("./messaging").EmailProvider>;
             <T extends string>(body: Omit<import("./messaging").MessagingProviderInput, "transport"> & {
@@ -945,7 +1015,7 @@ declare function buildNamespaces(request: RequestFn): {
             force?: boolean;
         }): Promise<import("./messaging").DeletedMessagingProvider>;
         developmentEmail: {
-            get(): Promise<import("./messaging").DevelopmentEmail>;
+            get(): Promise<import("./messaging").DevelopmentEmail | import("./messaging").NotConfigured<"development_email">>;
             enable(body: import("./messaging").EnableDevelopmentEmailBody): Promise<import("./messaging").DevelopmentEmail>;
             disable(): Promise<{
                 object: "development_email";
@@ -955,7 +1025,7 @@ declare function buildNamespaces(request: RequestFn): {
             }>;
         };
         managedEmail: {
-            get(): Promise<import("./messaging").ManagedEmail>;
+            get(): Promise<import("./messaging").ManagedEmail | import("./messaging").NotConfigured<"managed_email">>;
             create(body: import("./messaging").CreateManagedEmailBody): Promise<import("./messaging").ManagedEmail>;
             verify(): Promise<import("./messaging").ManagedEmail>;
             delete(options?: {
@@ -1028,6 +1098,25 @@ declare function buildNamespaces(request: RequestFn): {
             reason?: string;
         }, idempotencyKey?: string): Promise<import("./data-subject-requests").DataSubjectRequest>;
     };
+    /** The data-rights executor protocol and the instance's orchestrator. */
+    privacy: {
+        discover(): Promise<Record<string, unknown>>;
+        preset(id: string): Promise<Record<string, unknown>>;
+        lookup(body: {
+            emails?: string[];
+            atlas?: import("./privacy").PrivacySubject;
+        }): Promise<import("./privacy").PrivacyLookupResult>;
+        createRequest(body: import("./privacy").CreatePrivacyRequestBody, idempotencyKey?: string): Promise<import("./privacy").PrivacyRequest>;
+        getRequest(id: string): Promise<import("./privacy").PrivacyRequest>;
+        cancelRequest(id: string, idempotencyKey?: string): Promise<import("./privacy").PrivacyRequest>;
+        orchestrator: {
+            get(): Promise<import("./privacy").PrivacyOrchestrator>;
+            set(body: import("./privacy").PrivacyOrchestratorInput): Promise<import("./privacy").PrivacyOrchestrator>;
+            delete(): Promise<import("./privacy").PrivacyOrchestrator & {
+                deleted: boolean;
+            }>;
+        };
+    };
     radiusClients: {
         list(): Promise<import("./types").ListPage<import("./radius-clients").RadiusClient>>;
         create(body: import("./radius-clients").CreateRadiusClientBody, idempotencyKey?: string): Promise<import("./radius-clients").RadiusClient>;
@@ -1053,10 +1142,62 @@ declare function buildNamespaces(request: RequestFn): {
     instance: {
         get(): Promise<import("./instance").Instance>;
         update(body: import("./instance").UpdateInstanceBody): Promise<import("./instance").InstanceUpdateResult>;
-        preflight(): Promise<import("./instance").PreflightReport>;
+        preflight(params?: import("./instance").PreflightParams): Promise<import("./instance").PreflightReport>;
+        unknownFieldsReport(params?: {
+            days?: number;
+        }): Promise<import("./instance").UnknownFieldsReport>;
+        openapiDiff(params: {
+            since: string;
+            surface?: string;
+        }): Promise<import("./instance").OpenApiDiff>;
         moveOrigin(body: import("./instance").OriginMoveRequest): Promise<import("./instance").OriginMove>;
+        integrationHealth(params?: {
+            only?: string[];
+            probe?: boolean;
+        }): Promise<import("./instance").IntegrationHealthReport>;
+        integrationHealthProviders(): Promise<{
+            object: "list";
+            data: {
+                object: "integration_health_provider";
+                source: string;
+                description: string;
+            }[];
+            has_more: false;
+        }>;
+        embed(params: {
+            instance: string;
+            origin?: string;
+            shape?: "redirect" | "panel" | "button";
+        }): Promise<import("./instance").EmbedManifest>;
         connections(): Promise<import("./instance").InstanceConnections>;
         integrations: {
+            list(): Promise<{
+                object: "list";
+                data: import("./instance").Integration[];
+                has_more: boolean;
+            }>;
+            get(id: string): Promise<import("./instance").Integration>;
+            set(id: string, body: import("./instance").SetIntegrationBody, opts?: {
+                dryRun?: boolean;
+            }): Promise<import("./instance").Integration>;
+            remove(id: string): Promise<import("./instance").Integration>;
+            deliveries(id: string, query?: {
+                limit?: number;
+                trace?: string;
+                kind?: "event" | "backchannel_logout";
+            }): Promise<{
+                object: "list";
+                data: import("./instance").IntegrationDelivery[];
+                has_more: boolean;
+            }>;
+            revealEventsSecret(id: string): Promise<{
+                object: "integration_events_secret";
+                integration: string;
+                endpoint_id: string;
+                url: string;
+                secret: string;
+            }>;
+            atlasIdToken(id: string, accessToken: string): Promise<import("./instance").IntegrationTokenResponse>;
             chatly: {
                 get(): Promise<import("./instance").ChatlyIntegration>;
                 set(body: import("./instance").SetChatlyIntegrationBody): Promise<import("./instance").ChatlyIntegration>;
@@ -1074,6 +1215,29 @@ declare function buildNamespaces(request: RequestFn): {
             delete(): Promise<import("./instance").CookieConsent>;
         };
     };
+    integrations: {
+        reportVerifyError(body: import("./integrations").ReportVerifyErrorBody): Promise<import("./integrations").IntegrationVerifyError>;
+        card(integration: string, query: {
+            sub: string;
+            iss?: string;
+        }): Promise<import("./integrations").IntegrationCard>;
+        revokeSessions(integration: string, body: {
+            sub: string;
+            iss?: string;
+            agent?: {
+                id?: string;
+                name?: string;
+                email?: string;
+            };
+        }): Promise<{
+            object: "integration_card_action";
+            integration: string;
+            action: "revoke_sessions";
+            ok: boolean;
+            sessions_revoked: number;
+        }>;
+        instanceMetadata(instanceId: string): Promise<import("./integrations").InstanceMetadata>;
+    };
     instanceSecurity: {
         listSigningKeys(): Promise<{
             object: "list";
@@ -1152,6 +1316,9 @@ declare function buildNamespaces(request: RequestFn): {
             kind?: import("./referrals").ReferralCallKind;
             error_code?: string;
         }, idempotencyKey?: string): Promise<import("./referrals").ReferralRetryFailedResult>;
+        install(preset: string, body?: {
+            return_to?: string | null;
+        }): Promise<import("./referrals").ReferralInstall>;
         simulate(body?: {
             code?: string;
         }): Promise<import("./referrals").ReferralSimulateResult>;
@@ -1159,6 +1326,103 @@ declare function buildNamespaces(request: RequestFn): {
         getBackfill(id: string): Promise<import("./referrals").ReferralBackfillJob>;
         getForUser(userId: string): Promise<import("./users").UserReferralResult>;
     };
+    policies: {
+        list(params?: {
+            include_retired?: boolean;
+        }): Promise<{
+            object: "list";
+            data: import("./policies").Policy[];
+        }>;
+        create(body: import("./policies").CreatePolicyBody): Promise<import("./policies").Policy>;
+        get(idOrKey: string): Promise<import("./policies").Policy>;
+        update(idOrKey: string, body: import("./policies").UpdatePolicyBody): Promise<import("./policies").Policy>;
+        delete(idOrKey: string): Promise<{
+            object: "policy";
+            id: string;
+            key: string;
+            deleted: boolean;
+            retired: boolean;
+            policy?: import("./policies").Policy;
+        }>;
+        versions: {
+            list(idOrKey: string): Promise<{
+                object: "list";
+                data: import("./policies").PolicyVersion[];
+            }>;
+            create(idOrKey: string, body: import("./policies").CreatePolicyVersionBody): Promise<import("./policies").PolicyVersion>;
+            get(idOrKey: string, versionIdOrLabel: string): Promise<import("./policies").PolicyVersion>;
+            update(idOrKey: string, versionIdOrLabel: string, body: import("./policies").UpdatePolicyVersionBody): Promise<import("./policies").PolicyVersion>;
+            delete(idOrKey: string, versionIdOrLabel: string): Promise<{
+                object: "policy_version";
+                id: string;
+                deleted: true;
+            }>;
+            publish(idOrKey: string, versionIdOrLabel: string, body?: {
+                effective_at?: number | string;
+            }): Promise<import("./policies").PolicyVersion>;
+            retire(idOrKey: string, versionIdOrLabel: string): Promise<import("./policies").PolicyVersion>;
+        };
+        listAcceptances(idOrKey: string, params?: import("./policies").ListPolicyAcceptancesParams): Promise<import("./policies").PolicyAcceptancePage>;
+        exportAcceptancesCsv(idOrKey: string, params?: Omit<import("./policies").ListPolicyAcceptancesParams, "limit" | "starting_after">): Promise<string>;
+        forUser(userId: string): Promise<{
+            object: "list";
+            user_id: string;
+            data: import("./policies").PolicyStanding[];
+            needs_acceptance: boolean;
+        }>;
+        settings: {
+            get(): Promise<import("./policies").PolicySettings>;
+            update(body: {
+                session_claim?: boolean;
+            }): Promise<import("./policies").PolicySettings>;
+        };
+    };
+    policySource: {
+        get(): Promise<import("./policies").PolicySource>;
+        update(body: import("./policies").UpdatePolicySourceBody): Promise<import("./policies").PolicySource>;
+        delete(): Promise<import("./policies").PolicySource>;
+        test(): Promise<import("./policies").PolicySourceTest>;
+        sync(): Promise<import("./policies").PolicySourceSync>;
+        listDeliveries(params?: {
+            limit?: number;
+            starting_after?: string;
+            kind?: string;
+            status?: string;
+        }): Promise<{
+            object: "list";
+            data: import("./policies").PolicySourceDelivery[];
+            has_more: boolean;
+            next_cursor: string | null;
+        }>;
+    };
+    status: {
+        service(): Promise<import("./status").ServiceStatus>;
+        getSubscription(): Promise<import("./status").StatusSubscription>;
+        updateSubscription(body: import("./status").UpdateStatusSubscriptionBody): Promise<import("./status").StatusSubscription>;
+        disableSubscription(): Promise<import("./status").StatusSubscription>;
+        rotateFeed(): Promise<import("./status").StatusSubscription>;
+        listIncidents(params?: {
+            open?: boolean;
+            limit?: number;
+        }): Promise<{
+            object: "list";
+            data: import("./status").StatusIncident[];
+        }>;
+        listDependencies(): Promise<{
+            object: "list";
+            data: import("./status").StatusDependency[];
+            state: import("./status").StatusDependencyState;
+        }>;
+        createDependency(body: import("./status").CreateStatusDependencyBody): Promise<import("./status").StatusDependency>;
+        getDependency(id: string): Promise<import("./status").StatusDependency>;
+        updateDependency(id: string, body: import("./status").UpdateStatusDependencyBody): Promise<import("./status").StatusDependency>;
+        deleteDependency(id: string): Promise<{
+            object: "status_dependency";
+            id: string;
+            deleted: true;
+        }>;
+        refreshDependency(id: string): Promise<import("./status").StatusDependency>;
+    };
     userHooks: {
         getBeforeUserCreate(): Promise<import("./user-hooks").BeforeUserCreateHook>;
         updateBeforeUserCreate(body: import("./user-hooks").UpdateBeforeUserCreateHookBody): Promise<import("./user-hooks").BeforeUserCreateHook>;
@@ -1173,6 +1437,11 @@ declare function buildNamespaces(request: RequestFn): {
     design: {
         get(): Promise<import("./design").DesignSettings>;
         replace(design: import("./design").AtlasDesign): Promise<import("./design").DesignSettings>;
+        importBrand(input: {
+            brandUrl: string;
+        } | {
+            brand: Record<string, unknown> | null;
+        }): Promise<import("./design").DesignSettings>;
         update(design: import("./design").AtlasDesignPatch): Promise<import("./design").DesignSettings>;
         preview(design: import("./design").AtlasDesign): Promise<import("./design").DesignPreview>;
         organizations: {
@@ -1196,6 +1465,12 @@ declare function buildNamespaces(request: RequestFn): {
             deleted: true;
         }>;
     };
+    entitlements: {
+        get(params: {
+            subject_type: import("./entitlement-overrides").EntitlementOverrideSubjectType;
+            subject_id: string;
+        }): Promise<import("./entitlement-overrides").Entitlements>;
+    };
     orgLdapConnections: {
         list(params?: {
             organization_id?: string;
@@ -1370,6 +1645,98 @@ declare function buildNamespaces(request: RequestFn): {
             deleted: number;
         }>;
     };
+    whoami: () => Promise<import("./credentials").Whoami>;
+    secretKeys: {
+        create(body: import("./credentials").CreateSecretKeyBody): Promise<import("./credentials").SecretKeyWithSecret>;
+        list(params?: {
+            metadata?: Record<string, string>;
+        }): Promise<import("./types").ListPage<import("./credentials").SecretKey>>;
+        get(id: string): Promise<import("./credentials").SecretKey>;
+        update(id: string, body: {
+            name?: string | null;
+            owner?: string | null;
+            expires_at?: number | string | null;
+            allowed_ips?: string[];
+            allowed_origins?: string[];
+            metadata?: Record<string, string | number | boolean> | null;
+        }): Promise<import("./credentials").SecretKey>;
+        rotate(id: string, body?: {
+            overlap_seconds?: number;
+            key_format?: "atlas" | "legacy";
+        }): Promise<import("./credentials").SecretKeyWithSecret & {
+            replaces: string;
+            previous_key_expires_at: number | null;
+        }>;
+        revoke(id: string): Promise<import("./credentials").SecretKey & {
+            revoked: true;
+        }>;
+    };
+    keys: {
+        list(): Promise<import("./types").ListPage<import("./credentials").StandardKey>>;
+    };
+    partnerLinks: {
+        create(body: {
+            partner: string;
+            name?: string;
+            scopes: string[];
+            expires_at?: number | string;
+            cert_fingerprints?: string[];
+        }): Promise<import("./credentials").PartnerLink>;
+        setCertificates(id: string, certFingerprints: string[]): Promise<import("./credentials").PartnerLink>;
+        requests: {
+            list(params?: {
+                direction?: "inbound" | "outbound";
+                status?: import("./credentials").PartnerLinkRequest["status"][];
+            }): Promise<import("./types").ListPage<import("./credentials").PartnerLinkRequest>>;
+            get(id: string): Promise<import("./credentials").PartnerLinkRequest>;
+            approve(id: string, body?: {
+                scopes?: string[];
+                expires_at?: number | string;
+            }): Promise<import("./credentials").PartnerLinkRequestApproval>;
+            deny(id: string): Promise<import("./credentials").PartnerLinkRequest>;
+        };
+        list(): Promise<import("./types").ListPage<import("./credentials").PartnerLink>>;
+        get(id: string): Promise<import("./credentials").PartnerLink>;
+        rotateSecret(id: string): Promise<import("./credentials").PartnerLink>;
+        revoke(id: string): Promise<import("./credentials").PartnerLink & {
+            revoked: true;
+        }>;
+        outbound: {
+            list(): Promise<import("./types").ListPage<import("./credentials").OutboundPartnerLink>>;
+            save(partner: string, body: import("./credentials").SaveOutboundPartnerLinkBody): Promise<import("./credentials").OutboundPartnerLink>;
+            test(partner: string): Promise<{
+                object: "partner_link_test";
+                partner: string;
+                ok: boolean;
+                error?: string;
+            }>;
+            remove(partner: string): Promise<{
+                object: "outbound_partner_link";
+                partner: string;
+                deleted: true;
+            }>;
+            request(partner: string, body: {
+                scopes: string[];
+                resource?: string;
+                base_url?: string;
+                token_url?: string;
+                name?: string;
+            }): Promise<import("./credentials").PartnerLinkRequest & {
+                note: string;
+            }>;
+        };
+    };
+    atlasIdGrants: {
+        listApps(): Promise<import("./types").ListPage<{
+            object: "atlas_id_app";
+            id: string;
+            client_id: string;
+            name: string;
+            managed_by_instance_id: string;
+        }>>;
+        lookup(appId: string, email: string): Promise<import("./types").ListPage<import("./credentials").AtlasIdGrantLookup>>;
+        revoke(appId: string, grantId: string): Promise<import("./credentials").InstanceAtlasIdGrantRevocation>;
+    };
     events: {
         list(params?: import("./activity").ListActivityEventsParams): Promise<import("./activity").ActivityEventsPage>;
     };
@@ -1491,14 +1858,16 @@ export interface AtlasClient extends AtlasClientNamespaces {
      */
     withOptions(overrides: AtlasRequestSettings): AtlasClient;
 }
-export type { AtlasClientConfig, AtlasRequestSettings, UnknownFieldsEvent, RawBody, } from './request';
+export type { AtlasClientConfig, AtlasRequestSettings, UnknownFieldsEvent, RawBody, DryRunChange, DryRunResult, } from './request';
 export { DEFAULT_API_URL } from './request';
+export { API_BASE_ENV_NAMES, apiBaseFromEnv, atlasConfigFromEnv, createAtlasClientFromEnv } from './env';
 export { AtlasErrorCodes, type AtlasErrorCode } from './error';
 export { createAtlasPlatformClient } from './platform';
 export type { AtlasPlatformClient, AtlasPlatformClientConfig } from './platform';
 export { AtlasApiError, type AtlasErrorItem } from './error';
 export { paginate, collect } from './paginate';
 export * from './types';
+export * from './compliance';
 export * from './users';
 export * from './sessions';
 export * from './organizations';
@@ -1541,11 +1910,15 @@ export * from './messaging';
 export * from './import-export';
 export * from './better-auth-imports';
 export * from './data-subject-requests';
+export * from './privacy';
 export * from './radius-clients';
 export * from './lti-platforms';
 export * from './instance';
+export * from './integrations';
 export * from './instance-security';
 export * from './referrals';
+export * from './policies';
+export * from './status';
 export * from './user-hooks';
 export * from './tokens';
 export * from './captcha';
@@ -1570,3 +1943,5 @@ export * from './test-mode';
 export * from './diagnostics';
 export * from './logout-notify-endpoints';
 export * from './platform';
+export * from './credentials';
+export * from './operator';