Trait clarifai_grpc::grpc::service_grpc::V2[−][src]

pub trait V2 {

Show 131 methods    fn list_concept_relations(
        &mut self, 
        ctx: RpcContext<'_>, 
        req: ListConceptRelationsRequest, 
        sink: UnarySink<MultiConceptRelationResponse>
    );

    fn post_concept_relations(
        &mut self, 
        ctx: RpcContext<'_>, 
        req: PostConceptRelationsRequest, 
        sink: UnarySink<MultiConceptRelationResponse>
    );

    fn delete_concept_relations(
        &mut self, 
        ctx: RpcContext<'_>, 
        req: DeleteConceptRelationsRequest, 
        sink: UnarySink<BaseResponse>
    );

    fn get_concept_counts(
        &mut self, 
        ctx: RpcContext<'_>, 
        req: GetConceptCountsRequest, 
        sink: UnarySink<MultiConceptCountResponse>
    );

    fn get_concept(
        &mut self, 
        ctx: RpcContext<'_>, 
        req: GetConceptRequest, 
        sink: UnarySink<SingleConceptResponse>
    );

    fn list_concepts(
        &mut self, 
        ctx: RpcContext<'_>, 
        req: ListConceptsRequest, 
        sink: UnarySink<MultiConceptResponse>
    );

    fn post_concepts_searches(
        &mut self, 
        ctx: RpcContext<'_>, 
        req: PostConceptsSearchesRequest, 
        sink: UnarySink<MultiConceptResponse>
    );

    fn post_concepts(
        &mut self, 
        ctx: RpcContext<'_>, 
        req: PostConceptsRequest, 
        sink: UnarySink<MultiConceptResponse>
    );

    fn patch_concepts(
        &mut self, 
        ctx: RpcContext<'_>, 
        req: PatchConceptsRequest, 
        sink: UnarySink<MultiConceptResponse>
    );

    fn get_concept_language(
        &mut self, 
        ctx: RpcContext<'_>, 
        req: GetConceptLanguageRequest, 
        sink: UnarySink<SingleConceptLanguageResponse>
    );

    fn list_concept_languages(
        &mut self, 
        ctx: RpcContext<'_>, 
        req: ListConceptLanguagesRequest, 
        sink: UnarySink<MultiConceptLanguageResponse>
    );

    fn post_concept_languages(
        &mut self, 
        ctx: RpcContext<'_>, 
        req: PostConceptLanguagesRequest, 
        sink: UnarySink<MultiConceptLanguageResponse>
    );

    fn patch_concept_languages(
        &mut self, 
        ctx: RpcContext<'_>, 
        req: PatchConceptLanguagesRequest, 
        sink: UnarySink<MultiConceptLanguageResponse>
    );

    fn list_knowledge_graphs(
        &mut self, 
        ctx: RpcContext<'_>, 
        req: ListKnowledgeGraphsRequest, 
        sink: UnarySink<MultiKnowledgeGraphResponse>
    );

    fn post_knowledge_graphs(
        &mut self, 
        ctx: RpcContext<'_>, 
        req: PostKnowledgeGraphsRequest, 
        sink: UnarySink<MultiKnowledgeGraphResponse>
    );

    fn post_concept_mapping_jobs(
        &mut self, 
        ctx: RpcContext<'_>, 
        req: PostConceptMappingJobsRequest, 
        sink: UnarySink<MultiConceptMappingJobResponse>
    );

    fn get_annotation(
        &mut self, 
        ctx: RpcContext<'_>, 
        req: GetAnnotationRequest, 
        sink: UnarySink<SingleAnnotationResponse>
    );

    fn list_annotations(
        &mut self, 
        ctx: RpcContext<'_>, 
        req: ListAnnotationsRequest, 
        sink: UnarySink<MultiAnnotationResponse>
    );

    fn post_annotations(
        &mut self, 
        ctx: RpcContext<'_>, 
        req: PostAnnotationsRequest, 
        sink: UnarySink<MultiAnnotationResponse>
    );

    fn patch_annotations(
        &mut self, 
        ctx: RpcContext<'_>, 
        req: PatchAnnotationsRequest, 
        sink: UnarySink<MultiAnnotationResponse>
    );

    fn patch_annotations_status(
        &mut self, 
        ctx: RpcContext<'_>, 
        req: PatchAnnotationsStatusRequest, 
        sink: UnarySink<PatchAnnotationsStatusResponse>
    );

