@pushwoosh/rpc-v2-http-api-data 0.2.64 → 0.2.66

package/emails_configurations.d.ts

@@ -8,13 +8,21 @@ export type EmailsConfigurationsService_UpsertCustomTrackingDomain = RpcMethod<U
 export type EmailsConfigurationsService_DeleteCustomTrackingDomain = RpcMethod<DeleteCustomTrackingDomainRequest, DeleteCustomTrackingDomainResponse>;
 export type EmailsConfigurationsService_VerifyCustomTrackingDomain = RpcMethod<VerifyCustomTrackingDomainRequest, VerifyCustomTrackingDomainResponse>;
 export interface EmailsConfigurationsService {
+    /** Lists the sender email domains configured for an application's account (format XXXXX-XXXXX) with their DKIM/SPF/DMARC statuses and the DNS CNAME records to add. Use to show email sender-domain setup; covers both Amazon SES and SMTP-service domains. */
     GetDomains: EmailsConfigurationsService_GetDomains;
+    /** Refreshes DKIM/SPF/DMARC verification statuses for the account's sender email domains by re-querying Amazon SES and the SMTP service, then persisting the new statuses. Use to poll whether just-added DNS records have propagated; safe to call repeatedly. */
     UpdateDomainStatuses: EmailsConfigurationsService_UpdateDomainStatuses;
+    /** Registers a new sender email domain for the account and requests Amazon SES DKIM verification (poll list_email_domains for the CNAME records to publish). Fails if the domain already exists or the account's verifying-domains limit is reached. */
     AddDomain: EmailsConfigurationsService_AddDomain;
+    /** Removes a sender email domain from the account and deletes its SMTP credentials, clearing the application's From/reply properties if it was the default. Fails if the domain is still used as another application's sender domain. */
     DeleteDomain: EmailsConfigurationsService_DeleteDomain;
+    /** Returns the custom email link-tracking domain configured for an application (format XXXXX-XXXXX), or empty if none is set. Use to display the current tracking CNAME before editing it. */
     GetCustomTrackingDomain: EmailsConfigurationsService_GetCustomTrackingDomain;
+    /** Sets (creates or overwrites) the custom email link-tracking domain for an application. Use to point email click-tracking links at a customer-branded CNAME; run validate_custom_tracking_domain first to confirm the DNS record. */
     UpsertCustomTrackingDomain: EmailsConfigurationsService_UpsertCustomTrackingDomain;
+    /** Removes the custom email link-tracking domain from an application, reverting click-tracking links to the default Pushwoosh domain. No-op if none is set. */
     DeleteCustomTrackingDomain: EmailsConfigurationsService_DeleteCustomTrackingDomain;
+    /** Checks via a live DNS CNAME lookup whether the given custom tracking domain points at api.pushwoosh.com, returning verified true/false without saving anything. Use before update_custom_tracking_domain to confirm the customer published the CNAME. */
     VerifyCustomTrackingDomain: EmailsConfigurationsService_VerifyCustomTrackingDomain;
 }
 export type Domain_CName = {
@@ -31,43 +39,54 @@ export type Domain = {
     cnames: Domain_CName[];
 };
 export type AddDomainRequest = {
+    /** Sender email domain to register (e.g. mail.example.com). */
     name?: string;
+    /** Application code (format XXXXX-XXXXX). */
     application?: string;
 };
 export type AddDomainResponse = {};
 export type GetDomainsRequest = {
+    /** Application code (format XXXXX-XXXXX). */
     application?: string;
 };
 export type GetDomainsResponse = {
     emailDomains: Domain[];
 };
 export type UpdateDomainStatusesRequest = {
+    /** Application code (format XXXXX-XXXXX). */
     application?: string;
 };
 export type UpdateDomainStatusesResponse = {};
 export type DeleteDomainRequest = {
+    /** Application code (format XXXXX-XXXXX). */
     application?: string;
+    /** Sender email domain to remove. */
     domain?: string;
 };
 export type DeleteDomainResponse = {};
 export type GetCustomTrackingDomainRequest = {
-    /** application code */
+    /** Application code (format XXXXX-XXXXX). */
     application?: string;
 };
 export type GetCustomTrackingDomainResponse = {
     customTrackingDomain: string;
 };
 export type UpsertCustomTrackingDomainRequest = {
+    /** Custom tracking domain (a CNAME that must point at api.pushwoosh.com). */
     customTrackingDomain?: string;
+    /** Application code (format XXXXX-XXXXX). */
     application?: string;
 };
 export type UpsertCustomTrackingDomainResponse = {};
 export type DeleteCustomTrackingDomainRequest = {
+    /** Application code (format XXXXX-XXXXX). */
     application?: string;
 };
 export type DeleteCustomTrackingDomainResponse = {};
 export type VerifyCustomTrackingDomainRequest = {
+    /** Custom tracking domain (a CNAME that must point at api.pushwoosh.com). */
     customTrackingDomain?: string;
+    /** Application code (format XXXXX-XXXXX). */
     application?: string;
 };
 export type VerifyCustomTrackingDomainResponse = {

package/events.d.ts

@@ -9,18 +9,29 @@ export type EventsService_GetTriggeredCount = RpcMethod<GetTriggeredCountRequest
 export type EventsService_GetDetailedStatistics = RpcMethod<GetDetailedStatisticsRequest, GetDetailedStatisticsResponse>;
 export type EventsService_GetTotalStatistics = RpcMethod<GetTotalStatisticsRequest, GetTotalStatisticsResponse>;
 export interface EventsService {
+    /** Returns one custom event by name for an application, including its attributes, store-days and revenue mapping. Use after list_events to inspect a single event's definition. */
     Get: EventsService_Get;
+    /** Lists an application's custom events (ordered by name or creation) with paging and an optional revenue-only filter. Use to browse events or find an event name before get_event or the statistics calls. */
     List: EventsService_List;
+    /** Creates a new custom event in an application with its attributes and optional revenue mapping. Fails if an event with the same name already exists; use update_event to change an existing one. */
     Create: EventsService_Create;
+    /** Overwrites a custom event's description, attribute set and revenue mapping (the name is immutable). Fully replaces the attribute list, so resend every attribute you want to keep. */
     Update: EventsService_Update;
+    /** Deletes a custom event and its attributes from an application. Fails if the event is still referenced by a filter/segment or in-app trigger; not undoable. */
     Delete: EventsService_Delete;
+    /** Returns distinct recorded values of one attribute of a custom event, with paging and a value search. Use to populate attribute-value pickers when building event-based filters. */
     GetAttributeValues: EventsService_GetAttributeValues;
+    /** Returns all-time total and unique triggered counts for the named custom events in an application. Use for a quick per-event volume check; for a time series use get_event_detailed_statistics. */
     GetTriggeredCount: EventsService_GetTriggeredCount;
+    /** Returns a triggered-count time series for one custom event over a date range bucketed by interval, with optional attribute conditions. Use to chart how often an event fired over time. */
     GetDetailedStatistics: EventsService_GetDetailedStatistics;
+    /** Returns total and unique triggered counts for custom events over a date range, optionally scoped to a message code or campaign. Use to attribute event volume to a specific send or campaign. */
     GetTotalStatistics: EventsService_GetTotalStatistics;
 }
 export type GetEventRequest = {
+    /** Application code (format XXXXX-XXXXX) the event belongs to. */
     application?: string;
+    /** Name of the custom event to fetch. */
     name?: string;
 };
 export type EventAttribute_Type = 'UNKNOWN' | 'INTEGER' | 'STRING' | 'LIST' | 'DATE' | 'BOOLEAN' | 'PRICE';
@@ -51,8 +62,9 @@ export type Event = {
 export type ListEventsRequest_OrderBy = 'NAME' | 'CREATED';
 export type ListEventsRequest_OrderDirection = 'ASC' | 'DESC';
 export type ListEventsRequest = {
+    /** Application code (format XXXXX-XXXXX) whose events to list. */
     application?: string;
-    /** like %name% */
+    /** Case-insensitive substring match on event name (matches %name%). */
     searchByName?: string;
     orderBy?: ListEventsRequest_OrderBy;
     orderDirection?: ListEventsRequest_OrderDirection;
@@ -69,9 +81,12 @@ export type ListEventsResponse = {
     total: number;
 };
 export type CreateEventRequest = {
+    /** Name of the custom event to create; must be unique within the application. */
     name?: string;
+    /** Application code (format XXXXX-XXXXX) to create the event in. */
     application?: string;
     description?: string;
+    /** Attributes recorded with each event trigger. */
     attributes?: EventAttribute[];
     revenueMapping?: RevenueMapping;
 };
@@ -79,27 +94,37 @@ export type CreateEventResponse = {
     name: string;
 };
 export type UpdateEventRequest = {
+    /** Name of the custom event to update (immutable, used to locate the event). */
     name?: string;
+    /** Application code (format XXXXX-XXXXX) the event belongs to. */
     application?: string;
     /** new description */
     description?: string;
-    /** new event attributes */
+    /** new event attributes (fully replaces the current set) */
     attributes?: EventAttribute[];
     /** revenue slot mapping (nil = leave unchanged, empty = clear) */
     revenueMapping?: RevenueMapping;
 };
 export type UpdateEventResponse = {};
 export type DeleteEventRequest = {
+    /** Name of the custom event to delete. */
     name?: string;
+    /** Application code (format XXXXX-XXXXX) the event belongs to. */
     application?: string;
 };
 export type DeleteEventResponse = {};
 export type GetAttributeValuesRequest = {
+    /** Application code (format XXXXX-XXXXX) the event belongs to. */
     application?: string;
+    /** Name of the custom event whose attribute values to return. */
     event?: string;
+    /** Name of the event attribute whose recorded values to return. */
     attribute?: string;
+    /** Number of values to skip (offset paging). */
     skip?: number;
+    /** Maximum number of values to return (defaults to 100). */
     limit?: number;
+    /** Free-text filter over the attribute values (not an id). */
     search?: string;
 };
 export type GetAttributeValuesResponse = {
@@ -107,7 +132,9 @@ export type GetAttributeValuesResponse = {
     values: string[];
 };
 export type GetTriggeredCountRequest = {
+    /** Application code (format XXXXX-XXXXX) the events belong to. */
     application?: string;
+    /** Names of the custom events to count. */
     events?: string[];
 };
 export type GetTriggeredCountResponse_Count = {
@@ -156,11 +183,15 @@ export type AttributeCondition = {
     values: Value[];
 };
 export type GetDetailedStatisticsRequest = {
+    /** Application code (format XXXXX-XXXXX) the event belongs to. */
     application?: string;
+    /** Name of the custom event to build the time series for. */
     name?: string;
     dateFrom?: Date;
     dateTo?: Date;
+    /** Bucket size for the time series (hour, day, week or month). */
     interval?: TimeInterval;
+    /** Filter triggers to those whose attributes match these conditions. */
     attributeConditions?: AttributeCondition[];
 };
 export type GetDetailedStatisticsResponse_TriggeredCount = {
@@ -171,11 +202,15 @@ export type GetDetailedStatisticsResponse = {
     metrics: GetDetailedStatisticsResponse_TriggeredCount[];
 };
 export type GetTotalStatisticsRequest = {
+    /** Application code (format XXXXX-XXXXX) the events belong to. */
     application?: string;
+    /** Names of the custom events to count. */
     events?: string[];
     dateFrom?: Date;
     dateTo?: Date;
+    /** Message code to attribute event triggers to a single send (transactional sends have no numeric id, so this returns empty). */
     messageCode?: string;
+    /** Campaign code to attribute event triggers to a whole campaign. */
     campaign?: string;
 };
 export type GetTotalStatisticsResponse_EventTriggeredCount = {

package/export_messages.d.ts

@@ -12,8 +12,12 @@ export type ExportStatisticsService_Status = RpcMethod<pushwoosh_export_messages
 export type ExportStatisticsService_Result = RpcMethod<pushwoosh_export_messages_v2_ResultRequest, pushwoosh_export_messages_v2_ResultResponse>;
 export type ExportStatisticsService_GetLastTasks = RpcMethod<pushwoosh_export_messages_v2_GetLastTasksRequest, pushwoosh_export_messages_v2_GetLastTasksResponse>;
 export interface ExportStatisticsService {
+    /** Starts an asynchronous export or computation task (CSV of message history, recipients, bounced emails, journey users, retention, or create-segment-from-message) and returns its numeric task uid. The task type and its args select what is produced; poll get_export_task_status, then fetch get_export_task_result. */
     Export: ExportStatisticsService_Export;
+    /** Returns the status (pending, success or failed) and progress of an export task by its numeric uid. Poll after create_export_task until success, then call get_export_task_result. */
     Status: ExportStatisticsService_Status;
+    /** Returns the finished output of an export task by its numeric uid — a downloadable file link, created segment code, or computed metrics depending on task type. Call only after get_export_task_status reports success. */
     Result: ExportStatisticsService_Result;
+    /** Lists recent export tasks for an application, optionally scoped by task type, message code/id, campaign, journey or event. Use to find a prior export's uid or check what was already run before starting a new one. */
     GetLastTasks: ExportStatisticsService_GetLastTasks;
 }

package/filters.d.ts

@@ -16,30 +16,47 @@ export type FiltersService_GetMatchedSegments = RpcMethod<GetMatchedSegmentsRequ
 export type FiltersService_GetFilterUsage = RpcMethod<GetFilterUsageRequest, GetFilterUsageResponse>;
 export type FiltersService_SearchAddress = RpcMethod<SearchAddressRequest, SearchAddressResponse>;
 export interface FiltersService {
+    /** Lists an account's saved segments (filters) for an application, newest first, with paging, name/code search and a high-speed-only toggle. Use to browse segments or find a filter code before get_filter or compile_filter. */
     List: FiltersService_List;
+    /** Returns one segment (filter) by its filter code, including its filter expression, seglang, device-load policy and compiling stats. Use after list_filters to inspect a single segment. */
     Get: FiltersService_Get;
+    /** Creates a new segment (filter) from a filter expression under an application, optionally as a high-speed prepared filter with an expiration date. The name must be unique for the account; use clone_filter to copy an existing one. */
     Create: FiltersService_Create;
+    /** Duplicates an existing segment (filter), identified by source filter code, under a new unique name. High-speed filters cannot be cloned; use create_filter to build a segment from scratch. */
     Clone: FiltersService_Clone;
+    /** Overwrites a segment's (filter) name, filter expression and device-load policy by filter code. Use to edit an existing segment; the new name must stay unique within the account. */
     Update: FiltersService_Update;
+    /** Deletes a segment (filter) by filter code after verifying it is not used by any campaign, journey, preset, in-app or popup. Blocks instead of deleting if the filter is still in use; delete_filter_v2 auto-detaches journey/in-app usage first. */
     Delete: FiltersService_Delete;
+    /** Deletes a segment (filter) by filter code, first detaching it from journey split points and moving in-app messages that use it to draft. Use instead of delete_filter to force-remove a filter referenced by journeys or in-apps; still blocked by other filters or web popups using it. */
     DeleteV2: FiltersService_DeleteV2;
+    /** Returns cities (name, coordinates, subscriber count) matching a search string, from the account's City tag values enriched with geo data. Used by the Geo segment-filter builder to pick cities to target. */
     GetCountryCities: FiltersService_GetCountryCities;
+    /** Resolves a list of city hashes (country code, city name) to their coordinates and names. Use to hydrate cities already selected in a geo filter, e.g. after get_filter_country_cities. */
     GetCitiesByHashes: FiltersService_GetCitiesByHashes;
+    /** Recomputes a segment's (filter) reachable device count for an application, optionally producing a CSV export of matching devices. Use to refresh a filter's audience size; pass export_csv to also generate a download. */
     CompileFilter: FiltersService_CompileFilter;
+    /** Renders a filter expression into its seglang (segment-language) string representation. Pure conversion used by the segment editor; the inverse of get_filter_expression_from_seglang. */
     GetSeglang: FiltersService_GetSeglang;
+    /** Parses a seglang (segment-language) query string into a structured filter expression. Pure conversion used by the segment editor; the inverse of get_filter_seglang. */
     SeglangToFilterExpression: FiltersService_SeglangToFilterExpression;
+    /** Lists the account's segments (filters) that a given device (by HWID) currently matches, for an application, with paging and name search. Use to see which segments a specific device falls into. */
     GetMatchedSegments: FiltersService_GetMatchedSegments;
+    /** Lists where a segment (filter) is used across journeys, one-time messages, in-app messages, presets and web popups. Use before delete_filter to see what references a filter; set only_active_campaigns to skip finished ones. */
     GetFilterUsage: FiltersService_GetFilterUsage;
+    /** Geocodes a free-form address or place query into map candidates (name, lat/lon, bounding box) via an external geocoding provider. Used by the Geo segment-filter builder to drop a point or radius on the map. */
     SearchAddress: FiltersService_SearchAddress;
 }
 export type ListFiltersRequest_OrderBy = 'NAME' | 'CREATED' | 'UPDATED';
 export type ListFiltersRequest_OrderDirection = 'ASC' | 'DESC';
 export type ListFiltersRequest = {
+    /** application code (XXXXX-XXXXX); scopes the listing */
     application?: string;
     /** like %name% */
     searchByName?: string;
     /** return only high speed filters */
     highSpeedOnly?: boolean;
+    /** filter (segment) codes to fetch; empty returns all */
     codes?: string[];
     orderBy?: ListFiltersRequest_OrderBy;
     orderDirection?: ListFiltersRequest_OrderDirection;
@@ -106,7 +123,9 @@ export type ListFiltersResponse = {
     totalFilters: number;
 };
 export type GetFilterRequest = {
+    /** application code (XXXXX-XXXXX) */
     application?: string;
+    /** filter (segment) code to fetch */
     filter?: string;
 };
 export type CreateFilterRequest = {
@@ -134,7 +153,9 @@ export type CreateFilterResponse = {
 export type CloneFilterRequest = {
     /** required when account has ApplicationSpecificFilters restriction, otherwise optional */
     application?: string;
+    /** name for the new filter (segment); must be unique within the account */
     newName?: string;
+    /** source filter (segment) code to clone */
     filter?: string;
 };
 export type CloneFilterResponse = {
@@ -143,6 +164,7 @@ export type CloneFilterResponse = {
 export type UpdateFilterRequest = {
     /** required when account has ApplicationSpecificFilters restriction, otherwise optional */
     application?: string;
+    /** filter (segment) code to update */
     filter?: string;
     name?: string;
     filterExpression?: pushwoosh_objects_filters_v1_FilterExpression;
@@ -152,6 +174,7 @@ export type UpdateFilterResponse = {};
 export type DeleteFilterRequest = {
     /** required when account has ApplicationSpecificFilters restriction, otherwise optional */
     application?: string;
+    /** filter (segment) code to delete */
     filter?: string;
 };
 export type DeleteFilterResponse = {};
@@ -183,14 +206,18 @@ export type GetCitiesByHashesResponse = {
     cities: GetCountryCitiesResponse_City[];
 };
 export type CompileFilterRequest = {
+    /** application code (XXXXX-XXXXX) the filter is compiled against */
     application?: string;
+    /** filter (segment) code to (re)compile */
     filter?: string;
+    /** also generate a downloadable CSV export of matching devices */
     exportCsv?: boolean;
 };
 export type CompileFilterResponse = {};
 export type GetSeglangRequest = {
     /** required when account has ApplicationSpecificFilters restriction, otherwise optional */
     application?: string;
+    /** filter expression to render as seglang */
     filterExpression?: pushwoosh_objects_filters_v1_FilterExpression;
 };
 export type GetSeglangResponse = {
@@ -199,13 +226,16 @@ export type GetSeglangResponse = {
 export type SeglangToFilterExpressionRequest = {
     /** required when account has ApplicationSpecificFilters restriction, otherwise optional */
     application?: string;
+    /** seglang (segment-language) query string to parse */
     seglang?: string;
 };
 export type SeglangToFilterExpressionResponse = {
     filterExpression: pushwoosh_objects_filters_v1_FilterExpression;
 };
 export type GetMatchedSegmentsRequest = {
+    /** application code (XXXXX-XXXXX) */
     application?: string;
+    /** device HWID to match against the account's segments */
     hwid?: string;
     page?: number;
     perPage?: number;
@@ -222,7 +252,9 @@ export type GetMatchedSegmentsResponse = {
 export type GetFilterUsageRequest = {
     /** required when account has ApplicationSpecificFilters restriction, otherwise optional */
     application?: string;
+    /** filter (segment) code to inspect usage for */
     filter?: string;
+    /** limit results to active/running usages, skipping finished ones */
     onlyActiveCampaigns?: boolean;
 };
 /**

package/frequency_capping.d.ts

@@ -3,12 +3,17 @@ export type FrequencyCappingService_Get = RpcMethod<GetFrequencyCappingRequest,
 export type FrequencyCappingService_Update = RpcMethod<UpdateFrequencyCappingRequest, UpdateFrequencyCappingResponse>;
 export type FrequencyCappingService_Create = RpcMethod<CreateFrequencyCappingRequest, CreateFrequencyCappingResponse>;
 export interface FrequencyCappingService {
+    /** Returns the frequency-capping limits configured for an application code XXXXX-XXXXX, per channel (push, email, SMS, in-app, WhatsApp). Use to read current caps before updating them; errors if no capping has been created for the application. */
     Get: FrequencyCappingService_Get;
+    /** Overwrites the per-channel frequency-capping limits of an existing application capping. Use to change caps already created; only the channels present in the request are updated, and it errors if no capping exists yet (use create_frequency_capping first). */
     Update: FrequencyCappingService_Update;
+    /** Creates the initial per-channel frequency-capping configuration for an application code XXXXX-XXXXX. Use once to set up capping; use update_frequency_capping to change limits afterwards. */
     Create: FrequencyCappingService_Create;
 }
 export type Capping = {
+    /** Maximum number of messages allowed within the window (1-1000). */
     count: number;
+    /** Length of the rolling window in days (1-30). */
     days: number;
 };
 export type FrequencyCapping = {
@@ -19,28 +24,41 @@ export type FrequencyCapping = {
     whatsApp: Capping;
 };
 export type GetFrequencyCappingRequest = {
+    /** Application code XXXXX-XXXXX whose capping is read. */
     application?: string;
 };
 export type GetFrequencyCappingResponse = {
     frequencyCapping: FrequencyCapping;
 };
 export type CreateFrequencyCappingRequest = {
+    /** Application code XXXXX-XXXXX to configure capping for. */
     application?: string;
+    /** Push channel cap; omit to leave the channel uncapped. */
     push?: Capping;
+    /** Email channel cap; omit to leave the channel uncapped. */
     email?: Capping;
+    /** SMS channel cap; omit to leave the channel uncapped. */
     sms?: Capping;
+    /** In-app channel cap; omit to leave the channel uncapped. */
     inApp?: Capping;
+    /** WhatsApp channel cap; omit to leave the channel uncapped. */
     whatsApp?: Capping;
 };
 export type CreateFrequencyCappingResponse = {
     frequencyCapping: FrequencyCapping;
 };
 export type UpdateFrequencyCappingRequest = {
+    /** Application code XXXXX-XXXXX whose capping is updated. */
     application?: string;
+    /** Push channel cap; omit to leave that channel unchanged. */
     push?: Capping;
+    /** Email channel cap; omit to leave that channel unchanged. */
     email?: Capping;
+    /** SMS channel cap; omit to leave that channel unchanged. */
     sms?: Capping;
+    /** In-app channel cap; omit to leave that channel unchanged. */
     inApp?: Capping;
+    /** WhatsApp channel cap; omit to leave that channel unchanged. */
     whatsApp?: Capping;
 };
 export type UpdateFrequencyCappingResponse = {};

package/geozones.d.ts

@@ -5,10 +5,15 @@ export type GeozonesService_Update = RpcMethod<UpdateGeozonesRequest, UpdateGeoz
 export type GeozonesService_List = RpcMethod<ListGeozonesRequest, ListGeozonesResponse>;
 export type GeozonesService_Delete = RpcMethod<DeleteGeozonesRequest, DeleteGeozonesResponse>;
 export interface GeozonesService {
+    /** Creates a geozone (a location trigger with center lat/lng, radius and re-entry cooldown) for an application, sending a push preset or inline content when a device enters it. Requires either preset or content; edit it later with update_geozone. */
     Create: GeozonesService_Create;
+    /** Returns a single geozone by its geozone code, including coordinates, range, cooldown, timetable, linked cluster/preset/campaign and active status. Use after list_geozones to inspect one geozone. */
     Get: GeozonesService_Get;
+    /** Updates an existing geozone by its geozone code; only the fields you send are changed (PUT-style overwrite). Use to move coordinates, swap preset/content, change cooldown or range, toggle status, or reassign the cluster. */
     Update: GeozonesService_Update;
+    /** Lists geozones for one application (or across all account applications when application is empty), ordered by name or creation date, with paging and a name/code substring search. Use to browse geozones or find a geozone code. */
     List: GeozonesService_List;
+    /** Permanently deletes a geozone by its geozone code, removing the location trigger. Not undoable; use update_geozone to disable a geozone instead of deleting it. */
     Delete: GeozonesService_Delete;
 }
 /**

package/geozones_clusters.d.ts

@@ -5,9 +5,13 @@ export type GeozonesClustersService_Update = RpcMethod<UpdateGeozonesClusterRequ
 export type GeozonesClustersService_List = RpcMethod<ListGeozonesClustersRequest, ListGeozonesClustersResponse>;
 export type GeozonesClustersService_Delete = RpcMethod<DeleteGeozonesClusterRequest, DeleteGeozonesClusterResponse>;
 export interface GeozonesClustersService {
+    /** Creates a geozone cluster in an application: a named group of geozones sharing one entry cooldown. Use before assigning geozones to a cluster; returns the new cluster code. */
     Create: GeozonesClustersService_Create;
+    /** Updates a geozone cluster identified by its cluster code, overwriting the name, cooldown and/or active status supplied. Only the fields you set are changed; unset fields are left untouched. */
     Update: GeozonesClustersService_Update;
+    /** Lists geozone clusters for an application (or all accessible applications), newest first, with paging and optional name/code search. Use to browse clusters or find a cluster code before update or delete. */
     List: GeozonesClustersService_List;
+    /** Deletes a geozone cluster by its cluster code. Fails if any geozone still belongs to the cluster; reassign or delete those geozones first. */
     Delete: GeozonesClustersService_Delete;
 }
 export type GeozonesCluster = {
@@ -19,17 +23,24 @@ export type GeozonesCluster = {
     status: pushwoosh_rpc_v2_geozones_Status;
 };
 export type CreateGeozonesClusterRequest = {
+    /** Application code (format XXXXX-XXXXX) the cluster belongs to. */
     application?: string;
+    /** Human-readable cluster name. */
     name?: string;
+    /** Minimum time between entry triggers for geozones in this cluster. */
     cooldown?: Duration;
 };
 export type CreateGeozonesClusterResponse = {
     cluster: GeozonesCluster;
 };
 export type UpdateGeozonesClusterRequest = {
+    /** Cluster code of the cluster to update. */
     code?: string;
+    /** New cluster name; omit to leave unchanged. */
     name?: string;
+    /** New entry cooldown; omit to leave unchanged. */
     cooldown?: Duration;
+    /** New active/inactive status; STATUS_UNSPECIFIED leaves it unchanged. */
     status?: pushwoosh_rpc_v2_geozones_Status;
 };
 export type UpdateGeozonesClusterResponse = {
@@ -38,12 +49,13 @@ export type UpdateGeozonesClusterResponse = {
 export type ListGeozonesClustersRequest_OrderBy = 'NAME' | 'CREATED';
 export type ListGeozonesClustersRequest_OrderDirection = 'ASC' | 'DESC';
 export type ListGeozonesClustersRequest = {
+    /** Application code (format XXXXX-XXXXX) to list clusters for; empty lists across all accessible applications. */
     application?: string;
     orderBy?: ListGeozonesClustersRequest_OrderBy;
     orderDirection?: ListGeozonesClustersRequest_OrderDirection;
     page?: number;
     perPage?: number;
-    /** like %name% on name or code */
+    /** Case-insensitive substring matched against cluster name or code. */
     searchByName?: string;
 };
 export type ListGeozonesClustersResponse = {
@@ -53,6 +65,7 @@ export type ListGeozonesClustersResponse = {
     total: number;
 };
 export type DeleteGeozonesClusterRequest = {
+    /** Cluster code of the cluster to delete. */
     code?: string;
 };
 export type DeleteGeozonesClusterResponse = {};

package/inapp_messages.d.ts

@@ -8,25 +8,33 @@ export type InAppMessagesService_Update = RpcMethod<UpdateInappRequest, UpdateIn
 export type InAppMessagesService_Stop = RpcMethod<StopInappRequest, StopInappResponse>;
 export type InAppMessagesService_Publish = RpcMethod<PublishInappRequest, PublishInappResponse>;
 export interface InAppMessagesService {
+    /** Lists in-app messages for an application (format XXXXX-XXXXX), newest first, with paging, name/code search and an optional status filter. Use to browse in-app messages or find an in-app message code before fetching, editing or publishing one. */
     List: InAppMessagesService_List;
+    /** Returns a single in-app message by its code, including status, schedule, rich media, segment and tag/event/trigger filter expressions. Use after list_inapp_messages to inspect one in-app message. */
     Get: InAppMessagesService_Get;
+    /** Permanently deletes an in-app message by code within an application (format XXXXX-XXXXX), removing its record entirely. Use disable_inapp_message instead to stop an active one while keeping it. */
     Delete: InAppMessagesService_Delete;
+    /** Creates a new in-app message (a draft, or active when action is PUBLISH) with rich media, segment, schedule and trigger filter expression, returning its generated code. Use to add a new in-app message; use update_inapp_message to edit an existing one. */
     Create: InAppMessagesService_Create;
+    /** Updates an existing in-app message by code, overwriting name, rich media, segment, schedule and filter expressions and, per action, saving it as a draft or publishing it. Use to edit an in-app message; use create_inapp_message to add a new one. */
     Update: InAppMessagesService_Update;
+    /** Deactivates an active in-app message by code, setting its status to stopped so it no longer shows to devices. Reversible with enable_inapp_message; use delete_inapp_message to remove it entirely. */
     Stop: InAppMessagesService_Stop;
+    /** Activates a draft in-app message by code after validating it has a name, a trigger filter expression and rich media. Use to publish a prepared draft; the reverse is disable_inapp_message. */
     Publish: InAppMessagesService_Publish;
 }
 export type ListInappMessagesRequest_OrderBy = 'CREATED' | 'NAME' | 'UPDATED';
 export type ListInappMessagesRequest_OrderDirection = 'DESC' | 'ASC';
 export type ListInappMessagesRequest = {
+    /** Application code (format XXXXX-XXXXX) whose in-app messages to list. */
     application?: string;
-    /** like %name% or %code% */
+    /** Free-text search over in-app message name and code. */
     search?: string;
     page?: number;
     perPage?: number;
     orderBy?: ListInappMessagesRequest_OrderBy;
     orderDirection?: ListInappMessagesRequest_OrderDirection;
-    /** filter by statuses, empty means all */
+    /** Restrict to these statuses; empty means all. */
     statuses?: Inapp_Status[];
 };
 export type Inapp_Status = 'UNDEFINED' | 'ACTIVE' | 'SCHEDULED' | 'COMPLETED' | 'DRAFT' | 'STOPPED';
@@ -65,27 +73,34 @@ export type ListInappMessagesResponse = {
     totalInappMessages: number;
 };
 export type GetInappMessageRequest = {
+    /** In-app message code of the message to fetch. */
     code?: string;
 };
 export type GetInappMessageResponse = {
     inapp: Inapp;
 };
 export type DeleteInappMessageRequest = {
+    /** In-app message code of the message to delete. */
     code?: string;
+    /** Application code (format XXXXX-XXXXX) the in-app message belongs to. */
     application?: string;
 };
 export type DeleteInappMessageResponse = {};
 export type CreateInappRequest_Action = 'SAVE_DRAFT' | 'PUBLISH';
 /** Create - create new inapp (draft or active based on action) */
 export type CreateInappRequest = {
+    /** Application code (format XXXXX-XXXXX) to create the in-app message in. */
     application?: string;
+    /** SAVE_DRAFT keeps it as a draft; PUBLISH creates it active and requires rich_media_code and trigger_filter_expression. */
     action?: CreateInappRequest_Action;
     name?: string;
     description?: string;
     required?: boolean;
-    /** required for PUBLISH */
+    /** Rich media code holding the in-app content; required for PUBLISH. */
     richMediaCode?: string;
+    /** Segment filter name to target (alternative to filter_code). */
     filterName?: string;
+    /** Segment filter code to target (alternative to filter_name). */
     filterCode?: string;
     /** JSON (only capping is read/written server-side) */
     segment?: string;
@@ -96,7 +111,7 @@ export type CreateInappRequest = {
     messageType?: Inapp_MessageType;
     tagFilterExpression?: pushwoosh_objects_filters_v1_FilterExpression;
     eventFilterExpression?: pushwoosh_objects_filters_v1_FilterExpression;
-    /** required for PUBLISH */
+    /** Trigger condition that fires the in-app message; required for PUBLISH. */
     triggerFilterExpression?: pushwoosh_objects_filters_v1_FilterExpression;
 };
 export type CreateInappResponse = {
@@ -105,29 +120,36 @@ export type CreateInappResponse = {
 export type UpdateInappRequest_Action = 'UNKNOWN' | 'SAVE_DRAFT' | 'PUBLISH';
 /** Update - update existing inapp (both draft and active) */
 export type UpdateInappRequest = {
+    /** In-app message code of the message to update. */
     code?: string;
     name?: string;
     description?: string;
     required?: boolean;
+    /** Rich media code holding the in-app content. */
     richMediaCode?: string;
+    /** Segment filter name to target (alternative to filter_code). */
     filterName?: string;
+    /** Segment filter code to target (alternative to filter_name). */
     filterCode?: string;
     /** JSON */
     segment?: string;
     startDate?: Date;
     endDate?: Date;
     priority?: number;
+    /** SAVE_DRAFT stops (unpublishes) the message; PUBLISH activates it after validation. */
     action?: UpdateInappRequest_Action;
     timezone?: string;
     globalCappingEnabled?: boolean;
     messageType?: Inapp_MessageType;
     tagFilterExpression?: pushwoosh_objects_filters_v1_FilterExpression;
     eventFilterExpression?: pushwoosh_objects_filters_v1_FilterExpression;
+    /** Trigger condition that fires the in-app message. */
     triggerFilterExpression?: pushwoosh_objects_filters_v1_FilterExpression;
 };
 export type UpdateInappResponse = {};
 /** Stop - convert active inapp to draft */
 export type StopInappRequest = {
+    /** In-app message code of the active message to stop. */
     code?: string;
 };
 export type StopInappResponse = {
@@ -135,6 +157,7 @@ export type StopInappResponse = {
 };
 /** Publish - convert draft inapp to active with validation */
 export type PublishInappRequest = {
+    /** In-app message code of the draft message to publish. */
     code?: string;
 };
 export type PublishInappResponse = {

package/inbound_webhooks.d.ts

@@ -9,14 +9,23 @@ export type InboundWebhooksService_Enable = RpcMethod<EnableInboundWebhookReques
 export type InboundWebhooksService_Disable = RpcMethod<DisableInboundWebhookRequest, DisableInboundWebhookResponse>;
 export type InboundWebhooksService_GetActivityLog = RpcMethod<GetActivityLogRequest, GetActivityLogResponse>;
 export interface InboundWebhooksService {
+    /** Returns one inbound webhook by its UUID within an application, including the mapped event, identifier config, attribute mappings and status. Use after list_inbound_webhooks to inspect a single webhook's configuration. */
     Get: InboundWebhooksService_Get;
+    /** Lists an application's inbound webhooks with paging, name search and status filter, enriched with 30-day trigger counts and last processing status. Use to browse configured inbound webhooks or find a webhook UUID. */
     List: InboundWebhooksService_List;
+    /** Creates an inbound webhook for an application (XXXXX-XXXXX) that maps an incoming HTTP payload to a Pushwoosh event via JSON-path attribute mappings, generating a new UUID and Bearer secret. Use to set up a new inbound integration endpoint; each call creates a distinct webhook. */
     Create: InboundWebhooksService_Create;
+    /** Overwrites an inbound webhook's name, event, identifier and attribute mappings by UUID; existing mappings are fully deleted and recreated. Use to reconfigure an existing webhook while keeping its UUID and secret. */
     Update: InboundWebhooksService_Update;
+    /** Deletes an inbound webhook by UUID, cascading its attribute mappings. Irreversible; the webhook URL stops accepting incoming calls. */
     Delete: InboundWebhooksService_Delete;
+    /** Returns the callable inbound webhook URL, Bearer secret and a ready-to-use curl example for a webhook UUID. Use to obtain the endpoint credentials for configuring the external system that will POST to it. */
     GetAPIInfo: InboundWebhooksService_GetAPIInfo;
+    /** Enables an inbound webhook by UUID so it resumes accepting and processing incoming calls. Use to reactivate a previously disabled webhook. */
     Enable: InboundWebhooksService_Enable;
+    /** Disables an inbound webhook by UUID so incoming calls are rejected as inactive, without deleting it. Use to temporarily pause an inbound integration; reverse with enable_inbound_webhook. */
     Disable: InboundWebhooksService_Disable;
+    /** Returns the recent (last 24h) processing log for an inbound webhook UUID — per-call timestamp, status, error message and raw request — with paging and success/failure totals. Use to debug why incoming calls fail. */
     GetActivityLog: InboundWebhooksService_GetActivityLog;
 }
 export type EventAttributeItem = {