object := gcs.client.Bucket(gcs.Bucket).Object(gcs.getDest(key)).ReadCompressed(true)

	r, err = object.NewRangeReader(ctx, opts.startOffset, opts.length)
	if err != nil {
		return nil, gcsToObjectError(err, gcs.Bucket, key)
	}
	return r, nil
}

func (gcs *warmBackendGCS) Remove(ctx context.Context, key string, rv remoteVersionID) error {
	err := gcs.client.Bucket(gcs.Bucket).Object(gcs.getDest(key)).Delete(ctx)

        // GCS URLs
        assertTrue(protocolHelper.isValidFileProtocol("gcs://bucket/"));
        assertTrue(protocolHelper.isValidFileProtocol("gcs://my-bucket/path"));
        assertTrue(protocolHelper.isValidFileProtocol("gcs://bucket.with.dots/path"));
        assertTrue(protocolHelper.isValidFileProtocol("gcs://bucket-with-dashes/path"));

        // Various GCS bucket and path formats
        assertEquals("gcs://bucket/", wizardAction.convertCrawlingPath("gcs://bucket/"));
        assertEquals("gcs://my-bucket/", wizardAction.convertCrawlingPath("gcs://my-bucket/"));
        assertEquals("gcs://bucket.with.dots/path", wizardAction.convertCrawlingPath("gcs://bucket.with.dots/path"));

        assertTrue(goAction.isFileSystemPath("gcs://bucket/path/to/file.txt"));
        assertTrue(goAction.isFileSystemPath("gcs://my-bucket/folder/document.pdf"));
        assertTrue(goAction.isFileSystemPath("gcs://bucket/"));
        assertTrue(goAction.isFileSystemPath("gcs://my-bucket-name/deep/nested/path/file.txt"));
        assertTrue(goAction.isFileSystemPath("gcs://bucket_with_underscores/file"));
    }

    @Test

     * @return true if the URL uses a file path protocol (smb, smb1, file, ftp, s3, gcs)
     */
    public boolean isFilePathProtocol(final String url) {
        return url.startsWith("smb:") || url.startsWith("smb1:") || url.startsWith("file:") || url.startsWith("ftp:")
                || url.startsWith("s3:") || url.startsWith("gcs:");
    }

    /**

- **Storage**: In-memory (default), OpenSearch (optional)
- **Cloud**: AWS SDK v2 (S3), Google Cloud Storage

### Protocols

HTTP/HTTPS, File, FTP/FTPS, SMB/CIFS (SMB1/SMB2+), Storage (MinIO via `storage://`), S3 (`s3://`), GCS (`gcs://`)

### Content Formats

Office (Word, Excel, PowerPoint), PDF, Archives (ZIP, TAR, GZ, LHA), HTML, XML, JSON, Markdown, Media metadata, Images (EXIF/IPTC/XMP), Email (EML)

---

## Architecture

        }

        isInit = true;
        if (logger.isInfoEnabled()) {
            logger.info("GCS client initialized successfully: projectId={}, endpoint={}", projectId,
                    endpoint != null ? endpoint : "default");
        }
    }

    /**
     * Processes a GCS request with timeout management.

    private final Storage storage;
    private final String bucket;

    /**
     * Creates a new GcsStorageClient instance.
     *
     * @param projectId the GCS project ID
     * @param bucket the bucket name
     * @param endpoint the custom endpoint URL (optional, for fake-gcs-server etc.)
     * @param credentialsPath the path to the credentials JSON file (optional)
     */

            return StorageType.S3;
        }

        final String lowerEndpoint = endpoint.toLowerCase(Locale.ROOT);

        // GCS patterns
        if (lowerEndpoint.contains("storage.googleapis.com") || lowerEndpoint.contains(".storage.cloud.google.com")) {
            return StorageType.GCS;
        }

        // S3 patterns

    public void test_ordinal() {
        assertEquals(0, StorageType.S3.ordinal());
        assertEquals(1, StorageType.GCS.ordinal());
        assertEquals(2, StorageType.S3_COMPAT.ordinal());
    }

    public void test_name() {
        assertEquals("S3", StorageType.S3.name());
        assertEquals("GCS", StorageType.GCS.name());
        assertEquals("S3_COMPAT", StorageType.S3_COMPAT.name());
    }