    fn delete_annotation(
        &mut self, 
        ctx: RpcContext<'_>, 
        req: DeleteAnnotationRequest, 
        sink: UnarySink<BaseResponse>
    );

    fn delete_annotations(
        &mut self, 
        ctx: RpcContext<'_>, 
        req: DeleteAnnotationsRequest, 
        sink: UnarySink<BaseResponse>
    );

    fn post_annotations_searches(
        &mut self, 
        ctx: RpcContext<'_>, 
        req: PostAnnotationsSearchesRequest, 
        sink: UnarySink<MultiSearchResponse>
    );

    fn get_input_count(
        &mut self, 
        ctx: RpcContext<'_>, 
        req: GetInputCountRequest, 
        sink: UnarySink<SingleInputCountResponse>
    );

    fn stream_inputs(
        &mut self, 
        ctx: RpcContext<'_>, 
        req: StreamInputsRequest, 
        sink: UnarySink<MultiInputResponse>
    );

    fn get_input_samples(
        &mut self, 
        ctx: RpcContext<'_>, 
        req: GetInputSamplesRequest, 
        sink: UnarySink<MultiInputAnnotationResponse>
    );

    fn get_input(
        &mut self, 
        ctx: RpcContext<'_>, 
        req: GetInputRequest, 
        sink: UnarySink<SingleInputResponse>
    );

    fn list_inputs(
        &mut self, 
        ctx: RpcContext<'_>, 
        req: ListInputsRequest, 
        sink: UnarySink<MultiInputResponse>
    );

    fn post_inputs(
        &mut self, 
        ctx: RpcContext<'_>, 
        req: PostInputsRequest, 
        sink: UnarySink<MultiInputResponse>
    );

    fn patch_inputs(
        &mut self, 
        ctx: RpcContext<'_>, 
        req: PatchInputsRequest, 
        sink: UnarySink<MultiInputResponse>
    );

    fn delete_input(
        &mut self, 
        ctx: RpcContext<'_>, 
        req: DeleteInputRequest, 
        sink: UnarySink<BaseResponse>
    );

    fn delete_inputs(
        &mut self, 
        ctx: RpcContext<'_>, 
        req: DeleteInputsRequest, 
        sink: UnarySink<BaseResponse>
    );

    fn post_inputs_searches(
        &mut self, 
        ctx: RpcContext<'_>, 
        req: PostInputsSearchesRequest, 
        sink: UnarySink<MultiSearchResponse>
    );

    fn post_model_outputs(
        &mut self, 
        ctx: RpcContext<'_>, 
        req: PostModelOutputsRequest, 
        sink: UnarySink<MultiOutputResponse>
    );

    fn get_model_type(
        &mut self, 
        ctx: RpcContext<'_>, 
        req: GetModelTypeRequest, 
        sink: UnarySink<SingleModelTypeResponse>
    );

    fn list_open_source_licenses(
        &mut self, 
        ctx: RpcContext<'_>, 
        req: ListOpenSourceLicensesRequest, 
        sink: UnarySink<ListOpenSourceLicensesResponse>
    );

    fn list_model_types(
        &mut self, 
        ctx: RpcContext<'_>, 
        req: ListModelTypesRequest, 
        sink: UnarySink<MultiModelTypeResponse>
    );

    fn get_model(
        &mut self, 
        ctx: RpcContext<'_>, 
        req: GetModelRequest, 
        sink: UnarySink<SingleModelResponse>
    );

    fn get_model_output_info(
        &mut self, 
        ctx: RpcContext<'_>, 
        req: GetModelRequest, 
        sink: UnarySink<SingleModelResponse>
    );

    fn list_models(
        &mut self, 
        ctx: RpcContext<'_>, 
        req: ListModelsRequest, 
        sink: UnarySink<MultiModelResponse>
    );

    fn post_models_searches(
        &mut self, 
        ctx: RpcContext<'_>, 
        req: PostModelsSearchesRequest, 
        sink: UnarySink<MultiModelResponse>
    );

    fn post_models(
        &mut self, 
        ctx: RpcContext<'_>, 
        req: PostModelsRequest, 
        sink: UnarySink<SingleModelResponse>
    );

    fn patch_models(
        &mut self, 
        ctx: RpcContext<'_>, 
        req: PatchModelsRequest, 
        sink: UnarySink<MultiModelResponse>
    );

