Interface components

interface components {
    headers: never;
    parameters: never;
    pathItems: never;
    requestBodies: never;
    responses: never;
    schemas: {
        AllowedFunctionsResponse: {
            endpoint_id: string;
            functions?: string[];
            restricted: boolean;
        };
        BatchStatusRequest: { task_ids: string[] };
        BatchStatusResponse: {
            response: string;
            results: {
                [key: string]: {
                    completion_t?: string;
                    exception?: string;
                    reason?: string;
                    result?: string;
                    status?: unknown;
                    task_id: string;
                };
            };
        };
        BatchStatusResponseResults: {
            completion_t?: string;
            exception?: string;
            reason?: string;
            result?: string;
            status?: unknown;
            task_id: string;
        };
        BatchSubmitResponseTask: {
            http_status_code: number;
            reason?: string;
            status: string;
            task_uuid: string;
        };
        BuildStatus: | "provided"
        | "submitted"
        | "initialized"
        | "queued"
        | "building"
        | "ready"
        | "failed";
        ConsoleNodeInfo: {
            endpoint_version?: string;
            idle_duration_seconds?: number;
            python_version?: string;
            sdk_version?: string;
            total_worker_count?: number;
        };
        ConsoleResponse: {
            user_endpoints: {
                account?: string;
                active: boolean;
                client_sdk_versions?: string[];
                config?: string;
                endpoint_version?: string;
                engine_type?: string;
                executed_task_count?: number;
                idle_worker_count?: number;
                last_heartbeat_unix?: number;
                node_info?: {
                    [key: string]: {
                        endpoint_version?: string;
                        idle_duration_seconds?: number;
                        python_version?: string;
                        sdk_version?: string;
                        total_worker_count?: number;
                    }[];
                };
                posix_pid?: number;
                posix_username?: string;
                provider_type?: string;
                python_version?: string;
                queue?: string;
                queued_task_count?: number;
                running_task_count?: number;
                start_time_iso?: string;
                start_time_unix?: number;
                total_node_count?: number;
                total_worker_count?: number;
                user_endpoint_id: string;
            }[];
        };
        ConsoleUserEndpointInfo: {
            account?: string;
            active: boolean;
            client_sdk_versions?: string[];
            config?: string;
            endpoint_version?: string;
            engine_type?: string;
            executed_task_count?: number;
            idle_worker_count?: number;
            last_heartbeat_unix?: number;
            node_info?: {
                [key: string]: {
                    endpoint_version?: string;
                    idle_duration_seconds?: number;
                    python_version?: string;
                    sdk_version?: string;
                    total_worker_count?: number;
                }[];
            };
            posix_pid?: number;
            posix_username?: string;
            provider_type?: string;
            python_version?: string;
            queue?: string;
            queued_task_count?: number;
            running_task_count?: number;
            start_time_iso?: string;
            start_time_unix?: number;
            total_node_count?: number;
            total_worker_count?: number;
            user_endpoint_id: string;
        };
        ContainerBuildRequest: {
            apt: string[];
            conda: string[];
            description?: string;
            name: string;
            payload_url?: string;
            pip: string[];
        };
        ContainerBuildResponse: { container_id: string };
        ContainerBuildStatusResponse: {
            status:
                | "provided"
                | "submitted"
                | "initialized"
                | "queued"
                | "building"
                | "ready"
                | "failed";
        };
        ContainerRegisterRequest: {
            description?: string;
            location: string;
            name: string;
            type: "docker"
            | "singularity";
        };
        ContainerRegisterResponse: { container_id: string };
        ContainerRuntime: "docker" | "singularity";
        ContainerStatus: {
            build_status:
                | "provided"
                | "submitted"
                | "initialized"
                | "queued"
                | "building"
                | "ready"
                | "failed";
            build_stderr?: string;
            container_uuid: string;
            err_message?: string;
            location?: string;
            name: string;
            type?: "docker"
            | "singularity";
        };
        ContainerStatusResponse: {
            container: {
                build_status: | "provided"
                | "submitted"
                | "initialized"
                | "queued"
                | "building"
                | "ready"
                | "failed";
                build_stderr?: string;
                container_uuid: string;
                err_message?: string;
                location?: string;
                name: string;
                type?: "docker"
                | "singularity";
            };
        };
        DeleteFunctionResponse: { result: number };
        Endpoint: {
            config?: Record<string, unknown>;
            description?: string;
            display_name: string;
            endpoint_config?: string;
            endpoint_version?: string;
            high_assurance: boolean;
            hostname?: string;
            ip_address?: string;
            local_user?: string;
            multi_user: boolean;
            name: string;
            public: boolean;
            python_version?: string;
            sdk_version?: string;
            subscription_uuid?: string;
            user_config_schema?: Record<string, unknown>;
            user_config_template?: string;
            uuid: string;
        };
        EndpointConfig: {
            endpoint_id: string;
            result_queue_info: {
                connection_url: string;
                exchange: string;
                queue: string;
                queue_publish_kwargs: {
                    exchange: string;
                    mandatory: boolean;
                    properties: { delivery_mode: number };
                    routing_key: string;
                };
            };
            task_queue_info: {
                connection_url: string;
                exchange: string;
                queue: string;
            };
            warnings?: string[];
        };
        EndpointConfigQueueInfo: {
            connection_url: string;
            exchange: string;
            queue: string;
        };
        EndpointConfigResultQueue: {
            connection_url: string;
            exchange: string;
            queue: string;
            queue_publish_kwargs: {
                exchange: string;
                mandatory: boolean;
                properties: { delivery_mode: number };
                routing_key: string;
            };
        };
        EndpointConfigResultQueuePublish: {
            exchange: string;
            mandatory: boolean;
            properties: { delivery_mode: number };
            routing_key: string;
        };
        EndpointConfigResultQueuePublishProperties: { delivery_mode: number };
        EndpointDeleteResponse: { result: number };
        EndpointListResponseEntry: {
            display_name: string;
            name: string;
            owner: string;
            uuid: string;
        };
        EndpointMetadata: {
            config?: Record<string, unknown>;
            description?: string;
            endpoint_config?: string;
            endpoint_version?: string;
            hostname?: string;
            ip_address?: string;
            local_user?: string;
            python_version?: string;
            sdk_version?: string;
            user_config_schema?: Record<string, unknown>;
            user_config_template?: string;
        };
        EndpointRegisterMetadata: {
            config?: Record<string, unknown>;
            description?: string;
            endpoint_config?: string;
            endpoint_version?: string;
            hostname?: string;
            ip_address?: string;
            local_user?: string;
            python_version?: string;
            sdk_version?: string;
            user_config_schema?: Record<string, unknown>;
            user_config_template?: string;
        };
        EndpointRegisterResponse: {
            endpoint_id: string;
            heartbeat_queue_info: {
                connection_url: string;
                exchange: string;
                queue: string;
                queue_publish_kwargs: {
                    exchange: string;
                    mandatory: boolean;
                    properties: { delivery_mode: number };
                    routing_key: string;
                };
            };
            result_queue_info: {
                connection_url: string;
                exchange: string;
                queue: string;
                queue_publish_kwargs: {
                    exchange: string;
                    mandatory: boolean;
                    properties: { delivery_mode: number };
                    routing_key: string;
                };
            };
            task_queue_info: {
                connection_url: string;
                exchange: string;
                queue: string;
            };
            warnings?: string[];
        };
        EndpointStatusDetails: {
            idle_workers: number;
            managers?: number;
            outstanding_tasks: number;
            pending_tasks: number;
            total_workers: number;
        };
        EndpointStatusResponse: {
            details?: {
                idle_workers: number;
                managers?: number;
                outstanding_tasks: number;
                pending_tasks: number;
                total_workers: number;
            };
            status: string;
        };
        ErrorResponse: {
            code: string;
            error_args: unknown[];
            http_status_code: number;
            reason: string;
            status: string;
        };
        Function: {
            description?: string;
            function_code: string;
            function_name?: string;
            function_uuid: string;
            metadata: { python_version?: string; sdk_version?: string };
        };
        FunctionMetadata: { python_version?: string; sdk_version?: string };
        funcx_web_service__schemas__v2__endpoint__EndpointLockResponse: {
            endpoint_id: string;
            lock_expiration_timestamp: string;
        };
        funcx_web_service__schemas__v2__endpoint__EndpointRegisterRequest: {
            allowed_functions?: string[];
            authentication_policy?: string;
            display_name?: string;
            endpoint_name: string;
            endpoint_uuid: string;
            metadata?: {
                config?: Record<string, unknown>;
                description?: string;
                endpoint_config?: string;
                endpoint_version?: string;
                hostname?: string;
                ip_address?: string;
                local_user?: string;
                python_version?: string;
                sdk_version?: string;
                user_config_schema?: Record<string, unknown>;
                user_config_template?: string;
            };
            multi_user: boolean;
            version?: string;
        };
        funcx_web_service__schemas__v2__function__RegisterFunctionMetadata: {
            python_version?: string;
            sdk_version?: string;
        };
        funcx_web_service__schemas__v2__function__RegisterFunctionRequest: {
            container_uuid?: string;
            description?: string;
            entry_point?: string;
            function_code: string;
            function_name: string;
            group?: string;
            metadata?: { python_version?: string; sdk_version?: string };
            public: boolean;
        };
        funcx_web_service__schemas__v2__task__BatchSubmitRequest: {
            create_websocket_queue: boolean;
            task_group_id?: string;
            tasks: [string, string, string][];
        };
        funcx_web_service__schemas__v2__task__BatchSubmitResponse: {
            response: string;
            results: (
                | string
                | {
                    http_status_code: number;
                    reason?: string;
                    status: string;
                    task_uuid: string;
                }
            )[];
            task_group_id?: string;
        };
        funcx_web_service__schemas__v3__endpoints__EndpointLockResponse: {
            endpoint_id: string;
            lock_expiration_timestamp: number;
        };
        funcx_web_service__schemas__v3__endpoints__EndpointRegisterRequest: {
            admins?: string[];
            allowed_functions?: string[];
            authentication_policy?: string;
            display_name?: string;
            endpoint_name: string;
            high_assurance: boolean;
            metadata: {
                config?: Record<string, unknown>;
                description?: string;
                endpoint_config?: string;
                endpoint_version?: string;
                hostname?: string;
                ip_address?: string;
                local_user?: string;
                python_version?: string;
                sdk_version?: string;
                user_config_schema?: Record<string, unknown>;
                user_config_template?: string;
            };
            multi_user: boolean;
            public: boolean;
            subscription_uuid?: string;
            version?: string;
        };
        funcx_web_service__schemas__v3__function__RegisterFunctionMetadata: {
            python_version: string;
            sdk_version: string;
            serde_identifier: string;
        };
        funcx_web_service__schemas__v3__function__RegisterFunctionRequest: {
            description?: string;
            function_code: string;
            function_name: string;
            group?: string;
            ha_endpoint_id?: string;
            meta: {
                python_version: string;
                sdk_version: string;
                serde_identifier: string;
            };
            public: boolean;
        };
        funcx_web_service__schemas__v3__tasks__BatchSubmitRequest: {
            create_queue: boolean;
            resource_specification?: {
                launcher_options?: string;
                num_nodes: number;
                num_ranks?: number;
                ranks_per_node?: number;
            };
            result_serializers?: string[];
            task_group_id?: string;
            tasks: { [key: string]: string[] };
            user_endpoint_config?: Record<string, unknown>;
            user_runtime?: {
                globus_compute_sdk_version?: string;
                globus_sdk_version?: string;
                python_version?: string;
            };
        };
        funcx_web_service__schemas__v3__tasks__BatchSubmitResponse: {
            endpoint_id: string;
            request_id: string;
            task_group_id: string;
            tasks: { [key: string]: string[] };
        };
        FuncxStatsResponse: { total_function_invocations: number };
        FuncxVersionResponse: {
            api: string;
            container_service?: string;
            git_sha?: string;
            min_ep_version?: string;
            min_sdk_version?: string;
        };
        HTTPValidationError: {
            detail?: { loc: (string | number)[]; msg: string; type: string }[];
        };
        MultiUserEndpointConfig: {
            command_queue_info: {
                connection_url: string;
                exchange: string;
                queue: string;
            };
            endpoint_id: string;
            warnings?: string[];
        };
        MultiUserEndpointRegisterResponse: {
            command_queue_info: {
                connection_url: string;
                exchange: string;
                queue: string;
            };
            endpoint_id: string;
            heartbeat_queue_info: {
                connection_url: string;
                exchange: string;
                queue: string;
                queue_publish_kwargs: {
                    exchange: string;
                    mandatory: boolean;
                    properties: { delivery_mode: number };
                    routing_key: string;
                };
            };
            result_queue_info: {
                connection_url: string;
                exchange: string;
                queue: string;
                queue_publish_kwargs: {
                    exchange: string;
                    mandatory: boolean;
                    properties: { delivery_mode: number };
                    routing_key: string;
                };
            };
            warnings?: string[];
        };
        ReadQueueInfo: { connection_url: string; exchange: string; queue: string };
        RegisterFunctionResponse: { function_uuid: string };
        ResourceSpecification: {
            launcher_options?: string;
            num_nodes: number;
            num_ranks?: number;
            ranks_per_node?: number;
        };
        ResultAmqpUrlResponse: { connection_url: string; queue_prefix: string };
        TaskGroupResponse: {
            create_websockets_queue?: boolean;
            taskgroup_id: string;
            tasks: { created_at: string; id: string }[];
        };
        TaskGroupResponseTask: { created_at: string; id: string };
        TaskStatusResponse: {
            completion_t?: string;
            details?: Record<string, unknown>;
            exception?: string;
            result?: string;
            status?: unknown;
            task_id: string;
        };
        UserRuntime: {
            globus_compute_sdk_version?: string;
            globus_sdk_version?: string;
            python_version?: string;
        };
        ValidationError: { loc: (string | number)[]; msg: string; type: string };
        ValidationErrorResponse: {
            code: string;
            error_args: unknown[];
            http_status_code: number;
            reason: { loc: (string | number)[]; msg: string; type: string }[];
            status: string;
        };
        VersionService: "all"
        | "api";
        WriteQueueInfo: {
            connection_url: string;
            exchange: string;
            queue: string;
            queue_publish_kwargs: {
                exchange: string;
                mandatory: boolean;
                properties: { delivery_mode: number };
                routing_key: string;
            };
        };
        WriteQueuePublishKwargs: {
            exchange: string;
            mandatory: boolean;
            properties: { delivery_mode: number };
            routing_key: string;
        };
        WriteQueuePublishProperties: { delivery_mode: number };
    };
}

