@efffrida/gplayapi 0.0.1

package/src/index.ts

@@ -0,0 +1,11 @@
+/**
+ * @since 1.0.0
+ */
+
+/**
+ * Unofficial Google Play Store API for downloading APKs directly from Google
+ * Play Store.
+ *
+ * @since 1.0.0
+ */
+export * as GooglePlayApi from "./GooglePlayApi.ts"

package/src/internal/auth.ts

@@ -0,0 +1,220 @@
+import type * as HttpClientError from "@effect/platform/HttpClientError";
+import type * as ParseResult from "effect/ParseResult";
+
+import * as HttpClient from "@effect/platform/HttpClient";
+import * as HttpClientRequest from "@effect/platform/HttpClientRequest";
+import * as HttpClientResponse from "@effect/platform/HttpClientResponse";
+import * as Effect from "effect/Effect";
+import * as Function from "effect/Function";
+import * as Layer from "effect/Layer";
+import * as Schema from "effect/Schema";
+
+import {
+    AndroidCheckinRequestSchema,
+    AndroidCheckinResponseSchema,
+    UploadDeviceConfigRequestSchema,
+} from "../generated/GooglePlay_pb.js";
+import { type Device } from "./device.js";
+import { decodeResponse, decodeResponseFromResponseWrapper, encodeRequest } from "./http.js";
+
+/** @internal */
+export const makeHttpClient: (
+    device: Device
+) => Layer.Layer<
+    HttpClient.HttpClient,
+    HttpClientError.HttpClientError | ParseResult.ParseError,
+    HttpClient.HttpClient
+> = Effect.fnUntraced(function* (device: Device) {
+    //  curl \
+    //      --request GET \
+    //      --header "Accept: application/json" \
+    //      --header "User-Agent: com.aurora.store-4.7.5-71" \
+    //      "https://auroraoss.com/api/auth"
+    const account = yield* Function.pipe(
+        HttpClientRequest.get("https://auroraoss.com/api/auth"),
+        HttpClientRequest.setHeader("User-Agent", "com.aurora.store-4.7.5-71"),
+        HttpClientRequest.acceptJson,
+        HttpClient.execute,
+        Effect.flatMap(HttpClientResponse.filterStatusOk),
+        Effect.flatMap(
+            HttpClientResponse.schemaBodyJson(
+                Schema.Struct({
+                    email: Schema.String,
+                    auth: Schema.String,
+                })
+            )
+        )
+    );
+
+    const checkinResponse = yield* Function.pipe(
+        HttpClientRequest.post("https://android.clients.google.com/checkin"),
+        HttpClientRequest.setHeaders({
+            "User-Agent": device.userAgent,
+            app: "com.google.android.gms",
+            Host: "android.clients.google.com",
+        }),
+        encodeRequest(AndroidCheckinRequestSchema, {
+            id: 0n,
+            version: 3,
+            fragment: 0,
+            locale: "en",
+            timeZone: device.TimeZone,
+            checkin: {
+                userNumber: 0,
+                lastCheckinMsec: 0n,
+                roaming: device.Roaming,
+                cellOperator: device.CellOperator,
+                simOperator: device.SimOperator ?? "",
+                build: {
+                    id: device["Build.FINGERPRINT"],
+                    product: device["Build.HARDWARE"],
+                    carrier: device["Build.BRAND"],
+                    radio: device["Build.RADIO"],
+                    bootloader: device["Build.BOOTLOADER"],
+                    device: device["Build.DEVICE"],
+                    sdkVersion: device["Build.VERSION.SDK_INT"],
+                    model: device["Build.MODEL"],
+                    manufacturer: device["Build.MANUFACTURER"],
+                    buildProduct: device["Build.PRODUCT"],
+                    client: device["Client"],
+                    timestamp: BigInt(Date.now()),
+                    googleServices: device["GSF.version"],
+                },
+            },
+            deviceConfiguration: {
+                touchScreen: device["TouchScreen"],
+                keyboard: device["Keyboard"],
+                navigation: device["Navigation"],
+                screenLayout: device["ScreenLayout"],
+                hasHardKeyboard: device["HasHardKeyboard"],
+                hasFiveWayNavigation: device["HasFiveWayNavigation"],
+                glEsVersion: device["GL.Version"],
+                glExtension: device["GL.Extensions"] as Array<string>,
+                systemSharedLibrary: device["SharedLibraries"] as Array<string>,
+                systemAvailableFeature: device["Features"] as Array<string>,
+                nativePlatform: device["Platforms"] as Array<string>,
+                screenDensity: device["Screen.Density"],
+                screenWidth: device["Screen.Width"],
+                screenHeight: device["Screen.Height"],
+                systemSupportedLocale: device["Locales"] as Array<string>,
+                deviceClass: 0,
+                deviceFeature: device["Features"].map((val) => ({ name: val, value: 0 })),
+            },
+        }),
+        Effect.flatMap(HttpClient.execute),
+        Effect.flatMap(HttpClientResponse.filterStatusOk),
+        Effect.flatMap(decodeResponse(AndroidCheckinResponseSchema))
+    );
+
+    const uploadDeviceConfigResponse = yield* Function.pipe(
+        HttpClientRequest.post("https://android.clients.google.com/fdfe/uploadDeviceConfig"),
+        HttpClientRequest.setHeaders({
+            "X-DFE-Encoded-Targets": "",
+            "User-Agent": device.userAgent,
+            "X-DFE-Cookie": "",
+            "X-DFE-Content-Filters": "",
+            "X-DFE-Device-Checkin-Consistency-Token": checkinResponse.deviceCheckinConsistencyToken,
+            "X-DFE-Device-Config-Token": "",
+            "X-DFE-MCCMNC": "21601",
+            "X-DFE-Client-Id": "am-android-google",
+            "X-DFE-UserLanguages": "en",
+            "X-DFE-Phenotype": "",
+            "X-DFE-Device-Id": checkinResponse.androidId.toString(16),
+            "X-DFE-Network-Type": "4",
+            "Accept-Language": "en",
+            "X-DFE-Request-Params": "timeoutMs=4000",
+            "X-DFE-Enabled-Experiments": "cl:billing.select_add_instrument_by_default",
+            "X-DFE-Unsupported-Experiments":
+                "nocache:billing.use_charging_poller,market_emails,buyer_currency,prod_baseline,checkin.set_asset_paid_app_field,shekel_test,content_ratings,buyer_currency_in_app,nocache:encrypted_apk,recent_changes",
+            Host: "android.clients.google.com",
+        }),
+        encodeRequest(UploadDeviceConfigRequestSchema, {
+            deviceConfiguration: {
+                touchScreen: Number(device["TouchScreen"]),
+                keyboard: Number(device["Keyboard"]),
+                navigation: Number(device["Navigation"]),
+                screenLayout: Number(device["ScreenLayout"]),
+                hasHardKeyboard: Boolean(device["HasHardKeyboard"]),
+                hasFiveWayNavigation: Boolean(device["HasFiveWayNavigation"]),
+                glEsVersion: Number(device["GL.Version"]),
+                glExtension: device["GL.Extensions"] as Array<string>,
+                systemSharedLibrary: device["SharedLibraries"] as Array<string>,
+                systemAvailableFeature: device["Features"] as Array<string>,
+                nativePlatform: device["Platforms"] as Array<string>,
+                screenDensity: Number(device["Screen.Density"]),
+                screenWidth: Number(device["Screen.Width"]),
+                screenHeight: Number(device["Screen.Height"]),
+                systemSupportedLocale: device["Locales"] as Array<string>,
+                deviceClass: 0,
+                deviceFeature: device["Features"].map((val) => ({ name: val, value: 0 })),
+            },
+        }),
+        Effect.flatMap(HttpClient.execute),
+        Effect.flatMap(HttpClientResponse.filterStatusOk),
+        Effect.flatMap(decodeResponseFromResponseWrapper("uploadDeviceConfigResponse"))
+    );
+
+    // const authResponse = yield* Function.pipe(
+    //     HttpClientRequest.post("https://android.clients.google.com/auth"),
+    //     HttpClientRequest.setHeaders({
+    //         app: "com.google.android.gms",
+    //         device: checkinResponse.androidId.toString(16),
+    //         "User-Agent": `GoogleAuth/1.4 (${device["Build.DEVICE"]} ${device["Build.ID"]})`,
+    //     }),
+    //     HttpClientRequest.setUrlParams({
+    //         app: "com.android.vending",
+    //         oauth2_foreground: "1",
+    //         Email: account.email,
+    //         token_request_options: "CAA4AVAB",
+    //         client_sig: "38918a453d07199354f8b19af05ec6562ced5788",
+    //         Token: account.auth,
+    //         google_play_services_version: `${device["GSF.version"]}`,
+    //         check_email: "1",
+    //         system_partition: "1",
+    //         sdk_version: `${device["Build.VERSION.SDK_INT"]}`,
+    //         callerPkg: "com.google.android.gms",
+    //         device_country: "IN",
+    //         lang: "en",
+    //         androidId: checkinResponse.androidId.toString(16),
+    //         callerSig: "38918a453d07199354f8b19af05ec6562ced5788",
+    //         service: "oauth2:https://www.googleapis.com/auth/googleplay",
+    //     }),
+    //     HttpClient.execute,
+    //     Effect.flatMap(HttpClientResponse.filterStatusOk),
+    //     Effect.flatMap((response) => response.text)
+    // );
+
+    return Layer.function(
+        HttpClient.HttpClient,
+        HttpClient.HttpClient,
+        Function.flow(
+            HttpClient.filterStatusOk,
+            HttpClient.mapRequest(
+                HttpClientRequest.updateUrl((url) =>
+                    url.startsWith("/fdfe/") ? `https://android.clients.google.com${url}` : url
+                )
+            ),
+            HttpClient.mapRequest(
+                HttpClientRequest.setHeaders({
+                    Authorization: "Bearer " + account.auth,
+                    "User-Agent": device.userAgent,
+                    "X-DFE-Device-Id": checkinResponse.androidId.toString(16),
+                    "Accept-Language": "en",
+                    "X-DFE-Encoded-Targets":
+                        "CAESN/qigQYC2AMBFfUbyA7SM5Ij/CvfBoIDgxHqGP8R3xzIBvoQtBKFDZ4HAY4FrwSVMasHBO0O2Q8akgYRAQECAQO7AQEpKZ0CnwECAwRrAQYBr9PPAoK7sQMBAQMCBAkIDAgBAwEDBAICBAUZEgMEBAMLAQEBBQEBAcYBARYED+cBfS8CHQEKkAEMMxcBIQoUDwYHIjd3DQ4MFk0JWGYZEREYAQOLAYEBFDMIEYMBAgICAgICOxkCD18LGQKEAcgDBIQBAgGLARkYCy8oBTJlBCUocxQn0QUBDkkGxgNZQq0BZSbeAmIDgAEBOgGtAaMCDAOQAZ4BBIEBKUtQUYYBQscDDxPSARA1oAEHAWmnAsMB2wFyywGLAxol+wImlwOOA80CtwN26A0WjwJVbQEJPAH+BRDeAfkHK/ABASEBCSAaHQemAzkaRiu2Ad8BdXeiAwEBGBUBBN4LEIABK4gB2AFLfwECAdoENq0CkQGMBsIBiQEtiwGgA1zyAUQ4uwS8AwhsvgPyAcEDF27vApsBHaICGhl3GSKxAR8MC6cBAgItmQYG9QIeywLvAeYBDArLAh8HASI4ELICDVmVBgsY/gHWARtcAsMBpALiAdsBA7QBpAJmIArpByn0AyAKBwHTARIHAX8D+AMBcRIBBbEDmwUBMacCHAciNp0BAQF0OgQLJDuSAh54kwFSP0eeAQQ4M5EBQgMEmwFXywFo0gFyWwMcapQBBugBPUW2AVgBKmy3AR6PAbMBGQxrUJECvQR+8gFoWDsYgQNwRSczBRXQAgtRswEW0ALMAREYAUEBIG6yATYCRE8OxgER8gMBvQEDRkwLc8MBTwHZAUOnAXiiBakDIbYBNNcCIUmuArIBSakBrgFHKs0EgwV/G3AD0wE6LgECtQJ4xQFwFbUCjQPkBS6vAQqEAUZF3QIM9wEhCoYCQhXsBCyZArQDugIziALWAdIBlQHwBdUErQE6qQaSA4EEIvYBHir9AQVLmgMCApsCKAwHuwgrENsBAjNYswEVmgIt7QJnN4wDEnta+wGfAcUBxgEtEFXQAQWdAUAeBcwBAQM7rAEJATJ0LENrdh73A6UBhAE+qwEeASxLZUMhDREuH0CGARbd7K0GlQo",
+                    "X-DFE-Phenotype":
+                        "H4sIAAAAAAAAAB3OO3KjMAAA0KRNuWXukBkBQkAJ2MhgAZb5u2GCwQZbCH_EJ77QHmgvtDtbv-Z9_H63zXXU0NVPB1odlyGy7751Q3CitlPDvFd8lxhz3tpNmz7P92CFw73zdHU2Ie0Ad2kmR8lxhiErTFLt3RPGfJQHSDy7Clw10bg8kqf2owLokN4SecJTLoSwBnzQSd652_MOf2d1vKBNVedzg4ciPoLz2mQ8efGAgYeLou-l-PXn_7Sna1MfhHuySxt-4esulEDp8Sbq54CPPKjpANW-lkU2IZ0F92LBI-ukCKSptqeq1eXU96LD9nZfhKHdtjSWwJqUm_2r6pMHOxk01saVanmNopjX3YxQafC4iC6T55aRbC8nTI98AF_kItIQAJb5EQxnKTO7TZDWnr01HVPxelb9A2OWX6poidMWl16K54kcu_jhXw-JSBQkVcD_fPsLSZu6joIBAAA",
+                    "X-DFE-Client-Id": "am-android-google",
+                    "X-DFE-Network-Type": "4",
+                    "X-DFE-Content-Filters": "",
+                    "X-Limit-Ad-Tracking-Enabled": "false",
+                    "X-Ad-Id": "",
+                    "X-DFE-UserLanguages": "en",
+                    "X-DFE-Request-Params": "timeoutMs=4000",
+                    "X-DFE-Device-Checkin-Consistency-Token": checkinResponse.deviceCheckinConsistencyToken,
+                    "X-DFE-Device-Config-Token": uploadDeviceConfigResponse.uploadDeviceConfigToken,
+                })
+            )
+        )
+    );
+}, Layer.unwrapEffect);