    fn delete_model(
        &mut self, 
        ctx: RpcContext<'_>, 
        req: DeleteModelRequest, 
        sink: UnarySink<BaseResponse>
    );

    fn delete_models(
        &mut self, 
        ctx: RpcContext<'_>, 
        req: DeleteModelsRequest, 
        sink: UnarySink<BaseResponse>
    );

    fn patch_model_toolkits(
        &mut self, 
        ctx: RpcContext<'_>, 
        req: PatchModelToolkitsRequest, 
        sink: UnarySink<MultiModelToolkitResponse>
    );

    fn patch_model_use_cases(
        &mut self, 
        ctx: RpcContext<'_>, 
        req: PatchModelUseCasesRequest, 
        sink: UnarySink<MultiModelUseCaseResponse>
    );

    fn patch_model_languages(
        &mut self, 
        ctx: RpcContext<'_>, 
        req: PatchModelLanguagesRequest, 
        sink: UnarySink<MultiModelLanguageResponse>
    );

    fn list_model_inputs(
        &mut self, 
        ctx: RpcContext<'_>, 
        req: ListModelInputsRequest, 
        sink: UnarySink<MultiInputResponse>
    );

    fn get_model_version(
        &mut self, 
        ctx: RpcContext<'_>, 
        req: GetModelVersionRequest, 
        sink: UnarySink<SingleModelVersionResponse>
    );

    fn list_model_versions(
        &mut self, 
        ctx: RpcContext<'_>, 
        req: ListModelVersionsRequest, 
        sink: UnarySink<MultiModelVersionResponse>
    );

    fn post_model_versions_publish(
        &mut self, 
        ctx: RpcContext<'_>, 
        req: PostModelVersionsPublishRequest, 
        sink: UnarySink<BaseResponse>
    );

    fn post_model_versions_un_publish(
        &mut self, 
        ctx: RpcContext<'_>, 
        req: PostModelVersionsUnPublishRequest, 
        sink: UnarySink<BaseResponse>
    );

    fn post_model_versions(
        &mut self, 
        ctx: RpcContext<'_>, 
        req: PostModelVersionsRequest, 
        sink: UnarySink<SingleModelResponse>
    );

    fn patch_model_versions(
        &mut self, 
        ctx: RpcContext<'_>, 
        req: PatchModelVersionsRequest, 
        sink: UnarySink<MultiModelVersionResponse>
    );

    fn delete_model_version(
        &mut self, 
        ctx: RpcContext<'_>, 
        req: DeleteModelVersionRequest, 
        sink: UnarySink<BaseResponse>
    );

    fn get_model_version_metrics(
        &mut self, 
        ctx: RpcContext<'_>, 
        req: GetModelVersionMetricsRequest, 
        sink: UnarySink<SingleModelVersionResponse>
    );

    fn post_model_version_metrics(
        &mut self, 
        ctx: RpcContext<'_>, 
        req: PostModelVersionMetricsRequest, 
        sink: UnarySink<SingleModelVersionResponse>
    );

    fn list_model_references(
        &mut self, 
        ctx: RpcContext<'_>, 
        req: ListModelReferencesRequest, 
        sink: UnarySink<MultiModelReferenceResponse>
    );

    fn get_model_version_input_example(
        &mut self, 
        ctx: RpcContext<'_>, 
        req: GetModelVersionInputExampleRequest, 
        sink: UnarySink<SingleModelVersionInputExampleResponse>
    );

    fn list_model_version_input_examples(
        &mut self, 
        ctx: RpcContext<'_>, 
        req: ListModelVersionInputExamplesRequest, 
        sink: UnarySink<MultiModelVersionInputExampleResponse>
    );

    fn get_workflow(
        &mut self, 
        ctx: RpcContext<'_>, 
        req: GetWorkflowRequest, 
        sink: UnarySink<SingleWorkflowResponse>
    );

    fn list_workflows(
        &mut self, 
        ctx: RpcContext<'_>, 
        req: ListWorkflowsRequest, 
        sink: UnarySink<MultiWorkflowResponse>
    );

    fn post_workflows(
        &mut self, 
        ctx: RpcContext<'_>, 
        req: PostWorkflowsRequest, 
        sink: UnarySink<MultiWorkflowResponse>
    );