Index

Properties

headers parameters pathItems requestBodies responses schemas

Properties

headers

headers: never

parameters

parameters: never

pathItems

pathItems: never

requestBodies

requestBodies: never

responses

responses: never

schemas

schemas: {
    AllowedFunctionsResponse: {
        endpoint_id: string;
        functions?: string[];
        restricted: boolean;
    };
    BatchStatusRequest: { task_ids: string[] };
    BatchStatusResponse: {
        response: string;
        results: {
            [key: string]: {
                completion_t?: string;
                exception?: string;
                reason?: string;
                result?: string;
                status?: unknown;
                task_id: string;
            };
        };
    };
    BatchStatusResponseResults: {
        completion_t?: string;
        exception?: string;
        reason?: string;
        result?: string;
        status?: unknown;
        task_id: string;
    };
    BatchSubmitResponseTask: {
        http_status_code: number;
        reason?: string;
        status: string;
        task_uuid: string;
    };
    BuildStatus: | "provided"
    | "submitted"
    | "initialized"
    | "queued"
    | "building"
    | "ready"
    | "failed";
    ConsoleNodeInfo: {
        endpoint_version?: string;
        idle_duration_seconds?: number;
        python_version?: string;
        sdk_version?: string;
        total_worker_count?: number;
    };
    ConsoleResponse: {
        user_endpoints: {
            account?: string;
            active: boolean;
            client_sdk_versions?: string[];
            config?: string;
            endpoint_version?: string;
            engine_type?: string;
            executed_task_count?: number;
            idle_worker_count?: number;
            last_heartbeat_unix?: number;
            node_info?: {
                [key: string]: {
                    endpoint_version?: string;
                    idle_duration_seconds?: number;
                    python_version?: string;
                    sdk_version?: string;
                    total_worker_count?: number;
                }[];
            };
            posix_pid?: number;
            posix_username?: string;
            provider_type?: string;
            python_version?: string;
            queue?: string;
            queued_task_count?: number;
            running_task_count?: number;
            start_time_iso?: string;
            start_time_unix?: number;
            total_node_count?: number;
            total_worker_count?: number;
            user_endpoint_id: string;
        }[];
    };
    ConsoleUserEndpointInfo: {
        account?: string;
        active: boolean;
        client_sdk_versions?: string[];
        config?: string;
        endpoint_version?: string;
        engine_type?: string;
        executed_task_count?: number;
        idle_worker_count?: number;
        last_heartbeat_unix?: number;
        node_info?: {
            [key: string]: {
                endpoint_version?: string;
                idle_duration_seconds?: number;
                python_version?: string;
                sdk_version?: string;
                total_worker_count?: number;
            }[];
        };
        posix_pid?: number;
        posix_username?: string;
        provider_type?: string;
        python_version?: string;
        queue?: string;
        queued_task_count?: number;
        running_task_count?: number;
        start_time_iso?: string;
        start_time_unix?: number;
        total_node_count?: number;
        total_worker_count?: number;
        user_endpoint_id: string;
    };
    ContainerBuildRequest: {
        apt: string[];
        conda: string[];
        description?: string;
        name: string;
        payload_url?: string;
        pip: string[];
    };
    ContainerBuildResponse: { container_id: string };
    ContainerBuildStatusResponse: {
        status:
            | "provided"
            | "submitted"
            | "initialized"
            | "queued"
            | "building"
            | "ready"
            | "failed";
    };
    ContainerRegisterRequest: {
        description?: string;
        location: string;
        name: string;
        type: "docker"
        | "singularity";
    };
    ContainerRegisterResponse: { container_id: string };
    ContainerRuntime: "docker" | "singularity";
    ContainerStatus: {
        build_status:
            | "provided"
            | "submitted"
            | "initialized"
            | "queued"
            | "building"
            | "ready"
            | "failed";
        build_stderr?: string;
        container_uuid: string;
        err_message?: string;
        location?: string;
        name: string;
        type?: "docker"
        | "singularity";
    };
    ContainerStatusResponse: {
        container: {
            build_status: | "provided"
            | "submitted"
            | "initialized"
            | "queued"
            | "building"
            | "ready"
            | "failed";
            build_stderr?: string;
            container_uuid: string;
            err_message?: string;
            location?: string;
            name: string;
            type?: "docker"
            | "singularity";
        };
    };
    DeleteFunctionResponse: { result: number };
    Endpoint: {
        config?: Record<string, unknown>;
        description?: string;
        display_name: string;
        endpoint_config?: string;
        endpoint_version?: string;
        high_assurance: boolean;
        hostname?: string;
        ip_address?: string;
        local_user?: string;
        multi_user: boolean;
        name: string;
        public: boolean;
        python_version?: string;
        sdk_version?: string;
        subscription_uuid?: string;
        user_config_schema?: Record<string, unknown>;
        user_config_template?: string;
        uuid: string;
    };
    EndpointConfig: {
        endpoint_id: string;
        result_queue_info: {
            connection_url: string;
            exchange: string;
            queue: string;
            queue_publish_kwargs: {
                exchange: string;
                mandatory: boolean;
                properties: { delivery_mode: number };
                routing_key: string;
            };
        };
        task_queue_info: {
            connection_url: string;
            exchange: string;
            queue: string;
        };
        warnings?: string[];
    };
    EndpointConfigQueueInfo: {
        connection_url: string;
        exchange: string;
        queue: string;
    };
    EndpointConfigResultQueue: {
        connection_url: string;
        exchange: string;
        queue: string;
        queue_publish_kwargs: {
            exchange: string;
            mandatory: boolean;
            properties: { delivery_mode: number };
            routing_key: string;
        };
    };
    EndpointConfigResultQueuePublish: {
        exchange: string;
        mandatory: boolean;
        properties: { delivery_mode: number };
        routing_key: string;
    };
    EndpointConfigResultQueuePublishProperties: { delivery_mode: number };
    EndpointDeleteResponse: { result: number };
    EndpointListResponseEntry: {
        display_name: string;
        name: string;
        owner: string;
        uuid: string;
    };
    EndpointMetadata: {
        config?: Record<string, unknown>;
        description?: string;
        endpoint_config?: string;
        endpoint_version?: string;
        hostname?: string;
        ip_address?: string;
        local_user?: string;
        python_version?: string;
        sdk_version?: string;
        user_config_schema?: Record<string, unknown>;
        user_config_template?: string;
    };
    EndpointRegisterMetadata: {
        config?: Record<string, unknown>;
        description?: string;
        endpoint_config?: string;
        endpoint_version?: string;
        hostname?: string;
        ip_address?: string;
        local_user?: string;
        python_version?: string;
        sdk_version?: string;
        user_config_schema?: Record<string, unknown>;
        user_config_template?: string;
    };
    EndpointRegisterResponse: {
        endpoint_id: string;
        heartbeat_queue_info: {
            connection_url: string;
            exchange: string;
            queue: string;
            queue_publish_kwargs: {
                exchange: string;
                mandatory: boolean;
                properties: { delivery_mode: number };
                routing_key: string;
            };
        };
        result_queue_info: {
            connection_url: string;
            exchange: string;
            queue: string;
            queue_publish_kwargs: {
                exchange: string;
                mandatory: boolean;
                properties: { delivery_mode: number };
                routing_key: string;
            };
        };
        task_queue_info: {
            connection_url: string;
            exchange: string;
            queue: string;
        };
        warnings?: string[];
    };
    EndpointStatusDetails: {
        idle_workers: number;
        managers?: number;
        outstanding_tasks: number;
        pending_tasks: number;
        total_workers: number;
    };
    EndpointStatusResponse: {
        details?: {
            idle_workers: number;
            managers?: number;
            outstanding_tasks: number;
            pending_tasks: number;
            total_workers: number;
        };
        status: string;
    };
    ErrorResponse: {
        code: string;
        error_args: unknown[];
        http_status_code: number;
        reason: string;
        status: string;
    };
    Function: {
        description?: string;
        function_code: string;
        function_name?: string;
        function_uuid: string;
        metadata: { python_version?: string; sdk_version?: string };
    };
    FunctionMetadata: { python_version?: string; sdk_version?: string };
    funcx_web_service__schemas__v2__endpoint__EndpointLockResponse: {
        endpoint_id: string;
        lock_expiration_timestamp: string;
    };
    funcx_web_service__schemas__v2__endpoint__EndpointRegisterRequest: {
        allowed_functions?: string[];
        authentication_policy?: string;
        display_name?: string;
        endpoint_name: string;
        endpoint_uuid: string;
        metadata?: {
            config?: Record<string, unknown>;
            description?: string;
            endpoint_config?: string;
            endpoint_version?: string;
            hostname?: string;
            ip_address?: string;
            local_user?: string;
            python_version?: string;
            sdk_version?: string;
            user_config_schema?: Record<string, unknown>;
            user_config_template?: string;
        };
        multi_user: boolean;
        version?: string;
    };
    funcx_web_service__schemas__v2__function__RegisterFunctionMetadata: {
        python_version?: string;
        sdk_version?: string;
    };
    funcx_web_service__schemas__v2__function__RegisterFunctionRequest: {
        container_uuid?: string;
        description?: string;
        entry_point?: string;
        function_code: string;
        function_name: string;
        group?: string;
        metadata?: { python_version?: string; sdk_version?: string };
        public: boolean;
    };
    funcx_web_service__schemas__v2__task__BatchSubmitRequest: {
        create_websocket_queue: boolean;
        task_group_id?: string;
        tasks: [string, string, string][];
    };
    funcx_web_service__schemas__v2__task__BatchSubmitResponse: {
        response: string;
        results: (
            | string
            | {
                http_status_code: number;
                reason?: string;
                status: string;
                task_uuid: string;
            }
        )[];
        task_group_id?: string;
    };
    funcx_web_service__schemas__v3__endpoints__EndpointLockResponse: {
        endpoint_id: string;
        lock_expiration_timestamp: number;
    };
    funcx_web_service__schemas__v3__endpoints__EndpointRegisterRequest: {
        admins?: string[];
        allowed_functions?: string[];
        authentication_policy?: string;
        display_name?: string;
        endpoint_name: string;
        high_assurance: boolean;
        metadata: {
            config?: Record<string, unknown>;
            description?: string;
            endpoint_config?: string;
            endpoint_version?: string;
            hostname?: string;
            ip_address?: string;
            local_user?: string;
            python_version?: string;
            sdk_version?: string;
            user_config_schema?: Record<string, unknown>;
            user_config_template?: string;
        };
        multi_user: boolean;
        public: boolean;
        subscription_uuid?: string;
        version?: string;
    };
    funcx_web_service__schemas__v3__function__RegisterFunctionMetadata: {
        python_version: string;
        sdk_version: string;
        serde_identifier: string;
    };
    funcx_web_service__schemas__v3__function__RegisterFunctionRequest: {
        description?: string;
        function_code: string;
        function_name: string;
        group?: string;
        ha_endpoint_id?: string;
        meta: {
            python_version: string;
            sdk_version: string;
            serde_identifier: string;
        };
        public: boolean;
    };
    funcx_web_service__schemas__v3__tasks__BatchSubmitRequest: {
        create_queue: boolean;
        resource_specification?: {
            launcher_options?: string;
            num_nodes: number;
            num_ranks?: number;
            ranks_per_node?: number;
        };
        result_serializers?: string[];
        task_group_id?: string;
        tasks: { [key: string]: string[] };
        user_endpoint_config?: Record<string, unknown>;
        user_runtime?: {
            globus_compute_sdk_version?: string;
            globus_sdk_version?: string;
            python_version?: string;
        };
    };
    funcx_web_service__schemas__v3__tasks__BatchSubmitResponse: {
        endpoint_id: string;
        request_id: string;
        task_group_id: string;
        tasks: { [key: string]: string[] };
    };
    FuncxStatsResponse: { total_function_invocations: number };
    FuncxVersionResponse: {
        api: string;
        container_service?: string;
        git_sha?: string;
        min_ep_version?: string;
        min_sdk_version?: string;
    };
    HTTPValidationError: {
        detail?: { loc: (string | number)[]; msg: string; type: string }[];
    };
    MultiUserEndpointConfig: {
        command_queue_info: {
            connection_url: string;
            exchange: string;
            queue: string;
        };
        endpoint_id: string;
        warnings?: string[];
    };
    MultiUserEndpointRegisterResponse: {
        command_queue_info: {
            connection_url: string;
            exchange: string;
            queue: string;
        };
        endpoint_id: string;
        heartbeat_queue_info: {
            connection_url: string;
            exchange: string;
            queue: string;
            queue_publish_kwargs: {
                exchange: string;
                mandatory: boolean;
                properties: { delivery_mode: number };
                routing_key: string;
            };
        };
        result_queue_info: {
            connection_url: string;
            exchange: string;
            queue: string;
            queue_publish_kwargs: {
                exchange: string;
                mandatory: boolean;
                properties: { delivery_mode: number };
                routing_key: string;
            };
        };
        warnings?: string[];
    };
    ReadQueueInfo: { connection_url: string; exchange: string; queue: string };
    RegisterFunctionResponse: { function_uuid: string };
    ResourceSpecification: {
        launcher_options?: string;
        num_nodes: number;
        num_ranks?: number;
        ranks_per_node?: number;
    };
    ResultAmqpUrlResponse: { connection_url: string; queue_prefix: string };
    TaskGroupResponse: {
        create_websockets_queue?: boolean;
        taskgroup_id: string;
        tasks: { created_at: string; id: string }[];
    };
    TaskGroupResponseTask: { created_at: string; id: string };
    TaskStatusResponse: {
        completion_t?: string;
        details?: Record<string, unknown>;
        exception?: string;
        result?: string;
        status?: unknown;
        task_id: string;
    };
    UserRuntime: {
        globus_compute_sdk_version?: string;
        globus_sdk_version?: string;
        python_version?: string;
    };
    ValidationError: { loc: (string | number)[]; msg: string; type: string };
    ValidationErrorResponse: {
        code: string;
        error_args: unknown[];
        http_status_code: number;
        reason: { loc: (string | number)[]; msg: string; type: string }[];
        status: string;
    };
    VersionService: "all"
    | "api";
    WriteQueueInfo: {
        connection_url: string;
        exchange: string;
        queue: string;
        queue_publish_kwargs: {
            exchange: string;
            mandatory: boolean;
            properties: { delivery_mode: number };
            routing_key: string;
        };
    };
    WriteQueuePublishKwargs: {
        exchange: string;
        mandatory: boolean;
        properties: { delivery_mode: number };
        routing_key: string;
    };
    WriteQueuePublishProperties: { delivery_mode: number };
}

