Google Apps Chat V1 Client - Class ChatServiceClient (0.27.0)

use Google\ApiCore\ApiException;
use Google\Apps\Chat\V1\Client\ChatServiceClient;
use Google\Apps\Chat\V1\CompleteImportSpaceRequest;
use Google\Apps\Chat\V1\CompleteImportSpaceResponse;

/**
 * @param string $formattedName Resource name of the import mode space.
 *
 *                              Format: `spaces/{space}`
 *                              Please see {@see ChatServiceClient::spaceName()} for help formatting this field.
 */
function complete_import_space_sample(string $formattedName): void
{
    // Create a client.
    $chatServiceClient = new ChatServiceClient();

    // Prepare the request message.
    $request = (new CompleteImportSpaceRequest())
        ->setName($formattedName);

    // Call the API and handle any network failures.
    try {
        /** @var CompleteImportSpaceResponse $response */
        $response = $chatServiceClient->completeImportSpace($request);
        printf('Response data: %s' . PHP_EOL, $response->serializeToJsonString());
    } catch (ApiException $ex) {
        printf('Call failed with message: %s' . PHP_EOL, $ex->getMessage());
    }
}

/**
 * Helper to execute the sample.
 *
 * This sample has been automatically generated and should be regarded as a code
 * template only. It will require modifications to work:
 *  - It may require correct/in-range values for request initialization.
 *  - It may require specifying regional endpoints when creating the service client,
 *    please see the apiEndpoint client configuration option for more details.
 */
function callSample(): void
{
    $formattedName = ChatServiceClient::spaceName('[SPACE]');

    complete_import_space_sample($formattedName);
}

use Google\ApiCore\ApiException;
use Google\Apps\Chat\V1\Client\ChatServiceClient;
use Google\Apps\Chat\V1\CreateCustomEmojiRequest;
use Google\Apps\Chat\V1\CustomEmoji;

/**
 * This sample has been automatically generated and should be regarded as a code
 * template only. It will require modifications to work:
 *  - It may require correct/in-range values for request initialization.
 *  - It may require specifying regional endpoints when creating the service client,
 *    please see the apiEndpoint client configuration option for more details.
 */
function create_custom_emoji_sample(): void
{
    // Create a client.
    $chatServiceClient = new ChatServiceClient();

    // Prepare the request message.
    $customEmoji = new CustomEmoji();
    $request = (new CreateCustomEmojiRequest())
        ->setCustomEmoji($customEmoji);

    // Call the API and handle any network failures.
    try {
        /** @var CustomEmoji $response */
        $response = $chatServiceClient->createCustomEmoji($request);
        printf('Response data: %s' . PHP_EOL, $response->serializeToJsonString());
    } catch (ApiException $ex) {
        printf('Call failed with message: %s' . PHP_EOL, $ex->getMessage());
    }
}

use Google\ApiCore\ApiException;
use Google\Apps\Chat\V1\Client\ChatServiceClient;
use Google\Apps\Chat\V1\CreateMembershipRequest;
use Google\Apps\Chat\V1\Membership;

/**
 * @param string $formattedParent The resource name of the space for which to create the
 *                                membership.
 *
 *                                Format: spaces/{space}
 *                                Please see {@see ChatServiceClient::spaceName()} for help formatting this field.
 */
function create_membership_sample(string $formattedParent): void
{
    // Create a client.
    $chatServiceClient = new ChatServiceClient();

    // Prepare the request message.
    $membership = new Membership();
    $request = (new CreateMembershipRequest())
        ->setParent($formattedParent)
        ->setMembership($membership);

    // Call the API and handle any network failures.
    try {
        /** @var Membership $response */
        $response = $chatServiceClient->createMembership($request);
        printf('Response data: %s' . PHP_EOL, $response->serializeToJsonString());
    } catch (ApiException $ex) {
        printf('Call failed with message: %s' . PHP_EOL, $ex->getMessage());
    }
}

/**
 * Helper to execute the sample.
 *
 * This sample has been automatically generated and should be regarded as a code
 * template only. It will require modifications to work:
 *  - It may require correct/in-range values for request initialization.
 *  - It may require specifying regional endpoints when creating the service client,
 *    please see the apiEndpoint client configuration option for more details.
 */
function callSample(): void
{
    $formattedParent = ChatServiceClient::spaceName('[SPACE]');

    create_membership_sample($formattedParent);
}

use Google\ApiCore\ApiException;
use Google\Apps\Chat\V1\Client\ChatServiceClient;
use Google\Apps\Chat\V1\CreateMessageRequest;
use Google\Apps\Chat\V1\Message;

/**
 * @param string $formattedParent The resource name of the space in which to create a message.
 *
 *                                Format: `spaces/{space}`
 *                                Please see {@see ChatServiceClient::spaceName()} for help formatting this field.
 */
function create_message_sample(string $formattedParent): void
{
    // Create a client.
    $chatServiceClient = new ChatServiceClient();

    // Prepare the request message.
    $message = new Message();
    $request = (new CreateMessageRequest())
        ->setParent($formattedParent)
        ->setMessage($message);

    // Call the API and handle any network failures.
    try {
        /** @var Message $response */
        $response = $chatServiceClient->createMessage($request);
        printf('Response data: %s' . PHP_EOL, $response->serializeToJsonString());
    } catch (ApiException $ex) {
        printf('Call failed with message: %s' . PHP_EOL, $ex->getMessage());
    }
}

/**
 * Helper to execute the sample.
 *
 * This sample has been automatically generated and should be regarded as a code
 * template only. It will require modifications to work:
 *  - It may require correct/in-range values for request initialization.
 *  - It may require specifying regional endpoints when creating the service client,
 *    please see the apiEndpoint client configuration option for more details.
 */
function callSample(): void
{
    $formattedParent = ChatServiceClient::spaceName('[SPACE]');

    create_message_sample($formattedParent);
}

use Google\ApiCore\ApiException;
use Google\Apps\Chat\V1\Client\ChatServiceClient;
use Google\Apps\Chat\V1\CreateMessagePinRequest;
use Google\Apps\Chat\V1\MessagePin;

/**
 * @param string $formattedParent            The parent space in which to create the message pin.
 *                                           Format: spaces/{space}
 *                                           Please see {@see ChatServiceClient::spaceName()} for help formatting this field.
 * @param string $formattedMessagePinMessage Immutable. The resource name of the message that is pinned.
 *                                           Format: `spaces/{space}/messages/{message}`
 *                                           Please see {@see ChatServiceClient::messageName()} for help formatting this field.
 */
function create_message_pin_sample(
    string $formattedParent,
    string $formattedMessagePinMessage
): void {
    // Create a client.
    $chatServiceClient = new ChatServiceClient();

    // Prepare the request message.
    $messagePin = (new MessagePin())
        ->setMessage($formattedMessagePinMessage);
    $request = (new CreateMessagePinRequest())
        ->setParent($formattedParent)
        ->setMessagePin($messagePin);

    // Call the API and handle any network failures.
    try {
        /** @var MessagePin $response */
        $response = $chatServiceClient->createMessagePin($request);
        printf('Response data: %s' . PHP_EOL, $response->serializeToJsonString());
    } catch (ApiException $ex) {
        printf('Call failed with message: %s' . PHP_EOL, $ex->getMessage());
    }
}

/**
 * Helper to execute the sample.
 *
 * This sample has been automatically generated and should be regarded as a code
 * template only. It will require modifications to work:
 *  - It may require correct/in-range values for request initialization.
 *  - It may require specifying regional endpoints when creating the service client,
 *    please see the apiEndpoint client configuration option for more details.
 */
function callSample(): void
{
    $formattedParent = ChatServiceClient::spaceName('[SPACE]');
    $formattedMessagePinMessage = ChatServiceClient::messageName('[SPACE]', '[MESSAGE]');

    create_message_pin_sample($formattedParent, $formattedMessagePinMessage);
}

use Google\ApiCore\ApiException;
use Google\Apps\Chat\V1\Client\ChatServiceClient;
use Google\Apps\Chat\V1\CreateReactionRequest;
use Google\Apps\Chat\V1\Emoji;
use Google\Apps\Chat\V1\Reaction;

/**
 * @param string $formattedParent The message where the reaction is created.
 *
 *                                Format: `spaces/{space}/messages/{message}`
 *                                Please see {@see ChatServiceClient::messageName()} for help formatting this field.
 */
function create_reaction_sample(string $formattedParent): void
{
    // Create a client.
    $chatServiceClient = new ChatServiceClient();

    // Prepare the request message.
    $reactionEmoji = new Emoji();
    $reaction = (new Reaction())
        ->setEmoji($reactionEmoji);
    $request = (new CreateReactionRequest())
        ->setParent($formattedParent)
        ->setReaction($reaction);

    // Call the API and handle any network failures.
    try {
        /** @var Reaction $response */
        $response = $chatServiceClient->createReaction($request);
        printf('Response data: %s' . PHP_EOL, $response->serializeToJsonString());
    } catch (ApiException $ex) {
        printf('Call failed with message: %s' . PHP_EOL, $ex->getMessage());
    }
}

/**
 * Helper to execute the sample.
 *
 * This sample has been automatically generated and should be regarded as a code
 * template only. It will require modifications to work:
 *  - It may require correct/in-range values for request initialization.
 *  - It may require specifying regional endpoints when creating the service client,
 *    please see the apiEndpoint client configuration option for more details.
 */
function callSample(): void
{
    $formattedParent = ChatServiceClient::messageName('[SPACE]', '[MESSAGE]');

    create_reaction_sample($formattedParent);
}

use Google\ApiCore\ApiException;
use Google\Apps\Chat\V1\Client\ChatServiceClient;
use Google\Apps\Chat\V1\CreateSectionRequest;
use Google\Apps\Chat\V1\Section;
use Google\Apps\Chat\V1\Section\SectionType;

/**
 * @param string $formattedParent The parent resource name where the section is created.
 *
 *                                Format: `users/{user}`
 *                                Please see {@see ChatServiceClient::userName()} for help formatting this field.
 * @param int    $sectionType     The type of the section.
 */
function create_section_sample(string $formattedParent, int $sectionType): void
{
    // Create a client.
    $chatServiceClient = new ChatServiceClient();

    // Prepare the request message.
    $section = (new Section())
        ->setType($sectionType);
    $request = (new CreateSectionRequest())
        ->setParent($formattedParent)
        ->setSection($section);

    // Call the API and handle any network failures.
    try {
        /** @var Section $response */
        $response = $chatServiceClient->createSection($request);
        printf('Response data: %s' . PHP_EOL, $response->serializeToJsonString());
    } catch (ApiException $ex) {
        printf('Call failed with message: %s' . PHP_EOL, $ex->getMessage());
    }
}

/**
 * Helper to execute the sample.
 *
 * This sample has been automatically generated and should be regarded as a code
 * template only. It will require modifications to work:
 *  - It may require correct/in-range values for request initialization.
 *  - It may require specifying regional endpoints when creating the service client,
 *    please see the apiEndpoint client configuration option for more details.
 */
function callSample(): void
{
    $formattedParent = ChatServiceClient::userName('[USER]');
    $sectionType = SectionType::SECTION_TYPE_UNSPECIFIED;

    create_section_sample($formattedParent, $sectionType);
}

use Google\ApiCore\ApiException;
use Google\Apps\Chat\V1\Client\ChatServiceClient;
use Google\Apps\Chat\V1\CreateSpaceRequest;
use Google\Apps\Chat\V1\Space;

/**
 * This sample has been automatically generated and should be regarded as a code
 * template only. It will require modifications to work:
 *  - It may require correct/in-range values for request initialization.
 *  - It may require specifying regional endpoints when creating the service client,
 *    please see the apiEndpoint client configuration option for more details.
 */
