diff --git a/Gax/src/GapicClientTrait.php b/Gax/src/GapicClientTrait.php
index 6cf858f21d16..77a20e4be2d6 100644
--- a/Gax/src/GapicClientTrait.php
+++ b/Gax/src/GapicClientTrait.php
@@ -32,7 +32,7 @@
 
 namespace Google\ApiCore;
 
-use Google\ApiCore\LongRunning\OperationsClient;
+use Google\ApiCore\LongRunning\OperationsClient as DeprecatedOperationsClient;
 use Google\ApiCore\Middleware\CredentialsWrapperMiddleware;
 use Google\ApiCore\Middleware\FixedHeaderMiddleware;
 use Google\ApiCore\Middleware\OperationsMiddleware;
@@ -50,6 +50,7 @@
 use Google\ApiCore\Transport\RestTransport;
 use Google\ApiCore\Transport\TransportInterface;
 use Google\Auth\FetchAuthTokenInterface;
+use Google\LongRunning\Client\OperationsClient;
 use Google\LongRunning\Operation;
 use Google\Protobuf\Internal\Message;
 use GuzzleHttp\Promise\PromiseInterface;
@@ -174,7 +175,7 @@ public static function getServiceScopes(): array
      *
      * @experimental
      */
-    public function close()
+    public function close(): void
     {
         $this->transport->close();
     }
@@ -454,7 +455,7 @@ private function createTransport(
 
     /**
      * @param array $options
-     * @return OperationsClient
+     * @return DeprecatedOperationsClient|OperationsClient|object
      */
     private function createOperationsClient(array $options)
     {
@@ -470,8 +471,11 @@ private function createOperationsClient(array $options)
         }
 
         // operationsClientClass option
+        $defaultClass = $this->isBackwardsCompatibilityMode()
+            ? DeprecatedOperationsClient::class
+            : OperationsClient::class;
         $operationsClientClass = $this->pluck('operationsClientClass', $options, false)
-            ?: OperationsCLient::class;
+            ?: $defaultClass;
         return new $operationsClientClass($options);
     }
 
