@atlasauth/backend 0.1.0

package/dist/client/index.d.ts

@@ -0,0 +1,796 @@
+import { type AtlasClientConfig } from './request';
+/**
+ * The typed management client for the Atlas Backend API — the secret-key
+ * surface, the peer of `@clerk/backend`'s `createClerkClient`.
+ *
+ * Each namespace is one line: it hands the shared, config-bound `request`
+ * function to a resource factory. That factory is where the method↔endpoint
+ * mapping and the wire types live, so this file stays a table of contents you
+ * can read top to bottom to see the whole surface.
+ */
+export declare function createAtlasClient(config: AtlasClientConfig): {
+    users: {
+        list(params?: import("./users").ListUsersParams): Promise<import("./types").CursorPage<import("./users").User>>;
+        get(id: string): Promise<import("./users").User>;
+        create(body: import("./users").CreateUserBody, idempotencyKey?: string): Promise<import("./users").User>;
+        update(id: string, body: import("./users").UpdateUserBody): Promise<import("./users").User>;
+        replaceMetadata(id: string, body: import("./users").ReplaceUserMetadataBody): Promise<import("./users").User>;
+        ban(id: string): Promise<import("./users").User>;
+        unban(id: string): Promise<import("./users").User>;
+        lock(id: string, body?: {
+            duration_in_seconds?: number;
+        }): Promise<import("./users").User>;
+        unlock(id: string): Promise<import("./users").User>;
+        delete(id: string): Promise<import("./types").DeletedObject>;
+        resetMfa(id: string): Promise<{
+            object: "user";
+            id: string;
+            mfa_enabled: false;
+        }>;
+        deleteMfaFactor(id: string, factorId: string): Promise<{
+            object: "mfa_factor";
+            id: string;
+            deleted: true;
+        }>;
+        listSessions(id: string): Promise<import("./types").ListPage<import("./users").UserSession>>;
+        revokeSessions(id: string): Promise<{
+            object: "user";
+            id: string;
+            sessions_revoked: number;
+        }>;
+        addEmail(id: string, body: {
+            email_address: string;
+        }): Promise<import("./users").EmailAddress>;
+        verifyEmail(id: string, emailId: string): Promise<import("./users").EmailAddress>;
+        setPrimaryEmail(id: string, emailId: string): Promise<import("./users").EmailAddress>;
+        getOAuthAccessToken(id: string, provider: string): Promise<import("./users").OAuthAccessToken>;
+        listIdentities(id: string): Promise<import("./types").ListPage<import("./users").Identity>>;
+        linkIdentity(id: string, body: {
+            secondary_user_id: string;
+        }, idempotencyKey?: string): Promise<import("./types").ListPage<import("./users").Identity> & {
+            collisions: Array<{
+                type: string;
+                detail: string;
+            }>;
+        }>;
+        connectExternalAccount(id: string, body: {
+            provider: string;
+            redirect_url: string;
+            additional_scopes?: string[];
+        }, idempotencyKey?: string): Promise<{
+            object: "external_account_connection";
+            provider: string;
+            user_id: string;
+            attempt_id: string;
+            authorization_url: string;
+            scopes: string[];
+        }>;
+        unlinkIdentity(id: string, identityId: string): Promise<{
+            object: "identity";
+            id: string;
+            provider: string;
+            unlinked: true;
+            new_user_id: string;
+        }>;
+        listGrants(id: string): Promise<import("./types").ListPage<import("./users").Grant>>;
+        revokeAllGrants(id: string): Promise<{
+            object: "user";
+            id: string;
+            grants_revoked: number;
+            tokens_revoked: number;
+        }>;
+        revokeGrant(grantId: string): Promise<{
+            object: "grant";
+            id: string;
+            deleted: true;
+            tokens_revoked: number;
+        }>;
+    };
+    sessions: {
+        create(params: import("./sessions").CreateSessionParams): Promise<import("./sessions").MintedSession>;
+        list(params: import("./sessions").ListSessionsParams): Promise<import("./types").ListPage<import("./sessions").Session>>;
+        get(id: string): Promise<import("./sessions").Session>;
+        revoke(id: string): Promise<{
+            object: "session";
+            id: string;
+            status: "revoked";
+        }>;
+    };
+    organizations: {
+        list(params?: import("./types").CursorParams): Promise<import("./types").CursorPage<import("./organizations").Organization>>;
+        get(id: string): Promise<import("./organizations").Organization>;
+        create(body: import("./organizations").CreateOrganizationBody, idempotencyKey?: string): Promise<import("./organizations").Organization>;
+        update(id: string, body: import("./organizations").UpdateOrganizationBody): Promise<import("./organizations").Organization>;
+        delete(id: string): Promise<import("./types").DeletedObject>;
+        updateMetadata(id: string, body: import("./organizations").ReplaceOrganizationMetadataBody): Promise<import("./organizations").Organization>;
+        updatePolicy(id: string, body: import("./organizations").OrganizationPolicyPatch): Promise<import("./organizations").OrganizationPolicy>;
+        setParent(id: string, body: {
+            parent_organization_id: string | null;
+        }): Promise<import("./organizations").Organization>;
+        hierarchy(id: string): Promise<import("./organizations").OrganizationHierarchy>;
+        entitlements(id: string): Promise<import("./organizations").OrganizationEntitlements>;
+        memberships: {
+            list(orgId: string): Promise<{
+                data: import("./organizations").OrganizationMembership[];
+                has_more: boolean;
+            }>;
+            add(orgId: string, body: {
+                user_id: string;
+                role?: string;
+            }, idempotencyKey?: string): Promise<{
+                object: "organization_membership";
+                organization_id: string;
+                user_id: string;
+                role: string;
+            }>;
+            update(orgId: string, userId: string, body: {
+                role: string;
+            }): Promise<{
+                object: "organization_membership";
+                role: string;
+                updated: true;
+            }>;
+            remove(orgId: string, userId: string): Promise<{
+                object: "organization_membership";
+                deleted: true;
+            }>;
+        };
+        invitations: {
+            list(orgId: string): Promise<import("./types").ListPage<import("./organizations").OrganizationInvitation>>;
+            create(orgId: string, body: {
+                email: string;
+                role: string;
+                inviter_user_id: string;
+            }, idempotencyKey?: string): Promise<{
+                object: "organization_invitation";
+                id: string;
+                organization_id: string;
+                email: string;
+                status: string;
+                expires_at: number;
+            }>;
+            revoke(orgId: string, invitationId: string): Promise<{
+                object: "organization_invitation";
+                id: string;
+                status: "revoked";
+            }>;
+        };
+        domains: {
+            list(orgId: string): Promise<import("./types").DataList<import("./organizations").OrgDomain> & {
+                object: "list";
+            }>;
+            create(orgId: string, body: {
+                domain: string;
+                auto_join?: boolean;
+                default_role_id?: string | null;
+            }, idempotencyKey?: string): Promise<import("./organizations").OrgDomain>;
+            verify(orgId: string, domainId: string): Promise<import("./organizations").OrgDomain & {
+                verified: boolean;
+            }>;
+            delete(orgId: string, domainId: string): Promise<{
+                object: "org_domain";
+                id: string;
+                deleted: true;
+            }>;
+        };
+        groupRoles: {
+            grant(orgId: string, groupId: string, roleId: string): Promise<{
+                object: "group_role_grant";
+                organization_id: string;
+                group_id: string;
+                role_id: string;
+                granted: true;
+            }>;
+            revoke(orgId: string, groupId: string, roleId: string): Promise<{
+                object: "group_role_grant";
+                organization_id: string;
+                group_id: string;
+                role_id: string;
+                deleted: boolean;
+            }>;
+        };
+    };
+    roles: {
+        list(): Promise<import("./types").ListPage<import("./roles").Role>>;
+        create(body: import("./roles").CreateRoleBody, idempotencyKey?: string): Promise<import("./roles").Role>;
+        update(id: string, body: import("./roles").UpdateRoleBody): Promise<import("./roles").Role>;
+        setPermissions(id: string, permissions: string[]): Promise<import("./roles").RolePermissionsResult>;
+        delete(id: string, opts?: {
+            reassignTo?: string;
+        }): Promise<{
+            object: "role";
+            id: string;
+            deleted: true;
+            members_reassigned: number;
+        }>;
+    };
+    permissions: {
+        list(): Promise<import("./types").ListPage<import("./roles").Permission>>;
+        create(body: import("./roles").CreatePermissionBody, idempotencyKey?: string): Promise<import("./roles").Permission>;
+        update(id: string, body: import("./roles").UpdatePermissionBody): Promise<import("./roles").Permission>;
+        delete(id: string): Promise<{
+            object: "permission";
+            id: string;
+            deleted: true;
+        }>;
+    };
+    oauthClients: {
+        list(): 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>;
+        rotateSecret(id: string): Promise<import("./oauth-clients").OAuthClientWithSecret>;
+        delete(id: string): Promise<{
+            object: "oauth_client";
+            id: string;
+            deleted: true;
+            note: string;
+        }>;
+        grants: {
+            list(clientId: string): Promise<import("./types").ListPage<import("./oauth-clients").ClientGrant>>;
+            create(clientId: string, body: {
+                resource_server_id: string;
+                scopes?: string[];
+            }): Promise<import("./oauth-clients").ClientGrant>;
+            delete(clientId: string, grantId: string): Promise<{
+                object: "client_grant";
+                id: string;
+                deleted: true;
+            }>;
+        };
+    };
+    resourceServers: {
+        list(): Promise<import("./types").ListPage<import("./resource-servers").ResourceServer>>;
+        get(id: string): Promise<import("./resource-servers").ResourceServer>;
+        create(body: import("./resource-servers").CreateResourceServerBody): Promise<import("./resource-servers").ResourceServer>;
+        update(id: string, body: import("./resource-servers").UpdateResourceServerBody): Promise<import("./resource-servers").ResourceServer>;
+        delete(id: string): Promise<{
+            object: "resource_server";
+            id: string;
+            deleted: true;
+        }>;
+    };
+    ssoConnections: {
+        list(): Promise<import("./types").ListPage<import("./sso-connections").SsoConnection>>;
+        get(id: string): Promise<import("./sso-connections").SsoConnection>;
+        create(body: import("./sso-connections").CreateSsoConnectionBody, idempotencyKey?: string): Promise<import("./sso-connections").SsoConnection>;
+        update(id: string, body: import("./sso-connections").UpdateSsoConnectionBody): Promise<import("./sso-connections").SsoConnection>;
+        delete(id: string): Promise<{
+            object: "sso_connection";
+            id: string;
+            deleted: true;
+        }>;
+        samlMetadata(id: string): Promise<import("./sso-connections").SamlMetadata>;
+    };
+    scimTokens: {
+        list(): Promise<import("./types").ListPage<import("./scim-tokens").ScimToken>>;
+        create(body: import("./scim-tokens").CreateScimTokenBody, idempotencyKey?: string): Promise<import("./scim-tokens").ScimTokenWithSecret>;
+        revoke(id: string): Promise<{
+            object: "scim_token";
+            id: string;
+            revoked: true;
+            note: string;
+        }>;
+    };
+    domains: {
+        list(): Promise<import("./domains").ListDomainsResponse>;
+        create(body: {
+            host: string;
+            role?: "fapi" | "accounts";
+        }, idempotencyKey?: string): Promise<import("./domains").CustomDomain & {
+            instructions: Record<string, unknown>;
+        }>;
+        verify(id: string): Promise<import("./domains").CustomDomain & {
+            verified: boolean;
+        }>;
+        delete(id: string): Promise<{
+            object: "custom_domain";
+            id: string;
+            deleted: true;
+        }>;
+    };
+    waitlist: {
+        list(params?: import("./waitlist").ListWaitlistParams): Promise<import("./waitlist").ListWaitlistResponse>;
+        decide(id: string, body: {
+            status: "approved" | "denied";
+            note?: string;
+        }): Promise<import("./waitlist").WaitlistEntry>;
+    };
+    allowlist: {
+        list(): Promise<{
+            object: "list";
+            data: import("./restrictions").AllowlistIdentifier[];
+            has_more: false;
+        }>;
+        add(identifier: string): Promise<import("./restrictions").AllowlistIdentifier>;
+        remove(id: string): Promise<{
+            object: string;
+            id: string;
+            deleted: true;
+        }>;
+    };
+    blocklist: {
+        list(): Promise<{
+            object: "list";
+            data: import("./restrictions").BlocklistIdentifier[];
+            has_more: false;
+        }>;
+        add(identifier: string): Promise<import("./restrictions").BlocklistIdentifier>;
+        remove(id: string): Promise<{
+            object: string;
+            id: string;
+            deleted: true;
+        }>;
+    };
+    attackProtection: {
+        get(): Promise<import("./attack-protection").AttackProtection>;
+        update(body: import("./attack-protection").UpdateAttackProtectionBody): Promise<import("./attack-protection").AttackProtection>;
+    };
+    actorTokens: {
+        create(body: import("./actor-tokens").CreateActorTokenBody, idempotencyKey?: string): Promise<import("./actor-tokens").ActorToken>;
+        revoke(id: string): Promise<{
+            object: "actor_token";
+            id: string;
+            revoked: true;
+        }>;
+    };
+    invitations: {
+        list(params?: import("./types").CursorParams): Promise<import("./types").CursorPage<import("./invitations").Invitation>>;
+        create(body: import("./invitations").CreateInvitationBody, idempotencyKey?: string): Promise<import("./invitations").Invitation>;
+        revoke(id: string): Promise<import("./invitations").Invitation>;
+    };
+    webhooks: {
+        endpoints: {
+            list(): Promise<{
+                data: import("./webhooks").WebhookEndpoint[];
+                has_more: false;
+            }>;
+            create(body: import("./webhooks").CreateWebhookEndpointBody, idempotencyKey?: string): Promise<import("./webhooks").WebhookEndpointWithSecret>;
+            delete(id: string): Promise<{
+                object: "webhook_endpoint";
+                id: string;
+                deleted: true;
+            }>;
+        };
+        deliveries(id: string): Promise<{
+            data: import("./webhooks").WebhookDelivery[];
+            has_more: false;
+        }>;
+    };
+    signInTokens: {
+        create(body: import("./sign-in-tokens").CreateSignInTokenBody, idempotencyKey?: string): Promise<import("./sign-in-tokens").SignInToken>;
+    };
+    auditLogs: {
+        list(params?: import("./audit-logs").ListAuditLogsParams): Promise<import("./types").CursorPage<import("./audit-logs").AuditLog>>;
+    };
+    jwtTemplates: {
+        list(): Promise<import("./types").ListPage<import("./jwt-templates").JwtTemplate>>;
+        get(name: string): Promise<import("./jwt-templates").JwtTemplate>;
+        create(body: import("./jwt-templates").CreateJwtTemplateBody): Promise<import("./jwt-templates").JwtTemplate>;
+        update(name: string, body: {
+            claims: Record<string, string>;
+        }): Promise<import("./jwt-templates").JwtTemplate>;
+        delete(name: string): Promise<{
+            object: "jwt_template";
+            name: string;
+            deleted: true;
+        }>;
+    };
+    apiKeys: {
+        list(query?: {
+            subject_type?: import("./api-keys").ApiKeySubjectType;
+            subject_id?: string;
+        }): Promise<import("./types").ListPage<import("./api-keys").ApiKey>>;
+        create(body: import("./api-keys").CreateApiKeyBody, idempotencyKey?: string): Promise<import("./api-keys").ApiKeyWithSecret>;
+        verify(secret: string): Promise<import("./api-keys").ApiKeyVerification>;
+        get(id: string): Promise<import("./api-keys").ApiKey>;
+        update(id: string, body: import("./api-keys").UpdateApiKeyBody): Promise<import("./api-keys").ApiKey>;
+        delete(id: string): Promise<{
+            object: "api_key";
+            id: string;
+            revoked: true;
+        }>;
+    };
+    oauthProviders: {
+        list(): Promise<import("./types").ListPage<import("./oauth-providers").OAuthProvider>>;
+        get(provider: string): Promise<import("./oauth-providers").OAuthProvider>;
+        upsert(provider: string, body: import("./oauth-providers").UpsertOAuthProviderBody, idempotencyKey?: string): Promise<{
+            object: "oauth_provider";
+            provider: string;
+            configured: true;
+        }>;
+        delete(provider: string): Promise<{
+            object: "oauth_provider";
+            provider: string;
+            deleted: true;
+            note: string;
+        }>;
+        setEnabled(provider: string, enabled: boolean): Promise<{
+            object: "oauth_provider";
+            provider: string;
+            enabled: boolean;
+        }>;
+        setScope(provider: string, body: {
+            allow_sign_in: boolean;
+            allow_sign_up: boolean;
+        }): Promise<{
+            object: "oauth_provider";
+            provider: string;
+            allow_sign_in: boolean;
+            allow_sign_up: boolean;
+        }>;
+        test(provider: string): Promise<import("./oauth-providers").OAuthConnectionTest>;
+    };
+    ssoOnboarding: {
+        list(): Promise<import("./types").ListPage<import("./sso-onboarding").SsoOnboardingProfile>>;
+        get(id: string): Promise<import("./sso-onboarding").SsoOnboardingProfile>;
+        create(body: import("./sso-onboarding").CreateSsoOnboardingProfileBody, idempotencyKey?: string): Promise<import("./sso-onboarding").SsoOnboardingProfile>;
+        delete(id: string): Promise<{
+            object: "sso_onboarding_profile";
+            id: string;
+            deleted: true;
+        }>;
+        createTicket(profileId: string, body?: import("./sso-onboarding").CreateSsoOnboardingTicketBody, idempotencyKey?: string): Promise<import("./sso-onboarding").IssuedSsoOnboardingTicket>;
+        revokeTicket(ticketId: string): Promise<{
+            object: "sso_onboarding_ticket";
+            id: string;
+            revoked: true;
+        }>;
+    };
+    scimProvisioning: {
+        list(): Promise<import("./types").ListPage<import("./scim-provisioning").ScimProvisioningTarget>>;
+        get(id: string): Promise<import("./scim-provisioning").ScimProvisioningTarget>;
+        create(body: import("./scim-provisioning").CreateScimProvisioningTargetBody, idempotencyKey?: string): Promise<import("./scim-provisioning").ScimProvisioningTarget>;
+        update(id: string, body: import("./scim-provisioning").UpdateScimProvisioningTargetBody): Promise<import("./scim-provisioning").ScimProvisioningTarget>;
+        delete(id: string): Promise<{
+            object: "scim_provisioning_target";
+            id: string;
+            deleted: true;
+        }>;
+        test(id: string): Promise<import("./scim-provisioning").ScimProvisioningTestResult>;
+        syncUser(id: string, userId: string): Promise<import("./scim-provisioning").ScimProvisioningSyncResult>;
+        syncGroup(id: string, organizationId: string): Promise<import("./scim-provisioning").ScimProvisioningGroupSyncResult>;
+    };
+    fga: {
+        stores: {
+            list(): Promise<import("./types").ListPage<import("./fga").FgaStore>>;
+            create(body: {
+                name: string;
+            }, idempotencyKey?: string): Promise<import("./fga").FgaStore>;
+            get(id: string): Promise<import("./fga").FgaStore>;
+            delete(id: string): Promise<{
+                object: "fga.store";
+                id: string;
+                deleted: true;
+            }>;
+        };
+        models: {
+            list(storeId: string): Promise<import("./types").ListPage<import("./fga").FgaAuthorizationModel>>;
+            create(storeId: string, body: import("./fga").FgaAuthorizationModelInput, idempotencyKey?: string): Promise<import("./fga").FgaAuthorizationModel>;
+            get(storeId: string, modelId: string): Promise<import("./fga").FgaAuthorizationModel>;
+        };
+        write(storeId: string, body: {
+            writes?: import("./fga").FgaTupleKeys;
+            deletes?: import("./fga").FgaTupleKeys;
+        }, idempotencyKey?: string): Promise<{
+            object: "fga.write_result";
+            writes: number;
+            deletes: number;
+        }>;
+        read(storeId: string, body: {
+            user?: string;
+            relation?: string;
+            object?: string;
+        }): Promise<import("./types").ListPage<import("./fga").FgaTuple>>;
+        check(storeId: string, body: import("./fga").FgaCheckBody): Promise<{
+            object: "fga.check";
+            allowed: boolean;
+            authorization_model_id: string;
+        }>;
+        batchCheck(storeId: string, body: {
+            checks: import("./fga").FgaBatchCheckItem[];
+            authorization_model_id?: string;
+        }): Promise<import("./fga").FgaBatchCheckResult>;
+        listObjects(storeId: string, body: import("./fga").FgaListObjectsBody): Promise<{
+            object: "fga.list_objects";
+            objects: string[];
+            authorization_model_id: string;
+        }>;
+        expand(storeId: string, body: {
+            object: string;
+            relation: string;
+            authorization_model_id?: string;
+        }): Promise<{
+            object: "fga.expand";
+            tree: unknown;
+            authorization_model_id: string;
+        }>;
+        store(storeId: string): {
+            write: (body: {
+                writes?: import("./fga").FgaTupleKeys;
+                deletes?: import("./fga").FgaTupleKeys;
+            }, idempotencyKey?: string) => Promise<{
+                object: "fga.write_result";
+                writes: number;
+                deletes: number;
+            }>;
+            read: (body: {
+                user?: string;
+                relation?: string;
+                object?: string;
+            }) => Promise<import("./types").ListPage<import("./fga").FgaTuple>>;
+            check: (body: import("./fga").FgaCheckBody) => Promise<{
+                object: "fga.check";
+                allowed: boolean;
+                authorization_model_id: string;
+            }>;
+            batchCheck: (body: {
+                checks: import("./fga").FgaBatchCheckItem[];
+                authorization_model_id?: string;
+            }) => Promise<import("./fga").FgaBatchCheckResult>;
+            listObjects: (body: import("./fga").FgaListObjectsBody) => Promise<{
+                object: "fga.list_objects";
+                objects: string[];
+                authorization_model_id: string;
+            }>;
+            expand: (body: {
+                object: string;
+                relation: string;
+                authorization_model_id?: string;
+            }) => Promise<{
+                object: "fga.expand";
+                tree: unknown;
+                authorization_model_id: string;
+            }>;
+            models: {
+                list: () => Promise<import("./types").ListPage<import("./fga").FgaAuthorizationModel>>;
+                create: (body: import("./fga").FgaAuthorizationModelInput, idempotencyKey?: string) => Promise<import("./fga").FgaAuthorizationModel>;
+                get: (modelId: string) => Promise<import("./fga").FgaAuthorizationModel>;
+            };
+        };
+    };
+    rateLimitPolicy: {
+        get(): Promise<import("./rate-limit").RateLimitPolicy>;
+        update(body: import("./rate-limit").UpdateRateLimitPolicyBody): Promise<import("./rate-limit").RateLimitPolicy>;
+    };
+    riskBasedMfa: {
+        get(): Promise<import("./risk-based-mfa").RiskBasedMfa>;
+        update(body: import("./risk-based-mfa").UpdateRiskBasedMfaBody): Promise<import("./risk-based-mfa").RiskBasedMfa>;
+    };
+    botSignals: {
+        list(query?: import("./bot-signals").BotExportParams): Promise<import("./bot-signals").BotExportPage<import("./bot-signals").BotSignal>>;
+        listLabels(query?: import("./bot-signals").BotExportParams): Promise<import("./bot-signals").BotExportPage<import("./bot-signals").BotLabel>>;
+        createLabel(body: import("./bot-signals").CreateBotLabelBody, idempotencyKey?: string): Promise<import("./bot-signals").BotLabel>;
+    };
+    networkAcls: {
+        list(): Promise<import("./types").ListPage<import("./network-acls").NetworkAcl>>;
+        get(id: string): Promise<import("./network-acls").NetworkAcl>;
+        create(body: import("./network-acls").CreateNetworkAclBody, idempotencyKey?: string): Promise<import("./network-acls").NetworkAcl>;
+        update(id: string, body: import("./network-acls").UpdateNetworkAclBody): Promise<import("./network-acls").NetworkAcl>;
+        delete(id: string): Promise<{
+            object: "network_acl";
+            id: string;
+            deleted: true;
+        }>;
+    };
+    managedWaf: {
+        get(): Promise<import("./managed-waf").ManagedWaf>;
+        status(): Promise<import("./managed-waf").ManagedWafStatus>;
+        update(body: import("./managed-waf").UpdateManagedWafBody): Promise<import("./managed-waf").ManagedWaf>;
+        provision(): Promise<import("./managed-waf").ManagedWafOutcome>;
+        deprovision(): Promise<import("./managed-waf").ManagedWafOutcome>;
+    };
+    logStreams: {
+        list(): Promise<import("./types").ListPage<import("./log-streams").LogStream>>;
+        get(id: string): Promise<import("./log-streams").LogStream>;
+        create(body: import("./log-streams").CreateLogStreamBody, idempotencyKey?: string): Promise<import("./log-streams").LogStream>;
+        update(id: string, body: import("./log-streams").UpdateLogStreamBody): Promise<import("./log-streams").LogStream>;
+        delete(id: string): Promise<{
+            object: "log_stream";
+            id: string;
+            deleted: true;
+        }>;
+        test(id: string): Promise<import("./log-streams").LogStreamTestResult>;
+    };
+    branding: {
+        get(): Promise<import("./branding").BrandingResponse>;
+        update(body: Partial<import("./branding").Branding>): Promise<import("./branding").BrandingResponse>;
+        preview(body: Partial<import("./branding").Branding>): Promise<import("./branding").HostedPagePreview>;
+    };
+    emailTemplates: {
+        list(): Promise<import("./types").ListPage<import("./email-templates").EmailTemplate>>;
+        preview(name: string, body?: import("./email-templates").EmailTemplateBody): Promise<import("./email-templates").EmailTemplatePreview>;
+        update(name: string, body: import("./email-templates").EmailTemplateBody): Promise<import("./email-templates").EmailTemplateResult>;
+        delete(name: string): Promise<import("./email-templates").EmailTemplateResult>;
+    };
+    smsTemplates: {
+        list(): Promise<import("./types").ListPage<import("./sms-templates").SmsTemplate>>;
+        create(body: import("./sms-templates").CreateSmsTemplateBody, idempotencyKey?: string): Promise<import("./sms-templates").SmsTemplate>;
+        get(name: string): Promise<import("./sms-templates").SmsTemplate>;
+        update(name: string, body: {
+            body?: string;
+            enabled?: boolean;
+        }): Promise<import("./sms-templates").SmsTemplate>;
+        delete(name: string): Promise<import("./sms-templates").SmsTemplate>;
+        preview(name: string, body?: {
+            body?: string;
+        }): Promise<import("./sms-templates").SmsTemplatePreview>;
+    };
+    localizations: {
+        list(params?: import("./localizations").ListLocalizationsParams): Promise<import("./types").ListPage<import("./localizations").Localization>>;
+        create(body: import("./localizations").CreateLocalizationBody, idempotencyKey?: string): Promise<import("./localizations").Localization>;
+        get(id: string): Promise<import("./localizations").Localization>;
+        update(id: string, body: {
+            content?: Record<string, unknown>;
+            enabled?: boolean;
+        }): Promise<import("./localizations").Localization>;
+        delete(id: string): Promise<void>;
+    };
+    actions: {
+        list(): Promise<import("./types").ListPage<import("./actions").Action>>;
+        create(body: import("./actions").CreateActionBody, idempotencyKey?: string): Promise<import("./actions").Action>;
+        get(id: string): Promise<import("./actions").Action>;
+        update(id: string, body: import("./actions").UpdateActionBody): Promise<import("./actions").Action>;
+        delete(id: string): Promise<{
+            object: "action";
+            id: string;
+            deleted: true;
+        }>;
+        test(id: string, event?: import("./actions").ActionTestEvent): Promise<import("./actions").ActionTestResult>;
+        getBindings(trigger: import("./actions").ActionTrigger): Promise<import("./actions").ActionBindingList>;
+        setBindings(trigger: import("./actions").ActionTrigger, actionIds: string[]): Promise<import("./actions").ActionBindingList>;
+    };
+    billing: {
+        listPlans(): Promise<import("./types").ListPage<import("./billing-plans").BillingPlan>>;
+        createPlan(body: import("./billing-plans").CreateBillingPlanBody, idempotencyKey?: string): Promise<import("./billing-plans").BillingPlan>;
+        getPlan(id: string): Promise<import("./billing-plans").BillingPlan>;
+        updatePlan(id: string, body: import("./billing-plans").UpdateBillingPlanBody): Promise<import("./billing-plans").BillingPlan>;
+        deletePlan(id: string): Promise<{
+            object: "billing_plan";
+            id: string;
+            deleted: true;
+        }>;
+        listSubscriptions(params?: import("./billing-plans").ListSubscriptionsParams): Promise<import("./types").ListPage<import("./billing-plans").BillingSubscription>>;
+    };
+    messaging: {
+        get(): Promise<import("./messaging").MessagingProviders>;
+        setEmail(body: import("./messaging").MessagingProviderInput): Promise<import("./messaging").MessagingProvider>;
+        setSms(body: import("./messaging").MessagingProviderInput): Promise<import("./messaging").MessagingProvider>;
+        deleteChannel(channel: "email" | "sms"): Promise<import("./messaging").DeletedMessagingProvider>;
+        test(channel: "email" | "sms", body: {
+            to: string;
+        }): Promise<import("./messaging").MessagingTestResult>;
+    };
+    importExport: {
+        importUsers(body: import("./import-export").ImportUsersBody, idempotencyKey?: string): Promise<import("./import-export").Job>;
+        exportUsers(idempotencyKey?: string): Promise<import("./import-export").Job>;
+        listJobs(params?: import("./types").CursorParams): Promise<import("./types").CursorPage<import("./import-export").Job>>;
+        getJob(id: string): Promise<import("./import-export").Job>;
+        getJobErrors(id: string): Promise<import("./types").ListPage<import("./import-export").JobError>>;
+    };
+    dataSubjectRequests: {
+        list(params?: import("./data-subject-requests").ListDataSubjectRequestsParams): Promise<import("./types").CursorPage<import("./data-subject-requests").DataSubjectRequest>>;
+        get(id: string): Promise<import("./data-subject-requests").DataSubjectRequest>;
+        fulfill(id: string, idempotencyKey?: string): Promise<import("./data-subject-requests").DataSubjectRequest>;
+        reject(id: string, body?: {
+            reason?: string;
+        }, idempotencyKey?: string): Promise<import("./data-subject-requests").DataSubjectRequest>;
+    };
+    radiusClients: {
+        list(): Promise<import("./types").ListPage<import("./radius-clients").RadiusClient>>;
+        create(body: import("./radius-clients").CreateRadiusClientBody, idempotencyKey?: string): Promise<import("./radius-clients").RadiusClient>;
+        get(id: string): Promise<import("./radius-clients").RadiusClient>;
+        update(id: string, body: import("./radius-clients").UpdateRadiusClientBody): Promise<import("./radius-clients").RadiusClient>;
+        delete(id: string): Promise<{
+            object: "radius_client";
+            id: string;
+            deleted: true;
+        }>;
+    };
+    ltiPlatforms: {
+        list(): Promise<import("./types").ListPage<import("./lti-platforms").LtiPlatform>>;
+        get(id: string): Promise<import("./lti-platforms").LtiPlatform>;
+        create(body: import("./lti-platforms").CreateLtiPlatformBody, idempotencyKey?: string): Promise<import("./lti-platforms").LtiPlatform>;
+        update(id: string, body: import("./lti-platforms").UpdateLtiPlatformBody): Promise<import("./lti-platforms").LtiPlatform>;
+        delete(id: string): Promise<{
+            object: "lti_platform";
+            id: string;
+            deleted: true;
+        }>;
+    };
+    instance: {
+        get(): Promise<import("./instance").Instance>;
+        update(body: import("./instance").UpdateInstanceBody): Promise<import("./instance").InstanceUpdateResult>;
+    };
+    instanceSecurity: {
+        get(): Promise<import("./instance-security").InstanceSecurity>;
+        update(body: import("./instance-security").UpdateInstanceSecurityBody): Promise<import("./instance-security").InstanceSecurityResult>;
+        setCaptchaSecret(body: {
+            secret: string;
+        }): Promise<{
+            object: "captcha_secret";
+            provider: string;
+            set: true;
+        }>;
+        deleteCaptchaSecret(): Promise<{
+            object: "captcha_secret";
+            provider: string;
+            deleted: true;
+        }>;
+        setKerberosSecret(body: {
+            secret: string;
+        }): Promise<{
+            object: "kerberos_secret";
+            set: true;
+        }>;
+        deleteKerberosSecret(): Promise<{
+            object: "kerberos_secret";
+            deleted: true;
+        }>;
+        setLdapBindPassword(connectionId: string, body: {
+            bind_password: string;
+        }): Promise<{
+            object: "ldap_bind_password";
+            connection_id: string;
+            set: true;
+        }>;
+        deleteLdapBindPassword(connectionId: string): Promise<{
+            object: "ldap_bind_password";
+            connection_id: string;
+            deleted: true;
+        }>;
+    };
+    tokens: {
+        verify(body: import("./tokens").VerifyTokenBody): Promise<import("./tokens").TokenVerification>;
+    };
+};
+/** The fully typed client instance `createAtlasClient` returns. */
+export type AtlasClient = ReturnType<typeof createAtlasClient>;
+export type { AtlasClientConfig } from './request';
+export { DEFAULT_API_URL } from './request';
+export { AtlasApiError, type AtlasErrorItem } from './error';
+export { paginate, collect } from './paginate';
+export * from './types';
+export * from './users';
+export * from './sessions';
+export * from './organizations';
+export * from './roles';
+export * from './oauth-clients';
+export * from './resource-servers';
+export * from './sso-connections';
+export * from './scim-tokens';
+export * from './domains';
+export * from './waitlist';
+export * from './restrictions';
+export * from './attack-protection';
+export * from './actor-tokens';
+export * from './invitations';
+export * from './webhooks';
+export * from './sign-in-tokens';
+export * from './audit-logs';
+export * from './jwt-templates';
+export * from './api-keys';
+export * from './oauth-providers';
+export * from './sso-onboarding';
+export * from './scim-provisioning';
+export * from './fga';
+export * from './rate-limit';
+export * from './risk-based-mfa';
+export * from './bot-signals';
+export * from './network-acls';
+export * from './managed-waf';
+export * from './log-streams';
+export * from './branding';
+export * from './email-templates';
+export * from './sms-templates';
+export * from './localizations';
+export * from './actions';
+export * from './billing-plans';
+export * from './messaging';
+export * from './import-export';
+export * from './data-subject-requests';
+export * from './radius-clients';
+export * from './lti-platforms';
+export * from './instance';
+export * from './instance-security';
+export * from './tokens';