function create_space_sample(): void
{
    // Create a client.
    $chatServiceClient = new ChatServiceClient();

    // Prepare the request message.
    $space = new Space();
    $request = (new CreateSpaceRequest())
        ->setSpace($space);

    // Call the API and handle any network failures.
    try {
        /** @var Space $response */
        $response = $chatServiceClient->createSpace($request);
        printf('Response data: %s' . PHP_EOL, $response->serializeToJsonString());
    } catch (ApiException $ex) {
        printf('Call failed with message: %s' . PHP_EOL, $ex->getMessage());
    }
}

use Google\ApiCore\ApiException;
use Google\Apps\Chat\V1\Client\ChatServiceClient;
use Google\Apps\Chat\V1\DeleteCustomEmojiRequest;

/**
 * @param string $formattedName Resource name of the custom emoji to delete.
 *
 *                              Format: `customEmojis/{customEmoji}`
 *
 *                              You can use the emoji name as an alias for `{customEmoji}`. For example,
 *                              `customEmojis/:example-emoji:` where `:example-emoji:` is the emoji name
 *                              for a custom emoji. Please see
 *                              {@see ChatServiceClient::customEmojiName()} for help formatting this field.
 */
function delete_custom_emoji_sample(string $formattedName): void
{
    // Create a client.
    $chatServiceClient = new ChatServiceClient();

    // Prepare the request message.
    $request = (new DeleteCustomEmojiRequest())
        ->setName($formattedName);

    // Call the API and handle any network failures.
    try {
        $chatServiceClient->deleteCustomEmoji($request);
        printf('Call completed successfully.' . PHP_EOL);
    } catch (ApiException $ex) {
        printf('Call failed with message: %s' . PHP_EOL, $ex->getMessage());
    }
}

/**
 * Helper to execute the sample.
 *
 * This sample has been automatically generated and should be regarded as a code
 * template only. It will require modifications to work:
 *  - It may require correct/in-range values for request initialization.
 *  - It may require specifying regional endpoints when creating the service client,
 *    please see the apiEndpoint client configuration option for more details.
 */
function callSample(): void
{
    $formattedName = ChatServiceClient::customEmojiName('[CUSTOM_EMOJI]');

    delete_custom_emoji_sample($formattedName);
}

use Google\ApiCore\ApiException;
use Google\Apps\Chat\V1\Client\ChatServiceClient;
use Google\Apps\Chat\V1\DeleteMembershipRequest;
use Google\Apps\Chat\V1\Membership;

/**
 * @param string $formattedName Resource name of the membership to delete. Chat apps can delete
 *                              human users' or their own memberships. Chat apps can't delete other apps'
 *                              memberships.
 *
 *                              When deleting a human membership, requires the `chat.memberships` scope
 *                              with [user
 *                              authentication](https://developers.google.com/workspace/chat/authenticate-authorize-chat-user)
 *                              or the `chat.memberships.app` scope with [app
 *                              authentication](https://developers.google.com/workspace/chat/authenticate-authorize-chat-app)
 *                              and the `spaces/{space}/members/{member}` format.
 *                              You can use the email as an alias for `{member}`. For example,
 *                              `spaces/{space}/members/example@gmail.com` where `example@gmail.com` is the
 *                              email of the Google Chat user.
 *
 *                              When deleting an app membership, requires the `chat.memberships.app` scope
 *                              and `spaces/{space}/members/app` format.
 *
 *                              Format: `spaces/{space}/members/{member}` or `spaces/{space}/members/app`. Please see
 *                              {@see ChatServiceClient::membershipName()} for help formatting this field.
 */
function delete_membership_sample(string $formattedName): void
{
    // Create a client.
    $chatServiceClient = new ChatServiceClient();

    // Prepare the request message.
    $request = (new DeleteMembershipRequest())
        ->setName($formattedName);

    // Call the API and handle any network failures.
    try {
        /** @var Membership $response */
        $response = $chatServiceClient->deleteMembership($request);
        printf('Response data: %s' . PHP_EOL, $response->serializeToJsonString());
    } catch (ApiException $ex) {
        printf('Call failed with message: %s' . PHP_EOL, $ex->getMessage());
    }
}

/**
 * Helper to execute the sample.
 *
 * This sample has been automatically generated and should be regarded as a code
 * template only. It will require modifications to work:
 *  - It may require correct/in-range values for request initialization.
 *  - It may require specifying regional endpoints when creating the service client,
 *    please see the apiEndpoint client configuration option for more details.
 */
function callSample(): void
{
    $formattedName = ChatServiceClient::membershipName('[SPACE]', '[MEMBER]');

    delete_membership_sample($formattedName);
}

use Google\ApiCore\ApiException;
use Google\Apps\Chat\V1\Client\ChatServiceClient;
use Google\Apps\Chat\V1\DeleteMessageRequest;

/**
 * @param string $formattedName Resource name of the message.
 *
 *                              Format: `spaces/{space}/messages/{message}`
 *
 *                              If you've set a custom ID for your message, you can use the value from the
 *                              `clientAssignedMessageId` field for `{message}`. For details, see [Name a
 *                              message]
 *                              (https://developers.google.com/workspace/chat/create-messages#name_a_created_message). Please see
 *                              {@see ChatServiceClient::messageName()} for help formatting this field.
 */
function delete_message_sample(string $formattedName): void
{
    // Create a client.
    $chatServiceClient = new ChatServiceClient();

    // Prepare the request message.
    $request = (new DeleteMessageRequest())
        ->setName($formattedName);

    // Call the API and handle any network failures.
    try {
        $chatServiceClient->deleteMessage($request);
        printf('Call completed successfully.' . PHP_EOL);
    } catch (ApiException $ex) {
        printf('Call failed with message: %s' . PHP_EOL, $ex->getMessage());
    }
}

/**
 * Helper to execute the sample.
 *
 * This sample has been automatically generated and should be regarded as a code
 * template only. It will require modifications to work:
 *  - It may require correct/in-range values for request initialization.
 *  - It may require specifying regional endpoints when creating the service client,
 *    please see the apiEndpoint client configuration option for more details.
 */
function callSample(): void
{
    $formattedName = ChatServiceClient::messageName('[SPACE]', '[MESSAGE]');

    delete_message_sample($formattedName);
}

use Google\ApiCore\ApiException;
use Google\Apps\Chat\V1\Client\ChatServiceClient;
use Google\Apps\Chat\V1\DeleteMessagePinRequest;

/**
 * @param string $formattedName The resource name of the message pin to remove.
 *                              Format: spaces/{space}/messagePins/{message_pin}
 *                              Please see {@see ChatServiceClient::messagePinName()} for help formatting this field.
 */
function delete_message_pin_sample(string $formattedName): void
{
    // Create a client.
    $chatServiceClient = new ChatServiceClient();

    // Prepare the request message.
    $request = (new DeleteMessagePinRequest())
        ->setName($formattedName);

    // Call the API and handle any network failures.
    try {
        $chatServiceClient->deleteMessagePin($request);
        printf('Call completed successfully.' . PHP_EOL);
    } catch (ApiException $ex) {
        printf('Call failed with message: %s' . PHP_EOL, $ex->getMessage());
    }
}

/**
 * Helper to execute the sample.
 *
 * This sample has been automatically generated and should be regarded as a code
 * template only. It will require modifications to work:
 *  - It may require correct/in-range values for request initialization.
 *  - It may require specifying regional endpoints when creating the service client,
 *    please see the apiEndpoint client configuration option for more details.
 */
function callSample(): void
{
    $formattedName = ChatServiceClient::messagePinName('[SPACE]', '[MESSAGE_PIN]');

    delete_message_pin_sample($formattedName);
}

use Google\ApiCore\ApiException;
use Google\Apps\Chat\V1\Client\ChatServiceClient;
use Google\Apps\Chat\V1\DeleteReactionRequest;

/**
 * @param string $formattedName Name of the reaction to delete.
 *
 *                              Format: `spaces/{space}/messages/{message}/reactions/{reaction}`
 *                              Please see {@see ChatServiceClient::reactionName()} for help formatting this field.
 */
function delete_reaction_sample(string $formattedName): void
{
    // Create a client.
    $chatServiceClient = new ChatServiceClient();

    // Prepare the request message.
    $request = (new DeleteReactionRequest())
        ->setName($formattedName);

    // Call the API and handle any network failures.
    try {
        $chatServiceClient->deleteReaction($request);
        printf('Call completed successfully.' . PHP_EOL);
    } catch (ApiException $ex) {
        printf('Call failed with message: %s' . PHP_EOL, $ex->getMessage());
    }
}

/**
 * Helper to execute the sample.
 *
 * This sample has been automatically generated and should be regarded as a code
 * template only. It will require modifications to work:
 *  - It may require correct/in-range values for request initialization.
 *  - It may require specifying regional endpoints when creating the service client,
 *    please see the apiEndpoint client configuration option for more details.
 */
function callSample(): void
{
    $formattedName = ChatServiceClient::reactionName('[SPACE]', '[MESSAGE]', '[REACTION]');

    delete_reaction_sample($formattedName);
}

use Google\ApiCore\ApiException;
use Google\Apps\Chat\V1\Client\ChatServiceClient;
use Google\Apps\Chat\V1\DeleteSectionRequest;

/**
 * @param string $formattedName The name of the section to delete.
 *
 *                              Format: `users/{user}/sections/{section}`
 *                              Please see {@see ChatServiceClient::sectionName()} for help formatting this field.
 */
function delete_section_sample(string $formattedName): void
{
    // Create a client.
    $chatServiceClient = new ChatServiceClient();

    // Prepare the request message.
    $request = (new DeleteSectionRequest())
        ->setName($formattedName);

    // Call the API and handle any network failures.
    try {
        $chatServiceClient->deleteSection($request);
        printf('Call completed successfully.' . PHP_EOL);
    } catch (ApiException $ex) {
        printf('Call failed with message: %s' . PHP_EOL, $ex->getMessage());
    }
}

/**
 * Helper to execute the sample.
 *
 * This sample has been automatically generated and should be regarded as a code
 * template only. It will require modifications to work:
 *  - It may require correct/in-range values for request initialization.
 *  - It may require specifying regional endpoints when creating the service client,
 *    please see the apiEndpoint client configuration option for more details.
 */
function callSample(): void
{
    $formattedName = ChatServiceClient::sectionName('[USER]', '[SECTION]');

    delete_section_sample($formattedName);
}

use Google\ApiCore\ApiException;
use Google\Apps\Chat\V1\Client\ChatServiceClient;
use Google\Apps\Chat\V1\DeleteSpaceRequest;

/**
 * @param string $formattedName Resource name of the space to delete.
 *
 *                              Format: `spaces/{space}`
 *                              Please see {@see ChatServiceClient::spaceName()} for help formatting this field.
 */
function delete_space_sample(string $formattedName): void
{
    // Create a client.
    $chatServiceClient = new ChatServiceClient();

    // Prepare the request message.
    $request = (new DeleteSpaceRequest())
        ->setName($formattedName);

    // Call the API and handle any network failures.
    try {
        $chatServiceClient->deleteSpace($request);
        printf('Call completed successfully.' . PHP_EOL);
    } catch (ApiException $ex) {
        printf('Call failed with message: %s' . PHP_EOL, $ex->getMessage());
    }
}

/**
 * Helper to execute the sample.
 *
 * This sample has been automatically generated and should be regarded as a code
 * template only. It will require modifications to work:
 *  - It may require correct/in-range values for request initialization.
 *  - It may require specifying regional endpoints when creating the service client,
 *    please see the apiEndpoint client configuration option for more details.
 */
function callSample(): void
{
    $formattedName = ChatServiceClient::spaceName('[SPACE]');

    delete_space_sample($formattedName);
}

use Google\ApiCore\ApiException;
use Google\Apps\Chat\V1\Client\ChatServiceClient;
use Google\Apps\Chat\V1\FindDirectMessageRequest;
use Google\Apps\Chat\V1\Space;