diff --git a/Gax/src/IamProviderInterface.php b/Gax/src/IamProviderInterface.php
new file mode 100644
index 000000000000..92b41802ee31
--- /dev/null
+++ b/Gax/src/IamProviderInterface.php
@@ -0,0 +1,119 @@
+<?php
+declare(strict_types=1);
+
+/*
+ * Copyright 2026 Google LLC
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are
+ * met:
+ *
+ *     * Redistributions of source code must retain the above copyright
+ * notice, this list of conditions and the following disclaimer.
+ *     * Redistributions in binary form must reproduce the above
+ * copyright notice, this list of conditions and the following disclaimer
+ * in the documentation and/or other materials provided with the
+ * distribution.
+ *     * Neither the name of Google Inc. nor the names of its
+ * contributors may be used to endorse or promote products derived from
+ * this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+ * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+ * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+ * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+ * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+ * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+namespace Google\ApiCore;
+
+use Google\Cloud\Iam\V1\GetIamPolicyRequest;
+use Google\Cloud\Iam\V1\Policy;
+use Google\Cloud\Iam\V1\SetIamPolicyRequest;
+use Google\Cloud\Iam\V1\TestIamPermissionsRequest;
+use Google\Cloud\Iam\V1\TestIamPermissionsResponse;
+
+/**
+ * Interface implemented by GAPIC service clients that expose IAM policy
+ * management methods (`getIamPolicy`, `setIamPolicy`, and `testIamPermissions`).
+ */
+interface IamProviderInterface
+{
+    /**
+     * Gets the access control policy for a resource. Returns an empty policy
+     * if the resource exists and does not have a policy set.
+     *
+     * @param GetIamPolicyRequest $request     A request to house fields associated with the call.
+     * @param array               $callOptions {
+     *     Optional.
+     *
+     *     @type RetrySettings|array $retrySettings
+     *           Retry settings to use for this call. Can be a {@see \Google\ApiCore\RetrySettings} object, or an
+     *           associative array of retry settings parameters. See the documentation on
+     *           {@see \Google\ApiCore\RetrySettings} for example usage.
+     * }
+     *
+     * @return Policy
+     *
+     * @throws ApiException Thrown if the API call fails.
+     */
+    public function getIamPolicy(GetIamPolicyRequest $request, array $callOptions = []): Policy;
+
+    /**
+     * Sets the access control policy on the specified resource. Replaces
+     * any existing policy.
+     *
+     * Can return `NOT_FOUND`, `INVALID_ARGUMENT`, and `PERMISSION_DENIED`
+     * errors.
+     *
+     * @param SetIamPolicyRequest $request     A request to house fields associated with the call.
+     * @param array               $callOptions {
+     *     Optional.
+     *
+     *     @type RetrySettings|array $retrySettings
+     *           Retry settings to use for this call. Can be a {@see \Google\ApiCore\RetrySettings} object, or an
+     *           associative array of retry settings parameters. See the documentation on
+     *           {@see \Google\ApiCore\RetrySettings} for example usage.
+     * }
+     *
+     * @return Policy
+     *
+     * @throws ApiException Thrown if the API call fails.
+     */
+    public function setIamPolicy(SetIamPolicyRequest $request, array $callOptions = []): Policy;
+
+    /**
+     * Returns permissions that a caller has on the specified resource. If the
+     * resource does not exist, this will return an empty set of
+     * permissions, not a `NOT_FOUND` error.
+     *
+     * Note: This operation is designed to be used for building
+     * permission-aware UIs and command-line tools, not for authorization
+     * checking. This operation may "fail open" without warning.
+     *
+     * @param TestIamPermissionsRequest $request     A request to house fields associated with the call.
+     * @param array                     $callOptions {
+     *     Optional.
+     *
+     *     @type RetrySettings|array $retrySettings
+     *           Retry settings to use for this call. Can be a {@see \Google\ApiCore\RetrySettings} object, or an
+     *           associative array of retry settings parameters. See the documentation on
+     *           {@see \Google\ApiCore\RetrySettings} for example usage.
+     * }
+     *
+     * @return TestIamPermissionsResponse
+     *
+     * @throws ApiException Thrown if the API call fails.
+     */
+    public function testIamPermissions(
+        TestIamPermissionsRequest $request,
+        array $callOptions = []
+    ): TestIamPermissionsResponse;
+}
diff --git a/Gax/src/LongRunningOperationProviderInterface.php b/Gax/src/LongRunningOperationProviderInterface.php
new file mode 100644
index 000000000000..ff9c39a35bac
--- /dev/null
+++ b/Gax/src/LongRunningOperationProviderInterface.php
@@ -0,0 +1,64 @@
+<?php
+declare(strict_types=1);
+
+/*
+ * Copyright 2026 Google LLC
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are
+ * met:
+ *
+ *     * Redistributions of source code must retain the above copyright
+ * notice, this list of conditions and the following disclaimer.
+ *     * Redistributions in binary form must reproduce the above
+ * copyright notice, this list of conditions and the following disclaimer
+ * in the documentation and/or other materials provided with the
+ * distribution.
+ *     * Neither the name of Google Inc. nor the names of its
+ * contributors may be used to endorse or promote products derived from
+ * this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+ * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+ * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+ * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+ * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+ * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+namespace Google\ApiCore;
+
+use Google\LongRunning\Client\OperationsClient;
+
+/**
+ * Interface implemented by GAPIC service clients that support standard
+ * Google Cloud Long-Running Operations (LROs).
+ */
+interface LongRunningOperationProviderInterface
+{
+    /**
+     * Resume an existing long running operation that was previously started by a long
+     * running API method. If $methodName is not provided, or does not match a long
+     * running API method, then the operation can still be resumed, but the
+     * OperationResponse object will not deserialize the final response.
+     *
+     * @param string      $operationName The name of the long running operation
+     * @param string|null $methodName    The name of the method used to start the operation
+     *
+     * @return OperationResponse
+     */
+    public function resumeOperation(string $operationName, ?string $methodName = null): OperationResponse;
+
+    /**
+     * Return an OperationsClient object with the same endpoint as $this.
+     *
+     * @return OperationsClient
+     */
+    public function getOperationsClient(): OperationsClient;
+}
diff --git a/Gax/src/ServiceInterface.php b/Gax/src/ServiceInterface.php
new file mode 100644
index 000000000000..98f445053105
--- /dev/null
+++ b/Gax/src/ServiceInterface.php
@@ -0,0 +1,123 @@
+<?php
+declare(strict_types=1);
+
+/*
+ * Copyright 2026 Google LLC
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are
+ * met:
+ *
+ *     * Redistributions of source code must retain the above copyright
+ * notice, this list of conditions and the following disclaimer.
+ *     * Redistributions in binary form must reproduce the above
+ * copyright notice, this list of conditions and the following disclaimer
+ * in the documentation and/or other materials provided with the
+ * distribution.
+ *     * Neither the name of Google Inc. nor the names of its
+ * contributors may be used to endorse or promote products derived from
+ * this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+ * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+ * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+ * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+ * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+ * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+namespace Google\ApiCore;
+
+/**
+ * Interface implemented by all GAPIC service clients, defining common lifecycle,
+ * scope, and middleware configuration methods.
+ */
+interface ServiceInterface
+{
+    /**
+     * Add a middleware to the call stack by providing a callable which will be
+     * invoked at the start of each call, and will return an instance of
+     * {@see \Google\ApiCore\Middleware\MiddlewareInterface} when invoked.
+     *
+     * The callable must have the following method signature:
+     *
+     *     callable(MiddlewareInterface): MiddlewareInterface
+     *
+     * An implementation may look something like this:
+     * ```
+     * $client->addMiddleware(function (MiddlewareInterface $handler) {
+     *     return new class ($handler) implements MiddlewareInterface {
+     *         public function __construct(private MiddlewareInterface $handler) {
+     *         }
+     *
+     *         public function __invoke(Call $call, array $options) {
+     *             // modify call and options (pre-request)
+     *             $response = ($this->handler)($call, $options);
+     *             // modify the response (post-request)
+     *             return $response;
+     *         }
+     *     };
+     * });
+     * ```
+     *
+     * @param callable $middlewareCallable A callable which returns an instance
+     *                 of {@see \Google\ApiCore\Middleware\MiddlewareInterface} when invoked with a
+     *                 MiddlewareInterface instance as its first argument.
+     * @return void
+     */
+    public function addMiddleware(callable $middlewareCallable): void;
+
+    /**
+     * Prepend a middleware to the call stack by providing a callable which will be
+     * invoked at the end of each call, and will return an instance of
+     * {@see \Google\ApiCore\Middleware\MiddlewareInterface} when invoked.
+     *
+     * The callable must have the following method signature:
+     *
+     *     callable(MiddlewareInterface): MiddlewareInterface
+     *
+     * An implementation may look something like this:
+     * ```
+     * $client->prependMiddleware(function (MiddlewareInterface $handler) {
+     *     return new class ($handler) implements MiddlewareInterface {
+     *         public function __construct(private MiddlewareInterface $handler) {
+     *         }
+     *
+     *         public function __invoke(Call $call, array $options) {
+     *             // modify call and options (pre-request)
+     *             $response = ($this->handler)($call, $options);
+     *             // modify the response (post-request)
+     *             return $response;
+     *         }
+     *     };
+     * });
+     * ```
+     *
+     * @param callable $middlewareCallable A callable which returns an instance
+     *                 of {@see \Google\ApiCore\Middleware\MiddlewareInterface} when invoked with a
+     *                 MiddlewareInterface instance as its first argument.
+     * @return void
+     */
+    public function prependMiddleware(callable $middlewareCallable): void;
+
+    /**
+     * Get the default scopes required by the service.
+     *
+     * @return array
+     */
+    public static function getServiceScopes(): array;
+
+    /**
+     * Initiates an orderly shutdown in which preexisting calls continue but new
+     * calls are immediately cancelled.
+     *
+     * @return void
+     */
+    public function close(): void;
+}
diff --git a/Gax/tests/Unit/GapicClientTraitTest.php b/Gax/tests/Unit/GapicClientTraitTest.php
index e6cec22e1a3b..e1115ad00ae4 100644
--- a/Gax/tests/Unit/GapicClientTraitTest.php
+++ b/Gax/tests/Unit/GapicClientTraitTest.php
@@ -39,12 +39,15 @@
 use Google\ApiCore\ClientStream;
 use Google\ApiCore\CredentialsWrapper;
 use Google\ApiCore\GapicClientTrait;