Type declaration

AllowedFunctionsResponse: { endpoint_id: string; functions?: string[]; restricted: boolean }

AllowedFunctionsResponse

Example

{
         *       "endpoint_id": "7348422a-1074-427b-a08a-0771068afccc",
         *       "restricted": true,
         *       "functions": [
         *         "063a3a9d-f40e-4b46-950a-fb24f75a345c",
         *         "e4b534c3-d9d0-47b0-8334-f52932ad3d9a",
         *         "ebe03b69-c966-42fb-ae3f-4a8c9e5b909e"
         *       ]
         *     }

endpoint_id: string
Endpoint Id Format: uuid

Description
Endpoint UUID
Optionalfunctions?: string[]
Functions

Description
The functions this endpoint is allowed to execute
restricted: boolean
Restricted

Description
False if the endpoint allows execution of any function. True if the endpoint will only execute functions from it's allowed list; see the functions field.

BatchStatusRequest: { task_ids: string[] }

BatchStatusRequest

Example

{
         *       "task_ids": [
         *         "7dac44aa-c480-4460-b453-a47b03b031f4",
         *         "4b35645f-0c5b-465d-aaec-fee87f74ff5b"
         *       ]
         *     }

task_ids: string[]
Task Ids

Description
Task UUIDs

BatchStatusResponse: {
    response: string;
    results: {
        [key: string]: {
            completion_t?: string;
            exception?: string;
            reason?: string;
            result?: string;
            status?: unknown;
            task_id: string;
        };
    };
}

BatchStatusResponse

Example

{
         *       "response": "batch",
         *       "results": {
         *         "7dac44aa-c480-4460-b453-a47b03b031f4": {
         *           "task_id": "7dac44aa-c480-4460-b453-a47b03b031f4",
         *           "status": "success",
         *           "result": "10000",
         *           "completion_t": "1677183605.212898"
         *         },
         *         "4b35645f-0c5b-465d-aaec-fee87f74ff5b": {
         *           "task_id": "4b35645f-0c5b-465d-aaec-fee87f74ff5b",
         *           "status": "failed",
         *           "reason": "Task failed"
         *         }
         *       }
         *     }

response: string
Response

Description
Response
results: {
    [key: string]: {
        completion_t?: string;
        exception?: string;
        reason?: string;
        result?: string;
        status?: unknown;
        task_id: string;
    };
}
Results

Description
Task results

BatchStatusResponseResults: {
    completion_t?: string;
    exception?: string;
    reason?: string;
    result?: string;
    status?: unknown;
    task_id: string;
}
BatchStatusResponseResults
- Optionalcompletion_t?: string
  Completion T
  
  Description
  Task completion Unix time
- Optionalexception?: string
  Exception
  
  Description
  Exception
- Optionalreason?: string
  Reason
  
  Description
  Reason for exception
- Optionalresult?: string
  Result
  
  Description
  Task result
- Optionalstatus?: unknown
  Status
  
  Description
  Task status
- task_id: string
  Task Id Format: uuid
  
  Description
  Task UUID
BatchSubmitResponseTask: { http_status_code: number; reason?: string; status: string; task_uuid: string }
BatchSubmitResponseTask
- http_status_code: number
  Http Status Code
  
  Description
  HTTP status code
- Optionalreason?: string
  Reason
  
  Description
  Reason for exception
- status: string
  Status
  
  Description
  Task status
- task_uuid: string
  Task Uuid Format: uuid
  
  Description
  Task UUID
BuildStatus:
    | "provided"
    | "submitted"
    | "initialized"
    | "queued"
    | "building"
    | "ready"
    | "failed"
BuildStatus

Description
An enumeration.
ConsoleNodeInfo: {
    endpoint_version?: string;
    idle_duration_seconds?: number;
    python_version?: string;
    sdk_version?: string;
    total_worker_count?: number;
}
ConsoleNodeInfo
- Optionalendpoint_version?: string
  Endpoint Version
  
  Description
  Version of globus-compute-endpoint running on the node
- Optionalidle_duration_seconds?: number
  Idle Duration Seconds
  
  Description
  Idle duration in seconds
- Optionalpython_version?: string
  Python Version
  
  Description
  Node Python version
- Optionalsdk_version?: string
  Sdk Version
  
  Description
  Version of globus-compute-sdk running on the node
- Optionaltotal_worker_count?: number
  Total Worker Count
  
  Description
  Total number of provisioned workers on the node

ConsoleResponse: {
    user_endpoints: {
        account?: string;
        active: boolean;
        client_sdk_versions?: string[];
        config?: string;
        endpoint_version?: string;
        engine_type?: string;
        executed_task_count?: number;
        idle_worker_count?: number;
        last_heartbeat_unix?: number;
        node_info?: {
            [key: string]: {
                endpoint_version?: string;
                idle_duration_seconds?: number;
                python_version?: string;
                sdk_version?: string;
                total_worker_count?: number;
            }[];
        };
        posix_pid?: number;
        posix_username?: string;
        provider_type?: string;
        python_version?: string;
        queue?: string;
        queued_task_count?: number;
        running_task_count?: number;
        start_time_iso?: string;
        start_time_unix?: number;
        total_node_count?: number;
        total_worker_count?: number;
        user_endpoint_id: string;
    }[];
}

ConsoleResponse

Example

{
         *       "user_endpoints": [
         *         {
         *           "user_endpoint_id": "7348422a-1074-427b-a08a-0771068afccc",
         *           "active": true,
         *           "python_version": "3.12.7",
         *           "endpoint_version": "3.1.1",
         *           "posix_pid": 12345,
         *           "posix_username": "test_user",
         *           "start_time_iso": "2025-01-02T21:20:19.123456-05:00",
         *           "start_time_unix": 1735870819.123456,
         *           "last_heartbeat_unix": 1735884207.498273,
         *           "running_task_count": 3,
         *           "queued_task_count": 0,
         *           "executed_task_count": 15,
         *           "total_worker_count": 2,
         *           "idle_worker_count": 0,
         *           "total_node_count": 1,
         *           "node_info": {
         *             "some_job_id": [
         *               {
         *                 "total_worker_count": 2,
         *                 "idle_duration_seconds": 0,
         *                 "python_version": "3.12.7",
         *                 "endpoint_version": "3.1.1",
         *                 "sdk_version": "3.1.1"
         *               }
         *             ]
         *           },
         *           "engine_type": "GlobusComputeEngine",
         *           "provider_type": "SlurmProvider",
         *           "account": "my-slurm-account",
         *           "queue": "caslake",
         *           "config": "engine:\n  type: GlobusComputeEngine\n  max_workers_per_node: 2\n  provider:\n    type: SlurmProvider\n    account: my-slurm-account\n    partition: caslake\n    worker_init: 'module load Anaconda; source activate compute-env'\n    nodes_per_block: 1\n    max_blocks: 1\n  address:\n    type: address_by_interface\n    ifname: bond0\n"
         *         }
         *       ]
         *     }

user_endpoints: {
    account?: string;
    active: boolean;
    client_sdk_versions?: string[];
    config?: string;
    endpoint_version?: string;
    engine_type?: string;
    executed_task_count?: number;
    idle_worker_count?: number;
    last_heartbeat_unix?: number;
    node_info?: {
        [key: string]: {
            endpoint_version?: string;
            idle_duration_seconds?: number;
            python_version?: string;
            sdk_version?: string;
            total_worker_count?: number;
        }[];
    };
    posix_pid?: number;
    posix_username?: string;
    provider_type?: string;
    python_version?: string;
    queue?: string;
    queued_task_count?: number;
    running_task_count?: number;
    start_time_iso?: string;
    start_time_unix?: number;
    total_node_count?: number;
    total_worker_count?: number;
    user_endpoint_id: string;
}[]
User Endpoints

Description
List of information about each running user endpoint process

ConsoleUserEndpointInfo: {
    account?: string;
    active: boolean;
    client_sdk_versions?: string[];
    config?: string;
    endpoint_version?: string;
    engine_type?: string;
    executed_task_count?: number;
    idle_worker_count?: number;
    last_heartbeat_unix?: number;
    node_info?: {
        [key: string]: {
            endpoint_version?: string;
            idle_duration_seconds?: number;
            python_version?: string;
            sdk_version?: string;
            total_worker_count?: number;
        }[];
    };
    posix_pid?: number;
    posix_username?: string;
    provider_type?: string;
    python_version?: string;
    queue?: string;
    queued_task_count?: number;
    running_task_count?: number;
    start_time_iso?: string;
    start_time_unix?: number;
    total_node_count?: number;
    total_worker_count?: number;
    user_endpoint_id: string;
}
ConsoleUserEndpointInfo
- Optionalaccount?: string
  Account
  
  Description
  The account against which the scheduler charges resources that are consumed by the user endpoint
- active: boolean
  Active
  Description
  Whether the user endpoint is active
  Default
```
true
```
- Optionalclient_sdk_versions?: string[]
  Client Sdk Versions
  
  Description
  SDK versions used to submit tasks to the user endpoint
- Optionalconfig?: string
  Config
  
  Description
  User endpoint configuration YAML content. We do not include this field by default because it may be quite large. Users must explicitly request it using the include_fields query parameter.
- Optionalendpoint_version?: string
  Endpoint Version
  
  Description
  User endpoint version
- Optionalengine_type?: string
  Engine Type
  
  Description
  User endpoint engine type. See our documentation for more information: https://globus-compute.readthedocs.io/en/latest/endpoints/config_reference.html#user-endpoint-configuration
- Optionalexecuted_task_count?: number
  Executed Task Count
  
  Description
  Number of executed tasks
- Optionalidle_worker_count?: number
  Idle Worker Count
  
  Description
  Number of idle workers
- Optionallast_heartbeat_unix?: number
  Last Heartbeat Unix
  
  Description
  UNIX timestamp indicating when the services last processed a heartbeat for the user endpoint
- Optionalnode_info?: {
      [key: string]: {
          endpoint_version?: string;
          idle_duration_seconds?: number;
          python_version?: string;
          sdk_version?: string;
          total_worker_count?: number;
      }[];
  }
  Node Info
  
  Description
  Details for each provisioned node, indexed by job ID
- Optionalposix_pid?: number
  Posix Pid
  
  Description
  User endpoint process ID
- Optionalposix_username?: string
  Posix Username
  
  Description
  Local POSIX user running the user endpoint