/**
 * @param string $name Resource name of the user to find direct message with.
 *
 *                     Format: `users/{user}`, where `{user}` is either the `id` for the
 *                     [person](https://developers.google.com/people/api/rest/v1/people) from the
 *                     People API, or the `id` for the
 *                     [user](https://developers.google.com/admin-sdk/directory/reference/rest/v1/users)
 *                     in the Directory API. For example, if the People API profile ID is
 *                     `123456789`, you can find a direct message with that person by using
 *                     `users/123456789` as the `name`. When [authenticated as a
 *                     user](https://developers.google.com/workspace/chat/authenticate-authorize-chat-user),
 *                     you can use the email as an alias for `{user}`. For example,
 *                     `users/example@gmail.com` where `example@gmail.com` is the email of the
 *                     Google Chat user.
 */
function find_direct_message_sample(string $name): void
{
    // Create a client.
    $chatServiceClient = new ChatServiceClient();

    // Prepare the request message.
    $request = (new FindDirectMessageRequest())
        ->setName($name);

    // Call the API and handle any network failures.
    try {
        /** @var Space $response */
        $response = $chatServiceClient->findDirectMessage($request);
        printf('Response data: %s' . PHP_EOL, $response->serializeToJsonString());
    } catch (ApiException $ex) {
        printf('Call failed with message: %s' . PHP_EOL, $ex->getMessage());
    }
}

/**
 * Helper to execute the sample.
 *
 * This sample has been automatically generated and should be regarded as a code
 * template only. It will require modifications to work:
 *  - It may require correct/in-range values for request initialization.
 *  - It may require specifying regional endpoints when creating the service client,
 *    please see the apiEndpoint client configuration option for more details.
 */
function callSample(): void
{
    $name = '[NAME]';

    find_direct_message_sample($name);
}

use Google\ApiCore\ApiException;
use Google\ApiCore\PagedListResponse;
use Google\Apps\Chat\V1\Client\ChatServiceClient;
use Google\Apps\Chat\V1\FindGroupChatsRequest;
use Google\Apps\Chat\V1\Space;

/**
 * This sample has been automatically generated and should be regarded as a code
 * template only. It will require modifications to work:
 *  - It may require correct/in-range values for request initialization.
 *  - It may require specifying regional endpoints when creating the service client,
 *    please see the apiEndpoint client configuration option for more details.
 */
function find_group_chats_sample(): void
{
    // Create a client.
    $chatServiceClient = new ChatServiceClient();

    // Prepare the request message.
    $request = new FindGroupChatsRequest();

    // Call the API and handle any network failures.
    try {
        /** @var PagedListResponse $response */
        $response = $chatServiceClient->findGroupChats($request);

        /** @var Space $element */
        foreach ($response as $element) {
            printf('Element data: %s' . PHP_EOL, $element->serializeToJsonString());
        }
    } catch (ApiException $ex) {
        printf('Call failed with message: %s' . PHP_EOL, $ex->getMessage());
    }
}

use Google\ApiCore\ApiException;
use Google\Apps\Chat\V1\Attachment;
use Google\Apps\Chat\V1\Client\ChatServiceClient;
use Google\Apps\Chat\V1\GetAttachmentRequest;

/**
 * @param string $formattedName Resource name of the attachment, in the form
 *                              `spaces/{space}/messages/{message}/attachments/{attachment}`. Please see
 *                              {@see ChatServiceClient::attachmentName()} for help formatting this field.
 */
function get_attachment_sample(string $formattedName): void
{
    // Create a client.
    $chatServiceClient = new ChatServiceClient();

    // Prepare the request message.
    $request = (new GetAttachmentRequest())
        ->setName($formattedName);

    // Call the API and handle any network failures.
    try {
        /** @var Attachment $response */
        $response = $chatServiceClient->getAttachment($request);
        printf('Response data: %s' . PHP_EOL, $response->serializeToJsonString());
    } catch (ApiException $ex) {
        printf('Call failed with message: %s' . PHP_EOL, $ex->getMessage());
    }
}

/**
 * Helper to execute the sample.
 *
 * This sample has been automatically generated and should be regarded as a code
 * template only. It will require modifications to work:
 *  - It may require correct/in-range values for request initialization.
 *  - It may require specifying regional endpoints when creating the service client,
 *    please see the apiEndpoint client configuration option for more details.
 */
function callSample(): void
{
    $formattedName = ChatServiceClient::attachmentName('[SPACE]', '[MESSAGE]', '[ATTACHMENT]');

    get_attachment_sample($formattedName);
}

use Google\ApiCore\ApiException;
use Google\Apps\Chat\V1\Availability;
use Google\Apps\Chat\V1\Client\ChatServiceClient;
use Google\Apps\Chat\V1\GetAvailabilityRequest;

/**
 * @param string $formattedName The resource name of the availability to retrieve.
 *
 *                              Format: users/{user}/availability
 *
 *                              `{user}` is the id for the Person in the People API or Admin SDK directory
 *                              API. For example, `users/123456789`.
 *
 *                              The user's email address or `me` can also be used as an alias to refer to
 *                              the caller.  For example, `users/user@example.com` or `users/me`. Please see
 *                              {@see ChatServiceClient::availabilityName()} for help formatting this field.
 */
function get_availability_sample(string $formattedName): void
{
    // Create a client.
    $chatServiceClient = new ChatServiceClient();

    // Prepare the request message.
    $request = (new GetAvailabilityRequest())
        ->setName($formattedName);

    // Call the API and handle any network failures.
    try {
        /** @var Availability $response */
        $response = $chatServiceClient->getAvailability($request);
        printf('Response data: %s' . PHP_EOL, $response->serializeToJsonString());
    } catch (ApiException $ex) {
        printf('Call failed with message: %s' . PHP_EOL, $ex->getMessage());
    }
}

/**
 * Helper to execute the sample.
 *
 * This sample has been automatically generated and should be regarded as a code
 * template only. It will require modifications to work:
 *  - It may require correct/in-range values for request initialization.
 *  - It may require specifying regional endpoints when creating the service client,
 *    please see the apiEndpoint client configuration option for more details.
 */
function callSample(): void
{
    $formattedName = ChatServiceClient::availabilityName('[USER]');

    get_availability_sample($formattedName);
}

use Google\ApiCore\ApiException;
use Google\Apps\Chat\V1\Client\ChatServiceClient;
use Google\Apps\Chat\V1\CustomEmoji;
use Google\Apps\Chat\V1\GetCustomEmojiRequest;

/**
 * @param string $formattedName Resource name of the custom emoji.
 *
 *                              Format: `customEmojis/{customEmoji}`
 *
 *                              You can use the emoji name as an alias for `{customEmoji}`. For example,
 *                              `customEmojis/:example-emoji:` where `:example-emoji:` is the emoji name
 *                              for a custom emoji. Please see
 *                              {@see ChatServiceClient::customEmojiName()} for help formatting this field.
 */
function get_custom_emoji_sample(string $formattedName): void
{
    // Create a client.
    $chatServiceClient = new ChatServiceClient();

    // Prepare the request message.
    $request = (new GetCustomEmojiRequest())
        ->setName($formattedName);

    // Call the API and handle any network failures.
    try {
        /** @var CustomEmoji $response */
        $response = $chatServiceClient->getCustomEmoji($request);
        printf('Response data: %s' . PHP_EOL, $response->serializeToJsonString());
    } catch (ApiException $ex) {
        printf('Call failed with message: %s' . PHP_EOL, $ex->getMessage());
    }
}

/**
 * Helper to execute the sample.
 *
 * This sample has been automatically generated and should be regarded as a code
 * template only. It will require modifications to work:
 *  - It may require correct/in-range values for request initialization.
 *  - It may require specifying regional endpoints when creating the service client,
 *    please see the apiEndpoint client configuration option for more details.
 */
function callSample(): void
{
    $formattedName = ChatServiceClient::customEmojiName('[CUSTOM_EMOJI]');

    get_custom_emoji_sample($formattedName);
}

use Google\ApiCore\ApiException;
use Google\Apps\Chat\V1\Client\ChatServiceClient;
use Google\Apps\Chat\V1\GetMembershipRequest;
use Google\Apps\Chat\V1\Membership;

/**
 * @param string $formattedName Resource name of the membership to retrieve.
 *
 *                              To get the app's own membership [by using user
 *                              authentication](https://developers.google.com/workspace/chat/authenticate-authorize-chat-user),
 *                              you can optionally use `spaces/{space}/members/app`.
 *
 *                              Format: `spaces/{space}/members/{member}` or `spaces/{space}/members/app`
 *
 *                              You can use the user's email as an alias for `{member}`. For example,
 *                              `spaces/{space}/members/example@gmail.com` where `example@gmail.com` is the
 *                              email of the Google Chat user. Please see
 *                              {@see ChatServiceClient::membershipName()} for help formatting this field.
 */
function get_membership_sample(string $formattedName): void
{
    // Create a client.
    $chatServiceClient = new ChatServiceClient();

    // Prepare the request message.
    $request = (new GetMembershipRequest())
        ->setName($formattedName);

    // Call the API and handle any network failures.
    try {
        /** @var Membership $response */
        $response = $chatServiceClient->getMembership($request);
        printf('Response data: %s' . PHP_EOL, $response->serializeToJsonString());
    } catch (ApiException $ex) {
        printf('Call failed with message: %s' . PHP_EOL, $ex->getMessage());
    }
}

/**
 * Helper to execute the sample.
 *
 * This sample has been automatically generated and should be regarded as a code
 * template only. It will require modifications to work:
 *  - It may require correct/in-range values for request initialization.
 *  - It may require specifying regional endpoints when creating the service client,
 *    please see the apiEndpoint client configuration option for more details.
 */
function callSample(): void
{
    $formattedName = ChatServiceClient::membershipName('[SPACE]', '[MEMBER]');

    get_membership_sample($formattedName);
}

use Google\ApiCore\ApiException;
use Google\Apps\Chat\V1\Client\ChatServiceClient;
use Google\Apps\Chat\V1\GetMessageRequest;
use Google\Apps\Chat\V1\Message;

/**
 * @param string $formattedName Resource name of the message.
 *
 *                              Format: `spaces/{space}/messages/{message}`
 *
 *                              If you've set a custom ID for your message, you can use the value from the
 *                              `clientAssignedMessageId` field for `{message}`. For details, see [Name a
 *                              message]
 *                              (https://developers.google.com/workspace/chat/create-messages#name_a_created_message). Please see
 *                              {@see ChatServiceClient::messageName()} for help formatting this field.
 */
function get_message_sample(string $formattedName): void
{
    // Create a client.
    $chatServiceClient = new ChatServiceClient();

    // Prepare the request message.
    $request = (new GetMessageRequest())
        ->setName($formattedName);

    // Call the API and handle any network failures.
    try {
        /** @var Message $response */
        $response = $chatServiceClient->getMessage($request);
        printf('Response data: %s' . PHP_EOL, $response->serializeToJsonString());
    } catch (ApiException $ex) {
        printf('Call failed with message: %s' . PHP_EOL, $ex->getMessage());
    }
}

/**
 * Helper to execute the sample.
 *
 * This sample has been automatically generated and should be regarded as a code
 * template only. It will require modifications to work:
 *  - It may require correct/in-range values for request initialization.
 *  - It may require specifying regional endpoints when creating the service client,
 *    please see the apiEndpoint client configuration option for more details.
 */
function callSample(): void
{
    $formattedName = ChatServiceClient::messageName('[SPACE]', '[MESSAGE]');

    get_message_sample($formattedName);
}

use Google\ApiCore\ApiException;
use Google\Apps\Chat\V1\Client\ChatServiceClient;
use Google\Apps\Chat\V1\GetSpaceRequest;
use Google\Apps\Chat\V1\Space;

/**
 * @param string $formattedName Resource name of the space, in the form `spaces/{space}`.
 *
 *                              Format: `spaces/{space}`
 *                              Please see {@see ChatServiceClient::spaceName()} for help formatting this field.
 */