-use Google\ApiCore\LongRunning\OperationsClient;
+use Google\ApiCore\IamProviderInterface;
+use Google\ApiCore\LongRunning\OperationsClient as DeprecatedOperationsClient;
+use Google\ApiCore\LongRunningOperationProviderInterface;
 use Google\ApiCore\Middleware\MiddlewareInterface;
 use Google\ApiCore\OperationResponse;
 use Google\ApiCore\RequestParamsHeaderDescriptor;
 use Google\ApiCore\RetrySettings;
 use Google\ApiCore\ServerStream;
+use Google\ApiCore\ServiceInterface;
 use Google\ApiCore\Testing\MockRequest;
 use Google\ApiCore\Testing\MockRequestBody;
 use Google\ApiCore\Testing\MockResponse;
@@ -54,6 +57,13 @@
 use Google\ApiCore\Transport\TransportInterface;
 use Google\ApiCore\ValidationException;
 use Google\Auth\FetchAuthTokenInterface;
+use Google\Cloud\Iam\V1\GetIamPolicyRequest;
+use Google\Cloud\Iam\V1\Policy;
+use Google\Cloud\Iam\V1\SetIamPolicyRequest;
+use Google\Cloud\Iam\V1\TestIamPermissionsRequest;
+use Google\Cloud\Iam\V1\TestIamPermissionsResponse;
+use Google\LongRunning\Client\OperationsClient;
+use Google\LongRunning\GetOperationRequest;
 use Google\LongRunning\Operation;
 use Grpc\Gcp\Config;
 use GuzzleHttp\Promise\FulfilledPromise;