- Optionalprovider_type?: string
  Provider Type
  
  Description
  User endpoint provider type. See our documentation for more information: https://globus-compute.readthedocs.io/en/latest/endpoints/config_reference.html#user-endpoint-configuration
- Optionalpython_version?: string
  Python Version
  
  Description
  User endpoint Python version
- Optionalqueue?: string
  Queue
  
  Description
  The scheduler queue to which the user endpoint will submit jobs
- Optionalqueued_task_count?: number
  Queued Task Count
  
  Description
  Number of queued tasks
- Optionalrunning_task_count?: number
  Running Task Count
  
  Description
  Number of running tasks
- Optionalstart_time_iso?: string
  Start Time Iso Format: date-time
  
  Description
  User endpoint start time in ISO format including timezone offset
- Optionalstart_time_unix?: number
  Start Time Unix
  
  Description
  UNIX timestamp indicating when the user endpoint was started
- Optionaltotal_node_count?: number
  Total Node Count
  
  Description
  Total number of provisioned nodes
- Optionaltotal_worker_count?: number
  Total Worker Count
  
  Description
  Total number of provisioned workers
- user_endpoint_id: string
  User Endpoint Id Format: uuid
  
  Description
  User endpoint UUID (key identifier)

ContainerBuildRequest: {
    apt: string[];
    conda: string[];
    description?: string;
    name: string;
    payload_url?: string;
    pip: string[];
}

ContainerBuildRequest

Example

{
         *       "name": "My Container",
         *       "description": "Container with vim and git installed using apt and numpy and pandas installed using pip.",
         *       "apt": [
         *         "vim",
         *         "git"
         *       ],
         *       "pip": [
         *         "numpy",
         *         "pandas"
         *       ],
         *       "conda": [],
         *       "payload_url": "https://github.com/my-container"
         *     }

apt: string[]
Apt

Description
Optional list of package names to be installed via apt-get
conda: string[]
Conda

Description
Optional list of conda requirements (name and optional version specifier)
Optionaldescription?: string
Description

Description
Long container description
name: string
Name

Description
Container name
Optionalpayload_url?: string
Payload Url Format: uri

Description
URL to GitHub repo or publicly readable zip file
pip: string[]
Pip

Description
Optional list of pip requirements (name and optional version specifier)

ContainerBuildResponse: { container_id: string }
ContainerBuildResponse
Example
```
{
         *       "container_id": "b7a42fa2-e97f-4061-9e64-2ede22ae7f5e"
         *     }
```
- container_id: string
  Container Id Format: uuid
  
  Description
  Container UUID
ContainerBuildStatusResponse: {
    status:
        | "provided"
        | "submitted"
        | "initialized"
        | "queued"
        | "building"
        | "ready"
        | "failed";
}
ContainerBuildStatusResponse
Example
```
{
         *       "status": "ready"
         *     }
```
- status:
      | "provided"
      | "submitted"
      | "initialized"
      | "queued"
      | "building"
      | "ready"
      | "failed"
  Description
  Container build status
ContainerRegisterRequest: {
    description?: string;
    location: string;
    name: string;
    type: "docker" | "singularity";
}
ContainerRegisterRequest
Example
```
{
         *       "name": "My Container",
         *       "description": "My container description",
         *       "type": "docker",
         *       "location": "docker://my-container:latest"
         *     }
```
- Optionaldescription?: string
  Description
  
  Description
  Long container description
- location: string
  Location
  
  Description
  The location of the container (e.g., its docker url)
- name: string
  Name
  
  Description
  Container name
- type: "docker" | "singularity"
ContainerRegisterResponse: { container_id: string }
ContainerRegisterResponse
Example
```
{
         *       "container_id": "b7a42fa2-e97f-4061-9e64-2ede22ae7f5e"
         *     }
```
- container_id: string
  Container Id Format: uuid
  
  Description
  Container UUID
ContainerRuntime: "docker" | "singularity"
ContainerRuntime

Description
Runtime to be used to execute the container.
ContainerStatus: {
    build_status:
        | "provided"
        | "submitted"
        | "initialized"
        | "queued"
        | "building"
        | "ready"
        | "failed";
    build_stderr?: string;
    container_uuid: string;
    err_message?: string;
    location?: string;
    name: string;
    type?: "docker"
    | "singularity";
}
ContainerStatus
- build_status:
      | "provided"
      | "submitted"
      | "initialized"
      | "queued"
      | "building"
      | "ready"
      | "failed"
  Description
  Container build status
- Optionalbuild_stderr?: string
  Build Stderr
  
  Description
  Container build stderr
- container_uuid: string
  Container Uuid Format: uuid
  
  Description
  Container UUID
- Optionalerr_message?: string
  Err Message
  
  Description
  Container error message
- Optionallocation?: string
  Location
  
  Description
  Container location
- name: string
  Name
  
  Description
  Container name
- Optionaltype?: "docker" | "singularity"
ContainerStatusResponse: {
    container: {
        build_status:
            | "provided"
            | "submitted"
            | "initialized"
            | "queued"
            | "building"
            | "ready"
            | "failed";
        build_stderr?: string;
        container_uuid: string;
        err_message?: string;
        location?: string;
        name: string;
        type?: "docker"
        | "singularity";
    };
}
ContainerStatusResponse
Example
```
{
         *       "container": {
         *         "container_uuid": "b7a42fa2-e97f-4061-9e64-2ede22ae7f5e",
         *         "name": "My Container",
         *         "build_status": "ready",
         *         "type": "docker",
         *         "location": "docker://my-container:latest"
         *       }
         *     }
```
- container: {
      build_status:
          | "provided"
          | "submitted"
          | "initialized"
          | "queued"
          | "building"
          | "ready"
          | "failed";
      build_stderr?: string;
      container_uuid: string;
      err_message?: string;
      location?: string;
      name: string;
      type?: "docker"
      | "singularity";
  }
  - build_status:
        | "provided"
        | "submitted"
        | "initialized"
        | "queued"
        | "building"
        | "ready"
        | "failed"
    Description
    Container build status
  - Optionalbuild_stderr?: string
    Build Stderr
    
    Description
    Container build stderr
  - container_uuid: string
    Container Uuid Format: uuid
    
    Description
    Container UUID
  - Optionalerr_message?: string
    Err Message
    
    Description
    Container error message
  - Optionallocation?: string
    Location
    
    Description
    Container location
  - name: string
    Name
    
    Description
    Container name
  - Optionaltype?: "docker" | "singularity"
DeleteFunctionResponse: { result: number }
DeleteFunctionResponse
Example
```
{
         *       "result": 302
         *     }
```
- result: number
  Result
  
  Description
  The result as a status code integer
Endpoint: {
    config?: Record<string, unknown>;
    description?: string;
    display_name: string;
    endpoint_config?: string;
    endpoint_version?: string;
    high_assurance: boolean;
    hostname?: string;
    ip_address?: string;
    local_user?: string;
    multi_user: boolean;
    name: string;
    public: boolean;
    python_version?: string;
    sdk_version?: string;
    subscription_uuid?: string;
    user_config_schema?: Record<string, unknown>;
    user_config_template?: string;
    uuid: string;
}
Endpoint
Example
```
{
         *       "uuid": "7348422a-1074-427b-a08a-0771068afccc",
         *       "name": "My Endpoint",
         *       "display_name": "My Endpoint's display name",
         *       "multi_user": false,
         *       "high_assurance": false,
         *       "public": false,
         *       "endpoint_config": "",
         *       "user_config_template": {},
         *       "user_config_schema": {},
         *       "description": "My endpoint description",
         *       "hostname": "my-endpoint",
         *       "local_user": "user",
         *       "ip_address": "140.221.112.13",
         *       "endpoint_version": "1.0.10",
         *       "sdk_version": "1.0.10",
         *       "python_version": "3.12.7",
         *       "subscription_uuid": "b0b7b089-707a-4d90-a036-05b7964d6b60"
         *     }
```
- Optionalconfig?: Record<string, unknown>
  Config
  
  Deprecated
  Description
  This field is deprecated. Please use endpoint_config instead.
- Optionaldescription?: string
  Description
  
  Description
  Endpoint description
- display_name: string
  Display Name
  
  Description
  Display name
- Optionalendpoint_config?: string
  Endpoint Config
  
  Description
  The contents of the endpoint's configuration file (config.yaml).
- Optionalendpoint_version?: string
  Endpoint Version
  
  Description
  Endpoint version
- high_assurance: boolean
  High Assurance
  
  Description
  Endpoint supports high-assurance protocols
- Optionalhostname?: string
  Hostname
  
  Description
  Endpoint hostname
- Optionalip_address?: string
  Ip Address Format: ipvanyaddress
  
  Description
  Endpoint IP address
- Optionallocal_user?: string
  Local User
  
  Description
  Endpoint local user
- multi_user: boolean
  Multi User
  
  Description
  Endpoint multi-user mode
- name: string
  Name
  
  Description
  Endpoint name
- public: boolean
  Public
  
  Description
  Indicates if all users can discover the multi-user endpoint.
- Optionalpython_version?: string
  Python Version
  
  Description
  Endpoint Python version
- Optionalsdk_version?: string
  Sdk Version
  
  Description
  Endpoint SDK version
- Optionalsubscription_uuid?: string
  Subscription Uuid Format: uuid
  
  Description
  Globus subscription UUID
- Optionaluser_config_schema?: Record<string, unknown>
  User Config Schema
  
  Description
  User endpoint configuration schema
- Optionaluser_config_template?: string
  User Config Template
  
  Description
  Multi-user endpoints will render this Jinja template with user-provided variables to generate a user-specific endpoint configuration.
- uuid: string
  Uuid Format: uuid
  
  Description
  Endpoint UUID
EndpointConfig: {
    endpoint_id: string;
    result_queue_info: {
        connection_url: string;
        exchange: string;
        queue: string;
        queue_publish_kwargs: {
            exchange: string;
            mandatory: boolean;
            properties: { delivery_mode: number };
            routing_key: string;
        };
    };
    task_queue_info: {
        connection_url: string;
        exchange: string;
        queue: string;
    };
    warnings?: string[];
}
EndpointConfig
Example
```
{
         *       "endpoint_id": "7348422a-1074-427b-a08a-0771068afccc",
         *       "task_queue_info": {
         *         "connection_url": "amqps://user:password@mq.fqdn",
         *         "exchange": "some_exchange",
         *         "queue": "some_queue"
         *       },
         *       "result_queue_info": {
         *         "connection_url": "amqps://user:password@mq.fqdn",
         *         "exchange": "some_exchange",
         *         "queue": "some_queue",
         *         "queue_publish_kwargs": {
         *           "exchange": "some_exchange",
         *           "routing_key": "some_key",
         *           "mandatory": true,
         *           "properties": {
         *             "delivery_mode": 2
         *           }
         *         }
         *       },
         *       "warnings": []
         *     }
```
- endpoint_id: string
  Endpoint Id Format: uuid
  
  Description
  Endpoint UUID
- result_queue_info: {
      connection_url: string;
      exchange: string;
      queue: string;
      queue_publish_kwargs: {
          exchange: string;
          mandatory: boolean;
          properties: { delivery_mode: number };
          routing_key: string;
      };
  }
  - connection_url: string
    Connection Url
    
    Description
    Connection URL
  - exchange: string
    Exchange
    
    Description
    Exchange
  - queue: string
    Queue
    
    Description
    Queue
  - queue_publish_kwargs: {
        exchange: string;
        mandatory: boolean;
        properties: { delivery_mode: number };
        routing_key: string;
    }
    - exchange: string
      Exchange
      
      Description
      Exchange
    - mandatory: boolean
      Mandatory
      
      Description
      Mandatory
    - properties: { delivery_mode: number }
      - delivery_mode: number
        Delivery Mode
        
        Description
        Delivery mode
    - routing_key: string
      Routing Key
      
      Description
      Routing key
- task_queue_info: { connection_url: string; exchange: string; queue: string }
  - connection_url: string
    Connection Url
    
    Description
    Connection URL
  - exchange: string
    Exchange
    
    Description
    Exchange
  - queue: string
    Queue
    
    Description
    Queue
- Optionalwarnings?: string[]
  Warnings
  
  Description
  Warnings
EndpointConfigQueueInfo: { connection_url: string; exchange: string; queue: string }
EndpointConfigQueueInfo
- connection_url: string
  Connection Url
  
  Description
  Connection URL
- exchange: string
  Exchange
  
  Description
  Exchange
- queue: string
  Queue
  
  Description
  Queue
EndpointConfigResultQueue: {
    connection_url: string;
    exchange: string;
    queue: string;
    queue_publish_kwargs: {
        exchange: string;
        mandatory: boolean;
        properties: { delivery_mode: number };
        routing_key: string;
    };
}
EndpointConfigResultQueue
- connection_url: string
  Connection Url
  
  Description
  Connection URL
- exchange: string
  Exchange
  
  Description
  Exchange
- queue: string
  Queue
  
  Description
  Queue