function get_space_sample(string $formattedName): void
{
    // Create a client.
    $chatServiceClient = new ChatServiceClient();

    // Prepare the request message.
    $request = (new GetSpaceRequest())
        ->setName($formattedName);

    // Call the API and handle any network failures.
    try {
        /** @var Space $response */
        $response = $chatServiceClient->getSpace($request);
        printf('Response data: %s' . PHP_EOL, $response->serializeToJsonString());
    } catch (ApiException $ex) {
        printf('Call failed with message: %s' . PHP_EOL, $ex->getMessage());
    }
}

/**
 * Helper to execute the sample.
 *
 * This sample has been automatically generated and should be regarded as a code
 * template only. It will require modifications to work:
 *  - It may require correct/in-range values for request initialization.
 *  - It may require specifying regional endpoints when creating the service client,
 *    please see the apiEndpoint client configuration option for more details.
 */
function callSample(): void
{
    $formattedName = ChatServiceClient::spaceName('[SPACE]');

    get_space_sample($formattedName);
}

use Google\ApiCore\ApiException;
use Google\Apps\Chat\V1\Client\ChatServiceClient;
use Google\Apps\Chat\V1\GetSpaceEventRequest;
use Google\Apps\Chat\V1\SpaceEvent;

/**
 * @param string $formattedName The resource name of the space event.
 *
 *                              Format: `spaces/{space}/spaceEvents/{spaceEvent}`
 *                              Please see {@see ChatServiceClient::spaceEventName()} for help formatting this field.
 */
function get_space_event_sample(string $formattedName): void
{
    // Create a client.
    $chatServiceClient = new ChatServiceClient();

    // Prepare the request message.
    $request = (new GetSpaceEventRequest())
        ->setName($formattedName);

    // Call the API and handle any network failures.
    try {
        /** @var SpaceEvent $response */
        $response = $chatServiceClient->getSpaceEvent($request);
        printf('Response data: %s' . PHP_EOL, $response->serializeToJsonString());
    } catch (ApiException $ex) {
        printf('Call failed with message: %s' . PHP_EOL, $ex->getMessage());
    }
}

/**
 * Helper to execute the sample.
 *
 * This sample has been automatically generated and should be regarded as a code
 * template only. It will require modifications to work:
 *  - It may require correct/in-range values for request initialization.
 *  - It may require specifying regional endpoints when creating the service client,
 *    please see the apiEndpoint client configuration option for more details.
 */
function callSample(): void
{
    $formattedName = ChatServiceClient::spaceEventName('[SPACE]', '[SPACE_EVENT]');

    get_space_event_sample($formattedName);
}

use Google\ApiCore\ApiException;
use Google\Apps\Chat\V1\Client\ChatServiceClient;
use Google\Apps\Chat\V1\GetSpaceNotificationSettingRequest;
use Google\Apps\Chat\V1\SpaceNotificationSetting;

/**
 * @param string $formattedName Format: users/{user}/spaces/{space}/spaceNotificationSetting
 *
 *                              - `users/me/spaces/{space}/spaceNotificationSetting`, OR
 *                              - `users/user@example.com/spaces/{space}/spaceNotificationSetting`, OR
 *                              - `users/123456789/spaces/{space}/spaceNotificationSetting`.
 *                              Note: Only the caller's user id or email is allowed in the path. Please see
 *                              {@see ChatServiceClient::spaceNotificationSettingName()} for help formatting this field.
 */
function get_space_notification_setting_sample(string $formattedName): void
{
    // Create a client.
    $chatServiceClient = new ChatServiceClient();

    // Prepare the request message.
    $request = (new GetSpaceNotificationSettingRequest())
        ->setName($formattedName);

    // Call the API and handle any network failures.
    try {
        /** @var SpaceNotificationSetting $response */
        $response = $chatServiceClient->getSpaceNotificationSetting($request);
        printf('Response data: %s' . PHP_EOL, $response->serializeToJsonString());
    } catch (ApiException $ex) {
        printf('Call failed with message: %s' . PHP_EOL, $ex->getMessage());
    }
}

/**
 * Helper to execute the sample.
 *
 * This sample has been automatically generated and should be regarded as a code
 * template only. It will require modifications to work:
 *  - It may require correct/in-range values for request initialization.
 *  - It may require specifying regional endpoints when creating the service client,
 *    please see the apiEndpoint client configuration option for more details.
 */
function callSample(): void
{
    $formattedName = ChatServiceClient::spaceNotificationSettingName('[USER]', '[SPACE]');

    get_space_notification_setting_sample($formattedName);
}

use Google\ApiCore\ApiException;
use Google\Apps\Chat\V1\Client\ChatServiceClient;
use Google\Apps\Chat\V1\GetSpaceReadStateRequest;
use Google\Apps\Chat\V1\SpaceReadState;

/**
 * @param string $formattedName Resource name of the space read state to retrieve.
 *
 *                              Only supports getting read state for the calling user.
 *
 *                              To refer to the calling user, set one of the following:
 *
 *                              - The `me` alias. For example, `users/me/spaces/{space}/spaceReadState`.
 *
 *                              - Their Workspace email address. For example,
 *                              `users/user@example.com/spaces/{space}/spaceReadState`.
 *
 *                              - Their user id. For example,
 *                              `users/123456789/spaces/{space}/spaceReadState`.
 *
 *                              Format: users/{user}/spaces/{space}/spaceReadState
 *                              Please see {@see ChatServiceClient::spaceReadStateName()} for help formatting this field.
 */
function get_space_read_state_sample(string $formattedName): void
{
    // Create a client.
    $chatServiceClient = new ChatServiceClient();

    // Prepare the request message.
    $request = (new GetSpaceReadStateRequest())
        ->setName($formattedName);

    // Call the API and handle any network failures.
    try {
        /** @var SpaceReadState $response */
        $response = $chatServiceClient->getSpaceReadState($request);
        printf('Response data: %s' . PHP_EOL, $response->serializeToJsonString());
    } catch (ApiException $ex) {
        printf('Call failed with message: %s' . PHP_EOL, $ex->getMessage());
    }
}

/**
 * Helper to execute the sample.
 *
 * This sample has been automatically generated and should be regarded as a code
 * template only. It will require modifications to work:
 *  - It may require correct/in-range values for request initialization.
 *  - It may require specifying regional endpoints when creating the service client,
 *    please see the apiEndpoint client configuration option for more details.
 */
function callSample(): void
{
    $formattedName = ChatServiceClient::spaceReadStateName('[USER]', '[SPACE]');

    get_space_read_state_sample($formattedName);
}

use Google\ApiCore\ApiException;
use Google\Apps\Chat\V1\Client\ChatServiceClient;
use Google\Apps\Chat\V1\GetThreadReadStateRequest;
use Google\Apps\Chat\V1\ThreadReadState;

/**
 * @param string $formattedName Resource name of the thread read state to retrieve.
 *
 *                              Only supports getting read state for the calling user.
 *
 *                              To refer to the calling user, set one of the following:
 *
 *                              - The `me` alias. For example,
 *                              `users/me/spaces/{space}/threads/{thread}/threadReadState`.
 *
 *                              - Their Workspace email address. For example,
 *                              `users/user@example.com/spaces/{space}/threads/{thread}/threadReadState`.
 *
 *                              - Their user id. For example,
 *                              `users/123456789/spaces/{space}/threads/{thread}/threadReadState`.
 *
 *                              Format: users/{user}/spaces/{space}/threads/{thread}/threadReadState
 *                              Please see {@see ChatServiceClient::threadReadStateName()} for help formatting this field.
 */
function get_thread_read_state_sample(string $formattedName): void
{
    // Create a client.
    $chatServiceClient = new ChatServiceClient();

    // Prepare the request message.
    $request = (new GetThreadReadStateRequest())
        ->setName($formattedName);

    // Call the API and handle any network failures.
    try {
        /** @var ThreadReadState $response */
        $response = $chatServiceClient->getThreadReadState($request);
        printf('Response data: %s' . PHP_EOL, $response->serializeToJsonString());
    } catch (ApiException $ex) {
        printf('Call failed with message: %s' . PHP_EOL, $ex->getMessage());
    }
}

/**
 * Helper to execute the sample.
 *
 * This sample has been automatically generated and should be regarded as a code
 * template only. It will require modifications to work:
 *  - It may require correct/in-range values for request initialization.
 *  - It may require specifying regional endpoints when creating the service client,
 *    please see the apiEndpoint client configuration option for more details.
 */
function callSample(): void
{
    $formattedName = ChatServiceClient::threadReadStateName('[USER]', '[SPACE]', '[THREAD]');

    get_thread_read_state_sample($formattedName);
}

use Google\ApiCore\ApiException;
use Google\ApiCore\PagedListResponse;
use Google\Apps\Chat\V1\Client\ChatServiceClient;
use Google\Apps\Chat\V1\CustomEmoji;
use Google\Apps\Chat\V1\ListCustomEmojisRequest;

/**
 * This sample has been automatically generated and should be regarded as a code
 * template only. It will require modifications to work:
 *  - It may require correct/in-range values for request initialization.
 *  - It may require specifying regional endpoints when creating the service client,
 *    please see the apiEndpoint client configuration option for more details.
 */
function list_custom_emojis_sample(): void
{
    // Create a client.
    $chatServiceClient = new ChatServiceClient();

    // Prepare the request message.
    $request = new ListCustomEmojisRequest();

    // Call the API and handle any network failures.
    try {
        /** @var PagedListResponse $response */
        $response = $chatServiceClient->listCustomEmojis($request);

        /** @var CustomEmoji $element */
        foreach ($response as $element) {
            printf('Element data: %s' . PHP_EOL, $element->serializeToJsonString());
        }
    } catch (ApiException $ex) {
        printf('Call failed with message: %s' . PHP_EOL, $ex->getMessage());
    }
}

use Google\ApiCore\ApiException;
use Google\ApiCore\PagedListResponse;
use Google\Apps\Chat\V1\Client\ChatServiceClient;
use Google\Apps\Chat\V1\ListMembershipsRequest;
use Google\Apps\Chat\V1\Membership;

/**
 * @param string $formattedParent The resource name of the space for which to fetch a membership
 *                                list.
 *
 *                                Format: spaces/{space}
 *                                Please see {@see ChatServiceClient::spaceName()} for help formatting this field.
 */
function list_memberships_sample(string $formattedParent): void
{
    // Create a client.
    $chatServiceClient = new ChatServiceClient();

    // Prepare the request message.
    $request = (new ListMembershipsRequest())
        ->setParent($formattedParent);

    // Call the API and handle any network failures.
    try {
        /** @var PagedListResponse $response */
        $response = $chatServiceClient->listMemberships($request);

        /** @var Membership $element */
        foreach ($response as $element) {
            printf('Element data: %s' . PHP_EOL, $element->serializeToJsonString());
        }
    } catch (ApiException $ex) {
        printf('Call failed with message: %s' . PHP_EOL, $ex->getMessage());
    }
}

/**
 * Helper to execute the sample.
 *
 * This sample has been automatically generated and should be regarded as a code
 * template only. It will require modifications to work:
 *  - It may require correct/in-range values for request initialization.
 *  - It may require specifying regional endpoints when creating the service client,
 *    please see the apiEndpoint client configuration option for more details.
 */
function callSample(): void
{
    $formattedParent = ChatServiceClient::spaceName('[SPACE]');

    list_memberships_sample($formattedParent);
}

use Google\ApiCore\ApiException;
use Google\ApiCore\PagedListResponse;
use Google\Apps\Chat\V1\Client\ChatServiceClient;
use Google\Apps\Chat\V1\ListMessagePinsRequest;
use Google\Apps\Chat\V1\MessagePin;

/**
 * @param string $formattedParent The parent space which owns the collection of pinned items
 *                                Format: `spaces/{space}`
 *                                Please see {@see ChatServiceClient::spaceName()} for help formatting this field.
 */