package/src/internal/device.ts

@@ -0,0 +1,96 @@
+import type * as PlatformError from "@effect/platform/Error";
+import type * as ParseResult from "effect/ParseResult";
+
+import * as FileSystem from "@effect/platform/FileSystem";
+import * as Effect from "effect/Effect";
+import * as Schema from "effect/Schema";
+import * as PropertiesFile from "properties-file";
+
+/** @internal */
+export class Device extends Schema.Class<Device>("Device")({
+    UserReadableName: Schema.String,
+    "Build.BOOTLOADER": Schema.String,
+    "Build.BRAND": Schema.String,
+    "Build.DEVICE": Schema.String,
+    "Build.FINGERPRINT": Schema.String,
+    "Build.HARDWARE": Schema.String,
+    "Build.ID": Schema.String,
+    "Build.MANUFACTURER": Schema.String,
+    "Build.MODEL": Schema.String,
+    "Build.PRODUCT": Schema.String,
+    "Build.RADIO": Schema.String,
+    "Build.VERSION.RELEASE": Schema.String,
+    "Build.VERSION.SDK_INT": Schema.NumberFromString,
+    CellOperator: Schema.String,
+    Client: Schema.String,
+    Features: Schema.transform(Schema.String, Schema.Array(Schema.String), {
+        encode: (features) => features.join(","),
+        decode: (str) => str.split(","),
+    }),
+    "GL.Extensions": Schema.transform(Schema.String, Schema.Array(Schema.String), {
+        encode: (extensions) => extensions.join(","),
+        decode: (str) => str.split(","),
+    }),
+    "GL.Version": Schema.NumberFromString,
+    "GSF.version": Schema.NumberFromString,
+    HasFiveWayNavigation: Schema.BooleanFromString,
+    HasHardKeyboard: Schema.BooleanFromString,
+    Keyboard: Schema.NumberFromString,
+    Locales: Schema.transform(Schema.String, Schema.Array(Schema.String), {
+        encode: (locales) => locales.join(","),
+        decode: (str) => str.split(","),
+    }),
+    Navigation: Schema.NumberFromString,
+    Platforms: Schema.transform(Schema.String, Schema.Array(Schema.String), {
+        encode: (libs) => libs.join(","),
+        decode: (str) => str.split(","),
+    }),
+    Roaming: Schema.String,
+    "Screen.Density": Schema.NumberFromString,
+    "Screen.Height": Schema.NumberFromString,
+    "Screen.Width": Schema.NumberFromString,
+    ScreenLayout: Schema.NumberFromString,
+    SharedLibraries: Schema.transform(Schema.String, Schema.Array(Schema.String), {
+        encode: (libs) => libs.join(","),
+        decode: (str) => str.split(","),
+    }),
+    SimCountry: Schema.String.pipe(Schema.optional),
+    SimOperator: Schema.String.pipe(Schema.optional),
+    TimeZone: Schema.String,
+    TouchScreen: Schema.NumberFromString,
+    "Vending.version": Schema.NumberFromString,
+    "Vending.versionString": Schema.String,
+}) {
+    public static fromPropertiesFile = (
+        path: string
+    ): Effect.Effect<Device, PlatformError.PlatformError | ParseResult.ParseError, FileSystem.FileSystem> =>
+        Effect.gen(function* () {
+            const fileSystem = yield* FileSystem.FileSystem;
+            const content = yield* fileSystem.readFileString(path);
+            const properties = PropertiesFile.getProperties(content);
+            const device = yield* Schema.decodeUnknown(Device)(properties);
+            return device;
+        });
+
+    public get userAgent(): string {
+        const deviceProperties = {
+            api: 3,
+            versionCode: this["Vending.version"],
+            sdk: this["Build.VERSION.SDK_INT"],
+            device: this["Build.DEVICE"],
+            hardware: this["Build.HARDWARE"],
+            product: this["Build.PRODUCT"],
+            platformVersionRelease: this["Build.VERSION.RELEASE"],
+            model: this["Build.MODEL"],
+            buildId: this["Build.ID"],
+            isWideScreen: 0,
+            supportedAbis: this["Platforms"].join(";"),
+        };
+
+        const devicePropertiesString = Object.entries(deviceProperties)
+            .map(([k, v]) => `${k}=${v}`)
+            .join(",");
+
+        return `Android-Finsky/${this["Vending.versionString"]} (${devicePropertiesString})`;
+    }
+}