- queue_publish_kwargs: {
      exchange: string;
      mandatory: boolean;
      properties: { delivery_mode: number };
      routing_key: string;
  }
  - exchange: string
    Exchange
    
    Description
    Exchange
  - mandatory: boolean
    Mandatory
    
    Description
    Mandatory
  - properties: { delivery_mode: number }
    - delivery_mode: number
      Delivery Mode
      
      Description
      Delivery mode
  - routing_key: string
    Routing Key
    
    Description
    Routing key
EndpointConfigResultQueuePublish: {
    exchange: string;
    mandatory: boolean;
    properties: { delivery_mode: number };
    routing_key: string;
}
EndpointConfigResultQueuePublish
- exchange: string
  Exchange
  
  Description
  Exchange
- mandatory: boolean
  Mandatory
  
  Description
  Mandatory
- properties: { delivery_mode: number }
  - delivery_mode: number
    Delivery Mode
    
    Description
    Delivery mode
- routing_key: string
  Routing Key
  
  Description
  Routing key
EndpointConfigResultQueuePublishProperties: { delivery_mode: number }
EndpointConfigResultQueuePublishProperties
- delivery_mode: number
  Delivery Mode
  
  Description
  Delivery mode
EndpointDeleteResponse: { result: number }
EndpointDeleteResponse
Example
```
{
         *       "result": 302
         *     }
```
- result: number
  Result
  
  Description
  The result as a status code integer
EndpointListResponseEntry: { display_name: string; name: string; owner: string; uuid: string }
EndpointListResponseEntry
Example
```
{
         *       "uuid": "7348422a-1074-427b-a08a-0771068afccc",
         *       "name": "My Endpoint",
         *       "display_name": "My Endpoint's display name",
         *       "owner": "0b3390f4-ca5f-496d-a7b9-9e4faed46bff"
         *     }
```
- display_name: string
  Display Name
  
  Description
  Display name
- name: string
  Name
  
  Description
  Endpoint name
- owner: string
  Owner Format: uuid
  
  Description
  Endpoint owner's identity ID
- uuid: string
  Uuid Format: uuid
  
  Description
  Endpoint UUID
EndpointMetadata: {
    config?: Record<string, unknown>;
    description?: string;
    endpoint_config?: string;
    endpoint_version?: string;
    hostname?: string;
    ip_address?: string;
    local_user?: string;
    python_version?: string;
    sdk_version?: string;
    user_config_schema?: Record<string, unknown>;
    user_config_template?: string;
}
EndpointMetadata
- Optionalconfig?: Record<string, unknown>
  Config
  
  Deprecated
  Description
  This field is deprecated. Please use endpoint_config instead.
- Optionaldescription?: string
  Description
  
  Description
  Endpoint description
- Optionalendpoint_config?: string
  Endpoint Config
  
  Description
  The contents of the endpoint's configuration file (config.yaml).
- Optionalendpoint_version?: string
  Endpoint Version
  
  Description
  Endpoint version
- Optionalhostname?: string
  Hostname
  
  Description
  Endpoint hostname
- Optionalip_address?: string
  Ip Address Format: ipvanyaddress
  
  Description
  Endpoint IP address
- Optionallocal_user?: string
  Local User
  
  Description
  Endpoint local user
- Optionalpython_version?: string
  Python Version
  
  Description
  Endpoint Python version
- Optionalsdk_version?: string
  Sdk Version
  
  Description
  Endpoint SDK version
- Optionaluser_config_schema?: Record<string, unknown>
  User Config Schema
  
  Description
  User endpoint configuration schema
- Optionaluser_config_template?: string
  User Config Template
  
  Description
  Multi-user endpoints will render this Jinja template with user-provided variables to generate a user-specific endpoint configuration.
EndpointRegisterMetadata: {
    config?: Record<string, unknown>;
    description?: string;
    endpoint_config?: string;
    endpoint_version?: string;
    hostname?: string;
    ip_address?: string;
    local_user?: string;
    python_version?: string;
    sdk_version?: string;
    user_config_schema?: Record<string, unknown>;
    user_config_template?: string;
}
EndpointRegisterMetadata
- Optionalconfig?: Record<string, unknown>
  Config
  
  Deprecated
  Description
  This field is deprecated. Please use endpoint_config instead.
- Optionaldescription?: string
  Description
  
  Description
  Endpoint description
- Optionalendpoint_config?: string
  Endpoint Config
  
  Description
  The contents of the endpoint's configuration file (config.yaml).
- Optionalendpoint_version?: string
  Endpoint Version
  
  Description
  Endpoint version
- Optionalhostname?: string
  Hostname
  
  Description
  Endpoint hostname
- Optionalip_address?: string
  Ip Address
  
  Description
  Endpoint IP address
- Optionallocal_user?: string
  Local User
  
  Description
  Endpoint local user
- Optionalpython_version?: string
  Python Version
  
  Description
  Endpoint Python version
- Optionalsdk_version?: string
  Sdk Version
  
  Description
  Endpoint SDK version
- Optionaluser_config_schema?: Record<string, unknown>
  User Config Schema
  
  Description
  User endpoint configuration schema
- Optionaluser_config_template?: string
  User Config Template
  
  Description
  Multi-user endpoints will render this Jinja template with user-provided variables to generate a user-specific endpoint configuration.
EndpointRegisterResponse: {
    endpoint_id: string;
    heartbeat_queue_info: {
        connection_url: string;
        exchange: string;
        queue: string;
        queue_publish_kwargs: {
            exchange: string;
            mandatory: boolean;
            properties: { delivery_mode: number };
            routing_key: string;
        };
    };
    result_queue_info: {
        connection_url: string;
        exchange: string;
        queue: string;
        queue_publish_kwargs: {
            exchange: string;
            mandatory: boolean;
            properties: { delivery_mode: number };
            routing_key: string;
        };
    };
    task_queue_info: {
        connection_url: string;
        exchange: string;
        queue: string;
    };
    warnings?: string[];
}
EndpointRegisterResponse
Example
```
{
         *       "endpoint_id": "7348422a-1074-427b-a08a-0771068afccc",
         *       "task_queue_info": {
         *         "connection_url": "amqps://user:password@mq.fqdn",
         *         "exchange": "some_exchange",
         *         "queue": "some_queue"
         *       },
         *       "result_queue_info": {
         *         "connection_url": "amqps://user:password@mq.fqdn",
         *         "exchange": "some_exchange",
         *         "queue": "some_queue",
         *         "queue_publish_kwargs": {
         *           "exchange": "some_exchange",
         *           "routing_key": "some_key",
         *           "mandatory": true,
         *           "properties": {
         *             "delivery_mode": 2
         *           }
         *         }
         *       },
         *       "heartbeat_queue_info": {
         *         "connection_url": "amqps://user:password@mq.fqdn",
         *         "exchange": "some_exchange",
         *         "queue": "some_queue",
         *         "queue_publish_kwargs": {
         *           "exchange": "some_exchange",
         *           "routing_key": "some_key",
         *           "mandatory": true,
         *           "properties": {
         *             "delivery_mode": 2
         *           }
         *         }
         *       }
         *     }
```
- endpoint_id: string
  Endpoint Id Format: uuid
  
  Description
  Endpoint UUID
- heartbeat_queue_info: {
      connection_url: string;
      exchange: string;
      queue: string;
      queue_publish_kwargs: {
          exchange: string;
          mandatory: boolean;
          properties: { delivery_mode: number };
          routing_key: string;
      };
  }
  - connection_url: string
    Connection Url
    
    Description
    Connection URL
  - exchange: string
    Exchange
    
    Description
    Exchange
  - queue: string
    Queue
    
    Description
    Queue
  - queue_publish_kwargs: {
        exchange: string;
        mandatory: boolean;
        properties: { delivery_mode: number };
        routing_key: string;
    }
    - exchange: string
      Exchange
      
      Description
      Exchange
    - mandatory: boolean
      Mandatory
      
      Description
      Mandatory
    - properties: { delivery_mode: number }
      - delivery_mode: number
        Delivery Mode
        
        Description
        Delivery mode
    - routing_key: string
      Routing Key
      
      Description
      Routing key
- result_queue_info: {
      connection_url: string;
      exchange: string;
      queue: string;
      queue_publish_kwargs: {
          exchange: string;
          mandatory: boolean;
          properties: { delivery_mode: number };
          routing_key: string;
      };
  }
  - connection_url: string
    Connection Url
    
    Description
    Connection URL
  - exchange: string
    Exchange
    
    Description
    Exchange
  - queue: string
    Queue
    
    Description
    Queue
  - queue_publish_kwargs: {
        exchange: string;
        mandatory: boolean;
        properties: { delivery_mode: number };
        routing_key: string;
    }
    - exchange: string
      Exchange
      
      Description
      Exchange
    - mandatory: boolean
      Mandatory
      
      Description
      Mandatory
    - properties: { delivery_mode: number }
      - delivery_mode: number
        Delivery Mode
        
        Description
        Delivery mode
    - routing_key: string
      Routing Key
      
      Description
      Routing key
- task_queue_info: { connection_url: string; exchange: string; queue: string }
  - connection_url: string
    Connection Url
    
    Description
    Connection URL
  - exchange: string
    Exchange
    
    Description
    Exchange
  - queue: string
    Queue
    
    Description
    Queue
- Optionalwarnings?: string[]
  Warnings
  
  Description
  Warnings
EndpointStatusDetails: {
    idle_workers: number;
    managers?: number;
    outstanding_tasks: number;
    pending_tasks: number;
    total_workers: number;
}
EndpointStatusDetails
- idle_workers: number
  Idle Workers
  
  Description
  Number of idle workers
- Optionalmanagers?: number
  Managers
  
  Description
  Number of managers
- outstanding_tasks: number
  Outstanding Tasks
  
  Description
  Number of outstanding tasks
- pending_tasks: number
  Pending Tasks
  
  Description
  Number of pending tasks
- total_workers: number
  Total Workers
  
  Description
  Total number of workers
EndpointStatusResponse: {
    details?: {
        idle_workers: number;
        managers?: number;
        outstanding_tasks: number;
        pending_tasks: number;
        total_workers: number;
    };
    status: string;
}
EndpointStatusResponse
Example
```
{
         *       "details": {
         *         "total_workers": 1,
         *         "idle_workers": 0,
         *         "pending_tasks": 0,
         *         "outstanding_tasks": 0,
         *         "managers": 1
         *       },
         *       "status": "online"
         *     }
```
- Optionaldetails?: {
      idle_workers: number;
      managers?: number;
      outstanding_tasks: number;
      pending_tasks: number;
      total_workers: number;
  }
  - idle_workers: number
    Idle Workers
    
    Description
    Number of idle workers
  - Optionalmanagers?: number
    Managers
    
    Description
    Number of managers
  - outstanding_tasks: number
    Outstanding Tasks
    
    Description
    Number of outstanding tasks
  - pending_tasks: number
    Pending Tasks
    
    Description
    Number of pending tasks
  - total_workers: number
    Total Workers
    
    Description
    Total number of workers
- status: string
  Status
  
  Description
  Endpoint status
ErrorResponse: {
    code: string;
    error_args: unknown[];
    http_status_code: number;
    reason: string;
    status: string;
}
ErrorResponse
- code: string
  Code
- error_args: unknown[]
  Error Args
- http_status_code: number
  Http Status Code
- reason: string
  Reason
- status: string
  Status
Function: {
    description?: string;
    function_code: string;
    function_name?: string;
    function_uuid: string;
    metadata: { python_version?: string; sdk_version?: string };
}
Function
Example
```
{
         *       "function_uuid": "11291b86-4f9c-47cb-848e-d3c06285951c",
         *       "function_name": "My Function",
         *       "function_code": "wuX2RpbGyUjBBfY3JlYXRlX2Z1bmN0 ...",
         *       "description": "My first function",
         *       "metadata": {
         *         "python_version": "3.11.3",
         *         "sdk_version": "2.3.3"
         *       }
         *     }
```
- Optionaldescription?: string
  Description
  
  Description
  Function description
- function_code: string
  Function Code
  
  Description
  Serialized function source code
- Optionalfunction_name?: string
  Function Name
  
  Description
  Function name
- function_uuid: string
  Function Uuid Format: uuid
  
  Description
  Function UUID
- metadata: { python_version?: string; sdk_version?: string }
  Metadata
  
  Description
  Function metadata
  - Optionalpython_version?: string
    Python Version
    
    Description
    Python version used to serialize function.
  - Optionalsdk_version?: string
    Sdk Version
    
    Description
    SDK version used to serialize function.
FunctionMetadata: { python_version?: string; sdk_version?: string }
FunctionMetadata
- Optionalpython_version?: string
  Python Version
  
  Description
  Python version used to serialize function.
- Optionalsdk_version?: string
  Sdk Version
  
  Description
  SDK version used to serialize function.
funcx_web_service__schemas__v2__endpoint__EndpointLockResponse: { endpoint_id: string; lock_expiration_timestamp: string }
EndpointLockResponse
Example
```
{
         *       "endpoint_id": "7348422a-1074-427b-a08a-0771068afccc",
         *       "lock_expiration_timestamp": "2021-07-01T00:00:00.000000"
         *     }
```
- endpoint_id: string
  Endpoint Id Format: uuid
  
  Description
  Endpoint UUID