    fn patch_workflows(
        &mut self, 
        ctx: RpcContext<'_>, 
        req: PatchWorkflowsRequest, 
        sink: UnarySink<MultiWorkflowResponse>
    );

    fn delete_workflow(
        &mut self, 
        ctx: RpcContext<'_>, 
        req: DeleteWorkflowRequest, 
        sink: UnarySink<BaseResponse>
    );

    fn delete_workflows(
        &mut self, 
        ctx: RpcContext<'_>, 
        req: DeleteWorkflowsRequest, 
        sink: UnarySink<BaseResponse>
    );

    fn post_workflow_results(
        &mut self, 
        ctx: RpcContext<'_>, 
        req: PostWorkflowResultsRequest, 
        sink: UnarySink<PostWorkflowResultsResponse>
    );

    fn post_workflow_results_similarity(
        &mut self, 
        ctx: RpcContext<'_>, 
        req: PostWorkflowResultsSimilarityRequest, 
        sink: UnarySink<PostWorkflowResultsSimilarityResponse>
    );

    fn list_workflow_versions(
        &mut self, 
        ctx: RpcContext<'_>, 
        req: ListWorkflowVersionsRequest, 
        sink: UnarySink<MultiWorkflowVersionResponse>
    );

    fn get_workflow_version(
        &mut self, 
        ctx: RpcContext<'_>, 
        req: GetWorkflowVersionRequest, 
        sink: UnarySink<SingleWorkflowVersionResponse>
    );

    fn delete_workflow_versions(
        &mut self, 
        ctx: RpcContext<'_>, 
        req: DeleteWorkflowVersionsRequest, 
        sink: UnarySink<BaseResponse>
    );

    fn patch_workflow_versions(
        &mut self, 
        ctx: RpcContext<'_>, 
        req: PatchWorkflowVersionsRequest, 
        sink: UnarySink<MultiWorkflowVersionResponse>
    );

    fn get_key(
        &mut self, 
        ctx: RpcContext<'_>, 
        req: GetKeyRequest, 
        sink: UnarySink<SingleKeyResponse>
    );

    fn list_keys(
        &mut self, 
        ctx: RpcContext<'_>, 
        req: ListKeysRequest, 
        sink: UnarySink<MultiKeyResponse>
    );

    fn list_app_keys(
        &mut self, 
        ctx: RpcContext<'_>, 
        req: ListAppKeysRequest, 
        sink: UnarySink<MultiKeyResponse>
    );

    fn delete_key(
        &mut self, 
        ctx: RpcContext<'_>, 
        req: DeleteKeyRequest, 
        sink: UnarySink<BaseResponse>
    );

    fn post_keys(
        &mut self, 
        ctx: RpcContext<'_>, 
        req: PostKeysRequest, 
        sink: UnarySink<MultiKeyResponse>
    );

    fn patch_keys(
        &mut self, 
        ctx: RpcContext<'_>, 
        req: PatchKeysRequest, 
        sink: UnarySink<MultiKeyResponse>
    );

    fn my_scopes(
        &mut self, 
        ctx: RpcContext<'_>, 
        req: MyScopesRequest, 
        sink: UnarySink<MultiScopeResponse>
    );

    fn my_scopes_user(
        &mut self, 
        ctx: RpcContext<'_>, 
        req: MyScopesUserRequest, 
        sink: UnarySink<MultiScopeUserResponse>
    );

    fn my_scopes_root(
        &mut self, 
        ctx: RpcContext<'_>, 
        req: MyScopesRootRequest, 
        sink: UnarySink<MultiScopeRootResponse>
    );

    fn list_scopes(
        &mut self, 
        ctx: RpcContext<'_>, 
        req: ListScopesRequest, 
        sink: UnarySink<MultiScopeDepsResponse>
    );

    fn get_app(
        &mut self, 
        ctx: RpcContext<'_>, 
        req: GetAppRequest, 
        sink: UnarySink<SingleAppResponse>
    );

    fn list_apps(
        &mut self, 
        ctx: RpcContext<'_>, 
        req: ListAppsRequest, 
        sink: UnarySink<MultiAppResponse>
    );

    fn delete_app(
        &mut self, 
        ctx: RpcContext<'_>, 
        req: DeleteAppRequest, 
        sink: UnarySink<BaseResponse>
    );

    fn post_apps(
        &mut self, 
        ctx: RpcContext<'_>, 
        req: PostAppsRequest, 
        sink: UnarySink<MultiAppResponse>
    );