@@ -1968,6 +1978,113 @@ public function testGetServiceScopes()
             DefaultScopeAndAudienceGapicClient::getServiceScopes()
         );
     }
+
+    public function testCreateOperationsClientDefaultClass()
+    {
+        $v1Client = new StubGapicClient();
+        $this->assertInstanceOf(
+            DeprecatedOperationsClient::class,
+            $v1Client->createOperationsClient([])
+        );
+
+        $v2Client = new GapicV2SurfaceClient();
+        $method = new \ReflectionMethod($v2Client, 'createOperationsClient');
+        $this->assertInstanceOf(
+            OperationsClient::class,
+            $method->invoke($v2Client, [])
+        );
+    }
+
+    public function testServiceInterface()
+    {
+        $transport = $this->prophesize(TransportInterface::class);
+        $transport->close()->shouldBeCalledOnce();
+
+        $client = new GapicV2SurfaceClient([
+            'transport' => $transport->reveal(),
+        ]);
+
+        $this->assertInstanceOf(ServiceInterface::class, $client);
+        $this->assertEquals([], GapicV2SurfaceClient::getServiceScopes());
+        $client->close();
+    }
+
+    public function testLongRunningOperationProviderInterface()
+    {
+        $operationsClient = $this->prophesize(OperationsClient::class);
+        $operationsClient->getOperation(
+            Argument::that(fn (GetOperationRequest $req) => $req->getName() === 'operations/test-op')
+        )
+            ->shouldBeCalledOnce()
+            ->willReturn(new Operation(['name' => 'operations/test-op', 'done' => true]));
+
+        $client = new GapicV2SurfaceClient([
+            'operationsClient' => $operationsClient->reveal(),
+        ]);
+
+        $this->assertInstanceOf(LongRunningOperationProviderInterface::class, $client);
+        $this->assertSame($operationsClient->reveal(), $client->getOperationsClient());
+
+        $operation = $client->resumeOperation('operations/test-op');
+        $this->assertInstanceOf(OperationResponse::class, $operation);
+        $this->assertEquals('operations/test-op', $operation->getName());
+        $this->assertTrue($operation->isDone());
+    }
+
+    public function testIamProviderInterface()
+    {
+        $policy = new Policy();
+        $permissionsResponse = new TestIamPermissionsResponse();
+
+        $transport = $this->prophesize(TransportInterface::class);
+        $transport->startUnaryCall(
+            Argument::that(fn (Call $call) => $call->getMethod() === 'test.interface.v1.api/GetIamPolicy'),
+            Argument::type('array')
+        )
+            ->shouldBeCalledOnce()
+            ->willReturn(new FulfilledPromise($policy));
+        $transport->startUnaryCall(
+            Argument::that(fn (Call $call) => $call->getMethod() === 'test.interface.v1.api/SetIamPolicy'),
+            Argument::type('array')
+        )
+            ->shouldBeCalledOnce()
+            ->willReturn(new FulfilledPromise($policy));
+        $transport->startUnaryCall(
+            Argument::that(fn (Call $call) => $call->getMethod() === 'test.interface.v1.api/TestIamPermissions'),
+            Argument::type('array')
+        )
+            ->shouldBeCalledOnce()
+            ->willReturn(new FulfilledPromise($permissionsResponse));
+
+        $client = new GapicV2SurfaceClient([
+            'transport' => $transport->reveal(),
+        ]);
+        $client->set('descriptors', [
+            'GetIamPolicy' => [
+                'callType' => Call::UNARY_CALL,
+                'responseType' => Policy::class,
+            ],
+            'SetIamPolicy' => [
+                'callType' => Call::UNARY_CALL,
+                'responseType' => Policy::class,
+            ],
+            'TestIamPermissions' => [
+                'callType' => Call::UNARY_CALL,
+                'responseType' => TestIamPermissionsResponse::class,
+            ],
+        ]);
+        $retrySettings = RetrySettings::constructDefault();
+        $client->set('retrySettings', [
+            'GetIamPolicy' => $retrySettings,
+            'SetIamPolicy' => $retrySettings,
+            'TestIamPermissions' => $retrySettings,
+        ]);
+
+        $this->assertInstanceOf(IamProviderInterface::class, $client);
+        $this->assertSame($policy, $client->getIamPolicy(new GetIamPolicyRequest()));
+        $this->assertSame($policy, $client->setIamPolicy(new SetIamPolicyRequest()));
+        $this->assertSame($permissionsResponse, $client->testIamPermissions(new TestIamPermissionsRequest()));
+    }
 }
 
 class StubGapicClient