- lock_expiration_timestamp: string
  Lock Expiration Timestamp Format: date-time
  
  Description
  Lock expiration timestamp
funcx_web_service__schemas__v2__endpoint__EndpointRegisterRequest: {
    allowed_functions?: string[];
    authentication_policy?: string;
    display_name?: string;
    endpoint_name: string;
    endpoint_uuid: string;
    metadata?: {
        config?: Record<string, unknown>;
        description?: string;
        endpoint_config?: string;
        endpoint_version?: string;
        hostname?: string;
        ip_address?: string;
        local_user?: string;
        python_version?: string;
        sdk_version?: string;
        user_config_schema?: Record<string, unknown>;
        user_config_template?: string;
    };
    multi_user: boolean;
    version?: string;
}
EndpointRegisterRequest
Example
```
{
         *       "endpoint_name": "My Endpoint",
         *       "display_name": "My Endpoint's display name",
         *       "endpoint_uuid": "7348422a-1074-427b-a08a-0771068afccc",
         *       "version": "1.0.10",
         *       "multi_user": false,
         *       "allowed_functions": [
         *         "11291b86-4f9c-47cb-848e-d3c06285951c"
         *       ],
         *       "authentication_policy": "67b4e120-2638-4771-86bb-6ac2a0f69e0b",
         *       "metadata": {
         *         "endpoint_config": "",
         *         "user_config_template": {},
         *         "user_config_schema": {},
         *         "description": "My endpoint description",
         *         "ip_address": "140.221.112.13",
         *         "hostname": "my-endpoint",
         *         "local_user": "user",
         *         "sdk_version": "1.0.10",
         *         "endpoint_version": "1.0.10",
         *         "python_version": "3.12.7"
         *       }
         *     }
```
- Optionalallowed_functions?: string[]
  Allowed Functions
  
  Description
  Functions that are allowed to be run on the endpoint
- Optionalauthentication_policy?: string
  Authentication Policy Format: uuid
  
  Description
  Endpoint users are evaluated against this Globus authentication policy. For more information on Globus authentication policies, visit https://docs.globus.org/api/auth/developer-guide/#authentication-policies.
- Optionaldisplay_name?: string
  Display Name
  
  Description
  Endpoint display name
- endpoint_name: string
  Endpoint Name
  
  Description
  Endpoint name
- endpoint_uuid: string
  Endpoint Uuid Format: uuid
  
  Description
  Endpoint UUID
- Optionalmetadata?: {
      config?: Record<string, unknown>;
      description?: string;
      endpoint_config?: string;
      endpoint_version?: string;
      hostname?: string;
      ip_address?: string;
      local_user?: string;
      python_version?: string;
      sdk_version?: string;
      user_config_schema?: Record<string, unknown>;
      user_config_template?: string;
  }
  - Optionalconfig?: Record<string, unknown>
    Config
    
    Deprecated
    Description
    This field is deprecated. Please use endpoint_config instead.
  - Optionaldescription?: string
    Description
    
    Description
    Endpoint description
  - Optionalendpoint_config?: string
    Endpoint Config
    
    Description
    The contents of the endpoint's configuration file (config.yaml).
  - Optionalendpoint_version?: string
    Endpoint Version
    
    Description
    Endpoint version
  - Optionalhostname?: string
    Hostname
    
    Description
    Endpoint hostname
  - Optionalip_address?: string
    Ip Address
    
    Description
    Endpoint IP address
  - Optionallocal_user?: string
    Local User
    
    Description
    Endpoint local user
  - Optionalpython_version?: string
    Python Version
    
    Description
    Endpoint Python version
  - Optionalsdk_version?: string
    Sdk Version
    
    Description
    Endpoint SDK version
  - Optionaluser_config_schema?: Record<string, unknown>
    User Config Schema
    
    Description
    User endpoint configuration schema
  - Optionaluser_config_template?: string
    User Config Template
    
    Description
    Multi-user endpoints will render this Jinja template with user-provided variables to generate a user-specific endpoint configuration.
- multi_user: boolean
  Multi User
  Description
  Endpoint multi-user mode
  Default
```
false
```
- Optionalversion?: string
  Version
  
  Description
  Endpoint version
funcx_web_service__schemas__v2__function__RegisterFunctionMetadata: { python_version?: string; sdk_version?: string }
RegisterFunctionMetadata
- Optionalpython_version?: string
  Python Version
  
  Description
  Python version used to serialize function.
- Optionalsdk_version?: string
  Sdk Version
  
  Description
  SDK version used to serialize function.
funcx_web_service__schemas__v2__function__RegisterFunctionRequest: {
    container_uuid?: string;
    description?: string;
    entry_point?: string;
    function_code: string;
    function_name: string;
    group?: string;
    metadata?: { python_version?: string; sdk_version?: string };
    public: boolean;
}
RegisterFunctionRequest
Example
```
{
         *       "function_name": "My Function",
         *       "function_code": "wuX2RpbGyUjBBfY3JlYXRlX2Z1bmN0 ...",
         *       "description": "My first function",
         *       "metadata": {
         *         "python_version": "3.11.3",
         *         "sdk_version": "2.3.3"
         *       },
         *       "container_uuid": "b7a42fa2-e97f-4061-9e64-2ede22ae7f5e",
         *       "group": "a2d6feb6-5386-4a06-8a22-99ea5ad7e651",
         *       "public": false
         *     }
```
- Optionalcontainer_uuid?: string
  Container Uuid Format: uuid
  
  Description
  Container UUID
- Optionaldescription?: string
  Description
  
  Description
  Function description
- Optionalentry_point?: string
  Entry Point
  
  Description
  (DEPRECATED) Entry point
- function_code: string
  Function Code
  
  Description
  Serialized function source code
- function_name: string
  Function Name
  
  Description
  Function name
- Optionalgroup?: string
  Group Format: uuid
  
  Description
  Globus group UUID
- Optionalmetadata?: { python_version?: string; sdk_version?: string }
  - Optionalpython_version?: string
    Python Version
    
    Description
    Python version used to serialize function.
  - Optionalsdk_version?: string
    Sdk Version
    
    Description
    SDK version used to serialize function.
- public: boolean
  Public
  Description
  Public function
  Default
```
false
```

funcx_web_serviceschemasv2taskBatchSubmitRequest: {
    create_websocket_queue: boolean;
    task_group_id?: string;
    tasks: [string, string, string][];
}

BatchSubmitRequest

Example

{
         *       "task_group_id": "97241626-8ff4-4550-9938-5909bd221869",
         *       "create_websocket_queue": false,
         *       "tasks": [
         *         [
         *           "116f1b48-0aab-4228-92f0-021c2ab14b5e",
         *           "ff960aba-fa23-43d5-9cbe-3f4f91a066e1",
         *           "... <serialized_arguments> ..."
         *         ],
         *         [
         *           "116f1b48-0aab-4228-92f0-021c2ab14b5e",
         *           "ff960aba-fa23-43d5-9cbe-3f4f91a066e1",
         *           "... <serialized_arguments> ..."
         *         ]
         *       ]
         *     }

create_websocket_queue: boolean
Create Websocket Queue
Description
Create websocket queue
Default
```
true
```
Optionaltask_group_id?: string
Task Group Id Format: uuid

Description
Task group UUID
tasks: [string, string, string][]
Tasks

Description
List of tasks to invoke, each referencing function and endpoint UUIDs.

funcx_web_serviceschemasv2taskBatchSubmitResponse: {
    response: string;
    results: (
        | string
        | {
            http_status_code: number;
            reason?: string;
            status: string;
            task_uuid: string;
        }
    )[];
    task_group_id?: string;
}

BatchSubmitResponse

Example

{
         *       "response": "success",
         *       "task_group_id": "97241626-8ff4-4550-9938-5909bd221869",
         *       "results": [
         *         {
         *           "status": "success",
         *           "task_uuid": "7dac44aa-c480-4460-b453-a47b03b031f4",
         *           "http_status_code": 200
         *         },
         *         {
         *           "status": "success",
         *           "task_uuid": "4b35645f-0c5b-465d-aaec-fee87f74ff5b",
         *           "http_status_code": 200
         *         }
         *       ]
         *     }

response: string
Response

Description
Response
results: (
    | string
    | {
        http_status_code: number;
        reason?: string;
        status: string;
        task_uuid: string;
    }
)[]
Results

Description
Task results
Optionaltask_group_id?: string
Task Group Id Format: uuid

Description
Task group UUID

funcx_web_service__schemas__v3__endpoints__EndpointLockResponse: { endpoint_id: string; lock_expiration_timestamp: number }
EndpointLockResponse
Example
```
{
         *       "endpoint_id": "7348422a-1074-427b-a08a-0771068afccc",
         *       "lock_expiration_timestamp": "1687531403.0434475"
         *     }
```
- endpoint_id: string
  Endpoint Id Format: uuid
  
  Description
  Endpoint UUID
- lock_expiration_timestamp: number
  Lock Expiration Timestamp
  
  Description
  Lock expiration UNIX timestamp
funcx_web_service__schemas__v3__endpoints__EndpointRegisterRequest: {
    admins?: string[];
    allowed_functions?: string[];
    authentication_policy?: string;
    display_name?: string;
    endpoint_name: string;
    high_assurance: boolean;
    metadata: {
        config?: Record<string, unknown>;
        description?: string;
        endpoint_config?: string;
        endpoint_version?: string;
        hostname?: string;
        ip_address?: string;
        local_user?: string;
        python_version?: string;
        sdk_version?: string;
        user_config_schema?: Record<string, unknown>;
        user_config_template?: string;
    };
    multi_user: boolean;
    public: boolean;
    subscription_uuid?: string;
    version?: string;
}
EndpointRegisterRequest
Example
```
{
         *       "endpoint_name": "my_endpoint",
         *       "display_name": "My Endpoint's Display Name",
         *       "version": "2.2.0",
         *       "multi_user": false,
         *       "public": false,
         *       "high_assurance": false,
         *       "allowed_functions": [
         *         "11291b86-4f9c-47cb-848e-d3c06285951c"
         *       ],
         *       "authentication_policy": "67b4e120-2638-4771-86bb-6ac2a0f69e0b",
         *       "subscription_uuid": "59b63c41-a765-4971-ac9a-41742059ade3",
         *       "metadata": {
         *         "endpoint_config": "",
         *         "user_config_template": {},
         *         "user_config_schema": {},
         *         "description": "My endpoint description",
         *         "ip_address": "140.221.112.13",
         *         "hostname": "my-endpoint",
         *         "local_user": "user",
         *         "sdk_version": "2.2.0",
         *         "endpoint_version": "2.2.0",
         *         "python_version": "3.12.7"
         *       }
         *     }
```
- Optionaladmins?: string[]
  Admins
  
  Description
  A set of Globus Auth identity IDs that, in addition to the owner, have administrative access to the endpoint. This field requires an active Globus subscription (i.e., subscription_uuid field).
- Optionalallowed_functions?: string[]
  Allowed Functions
  
  Description
  Functions that are allowed to be run on the endpoint
- Optionalauthentication_policy?: string
  Authentication Policy Format: uuid
  
  Description
  Endpoint users are evaluated against this Globus authentication policy. For more information on Globus authentication policies, visit https://docs.globus.org/api/auth/developer-guide/#authentication-policies.
- Optionaldisplay_name?: string
  Display Name
  
  Description
  Endpoint display name
- endpoint_name: string
  Endpoint Name
  
  Description
  Endpoint name
- high_assurance: boolean
  High Assurance
  Description
  Endpoint supports high-assurance protocols
  Default
```
false
```
- metadata: {
      config?: Record<string, unknown>;
      description?: string;
      endpoint_config?: string;
      endpoint_version?: string;
      hostname?: string;
      ip_address?: string;
      local_user?: string;
      python_version?: string;
      sdk_version?: string;
      user_config_schema?: Record<string, unknown>;
      user_config_template?: string;
  }
  Metadata
  
  Description
  Endpoint metadata
  - Optionalconfig?: Record<string, unknown>
    Config
    
    Deprecated
    Description
    This field is deprecated. Please use endpoint_config instead.
  - Optionaldescription?: string
    Description
    
    Description
    Endpoint description
  - Optionalendpoint_config?: string
    Endpoint Config
    
    Description
    The contents of the endpoint's configuration file (config.yaml).
  - Optionalendpoint_version?: string
    Endpoint Version
    
    Description
    Endpoint version
  - Optionalhostname?: string
    Hostname
    
    Description
    Endpoint hostname
  - Optionalip_address?: string
    Ip Address Format: ipvanyaddress
    
    Description
    Endpoint IP address
  - Optionallocal_user?: string
    Local User
    
    Description
    Endpoint local user
  - Optionalpython_version?: string
    Python Version
    
    Description
    Endpoint Python version
  - Optionalsdk_version?: string
    Sdk Version
    
    Description
    Endpoint SDK version
  - Optionaluser_config_schema?: Record<string, unknown>
    User Config Schema
    
    Description
    User endpoint configuration schema
  - Optionaluser_config_template?: string
    User Config Template
    
    Description
    Multi-user endpoints will render this Jinja template with user-provided variables to generate a user-specific endpoint configuration.
- multi_user: boolean
  Multi User
  Description
  Endpoint multi-user mode
  Default
