superposition-sdk 0.94.1__py3-none-any.whl

superposition_sdk/client.py

@@ -0,0 +1,2744 @@
+# Code generated by smithy-python-codegen DO NOT EDIT.
+
+import asyncio
+from asyncio import Future, iscoroutine, sleep
+from copy import copy, deepcopy
+from dataclasses import replace
+import logging
+import re
+from typing import Any, Awaitable, Callable, cast
+
+from smithy_core import URI
+from smithy_core.deserializers import DeserializeableShape
+from smithy_core.endpoints import EndpointResolverParams
+from smithy_core.exceptions import SmithyRetryException
+from smithy_core.interceptors import (
+    InputContext,
+    Interceptor,
+    InterceptorChain,
+    OutputContext,
+    RequestContext,
+    ResponseContext,
+)
+from smithy_core.interfaces.exceptions import HasFault
+from smithy_core.interfaces.identity import Identity
+from smithy_core.interfaces.retries import RetryErrorInfo, RetryErrorType
+from smithy_core.schemas import APIOperation
+from smithy_core.serializers import SerializeableShape
+from smithy_core.types import PropertyKey, TypedProperties
+from smithy_http.aio.interfaces import HTTPRequest, HTTPResponse
+from smithy_http.aio.interfaces.auth import HTTPAuthOption, HTTPSigner
+from smithy_http.interfaces import HTTPRequestConfiguration
+from smithy_http.plugins import user_agent_plugin
+
+from .auth import HTTPAuthParams
+from .config import Config, Plugin
+from .deserialize import (
+    _deserialize_add_members_to_group,
+    _deserialize_applicable_variants,
+    _deserialize_bulk_operation,
+    _deserialize_conclude_experiment,
+    _deserialize_create_context,
+    _deserialize_create_default_config,
+    _deserialize_create_dimension,
+    _deserialize_create_experiment,
+    _deserialize_create_experiment_group,
+    _deserialize_create_function,
+    _deserialize_create_organisation,
+    _deserialize_create_type_templates,
+    _deserialize_create_webhook,
+    _deserialize_create_workspace,
+    _deserialize_delete_context,
+    _deserialize_delete_default_config,
+    _deserialize_delete_dimension,
+    _deserialize_delete_experiment_group,
+    _deserialize_delete_function,
+    _deserialize_delete_type_templates,
+    _deserialize_delete_webhook,
+    _deserialize_discard_experiment,
+    _deserialize_get_config,
+    _deserialize_get_config_fast,
+    _deserialize_get_context,
+    _deserialize_get_context_from_condition,
+    _deserialize_get_default_config,
+    _deserialize_get_dimension,
+    _deserialize_get_experiment,
+    _deserialize_get_experiment_group,
+    _deserialize_get_function,
+    _deserialize_get_organisation,
+    _deserialize_get_resolved_config,
+    _deserialize_get_type_template,
+    _deserialize_get_type_templates_list,
+    _deserialize_get_version,
+    _deserialize_get_webhook,
+    _deserialize_get_webhook_by_event,
+    _deserialize_get_workspace,
+    _deserialize_list_audit_logs,
+    _deserialize_list_contexts,
+    _deserialize_list_default_configs,
+    _deserialize_list_dimensions,
+    _deserialize_list_experiment,
+    _deserialize_list_experiment_groups,
+    _deserialize_list_function,
+    _deserialize_list_organisation,
+    _deserialize_list_versions,
+    _deserialize_list_webhook,
+    _deserialize_list_workspace,
+    _deserialize_migrate_workspace_schema,
+    _deserialize_move_context,
+    _deserialize_pause_experiment,
+    _deserialize_publish,
+    _deserialize_ramp_experiment,
+    _deserialize_remove_members_from_group,
+    _deserialize_resume_experiment,
+    _deserialize_test,
+    _deserialize_update_default_config,
+    _deserialize_update_dimension,
+    _deserialize_update_experiment_group,
+    _deserialize_update_function,
+    _deserialize_update_organisation,
+    _deserialize_update_override,
+    _deserialize_update_overrides_experiment,
+    _deserialize_update_type_templates,
+    _deserialize_update_webhook,
+    _deserialize_update_workspace,
+    _deserialize_validate_context,
+    _deserialize_weight_recompute,
+)
+from .models import (
+    ADD_MEMBERS_TO_GROUP,
+    APPLICABLE_VARIANTS,
+    AddMembersToGroupInput,
+    AddMembersToGroupOutput,
+    ApplicableVariantsInput,
+    ApplicableVariantsOutput,
+    BULK_OPERATION,
+    BulkOperationInput,
+    BulkOperationOutput,
+    CONCLUDE_EXPERIMENT,
+    CREATE_CONTEXT,
+    CREATE_DEFAULT_CONFIG,
+    CREATE_DIMENSION,
+    CREATE_EXPERIMENT,
+    CREATE_EXPERIMENT_GROUP,
+    CREATE_FUNCTION,
+    CREATE_ORGANISATION,
+    CREATE_TYPE_TEMPLATES,
+    CREATE_WEBHOOK,
+    CREATE_WORKSPACE,
+    ConcludeExperimentInput,
+    ConcludeExperimentOutput,
+    CreateContextInput,
+    CreateContextOutput,
+    CreateDefaultConfigInput,
+    CreateDefaultConfigOutput,
+    CreateDimensionInput,
+    CreateDimensionOutput,
+    CreateExperimentGroupInput,
+    CreateExperimentGroupOutput,
+    CreateExperimentInput,
+    CreateExperimentOutput,
+    CreateFunctionInput,
+    CreateFunctionOutput,
+    CreateOrganisationInput,
+    CreateOrganisationOutput,
+    CreateTypeTemplatesInput,
+    CreateTypeTemplatesOutput,
+    CreateWebhookInput,
+    CreateWebhookOutput,
+    CreateWorkspaceInput,
+    CreateWorkspaceOutput,
+    DELETE_CONTEXT,
+    DELETE_DEFAULT_CONFIG,
+    DELETE_DIMENSION,
+    DELETE_EXPERIMENT_GROUP,
+    DELETE_FUNCTION,
+    DELETE_TYPE_TEMPLATES,
+    DELETE_WEBHOOK,
+    DISCARD_EXPERIMENT,
+    DeleteContextInput,
+    DeleteContextOutput,
+    DeleteDefaultConfigInput,
+    DeleteDefaultConfigOutput,
+    DeleteDimensionInput,
+    DeleteDimensionOutput,
+    DeleteExperimentGroupInput,
+    DeleteExperimentGroupOutput,
+    DeleteFunctionInput,
+    DeleteFunctionOutput,
+    DeleteTypeTemplatesInput,
+    DeleteTypeTemplatesOutput,
+    DeleteWebhookInput,
+    DeleteWebhookOutput,
+    DiscardExperimentInput,
+    DiscardExperimentOutput,
+    GET_CONFIG,
+    GET_CONFIG_FAST,
+    GET_CONTEXT,
+    GET_CONTEXT_FROM_CONDITION,
+    GET_DEFAULT_CONFIG,
+    GET_DIMENSION,
+    GET_EXPERIMENT,
+    GET_EXPERIMENT_GROUP,
+    GET_FUNCTION,
+    GET_ORGANISATION,
+    GET_RESOLVED_CONFIG,
+    GET_TYPE_TEMPLATE,
+    GET_TYPE_TEMPLATES_LIST,
+    GET_VERSION,
+    GET_WEBHOOK,
+    GET_WEBHOOK_BY_EVENT,
+    GET_WORKSPACE,
+    GetConfigFastInput,
+    GetConfigFastOutput,
+    GetConfigInput,
+    GetConfigOutput,
+    GetContextFromConditionInput,
+    GetContextFromConditionOutput,
+    GetContextInput,
+    GetContextOutput,
+    GetDefaultConfigInput,
+    GetDefaultConfigOutput,
+    GetDimensionInput,
+    GetDimensionOutput,
+    GetExperimentGroupInput,
+    GetExperimentGroupOutput,
+    GetExperimentInput,
+    GetExperimentOutput,
+    GetFunctionInput,
+    GetFunctionOutput,
+    GetOrganisationInput,
+    GetOrganisationOutput,
+    GetResolvedConfigInput,
+    GetResolvedConfigOutput,
+    GetTypeTemplateInput,
+    GetTypeTemplateOutput,
+    GetTypeTemplatesListInput,
+    GetTypeTemplatesListOutput,
+    GetVersionInput,
+    GetVersionOutput,
+    GetWebhookByEventInput,
+    GetWebhookByEventOutput,
+    GetWebhookInput,
+    GetWebhookOutput,
+    GetWorkspaceInput,
+    GetWorkspaceOutput,
+    LIST_AUDIT_LOGS,
+    LIST_CONTEXTS,
+    LIST_DEFAULT_CONFIGS,
+    LIST_DIMENSIONS,
+    LIST_EXPERIMENT,
+    LIST_EXPERIMENT_GROUPS,
+    LIST_FUNCTION,
+    LIST_ORGANISATION,
+    LIST_VERSIONS,
+    LIST_WEBHOOK,
+    LIST_WORKSPACE,
+    ListAuditLogsInput,
+    ListAuditLogsOutput,
+    ListContextsInput,
+    ListContextsOutput,
+    ListDefaultConfigsInput,
+    ListDefaultConfigsOutput,
+    ListDimensionsInput,
+    ListDimensionsOutput,
+    ListExperimentGroupsInput,
+    ListExperimentGroupsOutput,
+    ListExperimentInput,
+    ListExperimentOutput,
+    ListFunctionInput,
+    ListFunctionOutput,
+    ListOrganisationInput,
+    ListOrganisationOutput,
+    ListVersionsInput,
+    ListVersionsOutput,
+    ListWebhookInput,
+    ListWebhookOutput,
+    ListWorkspaceInput,
+    ListWorkspaceOutput,
+    MIGRATE_WORKSPACE_SCHEMA,
+    MOVE_CONTEXT,
+    MigrateWorkspaceSchemaInput,
+    MigrateWorkspaceSchemaOutput,
+    MoveContextInput,
+    MoveContextOutput,
+    PAUSE_EXPERIMENT,
+    PUBLISH,
+    PauseExperimentInput,
+    PauseExperimentOutput,
+    PublishInput,
+    PublishOutput,
+    RAMP_EXPERIMENT,
+    REMOVE_MEMBERS_FROM_GROUP,
+    RESUME_EXPERIMENT,
+    RampExperimentInput,
+    RampExperimentOutput,
+    RemoveMembersFromGroupInput,
+    RemoveMembersFromGroupOutput,
+    ResumeExperimentInput,
+    ResumeExperimentOutput,
+    ServiceError,
+    TEST,
+    TestInput,
+    TestOutput,
+    UPDATE_DEFAULT_CONFIG,
+    UPDATE_DIMENSION,
+    UPDATE_EXPERIMENT_GROUP,
+    UPDATE_FUNCTION,
+    UPDATE_ORGANISATION,
+    UPDATE_OVERRIDE,
+    UPDATE_OVERRIDES_EXPERIMENT,
+    UPDATE_TYPE_TEMPLATES,
+    UPDATE_WEBHOOK,
+    UPDATE_WORKSPACE,
+    UpdateDefaultConfigInput,
+    UpdateDefaultConfigOutput,
+    UpdateDimensionInput,
+    UpdateDimensionOutput,
+    UpdateExperimentGroupInput,
+    UpdateExperimentGroupOutput,
+    UpdateFunctionInput,
+    UpdateFunctionOutput,
+    UpdateOrganisationInput,
+    UpdateOrganisationOutput,
+    UpdateOverrideInput,
+    UpdateOverrideOutput,
+    UpdateOverridesExperimentInput,
+    UpdateOverridesExperimentOutput,
+    UpdateTypeTemplatesInput,
+    UpdateTypeTemplatesOutput,
+    UpdateWebhookInput,
+    UpdateWebhookOutput,
+    UpdateWorkspaceInput,
+    UpdateWorkspaceOutput,
+    VALIDATE_CONTEXT,
+    ValidateContextInput,
+    ValidateContextOutput,
+    WEIGHT_RECOMPUTE,
+    WeightRecomputeInput,
+    WeightRecomputeOutput,
+)
+from .serialize import (
+    _serialize_add_members_to_group,
+    _serialize_applicable_variants,
+    _serialize_bulk_operation,
+    _serialize_conclude_experiment,
+    _serialize_create_context,
+    _serialize_create_default_config,
+    _serialize_create_dimension,
+    _serialize_create_experiment,
+    _serialize_create_experiment_group,
+    _serialize_create_function,
+    _serialize_create_organisation,
+    _serialize_create_type_templates,
+    _serialize_create_webhook,
+    _serialize_create_workspace,
+    _serialize_delete_context,
+    _serialize_delete_default_config,
+    _serialize_delete_dimension,
+    _serialize_delete_experiment_group,
+    _serialize_delete_function,
+    _serialize_delete_type_templates,
+    _serialize_delete_webhook,
+    _serialize_discard_experiment,
+    _serialize_get_config,
+    _serialize_get_config_fast,
+    _serialize_get_context,
+    _serialize_get_context_from_condition,
+    _serialize_get_default_config,
+    _serialize_get_dimension,
+    _serialize_get_experiment,
+    _serialize_get_experiment_group,
+    _serialize_get_function,
+    _serialize_get_organisation,
+    _serialize_get_resolved_config,
+    _serialize_get_type_template,
+    _serialize_get_type_templates_list,
+    _serialize_get_version,
+    _serialize_get_webhook,
+    _serialize_get_webhook_by_event,
+    _serialize_get_workspace,
+    _serialize_list_audit_logs,
+    _serialize_list_contexts,
+    _serialize_list_default_configs,
+    _serialize_list_dimensions,
+    _serialize_list_experiment,
+    _serialize_list_experiment_groups,
+    _serialize_list_function,
+    _serialize_list_organisation,
+    _serialize_list_versions,
+    _serialize_list_webhook,
+    _serialize_list_workspace,
+    _serialize_migrate_workspace_schema,
+    _serialize_move_context,
+    _serialize_pause_experiment,
+    _serialize_publish,
+    _serialize_ramp_experiment,
+    _serialize_remove_members_from_group,
+    _serialize_resume_experiment,
+    _serialize_test,
+    _serialize_update_default_config,
+    _serialize_update_dimension,
+    _serialize_update_experiment_group,
+    _serialize_update_function,
+    _serialize_update_organisation,
+    _serialize_update_override,
+    _serialize_update_overrides_experiment,
+    _serialize_update_type_templates,
+    _serialize_update_webhook,
+    _serialize_update_workspace,
+    _serialize_validate_context,
+    _serialize_weight_recompute,
+)
+
+
+
+logger = logging.getLogger(__name__)
+
+class Superposition:
+    """
+    Client for Superposition
+
+    :param config: Optional configuration for the client. Here you can set things like the
+        endpoint for HTTP services or auth credentials.
+
+    :param plugins: A list of callables that modify the configuration dynamically. These
+        can be used to set defaults, for example.
+    """
+    def __init__(self, config: Config | None = None, plugins: list[Plugin] | None = None):
+        self._config = config or Config()
+
+        client_plugins: list[Plugin] = [
+            user_agent_plugin,
+        ]
+        if plugins:
+            client_plugins.extend(plugins)
+
+        for plugin in client_plugins:
+            plugin(self._config)
+
+    async def add_members_to_group(self, input: AddMembersToGroupInput, plugins: list[Plugin] | None = None) -> AddMembersToGroupOutput:
+        """
+        Adds members to an existing experiment group.
+
+        :param input: Input structure for adding members to an experiment group.
+
+        :param plugins: A list of callables that modify the configuration dynamically.
+            Changes made by these plugins only apply for the duration of the operation
+            execution and will not affect any other operation invocations.
+
+        """
+        operation_plugins: list[Plugin] = [
+
+        ]
+        if plugins:
+            operation_plugins.extend(plugins)
+
+        return await self._execute_operation(
+            input=input,
+            plugins=operation_plugins,
+            serialize=_serialize_add_members_to_group,
+            deserialize=_deserialize_add_members_to_group,
+            config=self._config,
+            operation=ADD_MEMBERS_TO_GROUP,
+        )
+
+    async def applicable_variants(self, input: ApplicableVariantsInput, plugins: list[Plugin] | None = None) -> ApplicableVariantsOutput:
+        """
+        Determines which experiment variants are applicable to a given context, used for
+        experiment evaluation and variant selection.
+
+        :param input: The operation's input.
+
+        :param plugins: A list of callables that modify the configuration dynamically.
+            Changes made by these plugins only apply for the duration of the operation
+            execution and will not affect any other operation invocations.
+
+        """
+        operation_plugins: list[Plugin] = [
+
+        ]
+        if plugins:
+            operation_plugins.extend(plugins)
+
+        return await self._execute_operation(
+            input=input,
+            plugins=operation_plugins,
+            serialize=_serialize_applicable_variants,
+            deserialize=_deserialize_applicable_variants,
+            config=self._config,
+            operation=APPLICABLE_VARIANTS,
+        )
+
+    async def bulk_operation(self, input: BulkOperationInput, plugins: list[Plugin] | None = None) -> BulkOperationOutput:
+        """
+        Executes multiple context operations (PUT, REPLACE, DELETE, MOVE) in a single
+        atomic transaction for efficient batch processing.
+
+        :param input: The operation's input.
+
+        :param plugins: A list of callables that modify the configuration dynamically.
+            Changes made by these plugins only apply for the duration of the operation
+            execution and will not affect any other operation invocations.
+
+        """
+        operation_plugins: list[Plugin] = [
+
+        ]
+        if plugins:
+            operation_plugins.extend(plugins)
+
+        return await self._execute_operation(
+            input=input,
+            plugins=operation_plugins,
+            serialize=_serialize_bulk_operation,
+            deserialize=_deserialize_bulk_operation,
+            config=self._config,
+            operation=BULK_OPERATION,
+        )
+
+    async def conclude_experiment(self, input: ConcludeExperimentInput, plugins: list[Plugin] | None = None) -> ConcludeExperimentOutput:
+        """
+        Concludes an inprogress experiment by selecting a winning variant and
+        transitioning the experiment to a concluded state.
+
+        :param input: The operation's input.
+
+        :param plugins: A list of callables that modify the configuration dynamically.
+            Changes made by these plugins only apply for the duration of the operation
+            execution and will not affect any other operation invocations.
+
+        """
+        operation_plugins: list[Plugin] = [
+
+        ]
+        if plugins:
+            operation_plugins.extend(plugins)
+
+        return await self._execute_operation(
+            input=input,
+            plugins=operation_plugins,
+            serialize=_serialize_conclude_experiment,
+            deserialize=_deserialize_conclude_experiment,
+            config=self._config,
+            operation=CONCLUDE_EXPERIMENT,
+        )
+
+    async def create_context(self, input: CreateContextInput, plugins: list[Plugin] | None = None) -> CreateContextOutput:
+        """
+        Creates a new context with specified conditions and overrides. Contexts define
+        conditional rules for config management.
+
+        :param input: The operation's input.
+
+        :param plugins: A list of callables that modify the configuration dynamically.
+            Changes made by these plugins only apply for the duration of the operation
+            execution and will not affect any other operation invocations.
+
+        """
+        operation_plugins: list[Plugin] = [
+
+        ]
+        if plugins:
+            operation_plugins.extend(plugins)
+
+        return await self._execute_operation(
+            input=input,
+            plugins=operation_plugins,
+            serialize=_serialize_create_context,
+            deserialize=_deserialize_create_context,
+            config=self._config,
+            operation=CREATE_CONTEXT,
+        )
+
+    async def create_default_config(self, input: CreateDefaultConfigInput, plugins: list[Plugin] | None = None) -> CreateDefaultConfigOutput:
+        """
+        Creates a new default config entry with specified key, value, schema, and
+        metadata. Default configs serve as fallback values when no specific context
+        matches.
+
+        :param input: The operation's input.
+
+        :param plugins: A list of callables that modify the configuration dynamically.
+            Changes made by these plugins only apply for the duration of the operation
+            execution and will not affect any other operation invocations.
+
+        """
+        operation_plugins: list[Plugin] = [
+
+        ]
+        if plugins:
+            operation_plugins.extend(plugins)
+
+        return await self._execute_operation(
+            input=input,
+            plugins=operation_plugins,
+            serialize=_serialize_create_default_config,
+            deserialize=_deserialize_create_default_config,
+            config=self._config,
+            operation=CREATE_DEFAULT_CONFIG,
+        )
+
+    async def create_dimension(self, input: CreateDimensionInput, plugins: list[Plugin] | None = None) -> CreateDimensionOutput:
+        """
+        Creates a new dimension with the specified json schema. Dimensions define
+        categorical attributes used for context-based config management.
+
+        :param input: The operation's input.
+
+        :param plugins: A list of callables that modify the configuration dynamically.
+            Changes made by these plugins only apply for the duration of the operation
+            execution and will not affect any other operation invocations.
+
+        """
+        operation_plugins: list[Plugin] = [
+
+        ]
+        if plugins:
+            operation_plugins.extend(plugins)
+
+        return await self._execute_operation(
+            input=input,
+            plugins=operation_plugins,
+            serialize=_serialize_create_dimension,
+            deserialize=_deserialize_create_dimension,
+            config=self._config,
+            operation=CREATE_DIMENSION,
+        )
+
+    async def create_experiment(self, input: CreateExperimentInput, plugins: list[Plugin] | None = None) -> CreateExperimentOutput:
+        """
+        Creates a new experiment with variants, context and conditions. You can
+        optionally specify metrics and experiment group for tracking and analysis.
+
+        :param input: The operation's input.
+
+        :param plugins: A list of callables that modify the configuration dynamically.
+            Changes made by these plugins only apply for the duration of the operation
+            execution and will not affect any other operation invocations.
+
+        """
+        operation_plugins: list[Plugin] = [
+
+        ]
+        if plugins:
+            operation_plugins.extend(plugins)
+
+        return await self._execute_operation(
+            input=input,
+            plugins=operation_plugins,
+            serialize=_serialize_create_experiment,
+            deserialize=_deserialize_create_experiment,
+            config=self._config,
+            operation=CREATE_EXPERIMENT,
+        )
+
+    async def create_experiment_group(self, input: CreateExperimentGroupInput, plugins: list[Plugin] | None = None) -> CreateExperimentGroupOutput:
+        """
+        Creates a new experiment group.
+
+        :param input: Input structure for creating a new experiment group.
+
+        :param plugins: A list of callables that modify the configuration dynamically.
+            Changes made by these plugins only apply for the duration of the operation
+            execution and will not affect any other operation invocations.
+
+        """
+        operation_plugins: list[Plugin] = [
+
+        ]
+        if plugins:
+            operation_plugins.extend(plugins)
+
+        return await self._execute_operation(
+            input=input,
+            plugins=operation_plugins,
+            serialize=_serialize_create_experiment_group,
+            deserialize=_deserialize_create_experiment_group,
+            config=self._config,
+            operation=CREATE_EXPERIMENT_GROUP,
+        )
+
+    async def create_function(self, input: CreateFunctionInput, plugins: list[Plugin] | None = None) -> CreateFunctionOutput:
+        """
+        Creates a new custom function for validation or autocompletion with specified
+        code, runtime version, and function type.
+
+        :param input: The operation's input.
+
+        :param plugins: A list of callables that modify the configuration dynamically.
+            Changes made by these plugins only apply for the duration of the operation
+            execution and will not affect any other operation invocations.
+
+        """
+        operation_plugins: list[Plugin] = [
+
+        ]
+        if plugins:
+            operation_plugins.extend(plugins)
+
+        return await self._execute_operation(
+            input=input,
+            plugins=operation_plugins,
+            serialize=_serialize_create_function,
+            deserialize=_deserialize_create_function,
+            config=self._config,
+            operation=CREATE_FUNCTION,
+        )
+
+    async def create_organisation(self, input: CreateOrganisationInput, plugins: list[Plugin] | None = None) -> CreateOrganisationOutput:
+        """
+        Creates a new organisation with specified name and administrator email. This is
+        the top-level entity that contains workspaces and manages organizational-level
+        settings.
+
+        :param input: The operation's input.
+
+        :param plugins: A list of callables that modify the configuration dynamically.
+            Changes made by these plugins only apply for the duration of the operation
+            execution and will not affect any other operation invocations.
+
+        """
+        operation_plugins: list[Plugin] = [
+
+        ]
+        if plugins:
+            operation_plugins.extend(plugins)
+
+        return await self._execute_operation(
+            input=input,
+            plugins=operation_plugins,
+            serialize=_serialize_create_organisation,
+            deserialize=_deserialize_create_organisation,
+            config=self._config,
+            operation=CREATE_ORGANISATION,
+        )
+
+    async def create_type_templates(self, input: CreateTypeTemplatesInput, plugins: list[Plugin] | None = None) -> CreateTypeTemplatesOutput:
+        """
+        Creates a new type template with specified schema definition, providing reusable
+        type definitions for config validation.
+
+        :param input: The operation's input.
+
+        :param plugins: A list of callables that modify the configuration dynamically.
+            Changes made by these plugins only apply for the duration of the operation
+            execution and will not affect any other operation invocations.
+
+        """
+        operation_plugins: list[Plugin] = [
+
+        ]
+        if plugins:
+            operation_plugins.extend(plugins)
+
+        return await self._execute_operation(
+            input=input,
+            plugins=operation_plugins,
+            serialize=_serialize_create_type_templates,
+            deserialize=_deserialize_create_type_templates,
+            config=self._config,
+            operation=CREATE_TYPE_TEMPLATES,
+        )
+
+    async def create_webhook(self, input: CreateWebhookInput, plugins: list[Plugin] | None = None) -> CreateWebhookOutput:
+        """
+        Creates a new webhook config to receive HTTP notifications when specified events
+        occur in the system.
+
+        :param input: The operation's input.
+
+        :param plugins: A list of callables that modify the configuration dynamically.
+            Changes made by these plugins only apply for the duration of the operation
+            execution and will not affect any other operation invocations.
+
+        """
+        operation_plugins: list[Plugin] = [
+
+        ]
+        if plugins:
+            operation_plugins.extend(plugins)
+
+        return await self._execute_operation(
+            input=input,
+            plugins=operation_plugins,
+            serialize=_serialize_create_webhook,
+            deserialize=_deserialize_create_webhook,
+            config=self._config,
+            operation=CREATE_WEBHOOK,
+        )
+
+    async def create_workspace(self, input: CreateWorkspaceInput, plugins: list[Plugin] | None = None) -> CreateWorkspaceOutput:
+        """
+        Creates a new workspace within an organisation, including database schema setup
+        and isolated environment for config management with specified admin and
+        settings.
+
+        :param input: The operation's input.
+
+        :param plugins: A list of callables that modify the configuration dynamically.
+            Changes made by these plugins only apply for the duration of the operation
+            execution and will not affect any other operation invocations.
+
+        """
+        operation_plugins: list[Plugin] = [
+
+        ]
+        if plugins:
+            operation_plugins.extend(plugins)
+
+        return await self._execute_operation(
+            input=input,
+            plugins=operation_plugins,
+            serialize=_serialize_create_workspace,
+            deserialize=_deserialize_create_workspace,
+            config=self._config,
+            operation=CREATE_WORKSPACE,
+        )
+
+    async def delete_context(self, input: DeleteContextInput, plugins: list[Plugin] | None = None) -> DeleteContextOutput:
+        """
+        Permanently removes a context from the workspace. This operation cannot be
+        undone and will affect config resolution.
+
+        :param input: The operation's input.
+
+        :param plugins: A list of callables that modify the configuration dynamically.
+            Changes made by these plugins only apply for the duration of the operation
+            execution and will not affect any other operation invocations.
+
+        """
+        operation_plugins: list[Plugin] = [
+
+        ]
+        if plugins:
+            operation_plugins.extend(plugins)
+
+        return await self._execute_operation(
+            input=input,
+            plugins=operation_plugins,
+            serialize=_serialize_delete_context,
+            deserialize=_deserialize_delete_context,
+            config=self._config,
+            operation=DELETE_CONTEXT,
+        )
+
+    async def delete_default_config(self, input: DeleteDefaultConfigInput, plugins: list[Plugin] | None = None) -> DeleteDefaultConfigOutput:
+        """
+        Permanently removes a default config entry from the workspace. This operation
+        cannot be performed if it affects config resolution for contexts that rely on
+        this fallback value.
+
+        :param input: The operation's input.
+
+        :param plugins: A list of callables that modify the configuration dynamically.
+            Changes made by these plugins only apply for the duration of the operation
+            execution and will not affect any other operation invocations.
+
+        """
+        operation_plugins: list[Plugin] = [
+
+        ]
+        if plugins:
+            operation_plugins.extend(plugins)
+
+        return await self._execute_operation(
+            input=input,
+            plugins=operation_plugins,
+            serialize=_serialize_delete_default_config,
+            deserialize=_deserialize_delete_default_config,
+            config=self._config,
+            operation=DELETE_DEFAULT_CONFIG,
+        )
+
+    async def delete_dimension(self, input: DeleteDimensionInput, plugins: list[Plugin] | None = None) -> DeleteDimensionOutput:
+        """
+        Permanently removes a dimension from the workspace. This operation will fail if
+        the dimension has active dependencies or is referenced by existing
+        configurations.
+
+        :param input: The operation's input.
+
+        :param plugins: A list of callables that modify the configuration dynamically.
+            Changes made by these plugins only apply for the duration of the operation
+            execution and will not affect any other operation invocations.
+
+        """
+        operation_plugins: list[Plugin] = [
+
+        ]
+        if plugins:
+            operation_plugins.extend(plugins)
+
+        return await self._execute_operation(
+            input=input,
+            plugins=operation_plugins,
+            serialize=_serialize_delete_dimension,
+            deserialize=_deserialize_delete_dimension,
+            config=self._config,
+            operation=DELETE_DIMENSION,
+        )
+
+    async def delete_experiment_group(self, input: DeleteExperimentGroupInput, plugins: list[Plugin] | None = None) -> DeleteExperimentGroupOutput:
+        """
+        Deletes an experiment group.
+
+        :param input: The operation's input.
+
+        :param plugins: A list of callables that modify the configuration dynamically.
+            Changes made by these plugins only apply for the duration of the operation
+            execution and will not affect any other operation invocations.
+
+        """
+        operation_plugins: list[Plugin] = [
+
+        ]
+        if plugins:
+            operation_plugins.extend(plugins)
+
+        return await self._execute_operation(
+            input=input,
+            plugins=operation_plugins,
+            serialize=_serialize_delete_experiment_group,
+            deserialize=_deserialize_delete_experiment_group,
+            config=self._config,
+            operation=DELETE_EXPERIMENT_GROUP,
+        )
+
+    async def delete_function(self, input: DeleteFunctionInput, plugins: list[Plugin] | None = None) -> DeleteFunctionOutput:
+        """
+        Permanently removes a function from the workspace, deleting both draft and
+        published versions along with all associated code. It fails if already in use
+
+        :param input: The operation's input.
+
+        :param plugins: A list of callables that modify the configuration dynamically.
+            Changes made by these plugins only apply for the duration of the operation
+            execution and will not affect any other operation invocations.
+
+        """
+        operation_plugins: list[Plugin] = [
+
+        ]
+        if plugins:
+            operation_plugins.extend(plugins)
+
+        return await self._execute_operation(
+            input=input,
+            plugins=operation_plugins,
+            serialize=_serialize_delete_function,
+            deserialize=_deserialize_delete_function,
+            config=self._config,
+            operation=DELETE_FUNCTION,
+        )
+
+    async def delete_type_templates(self, input: DeleteTypeTemplatesInput, plugins: list[Plugin] | None = None) -> DeleteTypeTemplatesOutput:
+        """
+        Permanently removes a type template from the workspace. No checks performed
+        while deleting
+
+        :param input: The operation's input.
+
+        :param plugins: A list of callables that modify the configuration dynamically.
+            Changes made by these plugins only apply for the duration of the operation
+            execution and will not affect any other operation invocations.
+
+        """
+        operation_plugins: list[Plugin] = [
+
+        ]
+        if plugins:
+            operation_plugins.extend(plugins)
+
+        return await self._execute_operation(
+            input=input,
+            plugins=operation_plugins,
+            serialize=_serialize_delete_type_templates,
+            deserialize=_deserialize_delete_type_templates,
+            config=self._config,
+            operation=DELETE_TYPE_TEMPLATES,
+        )
+
+    async def delete_webhook(self, input: DeleteWebhookInput, plugins: list[Plugin] | None = None) -> DeleteWebhookOutput:
+        """
+        Permanently removes a webhook config from the workspace, stopping all future
+        event notifications to that endpoint.
+
+        :param input: The operation's input.
+
+        :param plugins: A list of callables that modify the configuration dynamically.
+            Changes made by these plugins only apply for the duration of the operation
+            execution and will not affect any other operation invocations.
+
+        """
+        operation_plugins: list[Plugin] = [
+
+        ]
+        if plugins:
+            operation_plugins.extend(plugins)
+
+        return await self._execute_operation(
+            input=input,
+            plugins=operation_plugins,
+            serialize=_serialize_delete_webhook,
+            deserialize=_deserialize_delete_webhook,
+            config=self._config,
+            operation=DELETE_WEBHOOK,
+        )
+
+    async def discard_experiment(self, input: DiscardExperimentInput, plugins: list[Plugin] | None = None) -> DiscardExperimentOutput:
+        """
+        Discards an experiment without selecting a winner, effectively canceling the
+        experiment and removing its effects.
+
+        :param input: The operation's input.
+
+        :param plugins: A list of callables that modify the configuration dynamically.
+            Changes made by these plugins only apply for the duration of the operation
+            execution and will not affect any other operation invocations.
+
+        """
+        operation_plugins: list[Plugin] = [
+
+        ]
+        if plugins:
+            operation_plugins.extend(plugins)
+
+        return await self._execute_operation(
+            input=input,
+            plugins=operation_plugins,
+            serialize=_serialize_discard_experiment,
+            deserialize=_deserialize_discard_experiment,
+            config=self._config,
+            operation=DISCARD_EXPERIMENT,
+        )
+
+    async def get_config(self, input: GetConfigInput, plugins: list[Plugin] | None = None) -> GetConfigOutput:
+        """
+        Retrieves config data with context evaluation, including applicable contexts,
+        overrides, and default values based on provided conditions.
+
+        :param input: The operation's input.
+
+        :param plugins: A list of callables that modify the configuration dynamically.
+            Changes made by these plugins only apply for the duration of the operation
+            execution and will not affect any other operation invocations.
+
+        """
+        operation_plugins: list[Plugin] = [
+
+        ]
+        if plugins:
+            operation_plugins.extend(plugins)
+
+        return await self._execute_operation(
+            input=input,
+            plugins=operation_plugins,
+            serialize=_serialize_get_config,
+            deserialize=_deserialize_get_config,
+            config=self._config,
+            operation=GET_CONFIG,
+        )
+
+    async def get_config_fast(self, input: GetConfigFastInput, plugins: list[Plugin] | None = None) -> GetConfigFastOutput:
+        """
+        Retrieves the latest config with no processing for high-performance access.
+
+        :param input: The operation's input.
+
+        :param plugins: A list of callables that modify the configuration dynamically.
+            Changes made by these plugins only apply for the duration of the operation
+            execution and will not affect any other operation invocations.
+
+        """
+        operation_plugins: list[Plugin] = [
+
+        ]
+        if plugins:
+            operation_plugins.extend(plugins)
+
+        return await self._execute_operation(
+            input=input,
+            plugins=operation_plugins,
+            serialize=_serialize_get_config_fast,
+            deserialize=_deserialize_get_config_fast,
+            config=self._config,
+            operation=GET_CONFIG_FAST,
+        )
+
+    async def get_context(self, input: GetContextInput, plugins: list[Plugin] | None = None) -> GetContextOutput:
+        """
+        Retrieves detailed information about a specific context by its unique
+        identifier, including conditions, overrides, and metadata.
+
+        :param input: The operation's input.
+
+        :param plugins: A list of callables that modify the configuration dynamically.
+            Changes made by these plugins only apply for the duration of the operation
+            execution and will not affect any other operation invocations.
+
+        """
+        operation_plugins: list[Plugin] = [
+
+        ]
+        if plugins:
+            operation_plugins.extend(plugins)
+
+        return await self._execute_operation(
+            input=input,
+            plugins=operation_plugins,
+            serialize=_serialize_get_context,
+            deserialize=_deserialize_get_context,
+            config=self._config,
+            operation=GET_CONTEXT,
+        )
+
+    async def get_context_from_condition(self, input: GetContextFromConditionInput, plugins: list[Plugin] | None = None) -> GetContextFromConditionOutput:
+        """
+        Retrieves context information by matching against provided conditions. Used to
+        find contexts that would apply to specific scenarios.
+
+        :param input: The operation's input.
+
+        :param plugins: A list of callables that modify the configuration dynamically.
+            Changes made by these plugins only apply for the duration of the operation
+            execution and will not affect any other operation invocations.
+
+        """
+        operation_plugins: list[Plugin] = [
+
+        ]
+        if plugins:
+            operation_plugins.extend(plugins)
+
+        return await self._execute_operation(
+            input=input,
+            plugins=operation_plugins,
+            serialize=_serialize_get_context_from_condition,
+            deserialize=_deserialize_get_context_from_condition,
+            config=self._config,
+            operation=GET_CONTEXT_FROM_CONDITION,
+        )
+
+    async def get_default_config(self, input: GetDefaultConfigInput, plugins: list[Plugin] | None = None) -> GetDefaultConfigOutput:
+        """
+        Retrieves a specific default config entry by its key, including its value,
+        schema, function mappings, and metadata.
+
+        :param input: The operation's input.
+
+        :param plugins: A list of callables that modify the configuration dynamically.
+            Changes made by these plugins only apply for the duration of the operation
+            execution and will not affect any other operation invocations.
+
+        """
+        operation_plugins: list[Plugin] = [
+
+        ]
+        if plugins:
+            operation_plugins.extend(plugins)
+
+        return await self._execute_operation(
+            input=input,
+            plugins=operation_plugins,
+            serialize=_serialize_get_default_config,
+            deserialize=_deserialize_get_default_config,
+            config=self._config,
+            operation=GET_DEFAULT_CONFIG,
+        )
+
+    async def get_dimension(self, input: GetDimensionInput, plugins: list[Plugin] | None = None) -> GetDimensionOutput:
+        """
+        Retrieves detailed information about a specific dimension, including its schema,
+        cohort dependency graph, and configuration metadata.
+
+        :param input: The operation's input.
+
+        :param plugins: A list of callables that modify the configuration dynamically.
+            Changes made by these plugins only apply for the duration of the operation
+            execution and will not affect any other operation invocations.
+
+        """
+        operation_plugins: list[Plugin] = [
+
+        ]
+        if plugins:
+            operation_plugins.extend(plugins)
+
+        return await self._execute_operation(
+            input=input,
+            plugins=operation_plugins,
+            serialize=_serialize_get_dimension,
+            deserialize=_deserialize_get_dimension,
+            config=self._config,
+            operation=GET_DIMENSION,
+        )
+
+    async def get_experiment(self, input: GetExperimentInput, plugins: list[Plugin] | None = None) -> GetExperimentOutput:
+        """
+        Retrieves detailed information about a specific experiment, including its
+        config, variants, status, and metrics.
+
+        :param input: The operation's input.
+
+        :param plugins: A list of callables that modify the configuration dynamically.
+            Changes made by these plugins only apply for the duration of the operation
+            execution and will not affect any other operation invocations.
+
+        """
+        operation_plugins: list[Plugin] = [
+
+        ]
+        if plugins:
+            operation_plugins.extend(plugins)
+
+        return await self._execute_operation(
+            input=input,
+            plugins=operation_plugins,
+            serialize=_serialize_get_experiment,
+            deserialize=_deserialize_get_experiment,
+            config=self._config,
+            operation=GET_EXPERIMENT,
+        )
+
+    async def get_experiment_group(self, input: GetExperimentGroupInput, plugins: list[Plugin] | None = None) -> GetExperimentGroupOutput:
+        """
+        Retrieves an existing experiment group by its ID.
+
+        :param input: The operation's input.
+
+        :param plugins: A list of callables that modify the configuration dynamically.
+            Changes made by these plugins only apply for the duration of the operation
+            execution and will not affect any other operation invocations.
+
+        """
+        operation_plugins: list[Plugin] = [
+
+        ]
+        if plugins:
+            operation_plugins.extend(plugins)
+
+        return await self._execute_operation(
+            input=input,
+            plugins=operation_plugins,
+            serialize=_serialize_get_experiment_group,
+            deserialize=_deserialize_get_experiment_group,
+            config=self._config,
+            operation=GET_EXPERIMENT_GROUP,
+        )
+
+    async def get_function(self, input: GetFunctionInput, plugins: list[Plugin] | None = None) -> GetFunctionOutput:
+        """
+        Retrieves detailed information about a specific function including its published
+        and draft versions, code, and metadata.
+
+        :param input: The operation's input.
+
+        :param plugins: A list of callables that modify the configuration dynamically.
+            Changes made by these plugins only apply for the duration of the operation
+            execution and will not affect any other operation invocations.
+
+        """
+        operation_plugins: list[Plugin] = [
+
+        ]
+        if plugins:
+            operation_plugins.extend(plugins)
+
+        return await self._execute_operation(
+            input=input,
+            plugins=operation_plugins,
+            serialize=_serialize_get_function,
+            deserialize=_deserialize_get_function,
+            config=self._config,
+            operation=GET_FUNCTION,
+        )
+
+    async def get_organisation(self, input: GetOrganisationInput, plugins: list[Plugin] | None = None) -> GetOrganisationOutput:
+        """
+        Retrieves detailed information about a specific organisation including its
+        status, contact details, and administrative metadata.
+
+        :param input: The operation's input.
+
+        :param plugins: A list of callables that modify the configuration dynamically.
+            Changes made by these plugins only apply for the duration of the operation
+            execution and will not affect any other operation invocations.
+
+        """
+        operation_plugins: list[Plugin] = [
+
+        ]
+        if plugins:
+            operation_plugins.extend(plugins)
+
+        return await self._execute_operation(
+            input=input,
+            plugins=operation_plugins,
+            serialize=_serialize_get_organisation,
+            deserialize=_deserialize_get_organisation,
+            config=self._config,
+            operation=GET_ORGANISATION,
+        )
+
+    async def get_resolved_config(self, input: GetResolvedConfigInput, plugins: list[Plugin] | None = None) -> GetResolvedConfigOutput:
+        """
+        Resolves and merges config values based on context conditions, applying
+        overrides and merge strategies to produce the final configuration.
+
+        :param input: The operation's input.
+
+        :param plugins: A list of callables that modify the configuration dynamically.
+            Changes made by these plugins only apply for the duration of the operation
+            execution and will not affect any other operation invocations.
+
+        """
+        operation_plugins: list[Plugin] = [
+
+        ]
+        if plugins:
+            operation_plugins.extend(plugins)
+
+        return await self._execute_operation(
+            input=input,
+            plugins=operation_plugins,
+            serialize=_serialize_get_resolved_config,
+            deserialize=_deserialize_get_resolved_config,
+            config=self._config,
+            operation=GET_RESOLVED_CONFIG,
+        )
+
+    async def get_type_template(self, input: GetTypeTemplateInput, plugins: list[Plugin] | None = None) -> GetTypeTemplateOutput:
+        """
+        Retrieves detailed information about a specific type template including its
+        schema and metadata.
+
+        :param input: The operation's input.
+
+        :param plugins: A list of callables that modify the configuration dynamically.
+            Changes made by these plugins only apply for the duration of the operation
+            execution and will not affect any other operation invocations.
+
+        """
+        operation_plugins: list[Plugin] = [
+
+        ]
+        if plugins:
+            operation_plugins.extend(plugins)
+
+        return await self._execute_operation(
+            input=input,
+            plugins=operation_plugins,
+            serialize=_serialize_get_type_template,
+            deserialize=_deserialize_get_type_template,
+            config=self._config,
+            operation=GET_TYPE_TEMPLATE,
+        )
+
+    async def get_type_templates_list(self, input: GetTypeTemplatesListInput, plugins: list[Plugin] | None = None) -> GetTypeTemplatesListOutput:
+        """
+        Retrieves a paginated list of all type templates in the workspace, including
+        their schemas and metadata for type management.
+
+        :param input: The operation's input.
+
+        :param plugins: A list of callables that modify the configuration dynamically.
+            Changes made by these plugins only apply for the duration of the operation
+            execution and will not affect any other operation invocations.
+
+        """
+        operation_plugins: list[Plugin] = [
+
+        ]
+        if plugins:
+            operation_plugins.extend(plugins)
+
+        return await self._execute_operation(
+            input=input,
+            plugins=operation_plugins,
+            serialize=_serialize_get_type_templates_list,
+            deserialize=_deserialize_get_type_templates_list,
+            config=self._config,
+            operation=GET_TYPE_TEMPLATES_LIST,
+        )
+
+    async def get_version(self, input: GetVersionInput, plugins: list[Plugin] | None = None) -> GetVersionOutput:
+        """
+        Retrieves a specific config version along with its metadata for audit and
+        rollback purposes.
+
+        :param input: The operation's input.
+
+        :param plugins: A list of callables that modify the configuration dynamically.
+            Changes made by these plugins only apply for the duration of the operation
+            execution and will not affect any other operation invocations.
+
+        """
+        operation_plugins: list[Plugin] = [
+
+        ]
+        if plugins:
+            operation_plugins.extend(plugins)
+
+        return await self._execute_operation(
+            input=input,
+            plugins=operation_plugins,
+            serialize=_serialize_get_version,
+            deserialize=_deserialize_get_version,
+            config=self._config,
+            operation=GET_VERSION,
+        )
+
+    async def get_webhook(self, input: GetWebhookInput, plugins: list[Plugin] | None = None) -> GetWebhookOutput:
+        """
+        Retrieves detailed information about a specific webhook config, including its
+        events, headers, and trigger history.
+
+        :param input: The operation's input.
+
+        :param plugins: A list of callables that modify the configuration dynamically.
+            Changes made by these plugins only apply for the duration of the operation
+            execution and will not affect any other operation invocations.
+
+        """
+        operation_plugins: list[Plugin] = [
+
+        ]
+        if plugins:
+            operation_plugins.extend(plugins)
+
+        return await self._execute_operation(
+            input=input,
+            plugins=operation_plugins,
+            serialize=_serialize_get_webhook,
+            deserialize=_deserialize_get_webhook,
+            config=self._config,
+            operation=GET_WEBHOOK,
+        )
+
+    async def get_webhook_by_event(self, input: GetWebhookByEventInput, plugins: list[Plugin] | None = None) -> GetWebhookByEventOutput:
+        """
+        Retrieves a webhook configuration based on a specific event type, allowing users
+        to find which webhook is set to trigger for that event.
+
+        :param input: The operation's input.
+
+        :param plugins: A list of callables that modify the configuration dynamically.
+            Changes made by these plugins only apply for the duration of the operation
+            execution and will not affect any other operation invocations.
+
+        """
+        operation_plugins: list[Plugin] = [
+
+        ]
+        if plugins:
+            operation_plugins.extend(plugins)
+
+        return await self._execute_operation(
+            input=input,
+            plugins=operation_plugins,
+            serialize=_serialize_get_webhook_by_event,
+            deserialize=_deserialize_get_webhook_by_event,
+            config=self._config,
+            operation=GET_WEBHOOK_BY_EVENT,
+        )
+
+    async def get_workspace(self, input: GetWorkspaceInput, plugins: list[Plugin] | None = None) -> GetWorkspaceOutput:
+        """
+        Retrieves detailed information about a specific workspace including its
+        configuration and metadata.
+
+        :param input: The operation's input.
+
+        :param plugins: A list of callables that modify the configuration dynamically.
+            Changes made by these plugins only apply for the duration of the operation
+            execution and will not affect any other operation invocations.
+
+        """
+        operation_plugins: list[Plugin] = [
+
+        ]
+        if plugins:
+            operation_plugins.extend(plugins)
+
+        return await self._execute_operation(
+            input=input,
+            plugins=operation_plugins,
+            serialize=_serialize_get_workspace,
+            deserialize=_deserialize_get_workspace,
+            config=self._config,
+            operation=GET_WORKSPACE,
+        )
+
+    async def list_audit_logs(self, input: ListAuditLogsInput, plugins: list[Plugin] | None = None) -> ListAuditLogsOutput:
+        """
+        Retrieves a paginated list of audit logs with support for filtering by date
+        range, table names, actions, and usernames for compliance and monitoring
+        purposes.
+
+        :param input: The operation's input.
+
+        :param plugins: A list of callables that modify the configuration dynamically.
+            Changes made by these plugins only apply for the duration of the operation
+            execution and will not affect any other operation invocations.
+
+        """
+        operation_plugins: list[Plugin] = [
+
+        ]
+        if plugins:
+            operation_plugins.extend(plugins)
+
+        return await self._execute_operation(
+            input=input,
+            plugins=operation_plugins,
+            serialize=_serialize_list_audit_logs,
+            deserialize=_deserialize_list_audit_logs,
+            config=self._config,
+            operation=LIST_AUDIT_LOGS,
+        )
+
+    async def list_contexts(self, input: ListContextsInput, plugins: list[Plugin] | None = None) -> ListContextsOutput:
+        """
+        Retrieves a paginated list of contexts with support for filtering by creation
+        date, modification date, weight, and other criteria.
+
+        :param input: The operation's input.
+
+        :param plugins: A list of callables that modify the configuration dynamically.
+            Changes made by these plugins only apply for the duration of the operation
+            execution and will not affect any other operation invocations.
+
+        """
+        operation_plugins: list[Plugin] = [
+
+        ]
+        if plugins:
+            operation_plugins.extend(plugins)
+
+        return await self._execute_operation(
+            input=input,
+            plugins=operation_plugins,
+            serialize=_serialize_list_contexts,
+            deserialize=_deserialize_list_contexts,
+            config=self._config,
+            operation=LIST_CONTEXTS,
+        )
+
+    async def list_default_configs(self, input: ListDefaultConfigsInput, plugins: list[Plugin] | None = None) -> ListDefaultConfigsOutput:
+        """
+        Retrieves a paginated list of all default config entries in the workspace,
+        including their values, schemas, and metadata.
+
+        :param input: The operation's input.
+
+        :param plugins: A list of callables that modify the configuration dynamically.
+            Changes made by these plugins only apply for the duration of the operation
+            execution and will not affect any other operation invocations.
+
+        """
+        operation_plugins: list[Plugin] = [
+
+        ]
+        if plugins:
+            operation_plugins.extend(plugins)
+
+        return await self._execute_operation(
+            input=input,
+            plugins=operation_plugins,
+            serialize=_serialize_list_default_configs,
+            deserialize=_deserialize_list_default_configs,
+            config=self._config,
+            operation=LIST_DEFAULT_CONFIGS,
+        )
+
+    async def list_dimensions(self, input: ListDimensionsInput, plugins: list[Plugin] | None = None) -> ListDimensionsOutput:
+        """
+        Retrieves a paginated list of all dimensions in the workspace. Dimensions are
+        returned with their details and metadata.
+
+        :param input: The operation's input.
+
+        :param plugins: A list of callables that modify the configuration dynamically.
+            Changes made by these plugins only apply for the duration of the operation
+            execution and will not affect any other operation invocations.
+
+        """
+        operation_plugins: list[Plugin] = [
+
+        ]
+        if plugins:
+            operation_plugins.extend(plugins)
+
+        return await self._execute_operation(
+            input=input,
+            plugins=operation_plugins,
+            serialize=_serialize_list_dimensions,
+            deserialize=_deserialize_list_dimensions,
+            config=self._config,
+            operation=LIST_DIMENSIONS,
+        )
+
+    async def list_experiment(self, input: ListExperimentInput, plugins: list[Plugin] | None = None) -> ListExperimentOutput:
+        """
+        Retrieves a paginated list of experiments with support for filtering by status,
+        date range, name, creator, and experiment group.
+
+        :param input: The operation's input.
+
+        :param plugins: A list of callables that modify the configuration dynamically.
+            Changes made by these plugins only apply for the duration of the operation
+            execution and will not affect any other operation invocations.
+
+        """
+        operation_plugins: list[Plugin] = [
+
+        ]
+        if plugins:
+            operation_plugins.extend(plugins)
+
+        return await self._execute_operation(
+            input=input,
+            plugins=operation_plugins,
+            serialize=_serialize_list_experiment,
+            deserialize=_deserialize_list_experiment,
+            config=self._config,
+            operation=LIST_EXPERIMENT,
+        )
+
+    async def list_experiment_groups(self, input: ListExperimentGroupsInput, plugins: list[Plugin] | None = None) -> ListExperimentGroupsOutput:
+        """
+        Lists experiment groups, with support for filtering and pagination.
+
+        :param input: The operation's input.
+
+        :param plugins: A list of callables that modify the configuration dynamically.
+            Changes made by these plugins only apply for the duration of the operation
+            execution and will not affect any other operation invocations.
+
+        """
+        operation_plugins: list[Plugin] = [
+
+        ]
+        if plugins:
+            operation_plugins.extend(plugins)
+
+        return await self._execute_operation(
+            input=input,
+            plugins=operation_plugins,
+            serialize=_serialize_list_experiment_groups,
+            deserialize=_deserialize_list_experiment_groups,
+            config=self._config,
+            operation=LIST_EXPERIMENT_GROUPS,
+        )
+
+    async def list_function(self, input: ListFunctionInput, plugins: list[Plugin] | None = None) -> ListFunctionOutput:
+        """
+        Retrieves a paginated list of all functions in the workspace with their basic
+        information and current status.
+
+        :param input: The operation's input.
+
+        :param plugins: A list of callables that modify the configuration dynamically.
+            Changes made by these plugins only apply for the duration of the operation
+            execution and will not affect any other operation invocations.
+
+        """
+        operation_plugins: list[Plugin] = [
+
+        ]
+        if plugins:
+            operation_plugins.extend(plugins)
+
+        return await self._execute_operation(
+            input=input,
+            plugins=operation_plugins,
+            serialize=_serialize_list_function,
+            deserialize=_deserialize_list_function,
+            config=self._config,
+            operation=LIST_FUNCTION,
+        )
+
+    async def list_organisation(self, input: ListOrganisationInput, plugins: list[Plugin] | None = None) -> ListOrganisationOutput:
+        """
+        Retrieves a paginated list of all organisations with their basic information,
+        creation details, and current status.
+
+        :param input: The operation's input.
+
+        :param plugins: A list of callables that modify the configuration dynamically.
+            Changes made by these plugins only apply for the duration of the operation
+            execution and will not affect any other operation invocations.
+
+        """
+        operation_plugins: list[Plugin] = [
+
+        ]
+        if plugins:
+            operation_plugins.extend(plugins)
+
+        return await self._execute_operation(
+            input=input,
+            plugins=operation_plugins,
+            serialize=_serialize_list_organisation,
+            deserialize=_deserialize_list_organisation,
+            config=self._config,
+            operation=LIST_ORGANISATION,
+        )
+
+    async def list_versions(self, input: ListVersionsInput, plugins: list[Plugin] | None = None) -> ListVersionsOutput:
+        """
+        Retrieves a paginated list of config versions with their metadata, hash values,
+        and creation timestamps for audit and rollback purposes.
+
+        :param input: The operation's input.
+
+        :param plugins: A list of callables that modify the configuration dynamically.
+            Changes made by these plugins only apply for the duration of the operation
+            execution and will not affect any other operation invocations.
+
+        """
+        operation_plugins: list[Plugin] = [
+
+        ]
+        if plugins:
+            operation_plugins.extend(plugins)
+
+        return await self._execute_operation(
+            input=input,
+            plugins=operation_plugins,
+            serialize=_serialize_list_versions,
+            deserialize=_deserialize_list_versions,
+            config=self._config,
+            operation=LIST_VERSIONS,
+        )
+
+    async def list_webhook(self, input: ListWebhookInput, plugins: list[Plugin] | None = None) -> ListWebhookOutput:
+        """
+        Retrieves a paginated list of all webhook configs in the workspace, including
+        their status and config details.
+
+        :param input: The operation's input.
+
+        :param plugins: A list of callables that modify the configuration dynamically.
+            Changes made by these plugins only apply for the duration of the operation
+            execution and will not affect any other operation invocations.
+
+        """
+        operation_plugins: list[Plugin] = [
+
+        ]
+        if plugins:
+            operation_plugins.extend(plugins)
+
+        return await self._execute_operation(
+            input=input,
+            plugins=operation_plugins,
+            serialize=_serialize_list_webhook,
+            deserialize=_deserialize_list_webhook,
+            config=self._config,
+            operation=LIST_WEBHOOK,
+        )
+
+    async def list_workspace(self, input: ListWorkspaceInput, plugins: list[Plugin] | None = None) -> ListWorkspaceOutput:
+        """
+        Retrieves a paginated list of all workspaces with optional filtering by
+        workspace name, including their status, config details, and administrative
+        information.
+
+        :param input: The operation's input.
+
+        :param plugins: A list of callables that modify the configuration dynamically.
+            Changes made by these plugins only apply for the duration of the operation
+            execution and will not affect any other operation invocations.
+
+        """
+        operation_plugins: list[Plugin] = [
+
+        ]
+        if plugins:
+            operation_plugins.extend(plugins)
+
+        return await self._execute_operation(
+            input=input,
+            plugins=operation_plugins,
+            serialize=_serialize_list_workspace,
+            deserialize=_deserialize_list_workspace,
+            config=self._config,
+            operation=LIST_WORKSPACE,
+        )
+
+    async def migrate_workspace_schema(self, input: MigrateWorkspaceSchemaInput, plugins: list[Plugin] | None = None) -> MigrateWorkspaceSchemaOutput:
+        """
+        Migrates the workspace database schema to the new version of the template
+
+        :param input: The operation's input.
+
+        :param plugins: A list of callables that modify the configuration dynamically.
+            Changes made by these plugins only apply for the duration of the operation
+            execution and will not affect any other operation invocations.
+
+        """
+        operation_plugins: list[Plugin] = [
+
+        ]
+        if plugins:
+            operation_plugins.extend(plugins)
+
+        return await self._execute_operation(
+            input=input,
+            plugins=operation_plugins,
+            serialize=_serialize_migrate_workspace_schema,
+            deserialize=_deserialize_migrate_workspace_schema,
+            config=self._config,
+            operation=MIGRATE_WORKSPACE_SCHEMA,
+        )
+
+    async def move_context(self, input: MoveContextInput, plugins: list[Plugin] | None = None) -> MoveContextOutput:
+        """
+        Updates the condition of the mentioned context, if a context with the new
+        condition already exists, it merges the override and effectively deleting the
+        old context
+
+        :param input: The operation's input.
+
+        :param plugins: A list of callables that modify the configuration dynamically.
+            Changes made by these plugins only apply for the duration of the operation
+            execution and will not affect any other operation invocations.
+
+        """
+        operation_plugins: list[Plugin] = [
+
+        ]
+        if plugins:
+            operation_plugins.extend(plugins)
+
+        return await self._execute_operation(
+            input=input,
+            plugins=operation_plugins,
+            serialize=_serialize_move_context,
+            deserialize=_deserialize_move_context,
+            config=self._config,
+            operation=MOVE_CONTEXT,
+        )
+
+    async def pause_experiment(self, input: PauseExperimentInput, plugins: list[Plugin] | None = None) -> PauseExperimentOutput:
+        """
+        Temporarily pauses an inprogress experiment, suspending its effects while
+        preserving the experiment config for later resumption.
+
+        :param input: The operation's input.
+
+        :param plugins: A list of callables that modify the configuration dynamically.
+            Changes made by these plugins only apply for the duration of the operation
+            execution and will not affect any other operation invocations.
+
+        """
+        operation_plugins: list[Plugin] = [
+
+        ]
+        if plugins:
+            operation_plugins.extend(plugins)
+
+        return await self._execute_operation(
+            input=input,
+            plugins=operation_plugins,
+            serialize=_serialize_pause_experiment,
+            deserialize=_deserialize_pause_experiment,
+            config=self._config,
+            operation=PAUSE_EXPERIMENT,
+        )
+
+    async def publish(self, input: PublishInput, plugins: list[Plugin] | None = None) -> PublishOutput:
+        """
+        Publishes the draft version of a function, making it the active version used for
+        validation or autocompletion in the system.
+
+        :param input: The operation's input.
+
+        :param plugins: A list of callables that modify the configuration dynamically.
+            Changes made by these plugins only apply for the duration of the operation
+            execution and will not affect any other operation invocations.
+
+        """
+        operation_plugins: list[Plugin] = [
+
+        ]
+        if plugins:
+            operation_plugins.extend(plugins)
+
+        return await self._execute_operation(
+            input=input,
+            plugins=operation_plugins,
+            serialize=_serialize_publish,
+            deserialize=_deserialize_publish,
+            config=self._config,
+            operation=PUBLISH,
+        )
+
+    async def ramp_experiment(self, input: RampExperimentInput, plugins: list[Plugin] | None = None) -> RampExperimentOutput:
+        """
+        Adjusts the traffic percentage allocation for an in-progress experiment,
+        allowing gradual rollout or rollback of experimental features.
+
+        :param input: The operation's input.
+
+        :param plugins: A list of callables that modify the configuration dynamically.
+            Changes made by these plugins only apply for the duration of the operation
+            execution and will not affect any other operation invocations.
+
+        """
+        operation_plugins: list[Plugin] = [
+
+        ]
+        if plugins:
+            operation_plugins.extend(plugins)
+
+        return await self._execute_operation(
+            input=input,
+            plugins=operation_plugins,
+            serialize=_serialize_ramp_experiment,
+            deserialize=_deserialize_ramp_experiment,
+            config=self._config,
+            operation=RAMP_EXPERIMENT,
+        )
+
+    async def remove_members_from_group(self, input: RemoveMembersFromGroupInput, plugins: list[Plugin] | None = None) -> RemoveMembersFromGroupOutput:
+        """
+        Removes members from an existing experiment group.
+
+        :param input: Input structure for adding members to an experiment group.
+
+        :param plugins: A list of callables that modify the configuration dynamically.
+            Changes made by these plugins only apply for the duration of the operation
+            execution and will not affect any other operation invocations.
+
+        """
+        operation_plugins: list[Plugin] = [
+
+        ]
+        if plugins:
+            operation_plugins.extend(plugins)
+
+        return await self._execute_operation(
+            input=input,
+            plugins=operation_plugins,
+            serialize=_serialize_remove_members_from_group,
+            deserialize=_deserialize_remove_members_from_group,
+            config=self._config,
+            operation=REMOVE_MEMBERS_FROM_GROUP,
+        )
+
+    async def resume_experiment(self, input: ResumeExperimentInput, plugins: list[Plugin] | None = None) -> ResumeExperimentOutput:
+        """
+        Resumes a previously paused experiment, restoring its in-progress state and
+        re-enabling variant evaluation.
+
+        :param input: The operation's input.
+
+        :param plugins: A list of callables that modify the configuration dynamically.
+            Changes made by these plugins only apply for the duration of the operation
+            execution and will not affect any other operation invocations.
+
+        """
+        operation_plugins: list[Plugin] = [
+
+        ]
+        if plugins:
+            operation_plugins.extend(plugins)
+
+        return await self._execute_operation(
+            input=input,
+            plugins=operation_plugins,
+            serialize=_serialize_resume_experiment,
+            deserialize=_deserialize_resume_experiment,
+            config=self._config,
+            operation=RESUME_EXPERIMENT,
+        )
+
+    async def test(self, input: TestInput, plugins: list[Plugin] | None = None) -> TestOutput:
+        """
+        Executes a function in test mode with provided input parameters to validate its
+        behavior before publishing or deployment.
+
+        :param input: The operation's input.
+
+        :param plugins: A list of callables that modify the configuration dynamically.
+            Changes made by these plugins only apply for the duration of the operation
+            execution and will not affect any other operation invocations.
+
+        """
+        operation_plugins: list[Plugin] = [
+
+        ]
+        if plugins:
+            operation_plugins.extend(plugins)
+
+        return await self._execute_operation(
+            input=input,
+            plugins=operation_plugins,
+            serialize=_serialize_test,
+            deserialize=_deserialize_test,
+            config=self._config,
+            operation=TEST,
+        )
+
+    async def update_default_config(self, input: UpdateDefaultConfigInput, plugins: list[Plugin] | None = None) -> UpdateDefaultConfigOutput:
+        """
+        Updates an existing default config entry. Allows modification of value, schema,
+        function mappings, and description while preserving the key identifier.
+
+        :param input: The operation's input.
+
+        :param plugins: A list of callables that modify the configuration dynamically.
+            Changes made by these plugins only apply for the duration of the operation
+            execution and will not affect any other operation invocations.
+
+        """
+        operation_plugins: list[Plugin] = [
+
+        ]
+        if plugins:
+            operation_plugins.extend(plugins)
+
+        return await self._execute_operation(
+            input=input,
+            plugins=operation_plugins,
+            serialize=_serialize_update_default_config,
+            deserialize=_deserialize_update_default_config,
+            config=self._config,
+            operation=UPDATE_DEFAULT_CONFIG,
+        )
+
+    async def update_dimension(self, input: UpdateDimensionInput, plugins: list[Plugin] | None = None) -> UpdateDimensionOutput:
+        """
+        Updates an existing dimension's configuration. Allows modification of schema,
+        position, function mappings, and other properties while maintaining dependency
+        relationships.
+
+        :param input: The operation's input.
+
+        :param plugins: A list of callables that modify the configuration dynamically.
+            Changes made by these plugins only apply for the duration of the operation
+            execution and will not affect any other operation invocations.
+
+        """
+        operation_plugins: list[Plugin] = [
+
+        ]
+        if plugins:
+            operation_plugins.extend(plugins)
+
+        return await self._execute_operation(
+            input=input,
+            plugins=operation_plugins,
+            serialize=_serialize_update_dimension,
+            deserialize=_deserialize_update_dimension,
+            config=self._config,
+            operation=UPDATE_DIMENSION,
+        )
+
+    async def update_experiment_group(self, input: UpdateExperimentGroupInput, plugins: list[Plugin] | None = None) -> UpdateExperimentGroupOutput:
+        """
+        Updates an existing experiment group. Allows partial updates to specified
+        fields.
+
+        :param input: Input structure for updating an existing experiment group.
+
+        :param plugins: A list of callables that modify the configuration dynamically.
+            Changes made by these plugins only apply for the duration of the operation
+            execution and will not affect any other operation invocations.
+
+        """
+        operation_plugins: list[Plugin] = [
+
+        ]
+        if plugins:
+            operation_plugins.extend(plugins)
+
+        return await self._execute_operation(
+            input=input,
+            plugins=operation_plugins,
+            serialize=_serialize_update_experiment_group,
+            deserialize=_deserialize_update_experiment_group,
+            config=self._config,
+            operation=UPDATE_EXPERIMENT_GROUP,
+        )
+
+    async def update_function(self, input: UpdateFunctionInput, plugins: list[Plugin] | None = None) -> UpdateFunctionOutput:
+        """
+        Updates the draft version of an existing function with new code, runtime
+        version, or description while preserving the published version.
+
+        :param input: The operation's input.
+
+        :param plugins: A list of callables that modify the configuration dynamically.
+            Changes made by these plugins only apply for the duration of the operation
+            execution and will not affect any other operation invocations.
+
+        """
+        operation_plugins: list[Plugin] = [
+
+        ]
+        if plugins:
+            operation_plugins.extend(plugins)
+
+        return await self._execute_operation(
+            input=input,
+            plugins=operation_plugins,
+            serialize=_serialize_update_function,
+            deserialize=_deserialize_update_function,
+            config=self._config,
+            operation=UPDATE_FUNCTION,
+        )
+
+    async def update_organisation(self, input: UpdateOrganisationInput, plugins: list[Plugin] | None = None) -> UpdateOrganisationOutput:
+        """
+        Updates an existing organisation's information including contact details,
+        status, and administrative properties.
+
+        :param input: The operation's input.
+
+        :param plugins: A list of callables that modify the configuration dynamically.
+            Changes made by these plugins only apply for the duration of the operation
+            execution and will not affect any other operation invocations.
+
+        """
+        operation_plugins: list[Plugin] = [
+
+        ]
+        if plugins:
+            operation_plugins.extend(plugins)
+
+        return await self._execute_operation(
+            input=input,
+            plugins=operation_plugins,
+            serialize=_serialize_update_organisation,
+            deserialize=_deserialize_update_organisation,
+            config=self._config,
+            operation=UPDATE_ORGANISATION,
+        )
+
+    async def update_override(self, input: UpdateOverrideInput, plugins: list[Plugin] | None = None) -> UpdateOverrideOutput:
+        """
+        Updates the overrides for an existing context. Allows modification of override
+        values while maintaining the context's conditions.
+
+        :param input: The operation's input.
+
+        :param plugins: A list of callables that modify the configuration dynamically.
+            Changes made by these plugins only apply for the duration of the operation
+            execution and will not affect any other operation invocations.
+
+        """
+        operation_plugins: list[Plugin] = [
+
+        ]
+        if plugins:
+            operation_plugins.extend(plugins)
+
+        return await self._execute_operation(
+            input=input,
+            plugins=operation_plugins,
+            serialize=_serialize_update_override,
+            deserialize=_deserialize_update_override,
+            config=self._config,
+            operation=UPDATE_OVERRIDE,
+        )
+
+    async def update_overrides_experiment(self, input: UpdateOverridesExperimentInput, plugins: list[Plugin] | None = None) -> UpdateOverridesExperimentOutput:
+        """
+        Updates the overrides for specific variants within an experiment, allowing
+        modification of experiment behavior Updates the overrides for specific variants
+        within an experiment, allowing modification of experiment behavior while it is
+        in the created state.
+
+        :param input: The operation's input.
+
+        :param plugins: A list of callables that modify the configuration dynamically.
+            Changes made by these plugins only apply for the duration of the operation
+            execution and will not affect any other operation invocations.
+
+        """
+        operation_plugins: list[Plugin] = [
+
+        ]
+        if plugins:
+            operation_plugins.extend(plugins)
+
+        return await self._execute_operation(
+            input=input,
+            plugins=operation_plugins,
+            serialize=_serialize_update_overrides_experiment,
+            deserialize=_deserialize_update_overrides_experiment,
+            config=self._config,
+            operation=UPDATE_OVERRIDES_EXPERIMENT,
+        )
+
+    async def update_type_templates(self, input: UpdateTypeTemplatesInput, plugins: list[Plugin] | None = None) -> UpdateTypeTemplatesOutput:
+        """
+        Updates an existing type template's schema definition and metadata while
+        preserving its identifier and usage history.
+
+        :param input: The operation's input.
+
+        :param plugins: A list of callables that modify the configuration dynamically.
+            Changes made by these plugins only apply for the duration of the operation
+            execution and will not affect any other operation invocations.
+
+        """
+        operation_plugins: list[Plugin] = [
+
+        ]
+        if plugins:
+            operation_plugins.extend(plugins)
+
+        return await self._execute_operation(
+            input=input,
+            plugins=operation_plugins,
+            serialize=_serialize_update_type_templates,
+            deserialize=_deserialize_update_type_templates,
+            config=self._config,
+            operation=UPDATE_TYPE_TEMPLATES,
+        )
+
+    async def update_webhook(self, input: UpdateWebhookInput, plugins: list[Plugin] | None = None) -> UpdateWebhookOutput:
+        """
+        Updates an existing webhook config, allowing modification of URL, events,
+        headers, and other webhook properties.
+
+        :param input: The operation's input.
+
+        :param plugins: A list of callables that modify the configuration dynamically.
+            Changes made by these plugins only apply for the duration of the operation
+            execution and will not affect any other operation invocations.
+
+        """
+        operation_plugins: list[Plugin] = [
+
+        ]
+        if plugins:
+            operation_plugins.extend(plugins)
+
+        return await self._execute_operation(
+            input=input,
+            plugins=operation_plugins,
+            serialize=_serialize_update_webhook,
+            deserialize=_deserialize_update_webhook,
+            config=self._config,
+            operation=UPDATE_WEBHOOK,
+        )
+
+    async def update_workspace(self, input: UpdateWorkspaceInput, plugins: list[Plugin] | None = None) -> UpdateWorkspaceOutput:
+        """
+        Updates an existing workspace configuration, allowing modification of admin
+        settings, mandatory dimensions, and workspace properties. Validates config
+        version existence if provided.
+
+        :param input: The operation's input.
+
+        :param plugins: A list of callables that modify the configuration dynamically.
+            Changes made by these plugins only apply for the duration of the operation
+            execution and will not affect any other operation invocations.
+
+        """
+        operation_plugins: list[Plugin] = [
+
+        ]
+        if plugins:
+            operation_plugins.extend(plugins)
+
+        return await self._execute_operation(
+            input=input,
+            plugins=operation_plugins,
+            serialize=_serialize_update_workspace,
+            deserialize=_deserialize_update_workspace,
+            config=self._config,
+            operation=UPDATE_WORKSPACE,
+        )
+
+    async def validate_context(self, input: ValidateContextInput, plugins: list[Plugin] | None = None) -> ValidateContextOutput:
+        """
+        Validates if a given context condition is well-formed
+
+        :param input: The operation's input.
+
+        :param plugins: A list of callables that modify the configuration dynamically.
+            Changes made by these plugins only apply for the duration of the operation
+            execution and will not affect any other operation invocations.
+
+        """
+        operation_plugins: list[Plugin] = [
+
+        ]
+        if plugins:
+            operation_plugins.extend(plugins)
+
+        return await self._execute_operation(
+            input=input,
+            plugins=operation_plugins,
+            serialize=_serialize_validate_context,
+            deserialize=_deserialize_validate_context,
+            config=self._config,
+            operation=VALIDATE_CONTEXT,
+        )
+
+    async def weight_recompute(self, input: WeightRecomputeInput, plugins: list[Plugin] | None = None) -> WeightRecomputeOutput:
+        """
+        Recalculates and updates the priority weights for all contexts in the workspace
+        based on their dimensions.
+
+        :param input: The operation's input.
+
+        :param plugins: A list of callables that modify the configuration dynamically.
+            Changes made by these plugins only apply for the duration of the operation
+            execution and will not affect any other operation invocations.
+
+        """
+        operation_plugins: list[Plugin] = [
+
+        ]
+        if plugins:
+            operation_plugins.extend(plugins)
+
+        return await self._execute_operation(
+            input=input,
+            plugins=operation_plugins,
+            serialize=_serialize_weight_recompute,
+            deserialize=_deserialize_weight_recompute,
+            config=self._config,
+            operation=WEIGHT_RECOMPUTE,
+        )
+
+    def _classify_error(
+        self,
+        *,
+        error: Exception,
+        context: ResponseContext[Any, HTTPRequest, HTTPResponse | None]
+    ) -> RetryErrorInfo:
+        logger.debug("Classifying error: %s", error)
+
+        if not isinstance(error, HasFault) and not context.transport_response:
+            return RetryErrorInfo(error_type=RetryErrorType.TRANSIENT)
+
+        if context.transport_response:
+            if context.transport_response.status in [429, 503]:
+                retry_after = None
+                retry_header = context.transport_response.fields["retry-after"]
+                if retry_header and retry_header.values:
+                    retry_after = float(retry_header.values[0])
+                return RetryErrorInfo(error_type=RetryErrorType.THROTTLING, retry_after_hint=retry_after)
+
+            if context.transport_response.status >= 500:
+                return RetryErrorInfo(error_type=RetryErrorType.SERVER_ERROR)
+
+        error_type = RetryErrorType.CLIENT_ERROR
+        if isinstance(error, HasFault) and error.fault == "server":
+            error_type = RetryErrorType.SERVER_ERROR
+
+        return RetryErrorInfo(error_type=error_type)
+
+    async def _execute_operation[Input: SerializeableShape, Output: DeserializeableShape](
+        self,
+        input: Input,
+        plugins: list[Plugin],
+        serialize: Callable[[Input, Config], Awaitable[HTTPRequest]],
+        deserialize: Callable[[HTTPResponse, Config], Awaitable[Output]],
+        config: Config,
+        operation: APIOperation[Input, Output],
+        request_future: Future[RequestContext[Any, HTTPRequest]] | None = None,
+        response_future: Future[HTTPResponse] | None = None,
+    ) -> Output:
+        try:
+            return await self._handle_execution(
+                input, plugins, serialize, deserialize, config, operation,
+                request_future, response_future,
+            )
+        except Exception as e:
+            if request_future is not None and not request_future.done():
+                request_future.set_exception(ServiceError(e))
+            if response_future is not None and not response_future.done():
+                response_future.set_exception(ServiceError(e))
+
+            # Make sure every exception that we throw is an instance of ServiceError so
+            # customers can reliably catch everything we throw.
+            if not isinstance(e, ServiceError):
+                raise ServiceError(e) from e
+            raise
+
+    async def _handle_execution[Input: SerializeableShape, Output: DeserializeableShape](
+        self,
+        input: Input,
+        plugins: list[Plugin],
+        serialize: Callable[[Input, Config], Awaitable[HTTPRequest]],
+        deserialize: Callable[[HTTPResponse, Config], Awaitable[Output]],
+        config: Config,
+        operation: APIOperation[Input, Output],
+        request_future: Future[RequestContext[Any, HTTPRequest]] | None,
+        response_future: Future[HTTPResponse] | None,
+    ) -> Output:
+        operation_name = operation.schema.id.name
+        logger.debug('Making request for operation "%s" with parameters: %s', operation_name, input)
+        config = deepcopy(config)
+        for plugin in plugins:
+            plugin(config)
+
+        input_context = InputContext(request=input, properties=TypedProperties({"config": config}))
+        transport_request: HTTPRequest | None = None
+        output_context: OutputContext[Input, Output, HTTPRequest | None, HTTPResponse | None] | None = None
+
+        client_interceptors = cast(
+            list[Interceptor[Input, Output, HTTPRequest, HTTPResponse]], list(config.interceptors)
+        )
+        interceptor_chain = InterceptorChain(client_interceptors)
+
+        try:
+            # Step 1: Invoke read_before_execution
+            interceptor_chain.read_before_execution(input_context)
+
+            # Step 2: Invoke the modify_before_serialization hooks
+            input_context = replace(
+                input_context,
+                request=interceptor_chain.modify_before_serialization(input_context)
+            )
+
+            # Step 3: Invoke the read_before_serialization hooks
+            interceptor_chain.read_before_serialization(input_context)
+
+            # Step 4: Serialize the request
+            logger.debug("Serializing request for: %s", input_context.request)
+            transport_request = await serialize(input_context.request, config)
+            request_context = RequestContext(
+                request=input_context.request,
+                transport_request=transport_request,
+                properties=input_context.properties,
+            )
+            logger.debug("Serialization complete. Transport request: %s", request_context.transport_request)
+
+            # Step 5: Invoke read_after_serialization
+            interceptor_chain.read_after_serialization(request_context)
+
+            # Step 6: Invoke modify_before_retry_loop
+            request_context = replace(
+                request_context,
+                transport_request=interceptor_chain.modify_before_retry_loop(request_context)
+            )
+
+            # Step 7: Acquire the retry token.
+            retry_strategy = config.retry_strategy
+            retry_token = retry_strategy.acquire_initial_retry_token()
+
+            while True:
+                # Make an attempt
+                output_context = await self._handle_attempt(
+                    deserialize,
+                    interceptor_chain,
+                    replace(
+                      request_context,
+                      transport_request = copy(request_context.transport_request)
+                    ),
+                    config,
+                    operation,
+                    request_future,
+                )
+
+                if isinstance(output_context.response, Exception):
+                    # Step 7u: Reacquire retry token if the attempt failed
+                    try:
+                        retry_token = retry_strategy.refresh_retry_token_for_retry(
+                            token_to_renew=retry_token,
+                            error_info=self._classify_error(
+                                error=output_context.response,
+                                context=output_context,
+                            )
+                        )
+                    except SmithyRetryException:
+                        raise output_context.response
+                    logger.debug(
+                        "Retry needed. Attempting request #%s in %.4f seconds.",
+                        retry_token.retry_count + 1,
+                        retry_token.retry_delay
+                    )
+                    await sleep(retry_token.retry_delay)
+                    current_body = output_context.transport_request.body
+                    if (seek := getattr(current_body, "seek", None)) is not None:
+                        if iscoroutine((result := seek(0))):
+                            await result
+                else:
+                    # Step 8: Invoke record_success
+                    retry_strategy.record_success(token=retry_token)
+                    if response_future is not None:
+                        response_future.set_result(
+                            output_context.transport_response  # type: ignore
+                        )
+                    break
+        except Exception as e:
+            if output_context is not None:
+                logger.exception("Exception occurred while handling: %s", output_context.response)
+                output_context = replace(output_context, response=e)
+            else:
+                output_context = OutputContext(
+                    request=input_context.request,
+                    response=e,
+                    transport_request=transport_request,
+                    transport_response=None,
+                    properties=input_context.properties
+                )
+
+        return await self._finalize_execution(interceptor_chain, output_context)
+
+    async def _handle_attempt[Input: SerializeableShape, Output: DeserializeableShape](
+        self,
+        deserialize: Callable[[HTTPResponse, Config], Awaitable[Output]],
+        interceptor: Interceptor[Input, Output, HTTPRequest, HTTPResponse],
+        context: RequestContext[Input, HTTPRequest],
+        config: Config,
+        operation: APIOperation[Input, Output],
+        request_future: Future[RequestContext[Input, HTTPRequest]] | None,
+    ) -> OutputContext[Input, Output, HTTPRequest, HTTPResponse | None]:
+        transport_response: HTTPResponse | None = None
+        try:
+            # Step 7a: Invoke read_before_attempt
+            interceptor.read_before_attempt(context)
+
+            # Step 7b: Invoke service_auth_scheme_resolver.resolve_auth_scheme
+            auth_parameters: HTTPAuthParams = HTTPAuthParams(
+                operation=operation.schema.id.name,
+
+            )
+
+            auth_options = config.http_auth_scheme_resolver.resolve_auth_scheme(
+                auth_parameters=auth_parameters
+            )
+            auth_option: HTTPAuthOption | None = None
+            for option in auth_options:
+                if option.scheme_id in config.http_auth_schemes:
+                    auth_option = option
+                    break
+
+            signer: HTTPSigner[Any, Any] | None = None
+            identity: Identity | None = None
+
+            if auth_option:
+                auth_scheme = config.http_auth_schemes[auth_option.scheme_id]
+
+                # Step 7c: Invoke auth_scheme.identity_resolver
+                identity_resolver = auth_scheme.identity_resolver(config=config)
+
+                # Step 7d: Invoke auth_scheme.signer
+                signer = auth_scheme.signer
+
+                # Step 7e: Invoke identity_resolver.get_identity
+                identity = await identity_resolver.get_identity(
+                    identity_properties=auth_option.identity_properties
+                )
+
+            # Step 7f: Invoke endpoint_resolver.resolve_endpoint
+            endpoint_resolver_parameters = EndpointResolverParams(
+                operation=operation,
+                input=context.request,
+                context=context.properties
+            )
+            logger.debug("Calling endpoint resolver with parameters: %s", endpoint_resolver_parameters)
+            endpoint = await config.endpoint_resolver.resolve_endpoint(
+                endpoint_resolver_parameters
+            )
+            logger.debug("Endpoint resolver result: %s", endpoint)
+            if not endpoint.uri.path:
+                path = ""
+            elif endpoint.uri.path.endswith("/"):
+                path = endpoint.uri.path[:-1]
+            else:
+                path = endpoint.uri.path
+            if context.transport_request.destination.path:
+                path += context.transport_request.destination.path
+            context.transport_request.destination = URI(
+                scheme=endpoint.uri.scheme,
+                host=context.transport_request.destination.host + endpoint.uri.host,
+                path=path,
+                port=endpoint.uri.port,
+                query=context.transport_request.destination.query,
+            )
+
+            if (headers := endpoint.properties.get("headers")) is not None:
+                context.transport_request.fields.extend(headers)
+
+            # Step 7g: Invoke modify_before_signing
+            context = replace(
+                context,
+                transport_request=interceptor.modify_before_signing(context)
+            )
+
+            # Step 7h: Invoke read_before_signing
+            interceptor.read_before_signing(context)
+
+            # Step 7i: sign the request
+            if auth_option and signer:
+                logger.debug("HTTP request to sign: %s", context.transport_request)
+                logger.debug(
+                    "Signer properties: %s",
+                    auth_option.signer_properties
+                )
+                context = replace(
+                    context,
+                    transport_request= await signer.sign(
+                        http_request=context.transport_request,
+                        identity=identity,
+                        signing_properties=auth_option.signer_properties,
+                    )
+                )
+                logger.debug("Signed HTTP request: %s", context.transport_request)
+
+                # TODO - Move this to separate resolution/population function
+                fields = context.transport_request.fields
+                auth_value = fields["Authorization"].as_string()  # type: ignore
+                signature = re.split("Signature=", auth_value)[-1]  # type: ignore
+                context.properties["signature"] = signature.encode('utf-8')
+
+                identity_key: PropertyKey[Identity | None] = PropertyKey(
+                    key="identity",
+                    value_type=Identity | None  # type: ignore
+                )
+                sp_key: PropertyKey[dict[str, Any]] = PropertyKey(
+                    key="signer_properties",
+                    value_type=dict[str, Any]  # type: ignore
+                )
+                context.properties[identity_key] = identity
+                context.properties[sp_key] = auth_option.signer_properties
+
+            # Step 7j: Invoke read_after_signing
+            interceptor.read_after_signing(context)
+
+            # Step 7k: Invoke modify_before_transmit
+            context = replace(
+                context,
+                transport_request=interceptor.modify_before_transmit(context)
+            )
+
+            # Step 7l: Invoke read_before_transmit
+            interceptor.read_before_transmit(context)
+
+            # Step 7m: Invoke http_client.send
+            request_config = config.http_request_config or HTTPRequestConfiguration()
+            logger.debug("HTTP request config: %s", request_config)
+            logger.debug("Sending HTTP request: %s", context.transport_request)
+
+            if request_future is not None:
+                response_task = asyncio.create_task(config.http_client.send(
+                    request=context.transport_request,
+                    request_config=request_config,
+                ))
+                request_future.set_result(context)
+                transport_response = await response_task
+            else:
+                transport_response = await config.http_client.send(
+                    request=context.transport_request,
+                    request_config=request_config,
+                )
+
+            response_context = ResponseContext(
+                request=context.request,
+                transport_request=context.transport_request,
+                transport_response=transport_response,
+                properties=context.properties
+            )
+            logger.debug("Received HTTP response: %s", response_context.transport_response)
+
+            # Step 7n: Invoke read_after_transmit
+            interceptor.read_after_transmit(response_context)
+
+            # Step 7o: Invoke modify_before_deserialization
+            response_context = replace(
+                response_context,
+                transport_response=interceptor.modify_before_deserialization(response_context)
+            )
+
+            # Step 7p: Invoke read_before_deserialization
+            interceptor.read_before_deserialization(response_context)
+
+            # Step 7q: deserialize
+            logger.debug("Deserializing transport response: %s", response_context.transport_response)
+            output = await deserialize(
+                response_context.transport_response, config
+            )
+            output_context = OutputContext(
+                request=response_context.request,
+                response=output,
+                transport_request=response_context.transport_request,
+                transport_response=response_context.transport_response,
+                properties=response_context.properties
+            )
+            logger.debug("Deserialization complete. Response: %s", output_context.response)
+
+            # Step 7r: Invoke read_after_deserialization
+            interceptor.read_after_deserialization(output_context)
+        except Exception as e:
+            output_context: OutputContext[Input, Output, HTTPRequest, HTTPResponse] = OutputContext(
+                request=context.request,
+                response=e,  # type: ignore
+                transport_request=context.transport_request,
+                transport_response=transport_response,
+                properties=context.properties
+            )
+
+        return await self._finalize_attempt(interceptor, output_context)
+
+    async def _finalize_attempt[Input: SerializeableShape, Output: DeserializeableShape](
+        self,
+        interceptor: Interceptor[Input, Output, HTTPRequest, HTTPResponse],
+        context: OutputContext[Input, Output, HTTPRequest, HTTPResponse | None],
+    ) -> OutputContext[Input, Output, HTTPRequest, HTTPResponse | None]:
+        # Step 7s: Invoke modify_before_attempt_completion
+        try:
+            context = replace(
+                context,
+                response=interceptor.modify_before_attempt_completion(context)
+            )
+        except Exception as e:
+            logger.exception("Exception occurred while handling: %s", context.response)
+            context = replace(context, response=e)
+
+        # Step 7t: Invoke read_after_attempt
+        try:
+            interceptor.read_after_attempt(context)
+        except Exception as e:
+            context = replace(context, response=e)
+
+        return context
+
+    async def _finalize_execution[Input: SerializeableShape, Output: DeserializeableShape](
+        self,
+        interceptor: Interceptor[Input, Output, HTTPRequest, HTTPResponse],
+        context: OutputContext[Input, Output, HTTPRequest | None, HTTPResponse | None],
+    ) -> Output:
+        try:
+            # Step 9: Invoke modify_before_completion
+            context = replace(
+                context,
+                response=interceptor.modify_before_completion(context)
+            )
+
+            # Step 10: Invoke trace_probe.dispatch_events
+            try:
+                pass
+            except Exception as e:
+                # log and ignore exceptions
+                logger.exception("Exception occurred while dispatching trace events: %s", e)
+                pass
+        except Exception as e:
+            logger.exception("Exception occurred while handling: %s", context.response)
+            context = replace(context, response=e)
+
+        # Step 11: Invoke read_after_execution
+        try:
+            interceptor.read_after_execution(context)
+        except Exception as e:
+            context = replace(context, response=e)
+
+        # Step 12: Return / throw
+        if isinstance(context.response, Exception):
+            raise context.response
+
+        # We may want to add some aspects of this context to the output types so we can
+        # return it to the end-users.
+        return context.response