package/src/internal/http.ts

@@ -0,0 +1,194 @@
+import * as Protobuf from "@bufbuild/protobuf";
+import * as HttpClientError from "@effect/platform/HttpClientError";
+import * as HttpClientRequest from "@effect/platform/HttpClientRequest";
+import * as HttpClientResponse from "@effect/platform/HttpClientResponse";
+import * as Effect from "effect/Effect";
+import * as Function from "effect/Function";
+import * as Predicate from "effect/Predicate";
+
+import { type PayloadSchema, ResponseWrapperSchema } from "../generated/GooglePlay_pb.js";
+
+/** @internal */
+export const encodeRequest = Function.dual<
+    // Data-last signature
+    <Description extends Protobuf.DescMessage>(
+        description: Description,
+        body: Protobuf.MessageInitShape<Description>,
+        options?: Partial<Protobuf.BinaryWriteOptions> | undefined
+    ) => (
+        request: HttpClientRequest.HttpClientRequest
+    ) => Effect.Effect<HttpClientRequest.HttpClientRequest, HttpClientError.HttpClientError, never>,
+    // Data-first signature
+    <Description extends Protobuf.DescMessage>(
+        request: HttpClientRequest.HttpClientRequest,
+        description: Description,
+        body: Protobuf.MessageInitShape<Description>,
+        options?: Partial<Protobuf.BinaryWriteOptions> | undefined
+    ) => Effect.Effect<HttpClientRequest.HttpClientRequest, HttpClientError.HttpClientError, never>
+>(
+    // Data first if the first argument is an http request
+    (arguments_) => Predicate.hasProperty(arguments_[0], HttpClientRequest.TypeId),
+
+    // Body implementation
+    Effect.fn("encodeRequest")(function* <Description extends Protobuf.DescMessage>(
+        request: HttpClientRequest.HttpClientRequest,
+        description: Description,
+        body: Protobuf.MessageInitShape<Description>,
+        options?: Partial<Protobuf.BinaryWriteOptions> | undefined
+    ) {
+        const messageType = description.name;
+        yield* Effect.annotateCurrentSpan("messageType", messageType);
+
+        const bytes = yield* Effect.try({
+            try: () =>
+                Protobuf.toBinary(
+                    description,
+                    Protobuf.create(description, body),
+                    options ?? { writeUnknownFields: true }
+                ),
+            catch: (cause) =>
+                new HttpClientError.RequestError({
+                    cause,
+                    request,
+                    reason: "Encode",
+                    description: `Could not encode message of type ${messageType}`,
+                }),
+        });
+
+        const applyBody = HttpClientRequest.bodyUint8Array(bytes, "application/x-protobuf");
+        return applyBody(request);
+    })
+);
+
+/** @internal */
+export const decodeResponse = Function.dual<
+    // Data-last signature
+    <Desc extends Protobuf.DescMessage>(
+        protobufDescription: Desc,
+        options?: Partial<Protobuf.BinaryReadOptions> | undefined
+    ) => (
+        response: HttpClientResponse.HttpClientResponse
+    ) => Effect.Effect<Exclude<Protobuf.MessageShape<Desc>, undefined>, HttpClientError.HttpClientError, never>,
+    // Data-first signature
+    <Desc extends Protobuf.DescMessage>(
+        response: HttpClientResponse.HttpClientResponse,
+        protobufDescription: Desc,
+        options?: Partial<Protobuf.BinaryReadOptions> | undefined
+    ) => Effect.Effect<Exclude<Protobuf.MessageShape<Desc>, undefined>, HttpClientError.HttpClientError, never>
+>(
+    // Data first if the first argument is an http response
+    (arguments_) => Predicate.hasProperty(arguments_[0], HttpClientResponse.TypeId),
+
+    // Body implementation
+    Effect.fn("decodeResponse")(function* <Desc extends Protobuf.DescMessage>(
+        response: HttpClientResponse.HttpClientResponse,
+        protobufDescription: Desc,
+        options?: Partial<Protobuf.BinaryReadOptions> | undefined
+    ) {
+        const messageType = protobufDescription.name;
+        yield* Effect.annotateCurrentSpan("messageType", messageType);
+        const arrayBuffer = yield* response.arrayBuffer;
+
+        const message = yield* Effect.try({
+            try: () =>
+                Protobuf.fromBinary(
+                    protobufDescription,
+                    new Uint8Array(arrayBuffer),
+                    options ?? { readUnknownFields: true }
+                ),
+            catch: (cause) =>
+                new HttpClientError.ResponseError({
+                    cause,
+                    response,
+                    reason: "Decode",
+                    request: response.request,
+                    description: `Could not decode message of type ${messageType}`,
+                }),
+        });
+
+        if (Predicate.isUndefined(message)) {
+            return yield* new HttpClientError.ResponseError({
+                response,
+                reason: "Decode",
+                request: response.request,
+                description: `Message of type ${messageType} is missing`,
+            });
+        }
+
+        return message as Exclude<Protobuf.MessageShape<Desc>, undefined>;
+    })
+);
+
+/** @internal */
+export const decodeResponseFromResponseWrapper = Function.dual<
+    // Data-last signature
+    <
+        ExtractPayload extends Exclude<
+            keyof Protobuf.MessageShape<typeof PayloadSchema>,
+            keyof Protobuf.Message<"Payload">
+        >,
+    >(
+        extractPayload: ExtractPayload,
+        options?: Partial<Protobuf.BinaryReadOptions> | undefined
+    ) => (
+        response: HttpClientResponse.HttpClientResponse
+    ) => Effect.Effect<
+        Exclude<Protobuf.MessageShape<typeof PayloadSchema>[ExtractPayload], undefined>,
+        HttpClientError.HttpClientError,
+        never
+    >,
+    // Data-first signature
+    <
+        ExtractPayload extends Exclude<
+            keyof Protobuf.MessageShape<typeof PayloadSchema>,
+            keyof Protobuf.Message<"Payload">
+        >,
+    >(
+        response: HttpClientResponse.HttpClientResponse,
+        extractPayload: ExtractPayload,
+        options?: Partial<Protobuf.BinaryReadOptions> | undefined
+    ) => Effect.Effect<
+        Exclude<Protobuf.MessageShape<typeof PayloadSchema>[ExtractPayload], undefined>,
+        HttpClientError.HttpClientError,
+        never
+    >
+>(
+    // Data first if the first argument is an http response
+    (arguments_) => Predicate.hasProperty(arguments_[0], HttpClientResponse.TypeId),
+
+    // Body implementation
+    Effect.fn("decodeResponse")(function* <
+        ExtractPayload extends Exclude<
+            keyof Protobuf.MessageShape<typeof PayloadSchema>,
+            keyof Protobuf.Message<"Payload">
+        >,
+    >(
+        response: HttpClientResponse.HttpClientResponse,
+        extractPayload: ExtractPayload,
+        options?: Partial<Protobuf.BinaryReadOptions> | undefined
+    ) {
+        type Out = Exclude<Protobuf.MessageShape<typeof PayloadSchema>[ExtractPayload], undefined>;
+        const responseWrapper = yield* decodeResponse(response, ResponseWrapperSchema, options);
+
+        if (Predicate.isNotUndefined(responseWrapper.commands?.displayErrorMessage)) {
+            return yield* new HttpClientError.ResponseError({
+                response,
+                reason: "Decode",
+                request: response.request,
+                description: responseWrapper.commands.displayErrorMessage,
+            });
+        }
+
+        const extracted = responseWrapper.payload?.[extractPayload];
+        if (Predicate.isUndefined(extracted)) {
+            return yield* new HttpClientError.ResponseError({
+                response,
+                reason: "Decode",
+                request: response.request,
+                description: `ResponseWrapper has no payload of type ${extractPayload}`,
+            });
+        }
+
+        return extracted as Out;
+    })
+);