```
false
```
- public: boolean
  Public
  Description
  Indicates if all users can discover the multi-user endpoint. Please note that this field does not control access to the endpoint, so it should not be used as a security feature.
  Default
```
false
```
- Optionalsubscription_uuid?: string
  Subscription Uuid Format: uuid
  
  Description
  Associates an endpoint with a subscription.
- Optionalversion?: string
  Version
  
  Description
  Endpoint version
funcx_web_service__schemas__v3__function__RegisterFunctionMetadata: { python_version: string; sdk_version: string; serde_identifier: string }
RegisterFunctionMetadata
- python_version: string
  Python Version
  
  Description
  version used to serialize function
- sdk_version: string
  Globus Compute SDK version
  
  Description
  version used to serialize function
- serde_identifier: string
  Serde Identifier
  
  Description
  Identifier of SDK method used to serialize the function; the identifiers are not currently specifically documented, but may be found in the Globus Compute SDK repository as the identifier class variable of the respective serializers
funcx_web_service__schemas__v3__function__RegisterFunctionRequest: {
    description?: string;
    function_code: string;
    function_name: string;
    group?: string;
    ha_endpoint_id?: string;
    meta: {
        python_version: string;
        sdk_version: string;
        serde_identifier: string;
    };
    public: boolean;
}
RegisterFunctionRequest
Example
```
{
         *       "function_name": "dot_product",
         *       "function_code": "850\n01\ngASVZwIAAAAAAACMCmRpbGwuX2RpbGyUjBB...",
         *       "description": "Dot product of two vectors (unchecked length)",
         *       "metadata": {
         *         "python_version": "3.13.3",
         *         "sdk_version": "3.1.1",
         *         "serde_identifier": "01"
         *       },
         *       "public": true
         *     }
```
- Optionaldescription?: string
  Description
  
  Description
  Function description
- function_code: string
  Function Code
  
  Description
  Serialized function source code
- function_name: string
  Function Name
  
  Description
  Function name
- Optionalgroup?: string
  Group Format: uuid
  
  Description
  If specified, this function will be accessible to members of the Globus Group specified by this identifier
- Optionalha_endpoint_id?: string
  Ha Endpoint Id Format: uuid
  
  Description
  Users will only be able to run this function on the specified HA endpoint. Since HA functions cannot be shared, this field is mutually exclusive with the group and public fields.
- meta: { python_version: string; sdk_version: string; serde_identifier: string }
  Meta
  
  Description
  Function metadata
  - python_version: string
    Python Version
    
    Description
    version used to serialize function
  - sdk_version: string
    Globus Compute SDK version
    
    Description
    version used to serialize function
  - serde_identifier: string
    Serde Identifier
    
    Description
    Identifier of SDK method used to serialize the function; the identifiers are not currently specifically documented, but may be found in the Globus Compute SDK repository as the identifier class variable of the respective serializers
- public: boolean
  Public
  Description
  If true, this function will be accessible to any registered user
  Default
```
false
```
funcx_web_service__schemas__v3__tasks__BatchSubmitRequest: {
    create_queue: boolean;
    resource_specification?: {
        launcher_options?: string;
        num_nodes: number;
        num_ranks?: number;
        ranks_per_node?: number;
    };
    result_serializers?: string[];
    task_group_id?: string;
    tasks: { [key: string]: string[] };
    user_endpoint_config?: Record<string, unknown>;
    user_runtime?: {
        globus_compute_sdk_version?: string;
        globus_sdk_version?: string;
        python_version?: string;
    };
}
BatchSubmitRequest
Example
```
{
         *       "task_group_id": "97241626-8ff4-4550-9938-5909bd221869",
         *       "user_endpoint_config": {
         *         "min_blocks": 0,
         *         "max_blocks": 1,
         *         "scheduler_options": "#SBATCH --constraint=knl,quad,cache"
         *       },
         *       "resource_specification": {
         *         "num_nodes": 2,
         *         "ranks_per_node": 2,
         *         "num_ranks": 4,
         *         "launcher_options": "--cpu-bind quiet --mem 3072"
         *       },
         *       "result_serializers": [
         *         "globus_compute_sdk.serialize.JSONData",
         *         "globus_compute_sdk.serialize.DillDataBase64"
         *       ],
         *       "create_queue": true,
         *       "tasks": {
         *         "ff960aba-fa23-43d5-9cbe-3f4f91a066e1": [
         *           "... <serialized_arguments> ...",
         *           "... <serialized_arguments> ...",
         *           "..."
         *         ],
         *         "0a98fd06-edbd-11ed-abcd-0d705ebb4c49": [
         *           "... <serialized_arguments> ...",
         *           "..."
         *         ]
         *       }
         *     }
```
- create_queue: boolean
  Create Queue
  Description
  If true, create a Task Group specific AMQP queue for the results. In addition to the usual longer-term storage, results will also be copied to this AMQP queue, enabling consumers to get event-driven (instant) results. (See the Globus Compute SDK Executor for an implementation that uses this feature.)
  Default
```
false
```
- Optionalresource_specification?: {
      launcher_options?: string;
      num_nodes: number;
      num_ranks?: number;
      ranks_per_node?: number;
  }
  Resource Specification
  
  Description
  Specify resource requirements for individual task execution.
  - Optionallauncher_options?: string
    Launcher Options
    
    Description
    Options passed through to the MPI launcher command line prefix.
  - num_nodes: number
    Num Nodes
    
    Description
    Number of nodes required for an MPI application
  - Optionalnum_ranks?: number
    Num Ranks
    
    Description
    Total number of MPI ranks to launch across all nodes.
  - Optionalranks_per_node?: number
    Ranks Per Node
    
    Description
    Number of MPI ranks to launch per node.
- Optionalresult_serializers?: string[]
  Result Serializers
  
  Description
  A list of import paths to SerializationStrategy subclasses that the endpoint is allowed to use when serializing results.
- Optionaltask_group_id?: string
  Task Group Id Format: uuid
  
  Description
  Associate the request tasks with specified Task Group identifier; if not specified or invalid, a new identifier will be generated and returned in the response
- tasks: { [key: string]: string[] }
  Tasks
  
  Description
  Lists of serialized task arguments (strings), grouped by function identifiers
- Optionaluser_endpoint_config?: Record<string, unknown>
  User Endpoint Config
  
  Description
  Specify user endpoint configuration values as described and allowed by endpoint administrators.
- Optionaluser_runtime?: {
      globus_compute_sdk_version?: string;
      globus_sdk_version?: string;
      python_version?: string;
  }
  User Runtime
  
  Description
  Information about the runtime that submitted this batch, such as Python and Globus Compute SDK versions.
  - Optionalglobus_compute_sdk_version?: string
    Globus Compute Sdk Version
    
    Description
    Version of the Globus Compute SDK used to submit this batch.
  - Optionalglobus_sdk_version?: string
    Globus Sdk Version
    
    Description
    Version of the Globus SDK used to submit this batch.
  - Optionalpython_version?: string
    Python Version
    
    Description
    Python version that ran the SDK and submitted this batch.

funcx_web_serviceschemasv3tasksBatchSubmitResponse: {
    endpoint_id: string;
    request_id: string;
    task_group_id: string;
    tasks: { [key: string]: string[] };
}

BatchSubmitResponse

Example

{
         *       "request_id": "5158de19-10b5-4deb-9d87-a86c1dec3460",
         *       "task_group_id": "97241626-8ff4-4550-9938-5909bd221869",
         *       "endpoint_id": "116f1b48-0aab-4228-92f0-021c2ab14b5e",
         *       "tasks": {
         *         "ff960aba-fa23-43d5-9cbe-3f4f91a066e1": [
         *           "89bde6c3-85e9-4834-b0e8-5cb51955eaf5",
         *           "1e900b37-7a80-424b-aeac-56dd2860f59a",
         *           "9f12a732-3aa6-4878-9d58-b290837ab096"
         *         ],
         *         "0a98fd06-edbd-11ed-abcd-0d705ebb4c49": [
         *           "022151bf-7b2d-4240-b4d0-9ac5b7077314",
         *           "1f6f5f1e-15b0-4916-85ff-471511bd35d6"
         *         ]
         *       }
         *     }

endpoint_id: string
Endpoint Id Format: uuid

Description
The endpoint to which the request's tasks were sent for invocation
request_id: string
Request Id

Description
A unique string to identify the request; currently this is mainly to aid debugging efforts — such as if a user needs to verify an interaction with Globus Support — and has no automated API hookup or use elsewhere in the Compute ecosystem
task_group_id: string
Task Group Id Format: uuid

Description
The Task Group identifier to which the submitted tasks were associated
tasks: { [key: string]: string[] }
Tasks

Description
The task identifiers, grouped by the identifier of the function IDs that will execute them. Note that the order of the identifiers within each list exactly matches the order of serialized arguments in the request.

FuncxStatsResponse: { total_function_invocations: number }
FuncxStatsResponse
Example
```
{
         *       "total_function_invocations": 100
         *     }
```
- total_function_invocations: number
  Total Function Invocations
  
  Description
  Total function invocations
FuncxVersionResponse: {
    api: string;
    container_service?: string;
    git_sha?: string;
    min_ep_version?: string;
    min_sdk_version?: string;
}
FuncxVersionResponse
Example
```
{
         *       "api": "1.0.9",
         *       "min_sdk_version": "1.0.10",
         *       "min_ep_version": "1.0.10",
         *       "git_sha": "3ae0ff6bc42b6d5f9d92f3c426fe9e535a841hb6",
         *       "container_service": "0.0.1"
         *     }
```
- api: string
  Api
  
  Description
  API version
- Optionalcontainer_service?: string
  Container Service
  
  Description
  Container service version
- Optionalgit_sha?: string
  Git Sha
  
  Description
  Git SHA of the latest commit
- Optionalmin_ep_version?: string
  Min Ep Version
  
  Description
  Minimum endpoint version
- Optionalmin_sdk_version?: string
  Min Sdk Version
  
  Description
  Minimum SDK version
HTTPValidationError: { detail?: { loc: (string | number)[]; msg: string; type: string }[] }
HTTPValidationError
- Optionaldetail?: { loc: (string | number)[]; msg: string; type: string }[]
  Detail
MultiUserEndpointConfig: {
    command_queue_info: {
        connection_url: string;
        exchange: string;
        queue: string;
    };
    endpoint_id: string;
    warnings?: string[];
}
MultiUserEndpointConfig
- command_queue_info: { connection_url: string; exchange: string; queue: string }
  - connection_url: string
    Connection Url
    
    Description
    Connection URL
  - exchange: string
    Exchange
    
    Description
    Exchange
  - queue: string
    Queue
    
    Description
    Queue
- endpoint_id: string
  Endpoint Id Format: uuid
  
  Description
  Endpoint UUID
- Optionalwarnings?: string[]
  Warnings
  
  Description
  Warnings
MultiUserEndpointRegisterResponse: {
    command_queue_info: {
        connection_url: string;
        exchange: string;
        queue: string;
    };
    endpoint_id: string;
    heartbeat_queue_info: {
        connection_url: string;
        exchange: string;
        queue: string;
        queue_publish_kwargs: {
            exchange: string;
            mandatory: boolean;
            properties: { delivery_mode: number };
            routing_key: string;
        };
    };
    result_queue_info: {
        connection_url: string;
        exchange: string;
        queue: string;
        queue_publish_kwargs: {
            exchange: string;
            mandatory: boolean;
            properties: { delivery_mode: number };
            routing_key: string;
        };
    };
    warnings?: string[];
}
MultiUserEndpointRegisterResponse
Example
```
{
         *       "endpoint_id": "7348422a-1074-427b-a08a-0771068afccc",
         *       "command_queue_info": {
         *         "connection_url": "amqps://user:password@mq.fqdn",
         *         "exchange": "some_exchange",
         *         "queue": "some_queue"
         *       },
         *       "result_queue_info": {
         *         "connection_url": "amqps://user:password@mq.fqdn",
         *         "exchange": "some_exchange",
         *         "queue": "some_queue",
         *         "queue_publish_kwargs": {
         *           "exchange": "some_exchange",
         *           "routing_key": "some_key",
         *           "mandatory": true,
         *           "properties": {
         *             "delivery_mode": 2
         *           }
         *         }
         *       },
         *       "heartbeat_queue_info": {
         *         "connection_url": "amqps://user:password@mq.fqdn",
         *         "exchange": "some_exchange",
         *         "queue": "some_queue",
         *         "queue_publish_kwargs": {
         *           "exchange": "some_exchange",
         *           "routing_key": "some_key",
         *           "mandatory": true,
         *           "properties": {
         *             "delivery_mode": 2
         *           }
         *         }
         *       }
         *     }
```
- command_queue_info: { connection_url: string; exchange: string; queue: string }
  - connection_url: string
    Connection Url
    
    Description
    Connection URL
  - exchange: string
    Exchange
    
    Description
    Exchange
  - queue: string
    Queue
    
    Description
    Queue
- endpoint_id: string
  Endpoint Id Format: uuid
  
  Description
  Endpoint UUID