function list_message_pins_sample(string $formattedParent): void
{
    // Create a client.
    $chatServiceClient = new ChatServiceClient();

    // Prepare the request message.
    $request = (new ListMessagePinsRequest())
        ->setParent($formattedParent);

    // Call the API and handle any network failures.
    try {
        /** @var PagedListResponse $response */
        $response = $chatServiceClient->listMessagePins($request);

        /** @var MessagePin $element */
        foreach ($response as $element) {
            printf('Element data: %s' . PHP_EOL, $element->serializeToJsonString());
        }
    } catch (ApiException $ex) {
        printf('Call failed with message: %s' . PHP_EOL, $ex->getMessage());
    }
}

/**
 * Helper to execute the sample.
 *
 * This sample has been automatically generated and should be regarded as a code
 * template only. It will require modifications to work:
 *  - It may require correct/in-range values for request initialization.
 *  - It may require specifying regional endpoints when creating the service client,
 *    please see the apiEndpoint client configuration option for more details.
 */
function callSample(): void
{
    $formattedParent = ChatServiceClient::spaceName('[SPACE]');

    list_message_pins_sample($formattedParent);
}

use Google\ApiCore\ApiException;
use Google\ApiCore\PagedListResponse;
use Google\Apps\Chat\V1\Client\ChatServiceClient;
use Google\Apps\Chat\V1\ListMessagesRequest;
use Google\Apps\Chat\V1\Message;

/**
 * @param string $formattedParent The resource name of the space to list messages from.
 *
 *                                Format: `spaces/{space}`
 *                                Please see {@see ChatServiceClient::spaceName()} for help formatting this field.
 */
function list_messages_sample(string $formattedParent): void
{
    // Create a client.
    $chatServiceClient = new ChatServiceClient();

    // Prepare the request message.
    $request = (new ListMessagesRequest())
        ->setParent($formattedParent);

    // Call the API and handle any network failures.
    try {
        /** @var PagedListResponse $response */
        $response = $chatServiceClient->listMessages($request);

        /** @var Message $element */
        foreach ($response as $element) {
            printf('Element data: %s' . PHP_EOL, $element->serializeToJsonString());
        }
    } catch (ApiException $ex) {
        printf('Call failed with message: %s' . PHP_EOL, $ex->getMessage());
    }
}

/**
 * Helper to execute the sample.
 *
 * This sample has been automatically generated and should be regarded as a code
 * template only. It will require modifications to work:
 *  - It may require correct/in-range values for request initialization.
 *  - It may require specifying regional endpoints when creating the service client,
 *    please see the apiEndpoint client configuration option for more details.
 */
function callSample(): void
{
    $formattedParent = ChatServiceClient::spaceName('[SPACE]');

    list_messages_sample($formattedParent);
}

use Google\ApiCore\ApiException;
use Google\ApiCore\PagedListResponse;
use Google\Apps\Chat\V1\Client\ChatServiceClient;
use Google\Apps\Chat\V1\ListReactionsRequest;
use Google\Apps\Chat\V1\Reaction;

/**
 * @param string $formattedParent The message users reacted to.
 *
 *                                Format: `spaces/{space}/messages/{message}`
 *                                Please see {@see ChatServiceClient::messageName()} for help formatting this field.
 */
function list_reactions_sample(string $formattedParent): void
{
    // Create a client.
    $chatServiceClient = new ChatServiceClient();

    // Prepare the request message.
    $request = (new ListReactionsRequest())
        ->setParent($formattedParent);

    // Call the API and handle any network failures.
    try {
        /** @var PagedListResponse $response */
        $response = $chatServiceClient->listReactions($request);

        /** @var Reaction $element */
        foreach ($response as $element) {
            printf('Element data: %s' . PHP_EOL, $element->serializeToJsonString());
        }
    } catch (ApiException $ex) {
        printf('Call failed with message: %s' . PHP_EOL, $ex->getMessage());
    }
}

/**
 * Helper to execute the sample.
 *
 * This sample has been automatically generated and should be regarded as a code
 * template only. It will require modifications to work:
 *  - It may require correct/in-range values for request initialization.
 *  - It may require specifying regional endpoints when creating the service client,
 *    please see the apiEndpoint client configuration option for more details.
 */
function callSample(): void
{
    $formattedParent = ChatServiceClient::messageName('[SPACE]', '[MESSAGE]');

    list_reactions_sample($formattedParent);
}

use Google\ApiCore\ApiException;
use Google\ApiCore\PagedListResponse;
use Google\Apps\Chat\V1\Client\ChatServiceClient;
use Google\Apps\Chat\V1\ListSectionItemsRequest;
use Google\Apps\Chat\V1\SectionItem;

/**
 * @param string $formattedParent The parent, which is the section resource name that owns this
 *                                collection of section items. Only supports listing section items for the
 *                                calling user.
 *
 *                                When you're filtering by space, use the wildcard `-` to search across all
 *                                sections. For example, `users/{user}/sections/-`.
 *
 *                                Format: `users/{user}/sections/{section}`
 *                                Please see {@see ChatServiceClient::sectionName()} for help formatting this field.
 */
function list_section_items_sample(string $formattedParent): void
{
    // Create a client.
    $chatServiceClient = new ChatServiceClient();

    // Prepare the request message.
    $request = (new ListSectionItemsRequest())
        ->setParent($formattedParent);

    // Call the API and handle any network failures.
    try {
        /** @var PagedListResponse $response */
        $response = $chatServiceClient->listSectionItems($request);

        /** @var SectionItem $element */
        foreach ($response as $element) {
            printf('Element data: %s' . PHP_EOL, $element->serializeToJsonString());
        }
    } catch (ApiException $ex) {
        printf('Call failed with message: %s' . PHP_EOL, $ex->getMessage());
    }
}

/**
 * Helper to execute the sample.
 *
 * This sample has been automatically generated and should be regarded as a code
 * template only. It will require modifications to work:
 *  - It may require correct/in-range values for request initialization.
 *  - It may require specifying regional endpoints when creating the service client,
 *    please see the apiEndpoint client configuration option for more details.
 */
function callSample(): void
{
    $formattedParent = ChatServiceClient::sectionName('[USER]', '[SECTION]');

    list_section_items_sample($formattedParent);
}

use Google\ApiCore\ApiException;
use Google\ApiCore\PagedListResponse;
use Google\Apps\Chat\V1\Client\ChatServiceClient;
use Google\Apps\Chat\V1\ListSectionsRequest;
use Google\Apps\Chat\V1\Section;

/**
 * @param string $formattedParent The parent, which is the user resource name that owns this
 *                                collection of sections. Only supports listing sections for the calling
 *                                user. To refer to the calling user, set one of the following:
 *
 *                                - The `me` alias. For example, `users/me`.
 *
 *                                - Their Workspace email address. For example, `users/user@example.com`.
 *
 *                                - Their user id. For example, `users/123456789`.
 *
 *                                Format: `users/{user}`
 *                                Please see {@see ChatServiceClient::userName()} for help formatting this field.
 */
function list_sections_sample(string $formattedParent): void
{
    // Create a client.
    $chatServiceClient = new ChatServiceClient();

    // Prepare the request message.
    $request = (new ListSectionsRequest())
        ->setParent($formattedParent);

    // Call the API and handle any network failures.
    try {
        /** @var PagedListResponse $response */
        $response = $chatServiceClient->listSections($request);

        /** @var Section $element */
        foreach ($response as $element) {
            printf('Element data: %s' . PHP_EOL, $element->serializeToJsonString());
        }
    } catch (ApiException $ex) {
        printf('Call failed with message: %s' . PHP_EOL, $ex->getMessage());
    }
}

/**
 * Helper to execute the sample.
 *
 * This sample has been automatically generated and should be regarded as a code
 * template only. It will require modifications to work:
 *  - It may require correct/in-range values for request initialization.
 *  - It may require specifying regional endpoints when creating the service client,
 *    please see the apiEndpoint client configuration option for more details.
 */
function callSample(): void
{
    $formattedParent = ChatServiceClient::userName('[USER]');

    list_sections_sample($formattedParent);
}

use Google\ApiCore\ApiException;
use Google\ApiCore\PagedListResponse;
use Google\Apps\Chat\V1\Client\ChatServiceClient;
use Google\Apps\Chat\V1\ListSpaceEventsRequest;
use Google\Apps\Chat\V1\SpaceEvent;

/**
 * @param string $formattedParent Resource name of the [Google Chat
 *                                space](https://developers.google.com/workspace/chat/api/reference/rest/v1/spaces)
 *                                where the events occurred.
 *
 *                                Format: `spaces/{space}`. Please see
 *                                {@see ChatServiceClient::spaceName()} for help formatting this field.
 * @param string $filter          A query filter.
 *
 *                                You must specify at least one event type (`event_type`)
 *                                using the has `:` operator. To filter by multiple event types, use the `OR`
 *                                operator. Omit batch event types in your filter. The request automatically
 *                                returns any related batch events. For example, if you filter by new
 *                                reactions
 *                                (`google.workspace.chat.reaction.v1.created`), the server also returns
 *                                batch new reactions events
 *                                (`google.workspace.chat.reaction.v1.batchCreated`). For a list of supported
 *                                event types, see the [`SpaceEvents` reference
 *                                documentation](https://developers.google.com/workspace/chat/api/reference/rest/v1/spaces.spaceEvents#SpaceEvent.FIELDS.event_type).
 *
 *                                Optionally, you can also filter by start time (`start_time`) and
 *                                end time (`end_time`):
 *
 *                                * `start_time`: Exclusive timestamp from which to start listing space
 *                                events.
 *                                You can list events that occurred up to 28 days ago. If unspecified, lists
 *                                space events from the past 28 days.
 *                                * `end_time`: Inclusive timestamp until which space events are listed.
 *                                If unspecified, lists events up to the time of the request.
 *
 *                                To specify a start or end time, use the equals `=` operator and format in
 *                                [RFC-3339](https://www.rfc-editor.org/rfc/rfc3339). To filter by both
 *                                `start_time` and `end_time`, use the `AND` operator.
 *
 *                                For example, the following queries are valid:
 *
 *                                ```
 *                                start_time="2023-08-23T19:20:33+00:00" AND
 *                                end_time="2023-08-23T19:21:54+00:00"
 *                                ```
 *                                ```
 *                                start_time="2023-08-23T19:20:33+00:00" AND
 *                                (event_types:"google.workspace.chat.space.v1.updated" OR
 *                                event_types:"google.workspace.chat.message.v1.created")
 *                                ```
 *
 *                                The following queries are invalid:
 *
 *                                ```
 *                                start_time="2023-08-23T19:20:33+00:00" OR
 *                                end_time="2023-08-23T19:21:54+00:00"
 *                                ```
 *                                ```
 *                                event_types:"google.workspace.chat.space.v1.updated" AND
 *                                event_types:"google.workspace.chat.message.v1.created"
 *                                ```
 *
 *                                Invalid queries are rejected by the server with an `INVALID_ARGUMENT`
 *                                error.
 */
function list_space_events_sample(string $formattedParent, string $filter): void
{
    // Create a client.
    $chatServiceClient = new ChatServiceClient();

    // Prepare the request message.
    $request = (new ListSpaceEventsRequest())
        ->setParent($formattedParent)
        ->setFilter($filter);

    // Call the API and handle any network failures.
    try {
        /** @var PagedListResponse $response */
        $response = $chatServiceClient->listSpaceEvents($request);

        /** @var SpaceEvent $element */
        foreach ($response as $element) {
            printf('Element data: %s' . PHP_EOL, $element->serializeToJsonString());
        }
    } catch (ApiException $ex) {
        printf('Call failed with message: %s' . PHP_EOL, $ex->getMessage());
    }
}

/**
 * Helper to execute the sample.
 *
 * This sample has been automatically generated and should be regarded as a code
 * template only. It will require modifications to work:
 *  - It may require correct/in-range values for request initialization.
 *  - It may require specifying regional endpoints when creating the service client,
 *    please see the apiEndpoint client configuration option for more details.
 */
function callSample(): void
{
    $formattedParent = ChatServiceClient::spaceName('[SPACE]');
    $filter = '[FILTER]';

    list_space_events_sample($formattedParent, $filter);
}

