googleapis
Version:
Google APIs Client Library for Node.js
1,399 lines • 300 kB
TypeScript
/// <reference types="node" />
import { OAuth2Client, JWT, Compute, UserRefreshClient, BaseExternalAccountClient, GaxiosPromise, GoogleConfigurable, MethodOptions, StreamMethodOptions, GlobalOptions, GoogleAuth, BodyResponseCallback, APIRequestContext } from 'googleapis-common';
import { Readable } from 'stream';
export declare namespace androidpublisher_v3 {
export interface Options extends GlobalOptions {
version: 'v3';
}
interface StandardParameters {
/**
* Auth client or API Key for the request
*/
auth?: string | OAuth2Client | JWT | Compute | UserRefreshClient | BaseExternalAccountClient | GoogleAuth;
/**
* V1 error format.
*/
'$.xgafv'?: string;
/**
* OAuth access token.
*/
access_token?: string;
/**
* Data format for response.
*/
alt?: string;
/**
* JSONP
*/
callback?: string;
/**
* Selector specifying which fields to include in a partial response.
*/
fields?: string;
/**
* API key. Your API key identifies your project and provides you with API access, quota, and reports. Required unless you provide an OAuth 2.0 token.
*/
key?: string;
/**
* OAuth 2.0 token for the current user.
*/
oauth_token?: string;
/**
* Returns response with indentations and line breaks.
*/
prettyPrint?: boolean;
/**
* Available to use for quota purposes for server-side applications. Can be any arbitrary string assigned to a user, but should not exceed 40 characters.
*/
quotaUser?: string;
/**
* Legacy upload protocol for media (e.g. "media", "multipart").
*/
uploadType?: string;
/**
* Upload protocol for media (e.g. "raw", "multipart").
*/
upload_protocol?: string;
}
/**
* Google Play Android Developer API
*
* Lets Android application developers access their Google Play accounts. At a high level, the expected workflow is to "insert" an Edit, make changes as necessary, and then "commit" it.
*
* @example
* ```js
* const {google} = require('googleapis');
* const androidpublisher = google.androidpublisher('v3');
* ```
*/
export class Androidpublisher {
context: APIRequestContext;
applications: Resource$Applications;
edits: Resource$Edits;
externaltransactions: Resource$Externaltransactions;
generatedapks: Resource$Generatedapks;
grants: Resource$Grants;
inappproducts: Resource$Inappproducts;
internalappsharingartifacts: Resource$Internalappsharingartifacts;
monetization: Resource$Monetization;
orders: Resource$Orders;
purchases: Resource$Purchases;
reviews: Resource$Reviews;
systemapks: Resource$Systemapks;
users: Resource$Users;
constructor(options: GlobalOptions, google?: GoogleConfigurable);
}
/**
* Represents an Abi.
*/
export interface Schema$Abi {
/**
* Alias for an abi.
*/
alias?: string | null;
}
/**
* Targeting based on Abi.
*/
export interface Schema$AbiTargeting {
/**
* Targeting of other sibling directories that were in the Bundle. For main splits this is targeting of other main splits.
*/
alternatives?: Schema$Abi[];
/**
* Value of an abi.
*/
value?: Schema$Abi[];
}
/**
* Represents a targeting rule of the form: User never had {scope\} before.
*/
export interface Schema$AcquisitionTargetingRule {
/**
* Required. The scope of subscriptions this rule considers. Only allows "this subscription" and "any subscription in app".
*/
scope?: Schema$TargetingRuleScope;
}
/**
* Request message for ActivateBasePlan.
*/
export interface Schema$ActivateBasePlanRequest {
}
/**
* Request message for ActivateSubscriptionOffer.
*/
export interface Schema$ActivateSubscriptionOfferRequest {
}
/**
* Information about an APK. The resource for ApksService.
*/
export interface Schema$Apk {
/**
* Information about the binary payload of this APK.
*/
binary?: Schema$ApkBinary;
/**
* The version code of the APK, as specified in the manifest file.
*/
versionCode?: number | null;
}
/**
* Represents the binary payload of an APK.
*/
export interface Schema$ApkBinary {
/**
* A sha1 hash of the APK payload, encoded as a hex string and matching the output of the sha1sum command.
*/
sha1?: string | null;
/**
* A sha256 hash of the APK payload, encoded as a hex string and matching the output of the sha256sum command.
*/
sha256?: string | null;
}
/**
* Description of the created apks.
*/
export interface Schema$ApkDescription {
/**
* Set only for asset slices.
*/
assetSliceMetadata?: Schema$SplitApkMetadata;
/**
* Set only for Instant split APKs.
*/
instantApkMetadata?: Schema$SplitApkMetadata;
/**
* Path of the Apk, will be in the following format: .apk where DownloadId is the ID used to download the apk using GeneratedApks.Download API.
*/
path?: string | null;
/**
* Set only for Split APKs.
*/
splitApkMetadata?: Schema$SplitApkMetadata;
/**
* Set only for standalone APKs.
*/
standaloneApkMetadata?: Schema$StandaloneApkMetadata;
/**
* Apk-level targeting.
*/
targeting?: Schema$ApkTargeting;
}
/**
* Request to create a new externally hosted APK.
*/
export interface Schema$ApksAddExternallyHostedRequest {
/**
* The definition of the externally-hosted APK and where it is located.
*/
externallyHostedApk?: Schema$ExternallyHostedApk;
}
/**
* Response for creating a new externally hosted APK.
*/
export interface Schema$ApksAddExternallyHostedResponse {
/**
* The definition of the externally-hosted APK and where it is located.
*/
externallyHostedApk?: Schema$ExternallyHostedApk;
}
/**
* A set of apks representing a module.
*/
export interface Schema$ApkSet {
/**
* Description of the generated apks.
*/
apkDescription?: Schema$ApkDescription[];
/**
* Metadata about the module represented by this ApkSet
*/
moduleMetadata?: Schema$ModuleMetadata;
}
/**
* Response listing all APKs.
*/
export interface Schema$ApksListResponse {
/**
* All APKs.
*/
apks?: Schema$Apk[];
/**
* The kind of this response ("androidpublisher#apksListResponse").
*/
kind?: string | null;
}
/**
* Represents a set of apk-level targetings.
*/
export interface Schema$ApkTargeting {
/**
* The abi that the apk targets
*/
abiTargeting?: Schema$AbiTargeting;
/**
* The language that the apk targets
*/
languageTargeting?: Schema$LanguageTargeting;
/**
* Multi-api-level targeting.
*/
multiAbiTargeting?: Schema$MultiAbiTargeting;
/**
* The screen density that this apk supports.
*/
screenDensityTargeting?: Schema$ScreenDensityTargeting;
/**
* The sdk version that the apk targets
*/
sdkVersionTargeting?: Schema$SdkVersionTargeting;
/**
* Texture-compression-format-level targeting
*/
textureCompressionFormatTargeting?: Schema$TextureCompressionFormatTargeting;
}
/**
* The app details. The resource for DetailsService.
*/
export interface Schema$AppDetails {
/**
* The user-visible support email for this app.
*/
contactEmail?: string | null;
/**
* The user-visible support telephone number for this app.
*/
contactPhone?: string | null;
/**
* The user-visible website for this app.
*/
contactWebsite?: string | null;
/**
* Default language code, in BCP 47 format (eg "en-US").
*/
defaultLanguage?: string | null;
}
/**
* An app edit. The resource for EditsService.
*/
export interface Schema$AppEdit {
/**
* Output only. The time (as seconds since Epoch) at which the edit will expire and will be no longer valid for use.
*/
expiryTimeSeconds?: string | null;
/**
* Output only. Identifier of the edit. Can be used in subsequent API calls.
*/
id?: string | null;
}
/**
* Request message for ArchiveSubscription.
*/
export interface Schema$ArchiveSubscriptionRequest {
}
/**
* Metadata of an asset module.
*/
export interface Schema$AssetModuleMetadata {
/**
* Indicates the delivery type for persistent install.
*/
deliveryType?: string | null;
/**
* Module name.
*/
name?: string | null;
}
/**
* Set of asset slices belonging to a single asset module.
*/
export interface Schema$AssetSliceSet {
/**
* Asset slices.
*/
apkDescription?: Schema$ApkDescription[];
/**
* Module level metadata.
*/
assetModuleMetadata?: Schema$AssetModuleMetadata;
}
/**
* Represents a base plan that automatically renews at the end of its subscription period.
*/
export interface Schema$AutoRenewingBasePlanType {
/**
* Required. Subscription period, specified in ISO 8601 format. For a list of acceptable billing periods, refer to the help center.
*/
billingPeriodDuration?: string | null;
/**
* Grace period of the subscription, specified in ISO 8601 format. Acceptable values are P0D (zero days), P3D (3 days), P7D (7 days), P14D (14 days), and P30D (30 days). If not specified, a default value will be used based on the recurring period duration.
*/
gracePeriodDuration?: string | null;
/**
* Whether the renewing base plan is backward compatible. The backward compatible base plan is returned by the Google Play Billing Library deprecated method querySkuDetailsAsync(). Only one renewing base plan can be marked as legacy compatible for a given subscription.
*/
legacyCompatible?: boolean | null;
/**
* Subscription offer id which is legacy compatible. The backward compatible subscription offer is returned by the Google Play Billing Library deprecated method querySkuDetailsAsync(). Only one subscription offer can be marked as legacy compatible for a given renewing base plan. To have no Subscription offer as legacy compatible set this field as empty string.
*/
legacyCompatibleSubscriptionOfferId?: string | null;
/**
* The proration mode for the base plan determines what happens when a user switches to this plan from another base plan. If unspecified, defaults to CHARGE_ON_NEXT_BILLING_DATE.
*/
prorationMode?: string | null;
/**
* Whether users should be able to resubscribe to this base plan in Google Play surfaces. Defaults to RESUBSCRIBE_STATE_ACTIVE if not specified.
*/
resubscribeState?: string | null;
}
/**
* Information related to an auto renewing plan.
*/
export interface Schema$AutoRenewingPlan {
/**
* If the subscription is currently set to auto-renew, e.g. the user has not canceled the subscription
*/
autoRenewEnabled?: boolean | null;
/**
* The information of the last price change for the item since subscription signup.
*/
priceChangeDetails?: Schema$SubscriptionItemPriceChangeDetails;
}
/**
* A single base plan for a subscription.
*/
export interface Schema$BasePlan {
/**
* Set when the base plan automatically renews at a regular interval.
*/
autoRenewingBasePlanType?: Schema$AutoRenewingBasePlanType;
/**
* Required. Immutable. The unique identifier of this base plan. Must be unique within the subscription, and conform with RFC-1034. That is, this ID can only contain lower-case letters (a-z), numbers (0-9), and hyphens (-), and be at most 63 characters.
*/
basePlanId?: string | null;
/**
* List of up to 20 custom tags specified for this base plan, and returned to the app through the billing library. Subscription offers for this base plan will also receive these offer tags in the billing library.
*/
offerTags?: Schema$OfferTag[];
/**
* Pricing information for any new locations Play may launch in the future. If omitted, the BasePlan will not be automatically available any new locations Play may launch in the future.
*/
otherRegionsConfig?: Schema$OtherRegionsBasePlanConfig;
/**
* Set when the base plan does not automatically renew at the end of the billing period.
*/
prepaidBasePlanType?: Schema$PrepaidBasePlanType;
/**
* Region-specific information for this base plan.
*/
regionalConfigs?: Schema$RegionalBasePlanConfig[];
/**
* Output only. The state of the base plan, i.e. whether it's active. Draft and inactive base plans can be activated or deleted. Active base plans can be made inactive. Inactive base plans can be canceled. This field cannot be changed by updating the resource. Use the dedicated endpoints instead.
*/
state?: string | null;
}
/**
* Information about an app bundle. The resource for BundlesService.
*/
export interface Schema$Bundle {
/**
* A sha1 hash of the upload payload, encoded as a hex string and matching the output of the sha1sum command.
*/
sha1?: string | null;
/**
* A sha256 hash of the upload payload, encoded as a hex string and matching the output of the sha256sum command.
*/
sha256?: string | null;
/**
* The version code of the Android App Bundle, as specified in the Android App Bundle's base module APK manifest file.
*/
versionCode?: number | null;
}
/**
* Response listing all app bundles.
*/
export interface Schema$BundlesListResponse {
/**
* All app bundles.
*/
bundles?: Schema$Bundle[];
/**
* The kind of this response ("androidpublisher#bundlesListResponse").
*/
kind?: string | null;
}
/**
* Information specific to a subscription in canceled state.
*/
export interface Schema$CanceledStateContext {
/**
* Subscription was canceled by the developer.
*/
developerInitiatedCancellation?: Schema$DeveloperInitiatedCancellation;
/**
* Subscription was replaced by a new subscription.
*/
replacementCancellation?: Schema$ReplacementCancellation;
/**
* Subscription was canceled by the system, for example because of a billing problem.
*/
systemInitiatedCancellation?: Schema$SystemInitiatedCancellation;
/**
* Subscription was canceled by user.
*/
userInitiatedCancellation?: Schema$UserInitiatedCancellation;
}
/**
* Result of the cancel survey when the subscription was canceled by the user.
*/
export interface Schema$CancelSurveyResult {
/**
* The reason the user selected in the cancel survey.
*/
reason?: string | null;
/**
* Only set for CANCEL_SURVEY_REASON_OTHERS. This is the user's freeform response to the survey.
*/
reasonUserInput?: string | null;
}
/**
* An entry of conversation between user and developer.
*/
export interface Schema$Comment {
/**
* A comment from a developer.
*/
developerComment?: Schema$DeveloperComment;
/**
* A comment from a user.
*/
userComment?: Schema$UserComment;
}
/**
* Converted other regions prices.
*/
export interface Schema$ConvertedOtherRegionsPrice {
/**
* Price in EUR to use for the "Other regions" location exclusive of taxes.
*/
eurPrice?: Schema$Money;
/**
* Price in USD to use for the "Other regions" location exclusive of taxes.
*/
usdPrice?: Schema$Money;
}
/**
* A converted region price.
*/
export interface Schema$ConvertedRegionPrice {
/**
* The converted price tax inclusive.
*/
price?: Schema$Money;
/**
* The region code of the region.
*/
regionCode?: string | null;
/**
* The tax amount of the converted price.
*/
taxAmount?: Schema$Money;
}
/**
* Request message for ConvertRegionPrices.
*/
export interface Schema$ConvertRegionPricesRequest {
/**
* The intital price to convert other regions from. Tax exclusive.
*/
price?: Schema$Money;
}
/**
* Response message for ConvertRegionPrices.
*/
export interface Schema$ConvertRegionPricesResponse {
/**
* Converted other regions prices in USD and EUR, to use for countries where Play doesn't support a country's local currency.
*/
convertedOtherRegionsPrice?: Schema$ConvertedOtherRegionsPrice;
/**
* Map from region code to converted region price.
*/
convertedRegionPrices?: {
[key: string]: Schema$ConvertedRegionPrice;
} | null;
}
/**
* Country targeting specification.
*/
export interface Schema$CountryTargeting {
/**
* Countries to target, specified as two letter [CLDR codes](https://unicode.org/cldr/charts/latest/supplemental/territory_containment_un_m_49.html).
*/
countries?: string[] | null;
/**
* Include "rest of world" as well as explicitly targeted countries.
*/
includeRestOfWorld?: boolean | null;
}
/**
* Request message for DeactivateBasePlan.
*/
export interface Schema$DeactivateBasePlanRequest {
}
/**
* Request message for DeactivateSubscriptionOffer.
*/
export interface Schema$DeactivateSubscriptionOfferRequest {
}
/**
* Information related to deferred item replacement.
*/
export interface Schema$DeferredItemReplacement {
/**
* The product_id going to replace the existing product_id.
*/
productId?: string | null;
}
/**
* Represents a deobfuscation file.
*/
export interface Schema$DeobfuscationFile {
/**
* The type of the deobfuscation file.
*/
symbolType?: string | null;
}
/**
* Responses for the upload.
*/
export interface Schema$DeobfuscationFilesUploadResponse {
/**
* The uploaded Deobfuscation File configuration.
*/
deobfuscationFile?: Schema$DeobfuscationFile;
}
/**
* Developer entry from conversation between user and developer.
*/
export interface Schema$DeveloperComment {
/**
* The last time at which this comment was updated.
*/
lastModified?: Schema$Timestamp;
/**
* The content of the comment, i.e. reply body.
*/
text?: string | null;
}
/**
* Information specific to cancellations initiated by developers.
*/
export interface Schema$DeveloperInitiatedCancellation {
}
/**
* Represents a device feature.
*/
export interface Schema$DeviceFeature {
/**
* Name of the feature.
*/
featureName?: string | null;
/**
* The feature version specified by android:glEsVersion or android:version in in the AndroidManifest.
*/
featureVersion?: number | null;
}
/**
* Targeting for a device feature.
*/
export interface Schema$DeviceFeatureTargeting {
/**
* Feature of the device.
*/
requiredFeature?: Schema$DeviceFeature;
}
/**
* A group of devices. A group is defined by a set of device selectors. A device belongs to the group if it matches any selector (logical OR).
*/
export interface Schema$DeviceGroup {
/**
* Device selectors for this group. A device matching any of the selectors is included in this group.
*/
deviceSelectors?: Schema$DeviceSelector[];
/**
* The name of the group.
*/
name?: string | null;
}
/**
* Identifier of a device.
*/
export interface Schema$DeviceId {
/**
* Value of Build.BRAND.
*/
buildBrand?: string | null;
/**
* Value of Build.DEVICE.
*/
buildDevice?: string | null;
}
/**
* Characteristics of the user's device.
*/
export interface Schema$DeviceMetadata {
/**
* Device CPU make, e.g. "Qualcomm"
*/
cpuMake?: string | null;
/**
* Device CPU model, e.g. "MSM8974"
*/
cpuModel?: string | null;
/**
* Device class (e.g. tablet)
*/
deviceClass?: string | null;
/**
* OpenGL version
*/
glEsVersion?: number | null;
/**
* Device manufacturer (e.g. Motorola)
*/
manufacturer?: string | null;
/**
* Comma separated list of native platforms (e.g. "arm", "arm7")
*/
nativePlatform?: string | null;
/**
* Device model name (e.g. Droid)
*/
productName?: string | null;
/**
* Device RAM in Megabytes, e.g. "2048"
*/
ramMb?: number | null;
/**
* Screen density in DPI
*/
screenDensityDpi?: number | null;
/**
* Screen height in pixels
*/
screenHeightPx?: number | null;
/**
* Screen width in pixels
*/
screenWidthPx?: number | null;
}
/**
* Conditions about a device's RAM capabilities.
*/
export interface Schema$DeviceRam {
/**
* Maximum RAM in bytes (bound excluded).
*/
maxBytes?: string | null;
/**
* Minimum RAM in bytes (bound included).
*/
minBytes?: string | null;
}
/**
* Selector for a device group. A selector consists of a set of conditions on the device that should all match (logical AND) to determine a device group eligibility. For instance, if a selector specifies RAM conditions, device model inclusion and device model exclusion, a device is considered to match if: device matches RAM conditions AND device matches one of the included device models AND device doesn't match excluded device models
*/
export interface Schema$DeviceSelector {
/**
* Conditions on the device's RAM.
*/
deviceRam?: Schema$DeviceRam;
/**
* Device models excluded by this selector, even if they match all other conditions.
*/
excludedDeviceIds?: Schema$DeviceId[];
/**
* A device that has any of these system features is excluded by this selector, even if it matches all other conditions.
*/
forbiddenSystemFeatures?: Schema$SystemFeature[];
/**
* Device models included by this selector.
*/
includedDeviceIds?: Schema$DeviceId[];
/**
* A device needs to have all these system features to be included by the selector.
*/
requiredSystemFeatures?: Schema$SystemFeature[];
}
/**
* The device spec used to generate a system APK.
*/
export interface Schema$DeviceSpec {
/**
* Screen dpi.
*/
screenDensity?: number | null;
/**
* Supported ABI architectures in the order of preference. The values should be the string as reported by the platform, e.g. "armeabi-v7a", "x86_64".
*/
supportedAbis?: string[] | null;
/**
* All installed locales represented as BCP-47 strings, e.g. "en-US".
*/
supportedLocales?: string[] | null;
}
/**
* A single device tier. Devices matching any of the device groups in device_group_names are considered to match the tier.
*/
export interface Schema$DeviceTier {
/**
* Groups of devices included in this tier. These groups must be defined explicitly under device_groups in this configuration.
*/
deviceGroupNames?: string[] | null;
/**
* The priority level of the tier. Tiers are evaluated in descending order of level: the highest level tier has the highest priority. The highest tier matching a given device is selected for that device. You should use a contiguous range of levels for your tiers in a tier set; tier levels in a tier set must be unique. For instance, if your tier set has 4 tiers (including the global fallback), you should define tiers 1, 2 and 3 in this configuration. Note: tier 0 is implicitly defined as a global fallback and selected for devices that don't match any of the tiers explicitly defined here. You mustn't define level 0 explicitly in this configuration.
*/
level?: number | null;
}
/**
* Configuration describing device targeting criteria for the content of an app.
*/
export interface Schema$DeviceTierConfig {
/**
* Definition of device groups for the app.
*/
deviceGroups?: Schema$DeviceGroup[];
/**
* Output only. The device tier config ID.
*/
deviceTierConfigId?: string | null;
/**
* Definition of the set of device tiers for the app.
*/
deviceTierSet?: Schema$DeviceTierSet;
/**
* Definition of user country sets for the app.
*/
userCountrySets?: Schema$UserCountrySet[];
}
/**
* A set of device tiers. A tier set determines what variation of app content gets served to a specific device, for device-targeted content. You should assign a priority level to each tier, which determines the ordering by which they are evaluated by Play. See the documentation of DeviceTier.level for more details.
*/
export interface Schema$DeviceTierSet {
/**
* Device tiers belonging to the set.
*/
deviceTiers?: Schema$DeviceTier[];
}
/**
* An expansion file. The resource for ExpansionFilesService.
*/
export interface Schema$ExpansionFile {
/**
* If set, this field indicates that this APK has an expansion file uploaded to it: this APK does not reference another APK's expansion file. The field's value is the size of the uploaded expansion file in bytes.
*/
fileSize?: string | null;
/**
* If set, this APK's expansion file references another APK's expansion file. The file_size field will not be set.
*/
referencesVersion?: number | null;
}
/**
* Response for uploading an expansion file.
*/
export interface Schema$ExpansionFilesUploadResponse {
/**
* The uploaded expansion file configuration.
*/
expansionFile?: Schema$ExpansionFile;
}
/**
* User account identifier in the third-party service.
*/
export interface Schema$ExternalAccountIdentifiers {
/**
* User account identifier in the third-party service. Only present if account linking happened as part of the subscription purchase flow.
*/
externalAccountId?: string | null;
/**
* An obfuscated version of the id that is uniquely associated with the user's account in your app. Present for the following purchases: * If account linking happened as part of the subscription purchase flow. * It was specified using https://developer.android.com/reference/com/android/billingclient/api/BillingFlowParams.Builder#setobfuscatedaccountid when the purchase was made.
*/
obfuscatedExternalAccountId?: string | null;
/**
* An obfuscated version of the id that is uniquely associated with the user's profile in your app. Only present if specified using https://developer.android.com/reference/com/android/billingclient/api/BillingFlowParams.Builder#setobfuscatedprofileid when the purchase was made.
*/
obfuscatedExternalProfileId?: string | null;
}
/**
* Defines an APK available for this application that is hosted externally and not uploaded to Google Play. This function is only available to organizations using Managed Play whose application is configured to restrict distribution to the organizations.
*/
export interface Schema$ExternallyHostedApk {
/**
* The application label.
*/
applicationLabel?: string | null;
/**
* A certificate (or array of certificates if a certificate-chain is used) used to sign this APK, represented as a base64 encoded byte array.
*/
certificateBase64s?: string[] | null;
/**
* The URL at which the APK is hosted. This must be an https URL.
*/
externallyHostedUrl?: string | null;
/**
* The sha1 checksum of this APK, represented as a base64 encoded byte array.
*/
fileSha1Base64?: string | null;
/**
* The sha256 checksum of this APK, represented as a base64 encoded byte array.
*/
fileSha256Base64?: string | null;
/**
* The file size in bytes of this APK.
*/
fileSize?: string | null;
/**
* The icon image from the APK, as a base64 encoded byte array.
*/
iconBase64?: string | null;
/**
* The maximum SDK supported by this APK (optional).
*/
maximumSdk?: number | null;
/**
* The minimum SDK targeted by this APK.
*/
minimumSdk?: number | null;
/**
* The native code environments supported by this APK (optional).
*/
nativeCodes?: string[] | null;
/**
* The package name.
*/
packageName?: string | null;
/**
* The features required by this APK (optional).
*/
usesFeatures?: string[] | null;
/**
* The permissions requested by this APK.
*/
usesPermissions?: Schema$UsesPermission[];
/**
* The version code of this APK.
*/
versionCode?: number | null;
/**
* The version name of this APK.
*/
versionName?: string | null;
}
/**
* Details of an external subscription.
*/
export interface Schema$ExternalSubscription {
/**
* Required. The type of the external subscription.
*/
subscriptionType?: string | null;
}
/**
* The details of an external transaction.
*/
export interface Schema$ExternalTransaction {
/**
* Output only. The time when this transaction was created. This is the time when Google was notified of the transaction.
*/
createTime?: string | null;
/**
* Output only. The current transaction amount before tax. This represents the current pre-tax amount including any refunds that may have been applied to this transaction.
*/
currentPreTaxAmount?: Schema$Price;
/**
* Output only. The current tax amount. This represents the current tax amount including any refunds that may have been applied to this transaction.
*/
currentTaxAmount?: Schema$Price;
/**
* Output only. The id of this transaction. All transaction ids under the same package name must be unique. Set when creating the external transaction.
*/
externalTransactionId?: string | null;
/**
* This is a one-time transaction and not part of a subscription.
*/
oneTimeTransaction?: Schema$OneTimeExternalTransaction;
/**
* Required. The original transaction amount before taxes. This represents the pre-tax amount originally notified to Google before any refunds were applied.
*/
originalPreTaxAmount?: Schema$Price;
/**
* Required. The original tax amount. This represents the tax amount originally notified to Google before any refunds were applied.
*/
originalTaxAmount?: Schema$Price;
/**
* Output only. The resource name of the external transaction. The package name of the application the inapp products were sold (for example, 'com.some.app').
*/
packageName?: string | null;
/**
* This transaction is part of a recurring series of transactions.
*/
recurringTransaction?: Schema$RecurringExternalTransaction;
/**
* Output only. If set, this transaction was a test purchase. Google will not charge for a test transaction.
*/
testPurchase?: Schema$ExternalTransactionTestPurchase;
/**
* Output only. The current state of the transaction.
*/
transactionState?: string | null;
/**
* Required. The time when the transaction was completed.
*/
transactionTime?: string | null;
/**
* Required. User address for tax computation.
*/
userTaxAddress?: Schema$ExternalTransactionAddress;
}
/**
* User's address for the external transaction.
*/
export interface Schema$ExternalTransactionAddress {
/**
* Required. Two letter region code based on ISO-3166-1 Alpha-2 (UN region codes).
*/
regionCode?: string | null;
}
/**
* Represents a transaction performed using a test account. These transactions will not be charged by Google.
*/
export interface Schema$ExternalTransactionTestPurchase {
}
/**
* A full refund of the remaining amount of a transaction.
*/
export interface Schema$FullRefund {
}
/**
* Response to list generated APKs.
*/
export interface Schema$GeneratedApksListResponse {
/**
* All generated APKs, grouped by the APK signing key.
*/
generatedApks?: Schema$GeneratedApksPerSigningKey[];
}
/**
* Download metadata for split, standalone and universal APKs, as well as asset pack slices, signed with a given key.
*/
export interface Schema$GeneratedApksPerSigningKey {
/**
* SHA256 hash of the APK signing public key certificate.
*/
certificateSha256Hash?: string | null;
/**
* List of asset pack slices which will be served for this app bundle, signed with a key corresponding to certificate_sha256_hash.
*/
generatedAssetPackSlices?: Schema$GeneratedAssetPackSlice[];
/**
* List of generated split APKs, signed with a key corresponding to certificate_sha256_hash.
*/
generatedSplitApks?: Schema$GeneratedSplitApk[];
/**
* List of generated standalone APKs, signed with a key corresponding to certificate_sha256_hash.
*/
generatedStandaloneApks?: Schema$GeneratedStandaloneApk[];
/**
* Generated universal APK, signed with a key corresponding to certificate_sha256_hash. This field is not set if no universal APK was generated for this signing key.
*/
generatedUniversalApk?: Schema$GeneratedUniversalApk;
/**
* Contains targeting information about the generated apks.
*/
targetingInfo?: Schema$TargetingInfo;
}
/**
* Download metadata for an asset pack slice.
*/
export interface Schema$GeneratedAssetPackSlice {
/**
* Download ID, which uniquely identifies the APK to download. Should be supplied to `generatedapks.download` method.
*/
downloadId?: string | null;
/**
* Name of the module that this asset slice belongs to.
*/
moduleName?: string | null;
/**
* Asset slice ID.
*/
sliceId?: string | null;
/**
* Asset module version.
*/
version?: string | null;
}
/**
* Download metadata for a split APK.
*/
export interface Schema$GeneratedSplitApk {
/**
* Download ID, which uniquely identifies the APK to download. Should be supplied to `generatedapks.download` method.
*/
downloadId?: string | null;
/**
* Name of the module that this APK belongs to.
*/
moduleName?: string | null;
/**
* Split ID. Empty for the main split of the base module.
*/
splitId?: string | null;
/**
* ID of the generated variant.
*/
variantId?: number | null;
}
/**
* Download metadata for a standalone APK.
*/
export interface Schema$GeneratedStandaloneApk {
/**
* Download ID, which uniquely identifies the APK to download. Should be supplied to `generatedapks.download` method.
*/
downloadId?: string | null;
/**
* ID of the generated variant.
*/
variantId?: number | null;
}
/**
* Download metadata for a universal APK.
*/
export interface Schema$GeneratedUniversalApk {
/**
* Download ID, which uniquely identifies the APK to download. Should be supplied to `generatedapks.download` method.
*/
downloadId?: string | null;
}
/**
* An access grant resource.
*/
export interface Schema$Grant {
/**
* The permissions granted to the user for this app.
*/
appLevelPermissions?: string[] | null;
/**
* Required. Resource name for this grant, following the pattern "developers/{developer\}/users/{email\}/grants/{package_name\}". If this grant is for a draft app, the app ID will be used in this resource name instead of the package name.
*/
name?: string | null;
/**
* Immutable. The package name of the app. This will be empty for draft apps.
*/
packageName?: string | null;
}
/**
* An uploaded image. The resource for ImagesService.
*/
export interface Schema$Image {
/**
* A unique id representing this image.
*/
id?: string | null;
/**
* A sha1 hash of the image.
*/
sha1?: string | null;
/**
* A sha256 hash of the image.
*/
sha256?: string | null;
/**
* A URL that will serve a preview of the image.
*/
url?: string | null;
}
/**
* Response for deleting all images.
*/
export interface Schema$ImagesDeleteAllResponse {
/**
* The deleted images.
*/
deleted?: Schema$Image[];
}
/**
* Response listing all images.
*/
export interface Schema$ImagesListResponse {
/**
* All listed Images.
*/
images?: Schema$Image[];
}
/**
* Response for uploading an image.
*/
export interface Schema$ImagesUploadResponse {
/**
* The uploaded image.
*/
image?: Schema$Image;
}
/**
* An in-app product. The resource for InappproductsService.
*/
export interface Schema$InAppProduct {
/**
* Default language of the localized data, as defined by BCP-47. e.g. "en-US".
*/
defaultLanguage?: string | null;
/**
* Default price. Cannot be zero, as in-app products are never free. Always in the developer's Checkout merchant currency.
*/
defaultPrice?: Schema$Price;
/**
* Grace period of the subscription, specified in ISO 8601 format. Allows developers to give their subscribers a grace period when the payment for the new recurrence period is declined. Acceptable values are P0D (zero days), P3D (three days), P7D (seven days), P14D (14 days), and P30D (30 days).
*/
gracePeriod?: string | null;
/**
* List of localized title and description data. Map key is the language of the localized data, as defined by BCP-47, e.g. "en-US".
*/
listings?: {
[key: string]: Schema$InAppProductListing;
} | null;
/**
* Details about taxes and legal compliance. Only applicable to managed products.
*/
managedProductTaxesAndComplianceSettings?: Schema$ManagedProductTaxAndComplianceSettings;
/**
* Package name of the parent app.
*/
packageName?: string | null;
/**
* Prices per buyer region. None of these can be zero, as in-app products are never free. Map key is region code, as defined by ISO 3166-2.
*/
prices?: {
[key: string]: Schema$Price;
} | null;
/**
* The type of the product, e.g. a recurring subscription.
*/
purchaseType?: string | null;
/**
* Stock-keeping-unit (SKU) of the product, unique within an app.
*/
sku?: string | null;
/**
* The status of the product, e.g. whether it's active.
*/
status?: string | null;
/**
* Subscription period, specified in ISO 8601 format. Acceptable values are P1W (one week), P1M (one month), P3M (three months), P6M (six months), and P1Y (one year).
*/
subscriptionPeriod?: string | null;
/**
* Details about taxes and legal compliance. Only applicable to subscription products.
*/
subscriptionTaxesAndComplianceSettings?: Schema$SubscriptionTaxAndComplianceSettings;
/**
* Trial period, specified in ISO 8601 format. Acceptable values are anything between P7D (seven days) and P999D (999 days).
*/
trialPeriod?: string | null;
}
/**
* Store listing of a single in-app product.
*/
export interface Schema$InAppProductListing {
/**
* Localized entitlement benefits for a subscription.
*/
benefits?: string[] | null;
/**
* Description for the store listing.
*/
description?: string | null;
/**
* Title for the store listing.
*/
title?: string | null;
}
/**
* Response listing all in-app products.
*/
export interface Schema$InappproductsListResponse {
/**
* All in-app products.
*/
inappproduct?: Schema$InAppProduct[];
/**
* The kind of this response ("androidpublisher#inappproductsListResponse").
*/
kind?: string | null;
/**
* Deprecated and unset.
*/
pageInfo?: Schema$PageInfo;
/**
* Pagination token, to handle a number of products that is over one page.
*/
tokenPagination?: Schema$TokenPagination;
}
/**
* An artifact resource which gets created when uploading an APK or Android App Bundle through internal app sharing.
*/
export interface Schema$InternalAppSharingArtifact {
/**
* The sha256 fingerprint of the certificate used to sign the generated artifact.
*/
certificateFingerprint?: string | null;
/**
* The download URL generated for the uploaded artifact. Users that are authorized to download can follow the link to the Play Store app to install it.
*/
downloadUrl?: string | null;
/**
* The sha256 hash of the artifact represented as a lowercase hexadecimal number, matching the output of the sha256sum command.
*/
sha256?: string | null;
}
/**
* Contains the introductory price information for a subscription.
*/
export interface Schema$IntroductoryPriceInfo {
/**
* Introductory price of the subscription, not including tax. The currency is the same as price_currency_code. Price is expressed in micro-units, where 1,000,000 micro-units represents one unit of the currency. For example, if the subscription price is €1.99, price_amount_micros is 1990000.
*/
introductoryPriceAmountMicros?: string | null;
/**
* ISO 4217 currency code for the introductory subscription price. For example, if the price is specified in British pounds sterling, price_currency_code is "GBP".
*/
introductoryPriceCurrencyCode?: string | null;
/**
* The number of billing period to offer introductory pricing.
*/
introductoryPriceCycles?: number | null;
/**
* Introductory price period, specified in ISO 8601 format. Common values are (but not limited to) "P1W" (one week), "P1M" (one month), "P3M" (three months), "P6M" (six months), and "P1Y" (one year).
*/
introductoryPricePeriod?: string | null;
}
/**
* Targeting based on language.
*/
export interface Schema$LanguageTargeting {
/**
* Alternative languages.
*/
alternatives?: string[] | null;
/**
* ISO-639: 2 or 3 letter language code.
*/
value?: string[] | null;
}
/**
* Response listing existing device tier configs.
*/
export interface Schema$ListDeviceTierConfigsResponse {
/**
* Device tier configs created by the developer.
*/
deviceTierConfigs?: Schema$DeviceTierConfig[];
/**
* A token, which can be sent as `page_token` to retrieve the next page. If this field is omitted, there are no subsequent pages.
*/
nextPageToken?: string | null;
}
/**
* A localized store listing. The resource for ListingsService.
*/
export interface Schema$Listing {
/**
* Full description of the app.
*/
fullDescription?: string | null;
/**
* Language localization code (a BCP-47 language tag; for example, "de-AT" for Austrian German).
*/
language?: string | null;
/**
* Short description of the app.
*/
shortDescription?: string | null;
/**
* Localized title of the app.
*/
title?: string | null;
/**
* URL of a promotional YouTube video for the app.
*/
video?: string | null;
}
/**
* Response listing all localized listings.
*/
export interface Schema$ListingsListResponse {
/**
* The kind of this response ("androidpublisher#listingsListResponse").
*/
kind?: string | null;
/**
* All localized listings.
*/
listings?: Schema$Listing[];
}
/**
* Response message for ListSubscriptionOffers.
*/
export interface Schema$ListSubscriptionOffersResponse {
/**
* A token, which can be sent as `page_token` to retrieve the next page. If this field is omitted, there are no subsequent pages.
*/
nextPageToken?: string | null;
/**
* The subscription offers from the specified subscription.
*/
subscriptionOffers?: Schema$SubscriptionOffer[];
}
/**
* Response message for ListSubscriptions.
*/
export interface Schema$ListSubscriptionsResponse {
/**
* A token, which can be sent as `page_token` to retrieve the next page. If this field is omitted, there are no subsequent pages.
*/
nextPageToken?: string | null;
/**
* The subscriptions from the specified app.
*/
subscriptions?: Schema$Subscription[];
}
/**
* A response containing one or more users with access to an account.
*/
export interface Schema$ListUsersResponse {
/**
* A token to pass to subsequent calls in order to retrieve subsequent results. This will not be set if there are no more results to return.
*/
nextPageToken?: string | null;
/**
* The resulting users.
*/
users?: Schema$User[];
}
/**
* Localized text in given language.
*/
export interface Schema$LocalizedText {
/**
* Language localization code (a BCP-47 language tag; for example, "de-AT" for Austrian German).
*/
language?: string | null;
/**
* The text in the given language.
*/
text?: string | null;
}
/**
* De