@@ -2158,7 +2275,7 @@ public function getOperation($name, $arg1, $arg2)
     }
 }
 
-class GapicV2SurfaceClient
+class GapicV2SurfaceClient implements ServiceInterface, LongRunningOperationProviderInterface, IamProviderInterface
 {
     use GapicClientTrait {
         startCall as public;
@@ -2168,10 +2285,14 @@ class GapicV2SurfaceClient
         ClientDefaultsTrait::getClientDefaults insteadof GapicClientTrait;
     }
 
+    public static array $serviceScopes = [];
+    private OperationsClient $operationsClient;
+
     public function __construct(array $options = [])
     {
         $clientOptions = $this->buildClientOptions($options);
         $this->setClientOptions($clientOptions);
+        $this->operationsClient = $this->createOperationsClient($clientOptions);
     }
 
     public function getAgentHeader()
@@ -2179,4 +2300,33 @@ public function getAgentHeader()
         return $this->agentHeader;
     }
 
+    public function getOperationsClient(): OperationsClient
+    {
+        return $this->operationsClient;
+    }
+
+    public function resumeOperation(string $operationName, ?string $methodName = null): OperationResponse
+    {
+        $options = $this->descriptors[$methodName]['longRunning'] ?? [];
+        $operation = new OperationResponse($operationName, $this->getOperationsClient(), $options);
+        $operation->reload();
+        return $operation;
+    }
+
+    public function getIamPolicy(GetIamPolicyRequest $request, array $callOptions = []): Policy
+    {
+        return $this->startApiCall('GetIamPolicy', $request, $callOptions)->wait();
+    }
+
+    public function setIamPolicy(SetIamPolicyRequest $request, array $callOptions = []): Policy
+    {
+        return $this->startApiCall('SetIamPolicy', $request, $callOptions)->wait();
+    }
+
+    public function testIamPermissions(
+        TestIamPermissionsRequest $request,
+        array $callOptions = []
+    ): TestIamPermissionsResponse {
+        return $this->startApiCall('TestIamPermissions', $request, $callOptions)->wait();
+    }
 }