    fn patch_apps(
        &mut self, 
        ctx: RpcContext<'_>, 
        req: PatchAppsRequest, 
        sink: UnarySink<MultiAppResponse>
    );

    fn post_apps_searches(
        &mut self, 
        ctx: RpcContext<'_>, 
        req: PostAppsSearchesRequest, 
        sink: UnarySink<MultiAppResponse>
    );

    fn post_validate_password(
        &mut self, 
        ctx: RpcContext<'_>, 
        req: PostValidatePasswordRequest, 
        sink: UnarySink<SinglePasswordValidationResponse>
    );

    fn get_search(
        &mut self, 
        ctx: RpcContext<'_>, 
        req: GetSearchRequest, 
        sink: UnarySink<SingleSearchResponse>
    );

    fn list_searches(
        &mut self, 
        ctx: RpcContext<'_>, 
        req: ListSearchesRequest, 
        sink: UnarySink<MultiSearchResponse>
    );

    fn post_searches(
        &mut self, 
        ctx: RpcContext<'_>, 
        req: PostSearchesRequest, 
        sink: UnarySink<MultiSearchResponse>
    );

    fn post_searches_by_id(
        &mut self, 
        ctx: RpcContext<'_>, 
        req: PostSearchesByIDRequest, 
        sink: UnarySink<MultiSearchResponse>
    );

    fn post_annotation_search_metrics(
        &mut self, 
        ctx: RpcContext<'_>, 
        req: PostAnnotationSearchMetricsRequest, 
        sink: UnarySink<MultiAnnotationSearchMetricsResponse>
    );

    fn get_annotation_search_metrics(
        &mut self, 
        ctx: RpcContext<'_>, 
        req: GetAnnotationSearchMetricsRequest, 
        sink: UnarySink<MultiAnnotationSearchMetricsResponse>
    );

    fn list_annotation_search_metrics(
        &mut self, 
        ctx: RpcContext<'_>, 
        req: ListAnnotationSearchMetricsRequest, 
        sink: UnarySink<MultiAnnotationSearchMetricsResponse>
    );

    fn delete_annotation_search_metrics(
        &mut self, 
        ctx: RpcContext<'_>, 
        req: DeleteAnnotationSearchMetricsRequest, 
        sink: UnarySink<BaseResponse>
    );

    fn delete_search(
        &mut self, 
        ctx: RpcContext<'_>, 
        req: DeleteSearchRequest, 
        sink: UnarySink<BaseResponse>
    );

    fn list_status_codes(
        &mut self, 
        ctx: RpcContext<'_>, 
        req: ListStatusCodesRequest, 
        sink: UnarySink<MultiStatusCodeResponse>
    );

    fn get_status_code(
        &mut self, 
        ctx: RpcContext<'_>, 
        req: GetStatusCodeRequest, 
        sink: UnarySink<SingleStatusCodeResponse>
    );

    fn list_collaborators(
        &mut self, 
        ctx: RpcContext<'_>, 
        req: ListCollaboratorsRequest, 
        sink: UnarySink<MultiCollaboratorsResponse>
    );

    fn post_collaborators(
        &mut self, 
        ctx: RpcContext<'_>, 
        req: PostCollaboratorsRequest, 
        sink: UnarySink<MultiCollaboratorsResponse>
    );

    fn patch_collaborators(
        &mut self, 
        ctx: RpcContext<'_>, 
        req: PatchCollaboratorsRequest, 
        sink: UnarySink<MultiCollaboratorsResponse>
    );

    fn delete_collaborators(
        &mut self, 
        ctx: RpcContext<'_>, 
        req: DeleteCollaboratorsRequest, 
        sink: UnarySink<BaseResponse>
    );

    fn list_collaborations(
        &mut self, 
        ctx: RpcContext<'_>, 
        req: ListCollaborationsRequest, 
        sink: UnarySink<MultiCollaborationsResponse>
    );

    fn post_app_duplications(
        &mut self, 
        ctx: RpcContext<'_>, 
        req: PostAppDuplicationsRequest, 
        sink: UnarySink<MultiAppDuplicationsResponse>
    );

    fn list_app_duplications(
        &mut self, 
        ctx: RpcContext<'_>, 
        req: ListAppDuplicationsRequest, 
        sink: UnarySink<MultiAppDuplicationsResponse>
    );