- heartbeat_queue_info: {
      connection_url: string;
      exchange: string;
      queue: string;
      queue_publish_kwargs: {
          exchange: string;
          mandatory: boolean;
          properties: { delivery_mode: number };
          routing_key: string;
      };
  }
  - connection_url: string
    Connection Url
    
    Description
    Connection URL
  - exchange: string
    Exchange
    
    Description
    Exchange
  - queue: string
    Queue
    
    Description
    Queue
  - queue_publish_kwargs: {
        exchange: string;
        mandatory: boolean;
        properties: { delivery_mode: number };
        routing_key: string;
    }
    - exchange: string
      Exchange
      
      Description
      Exchange
    - mandatory: boolean
      Mandatory
      
      Description
      Mandatory
    - properties: { delivery_mode: number }
      - delivery_mode: number
        Delivery Mode
        
        Description
        Delivery mode
    - routing_key: string
      Routing Key
      
      Description
      Routing key
- result_queue_info: {
      connection_url: string;
      exchange: string;
      queue: string;
      queue_publish_kwargs: {
          exchange: string;
          mandatory: boolean;
          properties: { delivery_mode: number };
          routing_key: string;
      };
  }
  - connection_url: string
    Connection Url
    
    Description
    Connection URL
  - exchange: string
    Exchange
    
    Description
    Exchange
  - queue: string
    Queue
    
    Description
    Queue
  - queue_publish_kwargs: {
        exchange: string;
        mandatory: boolean;
        properties: { delivery_mode: number };
        routing_key: string;
    }
    - exchange: string
      Exchange
      
      Description
      Exchange
    - mandatory: boolean
      Mandatory
      
      Description
      Mandatory
    - properties: { delivery_mode: number }
      - delivery_mode: number
        Delivery Mode
        
        Description
        Delivery mode
    - routing_key: string
      Routing Key
      
      Description
      Routing key
- Optionalwarnings?: string[]
  Warnings
  
  Description
  Warnings
ReadQueueInfo: { connection_url: string; exchange: string; queue: string }
ReadQueueInfo
- connection_url: string
  Connection Url
  
  Description
  Connection URL
- exchange: string
  Exchange
  
  Description
  Exchange
- queue: string
  Queue
  
  Description
  Queue
RegisterFunctionResponse: { function_uuid: string }
RegisterFunctionResponse
Example
```
{
         *       "function_uuid": "11291b86-4f9c-47cb-848e-d3c06285951c"
         *     }
```
- function_uuid: string
  Function Uuid Format: uuid
  
  Description
  Function UUID
ResourceSpecification: {
    launcher_options?: string;
    num_nodes: number;
    num_ranks?: number;
    ranks_per_node?: number;
}
ResourceSpecification
- Optionallauncher_options?: string
  Launcher Options
  
  Description
  Options passed through to the MPI launcher command line prefix.
- num_nodes: number
  Num Nodes
  
  Description
  Number of nodes required for an MPI application
- Optionalnum_ranks?: number
  Num Ranks
  
  Description
  Total number of MPI ranks to launch across all nodes.
- Optionalranks_per_node?: number
  Ranks Per Node
  
  Description
  Number of MPI ranks to launch per node.
ResultAmqpUrlResponse: { connection_url: string; queue_prefix: string }
ResultAmqpUrlResponse
Example
```
{
         *       "queue_prefix": "some_prefix",
         *       "connection_url": "amqps://user:password@amq.fqdn"
         *     }
```
- connection_url: string
  Connection Url Format: uri
  
  Description
  Connection URL
- queue_prefix: string
  Queue Prefix
  
  Description
  Queue prefix

TaskGroupResponse: {
    create_websockets_queue?: boolean;
    taskgroup_id: string;
    tasks: { created_at: string; id: string }[];
}

TaskGroupResponse

Example

{
         *       "taskgroup_id": "4defbef8-0a1a-4c7b-9c83-b59174fca395",
         *       "create_websockets_queue": true,
         *       "tasks": [
         *         {
         *           "id": "9e38ed49-7d05-45c4-9ad0-bfa3bc92d6a1",
         *           "created_at": "2021-05-05T15:00:00.000000"
         *         }
         *       ]
         *     }

Optionalcreate_websockets_queue?: boolean
Create Websockets Queue

Description
Create websockets queue
taskgroup_id: string
Taskgroup Id Format: uuid

Description
Task Group UUID
tasks: { created_at: string; id: string }[]
Tasks

TaskGroupResponseTask: { created_at: string; id: string }
TaskGroupResponseTask
- created_at: string
  Created At Format: date-time
  
  Description
  Task creation time
- id: string
  Id Format: uuid
  
  Description
  Task UUID

TaskStatusResponse: {
    completion_t?: string;
    details?: Record<string, unknown>;
    exception?: string;
    result?: string;
    status?: unknown;
    task_id: string;
}

TaskStatusResponse

Example

{
         *       "task_id": "7dac44aa-c480-4460-b453-a47b03b031f4",
         *       "status": "success",
         *       "result": "10000",
         *       "completion_t": "1677183605.212898",
         *       "details": {
         *         "os": "Linux-5.19.0-1025-aws-x86_64-with-glibc2.35",
         *         "python_version": "3.10.4",
         *         "dill_version": "0.3.5.1",
         *         "globus_compute_sdk_version": "2.3.2",
         *         "task_transitions": {
         *           "execution-start": 1692742841.843334,
         *           "execution-end": 1692742846.123456
         *         }
         *       }
         *     }

Optionalcompletion_t?: string
Completion T

Description
Task completion Unix time
Optionaldetails?: Record<string, unknown>
Details

Description
Task execution details
Optionalexception?: string
Exception

Description
Exception
Optionalresult?: string
Result

Description
Task result
Optionalstatus?: unknown
Status

Description
Task status
task_id: string
Task Id Format: uuid

Description
Task UUID

UserRuntime: {
    globus_compute_sdk_version?: string;
    globus_sdk_version?: string;
    python_version?: string;
}
UserRuntime
- Optionalglobus_compute_sdk_version?: string
  Globus Compute Sdk Version
  
  Description
  Version of the Globus Compute SDK used to submit this batch.
- Optionalglobus_sdk_version?: string
  Globus Sdk Version
  
  Description
  Version of the Globus SDK used to submit this batch.
- Optionalpython_version?: string
  Python Version
  
  Description
  Python version that ran the SDK and submitted this batch.
ValidationError: { loc: (string | number)[]; msg: string; type: string }
ValidationError
- loc: (string | number)[]
  Location
- msg: string
  Message
- type: string
  Error Type
ValidationErrorResponse: {
    code: string;
    error_args: unknown[];
    http_status_code: number;
    reason: { loc: (string | number)[]; msg: string; type: string }[];
    status: string;
}
ValidationErrorResponse
- code: string
  Code
- error_args: unknown[]
  Error Args
- http_status_code: number
  Http Status Code
- reason: { loc: (string | number)[]; msg: string; type: string }[]
  Reason
- status: string
  Status
VersionService: "all" | "api"
VersionService

Description
An enumeration.
WriteQueueInfo: {
    connection_url: string;
    exchange: string;
    queue: string;
    queue_publish_kwargs: {
        exchange: string;
        mandatory: boolean;
        properties: { delivery_mode: number };
        routing_key: string;
    };
}
WriteQueueInfo
- connection_url: string
  Connection Url
  
  Description
  Connection URL
- exchange: string
  Exchange
  
  Description
  Exchange
- queue: string
  Queue
  
  Description
  Queue
- queue_publish_kwargs: {
      exchange: string;
      mandatory: boolean;
      properties: { delivery_mode: number };
      routing_key: string;
  }
  - exchange: string
    Exchange
    
    Description
    Exchange
  - mandatory: boolean
    Mandatory
    
    Description
    Mandatory
  - properties: { delivery_mode: number }
    - delivery_mode: number
      Delivery Mode
      
      Description
      Delivery mode
  - routing_key: string
    Routing Key
    
    Description
    Routing key
WriteQueuePublishKwargs: {
    exchange: string;
    mandatory: boolean;
    properties: { delivery_mode: number };
    routing_key: string;
}
WriteQueuePublishKwargs
- exchange: string
  Exchange
  
  Description
  Exchange
- mandatory: boolean
  Mandatory
  
  Description
  Mandatory
- properties: { delivery_mode: number }
  - delivery_mode: number
    Delivery Mode
    
    Description
    Delivery mode
- routing_key: string
  Routing Key
  
  Description
  Routing key
WriteQueuePublishProperties: { delivery_mode: number }
WriteQueuePublishProperties
- delivery_mode: number
  Delivery Mode
  
  Description
  Delivery mode

Interface components

Index

Properties

Properties

headers

parameters

pathItems

requestBodies

responses

schemas

Type declaration

AllowedFunctionsResponse: { endpoint_id: string; functions?: string[]; restricted: boolean }

Example

endpoint_id: string

Description

Optionalfunctions?: string[]

Description

restricted: boolean

Description

BatchStatusRequest: { task_ids: string[] }

Example

task_ids: string[]

Description

BatchStatusResponse: { response: string; results: { [key: string]: { completion_t?: string; exception?: string; reason?: string; result?: string; status?: unknown; task_id: string; }; };}

Example

response: string

Description

results: { [key: string]: { completion_t?: string; exception?: string; reason?: string; result?: string; status?: unknown; task_id: string; };}

Description

BatchStatusResponseResults: { completion_t?: string; exception?: string; reason?: string; result?: string; status?: unknown; task_id: string;}

Optionalcompletion_t?: string

Description

Optionalexception?: string

Description

Optionalreason?: string

Description

Optionalresult?: string

Description

Optionalstatus?: unknown

Description

task_id: string

Description

BatchSubmitResponseTask: { http_status_code: number; reason?: string; status: string; task_uuid: string }

http_status_code: number

Description

Optionalreason?: string

Description

status: string

Description

task_uuid: string

Description

BuildStatus: | "provided" | "submitted" | "initialized" | "queued" | "building" | "ready" | "failed"

Description

ConsoleNodeInfo: { endpoint_version?: string; idle_duration_seconds?: number; python_version?: string; sdk_version?: string; total_worker_count?: number;}

Optionalendpoint_version?: string

Description

Optionalidle_duration_seconds?: number

Description

Optionalpython_version?: string

Description

Optionalsdk_version?: string

Description

Optionaltotal_worker_count?: number

Description

Example

Description

Optionalaccount?: string

Description

active: boolean

Description

Default

Optionalclient_sdk_versions?: string[]

Description

Optionalconfig?: string

Description

Optionalendpoint_version?: string

Description

Optionalengine_type?: string

Description

Optionalexecuted_task_count?: number

`Optional`functions?: string[]

BatchStatusResponse: {
response: string;
results: {
[key: string]: {
completion_t?: string;
exception?: string;
reason?: string;
result?: string;
status?: unknown;
task_id: string;
};
};
}

results: {
[key: string]: {
completion_t?: string;
exception?: string;
reason?: string;
result?: string;
status?: unknown;
task_id: string;
};
}

BatchStatusResponseResults: {
completion_t?: string;
exception?: string;
reason?: string;
result?: string;
status?: unknown;
task_id: string;
}

`Optional`completion_t?: string

`Optional`exception?: string

`Optional`reason?: string

`Optional`result?: string

`Optional`status?: unknown

`Optional`reason?: string

BuildStatus:
| "provided"
| "submitted"
| "initialized"
| "queued"
| "building"
| "ready"
| "failed"

ConsoleNodeInfo: {
endpoint_version?: string;
idle_duration_seconds?: number;
python_version?: string;
sdk_version?: string;
total_worker_count?: number;
}

`Optional`endpoint_version?: string

`Optional`idle_duration_seconds?: number

`Optional`python_version?: string

`Optional`sdk_version?: string

`Optional`total_worker_count?: number

`Optional`account?: string

`Optional`client_sdk_versions?: string[]

`Optional`config?: string

`Optional`endpoint_version?: string

`Optional`engine_type?: string

`Optional`executed_task_count?: number

`Optional`idle_worker_count?: number

`Optional`last_heartbeat_unix?: number

`Optional`node_info?: {
[key: string]: {
endpoint_version?: string;
idle_duration_seconds?: number;
python_version?: string;
sdk_version?: string;
total_worker_count?: number;
}[];
}

`Optional`posix_pid?: number

`Optional`posix_username?: string

`Optional`provider_type?: string

`Optional`python_version?: string

`Optional`queue?: string

`Optional`queued_task_count?: number

`Optional`running_task_count?: number

`Optional`start_time_iso?: string

`Optional`start_time_unix?: number

`Optional`total_node_count?: number

`Optional`total_worker_count?: number

ContainerBuildRequest: {
apt: string[];
conda: string[];
description?: string;
name: string;
payload_url?: string;
pip: string[];
}

`Optional`description?: string

`Optional`payload_url?: string

ContainerBuildStatusResponse: {
status:
| "provided"
| "submitted"
| "initialized"
| "queued"
| "building"
| "ready"
| "failed";
}

status:
| "provided"
| "submitted"
| "initialized"
| "queued"
| "building"
| "ready"
| "failed"

ContainerRegisterRequest: {
description?: string;
location: string;
name: string;
type: "docker" | "singularity";
}

`Optional`description?: string