use Google\ApiCore\ApiException;
use Google\ApiCore\PagedListResponse;
use Google\Apps\Chat\V1\Client\ChatServiceClient;
use Google\Apps\Chat\V1\ListSpacesRequest;
use Google\Apps\Chat\V1\Space;

/**
 * This sample has been automatically generated and should be regarded as a code
 * template only. It will require modifications to work:
 *  - It may require correct/in-range values for request initialization.
 *  - It may require specifying regional endpoints when creating the service client,
 *    please see the apiEndpoint client configuration option for more details.
 */
function list_spaces_sample(): void
{
    // Create a client.
    $chatServiceClient = new ChatServiceClient();

    // Prepare the request message.
    $request = new ListSpacesRequest();

    // Call the API and handle any network failures.
    try {
        /** @var PagedListResponse $response */
        $response = $chatServiceClient->listSpaces($request);

        /** @var Space $element */
        foreach ($response as $element) {
            printf('Element data: %s' . PHP_EOL, $element->serializeToJsonString());
        }
    } catch (ApiException $ex) {
        printf('Call failed with message: %s' . PHP_EOL, $ex->getMessage());
    }
}

use Google\ApiCore\ApiException;
use Google\Apps\Chat\V1\Availability;
use Google\Apps\Chat\V1\Client\ChatServiceClient;
use Google\Apps\Chat\V1\MarkAsActiveRequest;

/**
 * @param string $formattedName The resource name of the availability to mark as active.
 *                              Format: users/{user}/availability
 *
 *                              `{user}` is the id for the Person in the People API or Admin SDK directory
 *                              API. For example, `users/123456789`.
 *
 *                              The user's email address or `me` can also be used as an alias to refer to
 *                              the caller.  For example, `users/user@example.com` or `users/me`. Please see
 *                              {@see ChatServiceClient::availabilityName()} for help formatting this field.
 */
function mark_as_active_sample(string $formattedName): void
{
    // Create a client.
    $chatServiceClient = new ChatServiceClient();

    // Prepare the request message.
    $request = (new MarkAsActiveRequest())
        ->setName($formattedName);

    // Call the API and handle any network failures.
    try {
        /** @var Availability $response */
        $response = $chatServiceClient->markAsActive($request);
        printf('Response data: %s' . PHP_EOL, $response->serializeToJsonString());
    } catch (ApiException $ex) {
        printf('Call failed with message: %s' . PHP_EOL, $ex->getMessage());
    }
}

/**
 * Helper to execute the sample.
 *
 * This sample has been automatically generated and should be regarded as a code
 * template only. It will require modifications to work:
 *  - It may require correct/in-range values for request initialization.
 *  - It may require specifying regional endpoints when creating the service client,
 *    please see the apiEndpoint client configuration option for more details.
 */
function callSample(): void
{
    $formattedName = ChatServiceClient::availabilityName('[USER]');

    mark_as_active_sample($formattedName);
}

use Google\ApiCore\ApiException;
use Google\Apps\Chat\V1\Availability;
use Google\Apps\Chat\V1\Client\ChatServiceClient;
use Google\Apps\Chat\V1\MarkAsAwayRequest;

/**
 * @param string $formattedName The resource name of the availability to mark as away.
 *                              Format: users/{user}/availability
 *
 *                              `{user}` is the id for the Person in the People API or Admin SDK directory
 *                              API. For example, `users/123456789`.
 *
 *                              The user's email address or `me` can also be used as an alias to refer to
 *                              the caller.  For example, `users/user@example.com` or `users/me`. Please see
 *                              {@see ChatServiceClient::availabilityName()} for help formatting this field.
 */
function mark_as_away_sample(string $formattedName): void
{
    // Create a client.
    $chatServiceClient = new ChatServiceClient();

    // Prepare the request message.
    $request = (new MarkAsAwayRequest())
        ->setName($formattedName);

    // Call the API and handle any network failures.
    try {
        /** @var Availability $response */
        $response = $chatServiceClient->markAsAway($request);
        printf('Response data: %s' . PHP_EOL, $response->serializeToJsonString());
    } catch (ApiException $ex) {
        printf('Call failed with message: %s' . PHP_EOL, $ex->getMessage());
    }
}

/**
 * Helper to execute the sample.
 *
 * This sample has been automatically generated and should be regarded as a code
 * template only. It will require modifications to work:
 *  - It may require correct/in-range values for request initialization.
 *  - It may require specifying regional endpoints when creating the service client,
 *    please see the apiEndpoint client configuration option for more details.
 */
function callSample(): void
{
    $formattedName = ChatServiceClient::availabilityName('[USER]');

    mark_as_away_sample($formattedName);
}

use Google\ApiCore\ApiException;
use Google\Apps\Chat\V1\Availability;
use Google\Apps\Chat\V1\Client\ChatServiceClient;
use Google\Apps\Chat\V1\MarkAsDoNotDisturbRequest;

/**
 * @param string $formattedName The resource name of the availability to mark as Do Not Disturb.
 *                              Format: users/{user}/availability
 *
 *                              `{user}` is the id for the Person in the People API or Admin SDK directory
 *                              API. For example, `users/123456789`.
 *
 *                              The user's email address or `me` can also be used as an alias to refer to
 *                              the caller.  For example, `users/user@example.com` or `users/me`. Please see
 *                              {@see ChatServiceClient::availabilityName()} for help formatting this field.
 */
function mark_as_do_not_disturb_sample(string $formattedName): void
{
    // Create a client.
    $chatServiceClient = new ChatServiceClient();

    // Prepare the request message.
    $request = (new MarkAsDoNotDisturbRequest())
        ->setName($formattedName);

    // Call the API and handle any network failures.
    try {
        /** @var Availability $response */
        $response = $chatServiceClient->markAsDoNotDisturb($request);
        printf('Response data: %s' . PHP_EOL, $response->serializeToJsonString());
    } catch (ApiException $ex) {
        printf('Call failed with message: %s' . PHP_EOL, $ex->getMessage());
    }
}

/**
 * Helper to execute the sample.
 *
 * This sample has been automatically generated and should be regarded as a code
 * template only. It will require modifications to work:
 *  - It may require correct/in-range values for request initialization.
 *  - It may require specifying regional endpoints when creating the service client,
 *    please see the apiEndpoint client configuration option for more details.
 */
function callSample(): void
{
    $formattedName = ChatServiceClient::availabilityName('[USER]');

    mark_as_do_not_disturb_sample($formattedName);
}

use Google\ApiCore\ApiException;
use Google\Apps\Chat\V1\Client\ChatServiceClient;
use Google\Apps\Chat\V1\MoveSectionItemRequest;
use Google\Apps\Chat\V1\MoveSectionItemResponse;

/**
 * @param string $formattedName          The resource name of the section item to move.
 *
 *                                       Format: `users/{user}/sections/{section}/items/{item}`
 *                                       Please see {@see ChatServiceClient::sectionItemName()} for help formatting this field.
 * @param string $formattedTargetSection The resource name of the section to move the section item to.
 *
 *                                       Format: `users/{user}/sections/{section}`
 *                                       Please see {@see ChatServiceClient::sectionName()} for help formatting this field.
 */
function move_section_item_sample(string $formattedName, string $formattedTargetSection): void
{
    // Create a client.
    $chatServiceClient = new ChatServiceClient();

    // Prepare the request message.
    $request = (new MoveSectionItemRequest())
        ->setName($formattedName)
        ->setTargetSection($formattedTargetSection);

    // Call the API and handle any network failures.
    try {
        /** @var MoveSectionItemResponse $response */
        $response = $chatServiceClient->moveSectionItem($request);
        printf('Response data: %s' . PHP_EOL, $response->serializeToJsonString());
    } catch (ApiException $ex) {
        printf('Call failed with message: %s' . PHP_EOL, $ex->getMessage());
    }
}

/**
 * Helper to execute the sample.
 *
 * This sample has been automatically generated and should be regarded as a code
 * template only. It will require modifications to work:
 *  - It may require correct/in-range values for request initialization.
 *  - It may require specifying regional endpoints when creating the service client,
 *    please see the apiEndpoint client configuration option for more details.
 */
function callSample(): void
{
    $formattedName = ChatServiceClient::sectionItemName('[USER]', '[SECTION]', '[ITEM]');
    $formattedTargetSection = ChatServiceClient::sectionName('[USER]', '[SECTION]');

    move_section_item_sample($formattedName, $formattedTargetSection);
}

use Google\ApiCore\ApiException;
use Google\Apps\Chat\V1\Client\ChatServiceClient;
use Google\Apps\Chat\V1\PositionSectionRequest;
use Google\Apps\Chat\V1\PositionSectionResponse;

/**
 * @param string $formattedName The resource name of the section to position.
 *
 *                              Format: `users/{user}/sections/{section}`
 *                              Please see {@see ChatServiceClient::sectionName()} for help formatting this field.
 */
function position_section_sample(string $formattedName): void
{
    // Create a client.
    $chatServiceClient = new ChatServiceClient();

    // Prepare the request message.
    $request = (new PositionSectionRequest())
        ->setName($formattedName);

    // Call the API and handle any network failures.
    try {
        /** @var PositionSectionResponse $response */
        $response = $chatServiceClient->positionSection($request);
        printf('Response data: %s' . PHP_EOL, $response->serializeToJsonString());
    } catch (ApiException $ex) {
        printf('Call failed with message: %s' . PHP_EOL, $ex->getMessage());
    }
}

/**
 * Helper to execute the sample.
 *
 * This sample has been automatically generated and should be regarded as a code
 * template only. It will require modifications to work:
 *  - It may require correct/in-range values for request initialization.
 *  - It may require specifying regional endpoints when creating the service client,
 *    please see the apiEndpoint client configuration option for more details.
 */
function callSample(): void
{
    $formattedName = ChatServiceClient::sectionName('[USER]', '[SECTION]');

    position_section_sample($formattedName);
}

use Google\ApiCore\ApiException;
use Google\ApiCore\PagedListResponse;
use Google\Apps\Chat\V1\Client\ChatServiceClient;
use Google\Apps\Chat\V1\SearchMessageResult;
use Google\Apps\Chat\V1\SearchMessagesRequest;

