import { Realm } from './realm/client.js';
import type { RealmServiceArgs, RealmServiceResult } from './realm/generated/type-helpers.js';
import { Runtime } from './runtime/runtime.js';
import type { ListConnectorsRequest, ListConnectorsResponse } from './runtime/generated/runtime/v1/connector.js';
import type { RuntimeCallOptions } from './runtime/types.js';
import type { WorldEvolutionCheckpointReadResult, WorldEvolutionCheckpointSelector, WorldEvolutionCommitRequestReadResult, WorldEvolutionCommitRequestSelector, WorldEvolutionExecutionEventReadResult, WorldEvolutionExecutionEventSelector, WorldEvolutionReplayReadResult, WorldEvolutionReplaySelector, WorldEvolutionSupervisionReadResult, WorldEvolutionSupervisionSelector } from './runtime/world-evolution-selector-read.js';
import { type PlatformWorldGovernanceDomain } from './platform-client-world-governance.js';
import type { PlatformClientInput } from './platform-client-types.js';
export type { PlatformAuthSessionStore, PlatformClientInput } from './platform-client-types.js';
type RealmServices = Realm['services'];
type RuntimeConnectorModule = Runtime['connector'];
type RuntimeAuditModule = Runtime['audit'];
type ListConnectorsInput = ListConnectorsRequest;
type AuthPasswordLoginBody = RealmServiceArgs<'AuthService', 'passwordLogin'>[0];
type AuthPasswordLoginInput = {
    identifier?: string;
    email?: string;
    password: AuthPasswordLoginBody['password'];
};
type AuthPasswordLoginResult = RealmServiceResult<'AuthService', 'passwordLogin'>;
type ListMyFriendsResult = RealmServiceResult<'MeService', 'listMyFriendsWithDetails'>;
type CreateImageDirectUploadResult = RealmServiceResult<'ResourcesService', 'createImageDirectUpload'>;
type CreateVideoDirectUploadResult = RealmServiceResult<'ResourcesService', 'createVideoDirectUpload'>;
type RequireSignedUrlsInput = {
    requireSignedUrls?: string | boolean;
};
type PlatformDomains = {
    auth: {
        checkEmail: RealmServices['AuthService']['checkEmail'];
        passwordLogin: (input: AuthPasswordLoginInput) => Promise<AuthPasswordLoginResult>;
        oauthLogin: RealmServices['AuthService']['oauthLogin'];
        requestEmailOtp: RealmServices['AuthService']['requestEmailOtp'];
        verifyEmailOtp: RealmServices['AuthService']['verifyEmailOtp'];
        verifyTwoFactor: RealmServices['AuthService']['verifyTwoFactor'];
        walletChallenge: RealmServices['AuthService']['walletChallenge'];
        walletLogin: RealmServices['AuthService']['walletLogin'];
        updatePassword: RealmServices['AuthService']['updatePassword'];
        getCurrentUser: RealmServices['MeService']['getMe'];
    };
    me: {
        getCurrentUser: RealmServices['MeService']['getMe'];
        listMyRealmAgents: RealmServices['MeService']['listMyRealmAgents'];
        getMyRealmAgent: RealmServices['MeService']['getMyRealmAgent'];
    };
    social: {
        startChat: RealmServices['HumanChatsService']['startChat'];
        listMessages: RealmServices['HumanChatsService']['listMessages'];
        markChatRead: RealmServices['HumanChatsService']['markChatRead'];
        sendMessage: RealmServices['HumanChatsService']['sendMessage'];
        listFriends: (limit?: number, cursor?: string) => Promise<ListMyFriendsResult>;
    };
    world: {
        getWorldTruth: RealmServices['WorldsService']['worldControllerGetWorld'];
        getWorldviewTruth: RealmServices['WorldsService']['worldControllerGetWorldview'];
        listWorlds: RealmServices['WorldsService']['worldControllerListWorlds'];
        getWorld: RealmServices['WorldsService']['worldControllerGetWorld'];
        getWorldview: RealmServices['WorldsService']['worldControllerGetWorldview'];
        getWorldDetailWithAgents: RealmServices['WorldsService']['worldControllerGetWorldDetailWithAgents'];
        getWorldState: RealmServices['WorldControlService']['worldControlControllerGetState'];
        commitWorldState: RealmServices['WorldControlService']['worldControlControllerCommitState'];
        listWorldHistory: RealmServices['WorldControlService']['worldControlControllerListWorldHistory'];
        appendWorldHistory: RealmServices['WorldControlService']['worldControlControllerAppendWorldHistory'];
        listMyWorlds: RealmServices['WorldControlService']['worldControlControllerListMyWorlds'];
        listWorldLorebooks: RealmServices['WorldsService']['worldControllerGetWorldLorebooks'];
        listWorldBindings: RealmServices['WorldsService']['worldControllerGetWorldBindings'];
        getWorldHistory: RealmServices['WorldsService']['worldControllerGetWorldHistory'];
        listWorldLevelAudits: RealmServices['WorldsService']['worldControllerGetWorldLevelAudits'];
    };
    worldGovernance: PlatformWorldGovernanceDomain;
    creator: {
        listAgents: RealmServices['CreatorService']['creatorControllerListAgents'];
        getAgent: RealmServices['CreatorService']['creatorControllerGetAgent'];
        createAgent: RealmServices['CreatorService']['creatorControllerCreateAgent'];
        updateAgent: RealmServices['CreatorService']['creatorControllerUpdateAgent'];
        batchCreateAgents: RealmServices['CreatorService']['creatorControllerBatchCreateAgents'];
    };
    resources: {
        createImageDirectUpload: (input?: RequireSignedUrlsInput) => Promise<CreateImageDirectUploadResult>;
        createVideoDirectUpload: (input?: RequireSignedUrlsInput) => Promise<CreateVideoDirectUploadResult>;
        createAudioDirectUpload: RealmServices['ResourcesService']['createAudioDirectUpload'];
        finalizeResource: RealmServices['ResourcesService']['finalizeResource'];
        getResource: RealmServices['ResourcesService']['getResource'];
        createPost: RealmServices['PostsService']['createPost'];
    };
    runtimeAdmin: {
        listProviderCatalog: RuntimeConnectorModule['listProviderCatalog'];
        listConnectors: (input?: Partial<ListConnectorsInput>, options?: RuntimeCallOptions) => Promise<ListConnectorsResponse>;
        createConnector: RuntimeConnectorModule['createConnector'];
        updateConnector: RuntimeConnectorModule['updateConnector'];
        deleteConnector: RuntimeConnectorModule['deleteConnector'];
        testConnector: RuntimeConnectorModule['testConnector'];
        listConnectorModels: RuntimeConnectorModule['listConnectorModels'];
        listModelCatalogProviders: RuntimeConnectorModule['listModelCatalogProviders'];
        listCatalogProviderModels: RuntimeConnectorModule['listCatalogProviderModels'];
        getCatalogModelDetail: RuntimeConnectorModule['getCatalogModelDetail'];
        upsertModelCatalogProvider: RuntimeConnectorModule['upsertModelCatalogProvider'];
        deleteModelCatalogProvider: RuntimeConnectorModule['deleteModelCatalogProvider'];
        upsertCatalogModelOverlay: RuntimeConnectorModule['upsertCatalogModelOverlay'];
        deleteCatalogModelOverlay: RuntimeConnectorModule['deleteCatalogModelOverlay'];
        listAuditEvents: RuntimeAuditModule['listAuditEvents'];
        exportAuditEvents: RuntimeAuditModule['exportAuditEvents'];
        listUsageStats: RuntimeAuditModule['listUsageStats'];
        getRuntimeHealth: RuntimeAuditModule['getRuntimeHealth'];
        listAIProviderHealth: RuntimeAuditModule['listAIProviderHealth'];
        healthEvents: Runtime['healthEvents'];
        providerHealthEvents: Runtime['providerHealthEvents'];
    };
    publicContent: {
        getPublicPost: RealmServices['PostsService']['getPublicPost'];
    };
};
type PlatformWorldEvolution = {
    executionEvents: {
        read: (selector: WorldEvolutionExecutionEventSelector) => Promise<WorldEvolutionExecutionEventReadResult>;
    };
    replays: {
        read: (selector: WorldEvolutionReplaySelector) => Promise<WorldEvolutionReplayReadResult>;
    };
    checkpoints: {
        read: (selector: WorldEvolutionCheckpointSelector) => Promise<WorldEvolutionCheckpointReadResult>;
    };
    supervision: {
        read: (selector: WorldEvolutionSupervisionSelector) => Promise<WorldEvolutionSupervisionReadResult>;
    };
    commitRequests: {
        read: (selector: WorldEvolutionCommitRequestSelector) => Promise<WorldEvolutionCommitRequestReadResult>;
    };
};
export type PlatformClient = {
    runtime: Runtime;
    realm: Realm;
    domains: PlatformDomains;
    worldEvolution: PlatformWorldEvolution;
};
export declare function createPlatformClient(input: PlatformClientInput): Promise<PlatformClient>;
export declare function createLocalFirstPartyRuntimePlatformClient(input: Omit<PlatformClientInput, 'authMode' | 'accessToken' | 'accessTokenProvider' | 'refreshTokenProvider' | 'subjectUserIdProvider' | 'sessionStore' | 'runtimeAppSession' | 'allowAnonymousRealm'>): Promise<PlatformClient>;
export declare function getPlatformClient(): PlatformClient;
export declare function clearPlatformClient(): void;
export declare function unstable_attachPlatformWorldEvolutionSelectorReadProvider(client: PlatformClient, provider: unknown): void;
//# sourceMappingURL=platform-client.d.ts.map