import type { AnyOperationDefinition, AnyRecord } from './types.js';
export interface AdminDevice extends AnyRecord {
    id: string;
    name?: string;
    type?: string;
    desiredConfigurationVersion?: string | null;
    state?: {
        agentVersion?: string | null;
        [key: string]: unknown;
    } | null;
}
export interface AdminOrganization extends AnyRecord {
    id: string;
    name?: string;
}
export type AdminCommandTemplate = AnyRecord;
export interface AdminCommandsQueryResponse {
    items: AnyRecord[];
}
export interface AdminItemsResponse {
    items: AnyRecord[];
}
export interface AdminDevicesCreateRequest extends AnyRecord {
    enabled?: boolean;
    name: string;
    tags?: Record<string, string>;
    type?: string;
}
export interface AdminKeyValueSetRequest {
    key: string;
    value: unknown;
}
export interface AdminEvent extends AnyRecord {
    id: string;
}
export interface AdminDevicesQueryRequest extends AnyRecord {
    count?: number;
    deviceIds?: string[];
    enabled?: boolean;
    offset?: number;
    query?: string;
    tags?: Record<string, string[]>;
    type?: string;
}
export interface AdminDevicesQueryResponse {
    items: AdminDevice[];
}
export type AdminEventsQueryRequest = AnyRecord;
export interface AdminSchedulesQueryRequest {
    organizationId: string;
}
export interface AdminDeviceConfigurationResponse extends AnyRecord {
    document?: {
        telemetry?: {
            streams?: Array<{
                name?: string;
                configuration?: AnyRecord;
            }>;
            [key: string]: unknown;
        };
        [key: string]: unknown;
    };
}
export interface AdminDeviceConfigurationTemplate extends AnyRecord {
    document?: Record<string, unknown>;
    id?: string;
    name?: string;
}
export interface AdminDeviceConfigurationUpdateRequest extends AnyRecord {
    deviceId: string;
    document: Record<string, unknown>;
}
export interface AdminDeviceConfigurationUpdateResponse extends AnyRecord {
    version?: number;
}
export type AdminValidateStreamConfigurationRequest = Record<string, unknown>;
export interface AdminKeyValueQueryRequest extends AnyRecord {
    keys?: string[];
    prefix?: string;
}
export interface AdminKeyValueQueryItem {
    key: string;
    value: unknown;
}
export interface AdminKeyValueQueryResponse {
    items: AdminKeyValueQueryItem[];
}
export interface AdminKeyValueListResponse {
    items: string[];
}
export interface AdminViewReorderItem {
    id: string;
    index: number;
}
export interface AdminViewsReorderRequest {
    items: AdminViewReorderItem[];
}
export interface AdminViewUpdateRequest extends AnyRecord {
    index: number;
}
export interface QueryStreamMetadataRequest {
    deviceIds: string[];
    start: string;
}
export interface QueryStreamMetadataItem {
    deviceId: string;
    name: string;
    organizationId: string;
    type: string;
}
export interface QueryStreamMetadataResponse {
    items: QueryStreamMetadataItem[];
}
export type QueryPoint = [number, unknown] | {
    time?: number | string;
    value?: unknown;
};
export interface QueryStreamResult extends AnyRecord {
    deviceId?: string;
    name?: string;
    points?: QueryPoint[];
    type?: string;
}
export interface QueryStreamsRequest extends AnyRecord {
    aggregate?: string;
    deviceIds: string[];
    end: string;
    latestOnly?: boolean;
    limit?: number;
    names: string[];
    start: string;
    types?: string[];
}
export interface QueryStreamsResponse {
    items: QueryStreamResult[];
}
export interface QueryOnlineDevicesResponse {
    items: string[];
}
export interface QueryAnalyticsRowsRequest {
    limit?: number;
    sqlQuery: string;
    type: 'advanced' | 'stream' | 'task';
}
export interface QueryAnalyticsRowColumn {
    dataType: string;
    name: string;
    tableName?: string;
}
export interface QueryAnalyticsRow {
    [key: string]: unknown;
    device_id: string;
    last_seen: string;
    stream_count: number;
    total_points: number;
}
export interface QueryAnalyticsRowsResponse {
    columns?: QueryAnalyticsRowColumn[];
    error?: string;
    rowCount?: number;
    rows: QueryAnalyticsRow[];
    sqlText?: string;
}
export interface QueryAnalyticsTableColumn extends AnyRecord {
    dataType: string;
    description?: string;
    name: string;
}
export interface QueryAnalyticsTable {
    columns: QueryAnalyticsTableColumn[];
    description?: string;
    name: string;
}
export interface QueryAnalyticsTablesResponse {
    items: QueryAnalyticsTable[];
}
export type IngestBatchItemType = 'bitset' | 'health' | 'image' | 'json' | 'numeric' | 'text' | 'video';
export interface IngestBatchItem extends AnyRecord {
    deviceId: string;
    name: string;
    points: Array<[number, unknown]>;
    tags?: Record<string, string>;
    type: IngestBatchItemType;
}
export interface IngestBatchRequest {
    items: IngestBatchItem[];
}
export interface TheopolisCreateSignalRequest extends AnyRecord {
    createdForTaskFlowId?: string;
    deviceId?: string;
    goal: string;
    personaId?: string;
    type: 'manual';
}
export interface TheopolisSignal extends AnyRecord {
    createdAt?: string;
    deviceId?: string;
    eventId?: string;
    goal?: string;
    id: string;
    personaId?: string;
    status?: string;
    type?: string;
}
export interface TheopolisCreateGroundTruthRequest {
    expectedOutcome: string;
    signalId: string;
}
export interface TheopolisEvalGroundTruth extends AnyRecord {
    expectedOutcome?: string;
    id?: string;
    signalId?: string;
}
export interface TheopolisTaskFlowRun extends AnyRecord {
    signalId?: string;
}
export interface TheopolisTaskFlowVersionDeletePathParams extends Record<string, number | string> {
    taskflowId: string;
    version: number;
}
export interface TheopolisTaskFlowGroundTruth {
    expectedOutcome: string;
    id: string;
    signalId: string;
    taskFlowId: string;
}
export interface TheopolisTaskFlowGroundTruthsResponse {
    groundTruths: TheopolisTaskFlowGroundTruth[];
}
export interface TheopolisTaskFlowRunResponse {
    run: TheopolisTaskFlowRun;
    events: unknown[];
}
export interface TheopolisTaskFlowEvalRunsResponse {
    runs: AnyRecord[];
}
export interface TheopolisTaskFlowsListResponse {
    items: AnyRecord[];
}
export interface TheopolisTaskFlowRunsPaginatedResponse {
    runs: AnyRecord[];
    total: number;
}
export interface TheopolisTaskFlowVersionCreateRequest {
    versionLabel?: string;
}
export interface TheopolisTaskFlowVersionsResponse {
    versions: AnyRecord[];
}
export interface TheopolisTaskFlowTriggerRequest {
    input: string;
    signalId?: string;
}
export interface TheopolisSignalsCountRequest {
    endTime?: string;
    startTime?: string;
}
export interface TheopolisSignalsCountResponse {
    counts: Record<string, number>;
}
export interface TheopolisInvestigationsAnalyticsRequest {
    endTime: string;
    groupBy?: 'resultType' | 'signalType';
    interval: 'daily' | 'hourly';
    startTime: string;
}
export interface TheopolisInvestigationsAnalyticsResponse {
    data: AnyRecord[];
}
export interface TheopolisInvestigationsStatsRequest {
    endTime: string;
    startTime: string;
}
export interface TheopolisExecutionLogResponse {
    taskFlowRunId: string;
    taskFlowId: string;
    executionLog: string;
}
export interface TheopolisThreadMessage extends AnyRecord {
    content?: string | null;
    createdAt?: string;
    id?: string;
    isComplete?: boolean | null;
    isPending?: boolean | null;
    role?: string;
    type?: string;
    updatedAt?: string;
}
export interface TheopolisThreadMessagesResponse {
    items: TheopolisThreadMessage[];
}
export interface TheopolisThread extends AnyRecord {
    createdAt?: string;
    currentPersonaId?: string;
    description?: string | null;
    id: string;
    isHidden?: boolean;
    name?: string | null;
    organizationId?: string;
    shared?: boolean;
    updatedAt?: string;
    userId?: string;
}
export interface GatewayAiIntegrationTool {
    description: string;
    enabled: boolean;
    inputSchema: {
        properties: Record<string, {
            description: string;
            type: string;
        }>;
        required: string[];
        type: string;
    };
    name: string;
}
export interface GatewayPersonaIntegration {
    aiIntegrationId: string;
    description?: string;
    enabled?: boolean;
    name?: string;
    tools?: GatewayAiIntegrationTool[];
}
export interface GatewayPersonaDelegation {
    description?: string;
    name?: string;
    personaId: string;
}
export interface GatewayOrgPersona extends AnyRecord {
    aiModel?: string;
    builtIn?: boolean;
    description?: string | null;
    enabled: boolean;
    name: string | null;
    personaId: string;
}
export interface GatewayPersonasOrgResponse {
    items: GatewayOrgPersona[];
}
export interface GatewayUserPersonaResponse extends AnyRecord {
    aiModel?: string;
    auxInstructions: string | null;
    builtIn?: boolean;
    createdAt: string;
    delegations: GatewayPersonaDelegation[] | null;
    description?: string | null;
    enableDynamicToolLoading?: boolean;
    enabled: boolean;
    instructions: string | null;
    integrations: GatewayPersonaIntegration[] | null;
    name: string | null;
    organizationId: string | null;
    personaId: string;
    updatedAt: string;
}
export interface TheopolisCreateTaskRequest extends AnyRecord {
    goal: string;
    guardrails: string;
    meaningfulness: string;
    name: string;
    personaId: string;
}
export interface TheopolisTask extends AnyRecord {
    createdAt: string;
    goal: string;
    id: string;
    name: string;
    personaId: string;
}
export interface TheopolisTaskRunQueueResponse extends AnyRecord {
    id?: string;
}
export interface TheopolisTaskRun extends AnyRecord {
    createdAt: string;
    goal: string;
    id: string;
    metadata: Record<string, unknown>;
    result: string;
    status: string;
    taskId: string;
    threadId: string | null;
    title: string | null;
    tldr: string | null;
    updatedAt: string;
}
export interface TheopolisTaskRunsResponse {
    items: TheopolisTaskRun[];
}
export interface TheopolisThreadCreateRequest extends AnyRecord {
    currentPersonaId: string;
    description: string;
    isHidden: boolean;
    name: string;
}
export interface TheopolisThreadUpdateRequest extends AnyRecord {
    currentPersonaId: string;
}
export interface TheopolisSignalsResponse {
    items: TheopolisSignal[];
}
export interface TheopolisSignalsQueryRequest extends AnyRecord {
    endTime?: string;
    startTime: string;
    type?: 'eventTrigger' | 'manual' | 'schedule' | 'slack';
}
export declare const operations: {
    readonly admin: {
        readonly annotationTemplatesList: import("./types.js").OperationDefinition<"admin.annotation-templates.list", undefined, undefined, AdminItemsResponse>;
        readonly annotationTemplatesCreate: import("./types.js").OperationDefinition<"admin.annotation-templates.create", undefined, AnyRecord, AnyRecord>;
        readonly annotationTemplatesGet: import("./types.js").OperationDefinition<"admin.annotation-templates.get", {
            annotationTemplateId: string;
        }, undefined, AnyRecord>;
        readonly annotationTemplatesUpdate: import("./types.js").OperationDefinition<"admin.annotation-templates.update", {
            annotationTemplateId: string;
        }, AnyRecord, AnyRecord>;
        readonly annotationTemplatesDelete: import("./types.js").OperationDefinition<"admin.annotation-templates.delete", {
            annotationTemplateId: string;
        }, undefined, undefined>;
        readonly deviceConfigurationTemplatesGet: import("./types.js").OperationDefinition<"admin.device-configuration-templates.get", {
            templateId: string;
        }, undefined, AdminDeviceConfigurationTemplate>;
        readonly deviceConfigurationTemplatesList: import("./types.js").OperationDefinition<"admin.device-configuration-templates.list", undefined, undefined, AdminItemsResponse>;
        readonly deviceConfigurationTemplatesCreate: import("./types.js").OperationDefinition<"admin.device-configuration-templates.create", undefined, AnyRecord, AnyRecord>;
        readonly deviceConfigurationTemplatesUpdate: import("./types.js").OperationDefinition<"admin.device-configuration-templates.update", {
            templateId: string;
        }, AnyRecord, AnyRecord>;
        readonly deviceConfigurationTemplatesDelete: import("./types.js").OperationDefinition<"admin.device-configuration-templates.delete", {
            templateId: string;
        }, undefined, unknown>;
        readonly devicesGet: import("./types.js").OperationDefinition<"admin.devices.get", {
            deviceId: string;
        }, undefined, AdminDevice>;
        readonly devicesGetConfigurationByVersion: import("./types.js").OperationDefinition<"admin.devices.configurations.getByVersion", {
            configurationVersion: string;
            deviceId: string;
        }, undefined, AdminDeviceConfigurationResponse>;
        readonly devicesQuery: import("./types.js").OperationDefinition<"admin.devices.query", undefined, AdminDevicesQueryRequest, AdminDevicesQueryResponse>;
        readonly devicesCreate: import("./types.js").OperationDefinition<"admin.devices.create", undefined, AdminDevicesCreateRequest, AdminDevice>;
        readonly devicesUpdate: import("./types.js").OperationDefinition<"admin.devices.update", {
            deviceId: string;
        }, AnyRecord, AdminDevice>;
        readonly devicesCommandsList: import("./types.js").OperationDefinition<"admin.devices.commands.list", {
            deviceId: string;
        }, undefined, AdminItemsResponse>;
        readonly devicesConfigurationUpdate: import("./types.js").OperationDefinition<"admin.devices.configuration.update", {
            deviceId: string;
        }, AdminDeviceConfigurationUpdateRequest, AdminDeviceConfigurationUpdateResponse>;
        readonly devicesValidateStreamConfiguration: import("./types.js").OperationDefinition<"admin.devices.validate-stream-configuration", undefined, AdminValidateStreamConfigurationRequest, unknown>;
        readonly eventsGet: import("./types.js").OperationDefinition<"admin.events.get", {
            eventId: string;
        }, undefined, AdminEvent>;
        readonly eventsQuery: import("./types.js").OperationDefinition<"admin.events.query", undefined, AnyRecord, AdminItemsResponse>;
        readonly eventTriggersGet: import("./types.js").OperationDefinition<"admin.event-triggers.get", {
            eventTriggerId: string;
        }, undefined, AnyRecord>;
        readonly eventTriggerGroupsList: import("./types.js").OperationDefinition<"admin.event-trigger-groups.list", undefined, undefined, AdminItemsResponse>;
        readonly eventTriggerGroupsCreate: import("./types.js").OperationDefinition<"admin.event-trigger-groups.create", undefined, AnyRecord, AnyRecord>;
        readonly eventTriggerGroupsGet: import("./types.js").OperationDefinition<"admin.event-trigger-groups.get", {
            eventTriggerGroupId: string;
        }, undefined, AnyRecord>;
        readonly eventTriggerGroupsUpdate: import("./types.js").OperationDefinition<"admin.event-trigger-groups.update", {
            eventTriggerGroupId: string;
        }, AnyRecord, AnyRecord>;
        readonly eventTriggersList: import("./types.js").OperationDefinition<"admin.event-triggers.list", undefined, undefined, AdminItemsResponse>;
        readonly eventTriggersCreate: import("./types.js").OperationDefinition<"admin.event-triggers.create", undefined, AnyRecord, AnyRecord>;
        readonly eventTriggersUpdate: import("./types.js").OperationDefinition<"admin.event-triggers.update", {
            eventTriggerId: string;
        }, AnyRecord, AnyRecord>;
        readonly groupsList: import("./types.js").OperationDefinition<"admin.groups.list", undefined, undefined, AdminItemsResponse>;
        readonly groupsCreate: import("./types.js").OperationDefinition<"admin.groups.create", undefined, AnyRecord, AnyRecord>;
        readonly groupsGet: import("./types.js").OperationDefinition<"admin.groups.get", {
            groupId: string;
        }, undefined, AnyRecord>;
        readonly groupsUpdate: import("./types.js").OperationDefinition<"admin.groups.update", {
            groupId: string;
        }, AnyRecord, AnyRecord>;
        readonly groupsDelete: import("./types.js").OperationDefinition<"admin.groups.delete", {
            groupId: string;
        }, undefined, unknown>;
        readonly channelsList: import("./types.js").OperationDefinition<"admin.channels.list", undefined, undefined, AdminItemsResponse>;
        readonly channelsCreate: import("./types.js").OperationDefinition<"admin.channels.create", undefined, AnyRecord, AnyRecord>;
        readonly channelsGet: import("./types.js").OperationDefinition<"admin.channels.get", {
            channelId: string;
        }, undefined, AnyRecord>;
        readonly channelsUpdate: import("./types.js").OperationDefinition<"admin.channels.update", {
            channelId: string;
        }, AnyRecord, AnyRecord>;
        readonly channelsDelete: import("./types.js").OperationDefinition<"admin.channels.delete", {
            channelId: string;
        }, undefined, unknown>;
        readonly commandTemplatesList: import("./types.js").OperationDefinition<"admin.command-templates.list", undefined, undefined, AdminItemsResponse>;
        readonly commandTemplatesCreate: import("./types.js").OperationDefinition<"admin.command-templates.create", undefined, AnyRecord, AnyRecord>;
        readonly commandTemplatesGet: import("./types.js").OperationDefinition<"admin.command-templates.get", {
            commandTemplateId: string;
        }, undefined, AnyRecord>;
        readonly commandTemplatesUpdate: import("./types.js").OperationDefinition<"admin.command-templates.update", {
            commandTemplateId: string;
        }, AnyRecord, AnyRecord>;
        readonly commandTemplatesDelete: import("./types.js").OperationDefinition<"admin.command-templates.delete", {
            commandTemplateId: string;
        }, undefined, unknown>;
        readonly commandsCreate: import("./types.js").OperationDefinition<"admin.commands.create", undefined, AnyRecord, AnyRecord>;
        readonly commandsQuery: import("./types.js").OperationDefinition<"admin.commands.query", undefined, AnyRecord, AdminCommandsQueryResponse>;
        readonly keyValueGet: import("./types.js").OperationDefinition<"admin.key-value.get", {
            key: string;
        }, undefined, AnyRecord>;
        readonly keyValueSet: import("./types.js").OperationDefinition<"admin.key-value.set", undefined, AdminKeyValueSetRequest, AnyRecord>;
        readonly keyValueDelete: import("./types.js").OperationDefinition<"admin.key-value.delete", {
            key: string;
        }, undefined, undefined>;
        readonly keyValueList: import("./types.js").OperationDefinition<"admin.key-value.list", undefined, undefined, AdminKeyValueListResponse>;
        readonly keyValueQuery: import("./types.js").OperationDefinition<"admin.key-value.query", undefined, AdminKeyValueQueryRequest, AdminKeyValueQueryResponse>;
        readonly modulesList: import("./types.js").OperationDefinition<"admin.modules.list", undefined, undefined, AdminItemsResponse>;
        readonly modulesCreate: import("./types.js").OperationDefinition<"admin.modules.create", undefined, AnyRecord, AnyRecord>;
        readonly modulesGet: import("./types.js").OperationDefinition<"admin.modules.get", {
            moduleId: string;
        }, undefined, AnyRecord>;
        readonly modulesUpdate: import("./types.js").OperationDefinition<"admin.modules.update", {
            moduleId: string;
        }, AnyRecord, AnyRecord>;
        readonly modulesDelete: import("./types.js").OperationDefinition<"admin.modules.delete", {
            moduleId: string;
        }, undefined, unknown>;
        readonly moduleConfigurationsList: import("./types.js").OperationDefinition<"admin.module-configurations.list", undefined, undefined, AdminItemsResponse>;
        readonly moduleConfigurationsCreate: import("./types.js").OperationDefinition<"admin.module-configurations.create", undefined, AnyRecord, AnyRecord>;
        readonly moduleConfigurationsGet: import("./types.js").OperationDefinition<"admin.module-configurations.get", {
            moduleConfigurationId: string;
        }, undefined, AnyRecord>;
        readonly moduleConfigurationsUpdate: import("./types.js").OperationDefinition<"admin.module-configurations.update", {
            moduleConfigurationId: string;
        }, AnyRecord, AnyRecord>;
        readonly moduleConfigurationsDelete: import("./types.js").OperationDefinition<"admin.module-configurations.delete", {
            moduleConfigurationId: string;
        }, undefined, unknown>;
        readonly organizationsGet: import("./types.js").OperationDefinition<"admin.organizations.get", {
            organizationId: string;
        }, undefined, AdminOrganization>;
        readonly schedulesCreate: import("./types.js").OperationDefinition<"admin.schedules.create", undefined, AnyRecord, AnyRecord>;
        readonly schedulesGet: import("./types.js").OperationDefinition<"admin.schedules.get", {
            scheduleId: string;
        }, undefined, AnyRecord>;
        readonly schedulesUpdate: import("./types.js").OperationDefinition<"admin.schedules.update", {
            scheduleId: string;
        }, AnyRecord, AnyRecord>;
        readonly schedulesDelete: import("./types.js").OperationDefinition<"admin.schedules.delete", {
            scheduleId: string;
        }, undefined, unknown>;
        readonly schedulesQuery: import("./types.js").OperationDefinition<"admin.schedules.query", undefined, AdminSchedulesQueryRequest, AdminItemsResponse>;
        readonly teamsList: import("./types.js").OperationDefinition<"admin.teams.list", undefined, undefined, AdminItemsResponse>;
        readonly teamsCreate: import("./types.js").OperationDefinition<"admin.teams.create", undefined, AnyRecord, AnyRecord>;
        readonly teamsGet: import("./types.js").OperationDefinition<"admin.teams.get", {
            teamId: string;
        }, undefined, AnyRecord>;
        readonly teamsUpdate: import("./types.js").OperationDefinition<"admin.teams.update", {
            teamId: string;
        }, AnyRecord, AnyRecord>;
        readonly teamsDelete: import("./types.js").OperationDefinition<"admin.teams.delete", {
            teamId: string;
        }, undefined, unknown>;
        readonly rolesList: import("./types.js").OperationDefinition<"admin.roles.list", undefined, undefined, AdminItemsResponse>;
        readonly rolesCreate: import("./types.js").OperationDefinition<"admin.roles.create", undefined, AnyRecord, AnyRecord>;
        readonly rolesGet: import("./types.js").OperationDefinition<"admin.roles.get", {
            roleId: string;
        }, undefined, AnyRecord>;
        readonly rolesUpdate: import("./types.js").OperationDefinition<"admin.roles.update", {
            roleId: string;
        }, AnyRecord, AnyRecord>;
        readonly rolesDelete: import("./types.js").OperationDefinition<"admin.roles.delete", {
            roleId: string;
        }, undefined, unknown>;
        readonly streamsList: import("./types.js").OperationDefinition<"admin.streams.list", undefined, undefined, AdminItemsResponse>;
        readonly streamsCreate: import("./types.js").OperationDefinition<"admin.streams.create", undefined, AnyRecord, AnyRecord>;
        readonly streamsGet: import("./types.js").OperationDefinition<"admin.streams.get", {
            streamId: string;
        }, undefined, AnyRecord>;
        readonly streamsUpdate: import("./types.js").OperationDefinition<"admin.streams.update", {
            streamId: string;
        }, AnyRecord, AnyRecord>;
        readonly streamsDelete: import("./types.js").OperationDefinition<"admin.streams.delete", {
            streamId: string;
        }, undefined, unknown>;
        readonly tagTemplatesList: import("./types.js").OperationDefinition<"admin.tag-templates.list", undefined, undefined, AdminItemsResponse>;
        readonly tagTemplatesCreate: import("./types.js").OperationDefinition<"admin.tag-templates.create", undefined, AnyRecord, AnyRecord>;
        readonly tagTemplatesGet: import("./types.js").OperationDefinition<"admin.tag-templates.get", {
            tagTemplateId: string;
        }, undefined, AnyRecord>;
        readonly tagTemplatesUpdate: import("./types.js").OperationDefinition<"admin.tag-templates.update", {
            tagTemplateId: string;
        }, AnyRecord, AnyRecord>;
        readonly tagTemplatesDelete: import("./types.js").OperationDefinition<"admin.tag-templates.delete", {
            tagTemplateId: string;
        }, undefined, unknown>;
        readonly teleopViewsList: import("./types.js").OperationDefinition<"admin.teleop-views.list", undefined, undefined, AdminItemsResponse>;
        readonly teleopViewsCreate: import("./types.js").OperationDefinition<"admin.teleop-views.create", undefined, AnyRecord, AnyRecord>;
        readonly teleopViewsGet: import("./types.js").OperationDefinition<"admin.teleop-views.get", {
            teleopViewId: string;
        }, undefined, AnyRecord>;
        readonly teleopViewsUpdate: import("./types.js").OperationDefinition<"admin.teleop-views.update", {
            teleopViewId: string;
        }, AnyRecord, AnyRecord>;
        readonly teleopViewsDelete: import("./types.js").OperationDefinition<"admin.teleop-views.delete", {
            teleopViewId: string;
        }, undefined, unknown>;
        readonly usersList: import("./types.js").OperationDefinition<"admin.users.list", undefined, undefined, AdminItemsResponse>;
        readonly usersGet: import("./types.js").OperationDefinition<"admin.users.get", {
            userId: string;
        }, undefined, AnyRecord>;
        readonly viewsCreate: import("./types.js").OperationDefinition<"admin.views.create", undefined, AnyRecord, AnyRecord>;
        readonly viewsList: import("./types.js").OperationDefinition<"admin.views.list", undefined, undefined, AdminItemsResponse>;
        readonly viewsGet: import("./types.js").OperationDefinition<"admin.views.get", {
            viewId: string;
        }, undefined, AnyRecord>;
        readonly viewsReorder: import("./types.js").OperationDefinition<"admin.views.reorder", undefined, AdminViewsReorderRequest, unknown>;
        readonly viewsDelete: import("./types.js").OperationDefinition<"admin.views.delete", {
            viewId: string;
        }, undefined, unknown>;
        readonly viewsUpdate: import("./types.js").OperationDefinition<"admin.views.update", {
            viewId: string;
        }, AdminViewUpdateRequest, unknown>;
    };
    readonly query: {
        readonly analyticsTablesList: import("./types.js").OperationDefinition<"query.analytics.tables.list", undefined, undefined, QueryAnalyticsTablesResponse>;
        readonly analyticsRows: import("./types.js").OperationDefinition<"query.analytics.rows", undefined, QueryAnalyticsRowsRequest, QueryAnalyticsRowsResponse>;
        readonly metadataSearch: import("./types.js").OperationDefinition<"query.metadata.search", undefined, QueryStreamMetadataRequest, QueryStreamMetadataResponse>;
        readonly onlineDevicesList: import("./types.js").OperationDefinition<"query.online-devices.list", undefined, undefined, QueryOnlineDevicesResponse>;
        readonly streamDataQuery: import("./types.js").OperationDefinition<"query.stream-data.query", undefined, QueryStreamsRequest, QueryStreamsResponse>;
    };
    readonly gateway: {
        readonly personasOrgList: import("./types.js").OperationDefinition<"gateway.personas.org.list", undefined, undefined, GatewayPersonasOrgResponse>;
        readonly personasUserGet: import("./types.js").OperationDefinition<"gateway.personas.user.get", {
            personaId: string;
        }, undefined, GatewayUserPersonaResponse>;
    };
    readonly ingest: {
        readonly batchCreate: import("./types.js").OperationDefinition<"ingest.batch.create", undefined, IngestBatchRequest, undefined>;
    };
    readonly theopolis: {
        readonly tasksCreate: import("./types.js").OperationDefinition<"theopolis.tasks.create", undefined, TheopolisCreateTaskRequest, TheopolisTask>;
        readonly tasksResultsList: import("./types.js").OperationDefinition<"theopolis.tasks.results.list", {
            taskId: string;
        }, undefined, TheopolisTaskRunsResponse>;
        readonly tasksRunsQueue: import("./types.js").OperationDefinition<"theopolis.tasks.runs.queue", {
            taskId: string;
        }, Record<string, never>, TheopolisTaskRunQueueResponse>;
        readonly threadsCreate: import("./types.js").OperationDefinition<"theopolis.threads.create", undefined, TheopolisThreadCreateRequest, TheopolisThread>;
        readonly signalsCreate: import("./types.js").OperationDefinition<"theopolis.signals.create", undefined, TheopolisCreateSignalRequest, TheopolisSignal>;
        readonly signalsList: import("./types.js").OperationDefinition<"theopolis.signals.list", undefined, undefined, TheopolisSignalsResponse>;
        readonly signalsGet: import("./types.js").OperationDefinition<"theopolis.signals.get", {
            signalId: string;
        }, undefined, TheopolisSignal>;
        readonly signalsQuery: import("./types.js").OperationDefinition<"theopolis.signals.query", undefined, TheopolisSignalsQueryRequest, TheopolisSignalsResponse>;
        readonly signalsCount: import("./types.js").OperationDefinition<"theopolis.signals.count", undefined, TheopolisSignalsCountRequest, TheopolisSignalsCountResponse>;
        readonly taskFlowRunExecutionLogGet: import("./types.js").OperationDefinition<"theopolis.taskflows.runs.execution-log.get", {
            runId: string;
            taskflowId: string;
        }, undefined, TheopolisExecutionLogResponse>;
        readonly taskFlowRunGet: import("./types.js").OperationDefinition<"theopolis.taskflows.runs.get", {
            runId: string;
            taskflowId: string;
        }, undefined, TheopolisTaskFlowRunResponse>;
        readonly taskFlowEvalRunsList: import("./types.js").OperationDefinition<"theopolis.taskflows.eval.runs.list", {
            taskflowId: string;
        }, undefined, TheopolisTaskFlowEvalRunsResponse>;
        readonly taskFlowSignalGroundTruthCreate: import("./types.js").OperationDefinition<"theopolis.taskflows.eval.ground-truths.create", {
            taskflowId: string;
        }, TheopolisCreateGroundTruthRequest, TheopolisEvalGroundTruth>;
        readonly taskFlowSignalGroundTruthsList: import("./types.js").OperationDefinition<"theopolis.taskflows.eval.ground-truths.list", {
            taskflowId: string;
        }, undefined, TheopolisTaskFlowGroundTruthsResponse>;
        readonly taskFlowVersionDelete: import("./types.js").OperationDefinition<"theopolis.taskflows.versions.delete", TheopolisTaskFlowVersionDeletePathParams, undefined, undefined>;
        readonly taskFlowsList: import("./types.js").OperationDefinition<"theopolis.taskflows.list", undefined, undefined, TheopolisTaskFlowsListResponse>;
        readonly taskFlowsGet: import("./types.js").OperationDefinition<"theopolis.taskflows.get", {
            taskflowId: string;
        }, undefined, AnyRecord>;
        readonly taskFlowsTrigger: import("./types.js").OperationDefinition<"theopolis.taskflows.trigger", {
            taskflowId: string;
        }, TheopolisTaskFlowTriggerRequest, AnyRecord>;
        readonly taskFlowsRunsPaginatedGet: import("./types.js").OperationDefinition<"theopolis.taskflows.runs.paginated.get", {
            taskflowId: string;
        }, undefined, TheopolisTaskFlowRunsPaginatedResponse>;
        readonly taskFlowsVersionsList: import("./types.js").OperationDefinition<"theopolis.taskflows.versions.list", {
            taskflowId: string;
        }, undefined, TheopolisTaskFlowVersionsResponse>;
        readonly taskFlowsVersionsGet: import("./types.js").OperationDefinition<"theopolis.taskflows.versions.get", {
            taskflowId: string;
            version: number;
        }, undefined, AnyRecord>;
        readonly taskFlowsVersionsCreate: import("./types.js").OperationDefinition<"theopolis.taskflows.versions.create", {
            taskflowId: string;
        }, TheopolisTaskFlowVersionCreateRequest, AnyRecord>;
        readonly taskFlowsVersionsRestore: import("./types.js").OperationDefinition<"theopolis.taskflows.versions.restore", {
            taskflowId: string;
            version: number;
        }, Record<string, never>, AnyRecord>;
        readonly investigationsAnalytics: import("./types.js").OperationDefinition<"theopolis.investigations.analytics", undefined, TheopolisInvestigationsAnalyticsRequest, TheopolisInvestigationsAnalyticsResponse>;
        readonly investigationsStats: import("./types.js").OperationDefinition<"theopolis.investigations.stats", undefined, TheopolisInvestigationsStatsRequest, AnyRecord>;
        readonly threadsGet: import("./types.js").OperationDefinition<"theopolis.threads.get", {
            threadId: string;
        }, undefined, TheopolisThread>;
        readonly threadsMessagesList: import("./types.js").OperationDefinition<"theopolis.threads.messages.list", {
            threadId: string;
        }, undefined, TheopolisThreadMessagesResponse>;
        readonly threadsUpdate: import("./types.js").OperationDefinition<"theopolis.threads.update", {
            threadId: string;
        }, TheopolisThreadUpdateRequest, TheopolisThread>;
    };
};
export type KnownOperation = AnyOperationDefinition;
export declare function listKnownOperations(): KnownOperation[];
export declare function getKnownOperationById(id: string): KnownOperation | undefined;