/**
 * @param string $formattedParent The resource name of the space to search within.
 *
 *                                To search across all spaces the user has access to, set this field to
 *                                `spaces/-`. Using any other value for `parent` results in an
 *                                `INVALID_ARGUMENT` error.
 *
 *                                To limit the search to one or more spaces, use `space.name` or
 *                                `space.display_name` in the `filter`. Please see
 *                                {@see ChatServiceClient::spaceName()} for help formatting this field.
 * @param string $filter          A search query.
 *
 *                                The query can specify one or more search keywords, which are used to filter
 *                                the results,
 *
 *                                You can also filter the results using the following message fields:
 *
 *                                - `create_time`: Accepts a timestamp in
 *                                [RFC-3339](https://www.rfc-editor.org/rfc/rfc3339) format and the
 *                                supported comparison operators are: `<` and `>=`.
 *                                - `sender.name`: The resource name of the sender (`users/{user}`). Only
 *                                supports `=`. You can use the e-mail as an alias for `{user}`. For
 *                                example, `users/example&#64;gmail.com`, where `example&#64;gmail.com` is the
 *                                e-mail of the Google Chat user.
 *                                - `space.name`: The resource name of the space where the message is posted.
 *                                (`spaces/{space}`). Only supports `=`. If this filter is not set, the
 *                                search is performed across all direct messages and spaces the user has
 *                                access to as a space member.
 *                                - `space.display_name`: Supports the operator `:` (has) and filters spaces
 *                                based on a partial match of their display name. Results are limited to
 *                                the top five space matches. For example, `space.display_name:Project`
 *                                searches for messages in the top five spaces that contain the word
 *                                "Project" in their display names.
 *                                - `space.space_type`: The type of the space. Only supports `=`. For
 *                                example, `space.space_type="DIRECT_MESSAGE"` returns only messages from
 *                                direct messages. The possible values are `DIRECT_MESSAGE`, `GROUP_CHAT`,
 *                                and `SPACE`.
 *                                - `attachment`: Supports the operator `:*` (has any) to check for the
 *                                presence of attachments. If `attachment:*` is specified, only messages
 *                                that have at least one attachment are returned.
 *                                - `annotations.user_mentions.user.name`: The resource name of the mentioned
 *                                user (`users/{user}`). Only supports `:` (has). For example:
 *                                `annotations.user_mentions.user.name:"users/1234567890"` returns only
 *                                messages that contain a mention to the specified user. Alternatively, the
 *                                alias `me` can be used to filter for messages that mention the caller
 *                                user, for example: `annotations.user_mentions.user.name:users/me`. You
 *                                can also use the e-mail as an alias for `{user}`, for example,
 *                                `users/example&#64;gmail.com`.
 *
 *                                For advanced filtering, the following functions are also available:
 *
 *                                - `has_link()`: Returns only messages that have at least one hyperlink in
 *                                the message text.
 *                                - `is_unread()`: Filters out messages that have been read by the calling
 *                                user.
 *
 *                                Using the `space.display_name` or the `space.space_type` filters requires
 *                                that the calling credentials include one of the following [authorization
 *                                scopes](https://developers.google.com/workspace/chat/authenticate-authorize#chat-api-scopes):
 *
 *                                - `https://www.googleapis.com/auth/chat.spaces.readonly`
 *                                - `https://www.googleapis.com/auth/chat.spaces`
 *
 *                                Using the `is_unread()` filter requires that the calling credentials
 *                                include one of the following [authorization
 *                                scopes](https://developers.google.com/workspace/chat/authenticate-authorize#chat-api-scopes):
 *
 *                                - `https://www.googleapis.com/auth/chat.users.readstate.readonly`
 *                                - `https://www.googleapis.com/auth/chat.users.readstate`
 *
 *
 *                                Across different fields, only `AND` operators are supported. A valid
 *                                example is `sender.name = "users/1234567890" AND is_unread()`. The word
 *                                `AND` is optional and is implied if omitted. For example, `sender.name =
 *                                "users/1234567890" is_unread()` is valid and is equivalent to the previous
 *                                example. An invalid example is `sender.name = "users/1234567890" OR
 *                                is_unread()` because `OR` is not supported between different fields.
 *
 *                                Among the same field:
 *
 *                                - `create_time` supports only `AND`, and can only be used to represent
 *                                an interval, such as `create_time >= "2022-01-01T00:00:00+00:00" AND
 *                                create_time < "2023-01-01T00:00:00+00:00"`.
 *                                - `sender.name` supports only the `OR` operator, for example:
 *                                `sender.name = "users/1234567890" OR sender.name = "users/0987654321"`.
 *                                - `space.name` supports only the `OR` operator, for example:
 *                                `space.name = "spaces/ABCDEFGH" OR space.name = "spaces/QWERTYUI"`.
 *                                - `space.display_name` supports the operators `AND` and `OR`, but not a
 *                                mix of both. For example:
 *                                `space.display_name:Project AND space.display_name:Tasks` returns
 *                                messages that are in spaces with display names containing both `Project`
 *                                and `Tasks`, whereas
 *                                `space.display_name:Project OR space.display_name:Tasks` returns messages
 *                                that are in spaces with display names containing either `Project` or
 *                                `Tasks` or both.
 *                                - `space.space_type` supports only the `OR` operator, for example:
 *                                `space.space_type = "DIRECT_MESSAGE" OR space.space_type = "GROUP_CHAT"`.
 *                                - `annotations.user_mentions.user.name` supports the operators `AND` and
 *                                `OR`, but not a mix of both. For example:
 *                                `annotations.user_mentions.user.name:"users/1234567890" AND
 *                                annotations.user_mentions.user.name:"users/0987654321"` returns only
 *                                messages that mentions both users, whereas
 *                                `annotations.user_mentions.user.name:"users/1234567890" OR
 *                                annotations.user_mentions.user.name:"users/0987654321"` returns messages
 *                                that mention either user or both.
 *
 *                                Parentheses are required to disambiguate operator precedence when combining
 *                                `AND` and `OR` operators in the same query. For example:
 *                                `(sender.name="users/me" OR sender.name="users/123456") AND is_unread()`.
 *                                Otherwise, parentheses are optional.
 *
 *                                The following example queries are valid:
 *
 *                                ```
 *                                "Pending reports" AND create_time >= "2023-01-01T00:00:00Z"
 *
 *                                sender.name = "users/example&#64;gmail.com"
 *
 *                                annotations.user_mentions.user.name:"users/0987654321"
 *
 *                                attachment:* AND space.name = "spaces/ABCDEFGH"
 *
 *                                tasks AND is_unread() AND sender.name = "users/1234567890"
 *
 *                                "things to do" "urgent"
 *
 *                                (sender.name = "users/1234567890")
 *                                AND (create_time < "2023-05-01T00:00:00Z")
 *
 *                                tasks AND space.name = "spaces/ABCDEFGH" AND has_link()
 *
 *                                "project one" is_unread()
 *
 *                                space.display_name:Project tasks
 *                                ```
 *
 *                                The maximum query length is 1,000 characters.
 *
 *                                Invalid queries are rejected by the server with an `INVALID_ARGUMENT`
 *                                error.
 */
function search_messages_sample(string $formattedParent, string $filter): void
{
    // Create a client.
    $chatServiceClient = new ChatServiceClient();

    // Prepare the request message.
    $request = (new SearchMessagesRequest())
        ->setParent($formattedParent)
        ->setFilter($filter);

    // Call the API and handle any network failures.
    try {
        /** @var PagedListResponse $response */
        $response = $chatServiceClient->searchMessages($request);

        /** @var SearchMessageResult $element */
        foreach ($response as $element) {
            printf('Element data: %s' . PHP_EOL, $element->serializeToJsonString());
        }
    } catch (ApiException $ex) {
        printf('Call failed with message: %s' . PHP_EOL, $ex->getMessage());
    }
}

/**
 * Helper to execute the sample.
 *
 * This sample has been automatically generated and should be regarded as a code
 * template only. It will require modifications to work:
 *  - It may require correct/in-range values for request initialization.
 *  - It may require specifying regional endpoints when creating the service client,
 *    please see the apiEndpoint client configuration option for more details.
 */
function callSample(): void
{
    $formattedParent = ChatServiceClient::spaceName('[SPACE]');
    $filter = '[FILTER]';

    search_messages_sample($formattedParent, $filter);
}

use Google\ApiCore\ApiException;
use Google\ApiCore\PagedListResponse;
use Google\Apps\Chat\V1\Client\ChatServiceClient;
use Google\Apps\Chat\V1\SearchSpacesRequest;
use Google\Apps\Chat\V1\Space;

/**
 * @param string $query A search query.
 *
 *                      You can search by using the following parameters when `useAdminAccess`
 *                      is set to `true`:
 *
 *                      - `create_time`
 *                      - `customer`
 *                      - `display_name`
 *                      - `external_user_allowed`
 *                      - `last_active_time`
 *                      - `space_history_state`
 *                      - `space_type`
 *
 *                      When `useAdminAccess` is set to `false`:
 *
 *                      - `display_name`
 *                      - `external_user_allowed`
 *                      - `space_type`
 *
 *                      `create_time` and `last_active_time` accept a timestamp in
 *                      [RFC-3339](https://www.rfc-editor.org/rfc/rfc3339) format and the supported
 *                      comparison operators are: `=`, `<`, `>`, `<=`, `>=`.
 *
 *                      `customer` is required when `useAdminAccess` is set to `true`, and is
 *                      used to indicate which customer to fetch spaces from.
 *                      `customers/my_customer` is the only supported value.
 *
 *                      `display_name` only accepts the `HAS` (`:`) operator. The text to
 *                      match is first tokenized into tokens and each token is prefix-matched
 *                      case-insensitively and independently as a substring anywhere in the space's
 *                      `display_name`. For example, `Fun Eve` matches `Fun event` or `The
 *                      evening was fun`, but not `notFun event` or `even`. When `useAdminAccess`
 *                      is set to `false`, `display_name` is required to retrieve meaningful
 *                      results. Otherwise, the default behavior is to return an empty response.
 *
 *                      `external_user_allowed` accepts either `true` or `false`.
 *
 *                      `space_history_state` only accepts values from the [`historyState`]
 *                      (https://developers.google.com/workspace/chat/api/reference/rest/v1/spaces#Space.HistoryState)
 *                      field of a `space` resource.
 *
 *                      `space_type` is required and the only valid value is `SPACE`.
 *
 *                      Across different fields, only `AND` operators are supported. A valid
 *                      example is `space_type = "SPACE" AND display_name:"Hello"` and an invalid
 *                      example is `space_type = "SPACE" OR display_name:"Hello"`.
 *
 *                      Among the same field,
 *                      `space_type` doesn't support `AND` or `OR` operators.
 *                      `display_name`, 'space_history_state', and 'external_user_allowed' only
 *                      support `OR` operators.
 *                      `last_active_time` and `create_time` support both `AND` and `OR` operators.
 *                      `AND` can only be used to represent an interval, such as `last_active_time
 *                      < "2022-01-01T00:00:00+00:00" AND last_active_time >
 *                      "2023-01-01T00:00:00+00:00"`.
 *
 *                      The following example queries are valid when `useAdminAccess` is set to
 *                      `true`:
 *
 *                      ```
 *                      customer = "customers/my_customer" AND space_type = "SPACE"
 *
 *                      customer = "customers/my_customer" AND space_type = "SPACE" AND
 *                      display_name:"Hello World"
 *
 *                      customer = "customers/my_customer" AND space_type = "SPACE" AND
 *                      (last_active_time < "2020-01-01T00:00:00+00:00" OR last_active_time >
 *                      "2022-01-01T00:00:00+00:00")
 *
 *                      customer = "customers/my_customer" AND space_type = "SPACE" AND
 *                      (display_name:"Hello World" OR display_name:"Fun event") AND
 *                      (last_active_time > "2020-01-01T00:00:00+00:00" AND last_active_time <
 *                      "2022-01-01T00:00:00+00:00")
 *
 *                      customer = "customers/my_customer" AND space_type = "SPACE" AND
 *                      (create_time > "2019-01-01T00:00:00+00:00" AND create_time <
 *                      "2020-01-01T00:00:00+00:00") AND (external_user_allowed = "true") AND
 *                      (space_history_state = "HISTORY_ON" OR space_history_state = "HISTORY_OFF")
 *                      ```
 *
 *                      The following example queries are valid when `useAdminAccess` is set to
 *                      `false`:
 *
 *                      ```
 *                      display_name:"Hello World" AND space_type = "SPACE"
 *
 *                      (display_name:"Hello" OR display_name:"Fun") AND space_type = "SPACE"
 *
 *                      (external_user_allowed = "true" AND space_type = "SPACE") // Returns an
 *                      empty response.
 *
 *                      (external_user_allowed = "true" AND display_name:"Hello" AND space_type =
 *                      "SPACE")
 *                      ```
 *
 *                      The maximum query length is 1,000 characters.
 *
 *                      Invalid queries are rejected by the server with an `INVALID_ARGUMENT`
 *                      error.
 */
function search_spaces_sample(string $query): void
{
    // Create a client.
    $chatServiceClient = new ChatServiceClient();

    // Prepare the request message.
    $request = (new SearchSpacesRequest())
        ->setQuery($query);

    // Call the API and handle any network failures.
    try {
        /** @var PagedListResponse $response */
        $response = $chatServiceClient->searchSpaces($request);

        /** @var Space $element */
        foreach ($response as $element) {
            printf('Element data: %s' . PHP_EOL, $element->serializeToJsonString());
        }
    } catch (ApiException $ex) {
        printf('Call failed with message: %s' . PHP_EOL, $ex->getMessage());
    }
}

/**
 * Helper to execute the sample.
 *
 * This sample has been automatically generated and should be regarded as a code
 * template only. It will require modifications to work:
 *  - It may require correct/in-range values for request initialization.
 *  - It may require specifying regional endpoints when creating the service client,
 *    please see the apiEndpoint client configuration option for more details.
 */