    fn get_app_duplication(
        &mut self, 
        ctx: RpcContext<'_>, 
        req: GetAppDuplicationRequest, 
        sink: UnarySink<SingleAppDuplicationResponse>
    );

    fn post_tasks(
        &mut self, 
        ctx: RpcContext<'_>, 
        req: PostTasksRequest, 
        sink: UnarySink<MultiTaskResponse>
    );

    fn get_task_annotation_count(
        &mut self, 
        ctx: RpcContext<'_>, 
        req: GetTaskCountRequest, 
        sink: UnarySink<SingleTaskCountResponse>
    );

    fn get_task_input_count(
        &mut self, 
        ctx: RpcContext<'_>, 
        req: GetTaskCountRequest, 
        sink: UnarySink<SingleTaskCountResponse>
    );

    fn get_task(
        &mut self, 
        ctx: RpcContext<'_>, 
        req: GetTaskRequest, 
        sink: UnarySink<SingleTaskResponse>
    );

    fn list_tasks(
        &mut self, 
        ctx: RpcContext<'_>, 
        req: ListTasksRequest, 
        sink: UnarySink<MultiTaskResponse>
    );

    fn patch_tasks(
        &mut self, 
        ctx: RpcContext<'_>, 
        req: PatchTasksRequest, 
        sink: UnarySink<MultiTaskResponse>
    );

    fn delete_tasks(
        &mut self, 
        ctx: RpcContext<'_>, 
        req: DeleteTasksRequest, 
        sink: UnarySink<BaseResponse>
    );

    fn post_label_orders(
        &mut self, 
        ctx: RpcContext<'_>, 
        req: PostLabelOrdersRequest, 
        sink: UnarySink<MultiLabelOrderResponse>
    );

    fn get_label_order(
        &mut self, 
        ctx: RpcContext<'_>, 
        req: GetLabelOrderRequest, 
        sink: UnarySink<SingleLabelOrderResponse>
    );

    fn list_label_orders(
        &mut self, 
        ctx: RpcContext<'_>, 
        req: ListLabelOrdersRequest, 
        sink: UnarySink<MultiLabelOrderResponse>
    );

    fn patch_label_orders(
        &mut self, 
        ctx: RpcContext<'_>, 
        req: PatchLabelOrdersRequest, 
        sink: UnarySink<MultiLabelOrderResponse>
    );

    fn delete_label_orders(
        &mut self, 
        ctx: RpcContext<'_>, 
        req: DeleteLabelOrdersRequest, 
        sink: UnarySink<BaseResponse>
    );

    fn post_collectors(
        &mut self, 
        ctx: RpcContext<'_>, 
        req: PostCollectorsRequest, 
        sink: UnarySink<MultiCollectorResponse>
    );

    fn get_collector(
        &mut self, 
        ctx: RpcContext<'_>, 
        req: GetCollectorRequest, 
        sink: UnarySink<SingleCollectorResponse>
    );

    fn list_collectors(
        &mut self, 
        ctx: RpcContext<'_>, 
        req: ListCollectorsRequest, 
        sink: UnarySink<MultiCollectorResponse>
    );

    fn patch_collectors(
        &mut self, 
        ctx: RpcContext<'_>, 
        req: PatchCollectorsRequest, 
        sink: UnarySink<MultiCollectorResponse>
    );

    fn delete_collectors(
        &mut self, 
        ctx: RpcContext<'_>, 
        req: DeleteCollectorsRequest, 
        sink: UnarySink<BaseResponse>
    );

    fn post_stat_values(
        &mut self, 
        ctx: RpcContext<'_>, 
        req: PostStatValuesRequest, 
        sink: UnarySink<MultiStatValueResponse>
    );

    fn post_stat_values_aggregate(
        &mut self, 
        ctx: RpcContext<'_>, 
        req: PostStatValuesAggregateRequest, 
        sink: UnarySink<MultiStatValueAggregateResponse>
    );

    fn post_trending_metrics_view(
        &mut self, 
        ctx: RpcContext<'_>, 
        req: PostTrendingMetricsViewRequest, 
        sink: UnarySink<BaseResponse>
    );

    fn list_trending_metrics_views(
        &mut self, 
        ctx: RpcContext<'_>, 
        req: ListTrendingMetricsViewsRequest, 
        sink: UnarySink<MultiTrendingMetricsViewResponse>
    );

}

Required methods

Implementors