function callSample(): void
{
    $query = '[QUERY]';

    search_spaces_sample($query);
}

use Google\ApiCore\ApiException;
use Google\Apps\Chat\V1\Client\ChatServiceClient;
use Google\Apps\Chat\V1\SetUpSpaceRequest;
use Google\Apps\Chat\V1\Space;

/**
 * This sample has been automatically generated and should be regarded as a code
 * template only. It will require modifications to work:
 *  - It may require correct/in-range values for request initialization.
 *  - It may require specifying regional endpoints when creating the service client,
 *    please see the apiEndpoint client configuration option for more details.
 */
function set_up_space_sample(): void
{
    // Create a client.
    $chatServiceClient = new ChatServiceClient();

    // Prepare the request message.
    $space = new Space();
    $request = (new SetUpSpaceRequest())
        ->setSpace($space);

    // Call the API and handle any network failures.
    try {
        /** @var Space $response */
        $response = $chatServiceClient->setUpSpace($request);
        printf('Response data: %s' . PHP_EOL, $response->serializeToJsonString());
    } catch (ApiException $ex) {
        printf('Call failed with message: %s' . PHP_EOL, $ex->getMessage());
    }
}

use Google\ApiCore\ApiException;
use Google\Apps\Chat\V1\Availability;
use Google\Apps\Chat\V1\Client\ChatServiceClient;
use Google\Apps\Chat\V1\UpdateAvailabilityRequest;
use Google\Protobuf\FieldMask;

/**
 * This sample has been automatically generated and should be regarded as a code
 * template only. It will require modifications to work:
 *  - It may require correct/in-range values for request initialization.
 *  - It may require specifying regional endpoints when creating the service client,
 *    please see the apiEndpoint client configuration option for more details.
 */
function update_availability_sample(): void
{
    // Create a client.
    $chatServiceClient = new ChatServiceClient();

    // Prepare the request message.
    $availability = new Availability();
    $updateMask = new FieldMask();
    $request = (new UpdateAvailabilityRequest())
        ->setAvailability($availability)
        ->setUpdateMask($updateMask);

    // Call the API and handle any network failures.
    try {
        /** @var Availability $response */
        $response = $chatServiceClient->updateAvailability($request);
        printf('Response data: %s' . PHP_EOL, $response->serializeToJsonString());
    } catch (ApiException $ex) {
        printf('Call failed with message: %s' . PHP_EOL, $ex->getMessage());
    }
}

use Google\ApiCore\ApiException;
use Google\Apps\Chat\V1\Client\ChatServiceClient;
use Google\Apps\Chat\V1\Membership;
use Google\Apps\Chat\V1\UpdateMembershipRequest;
use Google\Protobuf\FieldMask;

/**
 * This sample has been automatically generated and should be regarded as a code
 * template only. It will require modifications to work:
 *  - It may require correct/in-range values for request initialization.
 *  - It may require specifying regional endpoints when creating the service client,
 *    please see the apiEndpoint client configuration option for more details.
 */
function update_membership_sample(): void
{
    // Create a client.
    $chatServiceClient = new ChatServiceClient();

    // Prepare the request message.
    $membership = new Membership();
    $updateMask = new FieldMask();
    $request = (new UpdateMembershipRequest())
        ->setMembership($membership)
        ->setUpdateMask($updateMask);

    // Call the API and handle any network failures.
    try {
        /** @var Membership $response */
        $response = $chatServiceClient->updateMembership($request);
        printf('Response data: %s' . PHP_EOL, $response->serializeToJsonString());
    } catch (ApiException $ex) {
        printf('Call failed with message: %s' . PHP_EOL, $ex->getMessage());
    }
}

use Google\ApiCore\ApiException;
use Google\Apps\Chat\V1\Client\ChatServiceClient;
use Google\Apps\Chat\V1\Message;
use Google\Apps\Chat\V1\UpdateMessageRequest;
use Google\Protobuf\FieldMask;

/**
 * This sample has been automatically generated and should be regarded as a code
 * template only. It will require modifications to work:
 *  - It may require correct/in-range values for request initialization.
 *  - It may require specifying regional endpoints when creating the service client,
 *    please see the apiEndpoint client configuration option for more details.
 */
function update_message_sample(): void
{
    // Create a client.
    $chatServiceClient = new ChatServiceClient();

    // Prepare the request message.
    $message = new Message();
    $updateMask = new FieldMask();
    $request = (new UpdateMessageRequest())
        ->setMessage($message)
        ->setUpdateMask($updateMask);

    // Call the API and handle any network failures.
    try {
        /** @var Message $response */
        $response = $chatServiceClient->updateMessage($request);
        printf('Response data: %s' . PHP_EOL, $response->serializeToJsonString());
    } catch (ApiException $ex) {
        printf('Call failed with message: %s' . PHP_EOL, $ex->getMessage());
    }
}

use Google\ApiCore\ApiException;
use Google\Apps\Chat\V1\Client\ChatServiceClient;
use Google\Apps\Chat\V1\Section;
use Google\Apps\Chat\V1\Section\SectionType;
use Google\Apps\Chat\V1\UpdateSectionRequest;
use Google\Protobuf\FieldMask;

/**
 * @param int $sectionType The type of the section.
 */
function update_section_sample(int $sectionType): void
{
    // Create a client.
    $chatServiceClient = new ChatServiceClient();

    // Prepare the request message.
    $section = (new Section())
        ->setType($sectionType);
    $updateMask = new FieldMask();
    $request = (new UpdateSectionRequest())
        ->setSection($section)
        ->setUpdateMask($updateMask);

    // Call the API and handle any network failures.
    try {
        /** @var Section $response */
        $response = $chatServiceClient->updateSection($request);
        printf('Response data: %s' . PHP_EOL, $response->serializeToJsonString());
    } catch (ApiException $ex) {
        printf('Call failed with message: %s' . PHP_EOL, $ex->getMessage());
    }
}

/**
 * Helper to execute the sample.
 *
 * This sample has been automatically generated and should be regarded as a code
 * template only. It will require modifications to work:
 *  - It may require correct/in-range values for request initialization.
 *  - It may require specifying regional endpoints when creating the service client,
 *    please see the apiEndpoint client configuration option for more details.
 */
function callSample(): void
{
    $sectionType = SectionType::SECTION_TYPE_UNSPECIFIED;

    update_section_sample($sectionType);
}

use Google\ApiCore\ApiException;
use Google\Apps\Chat\V1\Client\ChatServiceClient;
use Google\Apps\Chat\V1\Space;
use Google\Apps\Chat\V1\UpdateSpaceRequest;
use Google\Protobuf\FieldMask;

/**
 * This sample has been automatically generated and should be regarded as a code
 * template only. It will require modifications to work:
 *  - It may require correct/in-range values for request initialization.
 *  - It may require specifying regional endpoints when creating the service client,
 *    please see the apiEndpoint client configuration option for more details.
 */
function update_space_sample(): void
{
    // Create a client.
    $chatServiceClient = new ChatServiceClient();

    // Prepare the request message.
    $space = new Space();
    $updateMask = new FieldMask();
    $request = (new UpdateSpaceRequest())
        ->setSpace($space)
        ->setUpdateMask($updateMask);

    // Call the API and handle any network failures.
    try {
        /** @var Space $response */
        $response = $chatServiceClient->updateSpace($request);
        printf('Response data: %s' . PHP_EOL, $response->serializeToJsonString());
    } catch (ApiException $ex) {
        printf('Call failed with message: %s' . PHP_EOL, $ex->getMessage());
    }
}

use Google\ApiCore\ApiException;
use Google\Apps\Chat\V1\Client\ChatServiceClient;
use Google\Apps\Chat\V1\SpaceNotificationSetting;
use Google\Apps\Chat\V1\UpdateSpaceNotificationSettingRequest;
use Google\Protobuf\FieldMask;

/**
 * This sample has been automatically generated and should be regarded as a code
 * template only. It will require modifications to work:
 *  - It may require correct/in-range values for request initialization.
 *  - It may require specifying regional endpoints when creating the service client,
 *    please see the apiEndpoint client configuration option for more details.
 */
function update_space_notification_setting_sample(): void
{
    // Create a client.
    $chatServiceClient = new ChatServiceClient();

    // Prepare the request message.
    $spaceNotificationSetting = new SpaceNotificationSetting();
    $updateMask = new FieldMask();
    $request = (new UpdateSpaceNotificationSettingRequest())
        ->setSpaceNotificationSetting($spaceNotificationSetting)
        ->setUpdateMask($updateMask);

    // Call the API and handle any network failures.
    try {
        /** @var SpaceNotificationSetting $response */
        $response = $chatServiceClient->updateSpaceNotificationSetting($request);
        printf('Response data: %s' . PHP_EOL, $response->serializeToJsonString());
    } catch (ApiException $ex) {
        printf('Call failed with message: %s' . PHP_EOL, $ex->getMessage());
    }
}

use Google\ApiCore\ApiException;
use Google\Apps\Chat\V1\Client\ChatServiceClient;
use Google\Apps\Chat\V1\SpaceReadState;
use Google\Apps\Chat\V1\UpdateSpaceReadStateRequest;
use Google\Protobuf\FieldMask;

/**
 * This sample has been automatically generated and should be regarded as a code
 * template only. It will require modifications to work:
 *  - It may require correct/in-range values for request initialization.
 *  - It may require specifying regional endpoints when creating the service client,
 *    please see the apiEndpoint client configuration option for more details.
 */
function update_space_read_state_sample(): void
{
    // Create a client.
    $chatServiceClient = new ChatServiceClient();

    // Prepare the request message.
    $spaceReadState = new SpaceReadState();
    $updateMask = new FieldMask();
    $request = (new UpdateSpaceReadStateRequest())
        ->setSpaceReadState($spaceReadState)
        ->setUpdateMask($updateMask);

    // Call the API and handle any network failures.
    try {
        /** @var SpaceReadState $response */
        $response = $chatServiceClient->updateSpaceReadState($request);
        printf('Response data: %s' . PHP_EOL, $response->serializeToJsonString());
    } catch (ApiException $ex) {
        printf('Call failed with message: %s' . PHP_EOL, $ex->getMessage());
    }
}

use Google\ApiCore\ApiException;
use Google\Apps\Chat\V1\Client\ChatServiceClient;
use Google\Apps\Chat\V1\UploadAttachmentRequest;
use Google\Apps\Chat\V1\UploadAttachmentResponse;

/**
 * @param string $formattedParent Resource name of the Chat space in which the attachment is
 *                                uploaded. Format "spaces/{space}". Please see
 *                                {@see ChatServiceClient::spaceName()} for help formatting this field.
 * @param string $filename        The filename of the attachment, including the file extension.
 */
function upload_attachment_sample(string $formattedParent, string $filename): void
{
    // Create a client.
    $chatServiceClient = new ChatServiceClient();

    // Prepare the request message.
    $request = (new UploadAttachmentRequest())
        ->setParent($formattedParent)
        ->setFilename($filename);

    // Call the API and handle any network failures.
    try {
        /** @var UploadAttachmentResponse $response */
        $response = $chatServiceClient->uploadAttachment($request);
        printf('Response data: %s' . PHP_EOL, $response->serializeToJsonString());
    } catch (ApiException $ex) {
        printf('Call failed with message: %s' . PHP_EOL, $ex->getMessage());
    }
}

/**
 * Helper to execute the sample.
 *
 * This sample has been automatically generated and should be regarded as a code
 * template only. It will require modifications to work:
 *  - It may require correct/in-range values for request initialization.
 *  - It may require specifying regional endpoints when creating the service client,
 *    please see the apiEndpoint client configuration option for more details.
 */
function callSample(): void
{
    $formattedParent = ChatServiceClient::spaceName('[SPACE]');
    $filename = '[FILENAME]';

    upload_attachment_sample($formattedParent, $filename);
}