@pushwoosh/rpc-v2-http-api-data 0.2.376 → 0.2.378

package/data.js

@@ -17730,6 +17730,462 @@ export const data = {
             }
         }
     },
+    "pushwoosh.rpc_v2.feature_flags.FeatureFlagsService_FieldViolations": {
+        "type": "E",
+        "values": [
+            "FV_UNSPECIFIED",
+            "KEY_INVALID",
+            "KEY_TAKEN",
+            "TEXT_INVALID",
+            "PROPERTIES_LIMIT",
+            "PROPERTY_KEY_INVALID",
+            "PROPERTY_TYPE_INVALID",
+            "PROPERTY_TYPE_IMMUTABLE",
+            "VALUE_INVALID",
+            "PROPERTIES_TOO_LARGE",
+            "RULES_LIMIT",
+            "RULE_NOT_FOUND",
+            "PERCENT_INVALID",
+            "OVERRIDE_UNKNOWN_PROPERTY",
+            "SEGMENT_NOT_FOUND",
+            "INVALID_SEGMENT_TYPE",
+            "FLAG_DEPENDENCY",
+            "CONFIRM_REQUIRED",
+            "TAG_CONFLICT"
+        ],
+        "valuesArgs": {
+            "KEY_INVALID": [
+                "pattern"
+            ],
+            "KEY_TAKEN": [
+                "key"
+            ],
+            "PROPERTIES_LIMIT": [
+                "max"
+            ],
+            "PROPERTY_TYPE_IMMUTABLE": [
+                "key"
+            ],
+            "PROPERTIES_TOO_LARGE": [
+                "size"
+            ],
+            "RULES_LIMIT": [
+                "max"
+            ],
+            "RULE_NOT_FOUND": [
+                "rule_id"
+            ],
+            "OVERRIDE_UNKNOWN_PROPERTY": [
+                "key"
+            ],
+            "SEGMENT_NOT_FOUND": [
+                "filter_code"
+            ],
+            "INVALID_SEGMENT_TYPE": [
+                "leaf"
+            ],
+            "FLAG_DEPENDENCY": [
+                "filter_code"
+            ],
+            "TAG_CONFLICT": [
+                "tag"
+            ]
+        }
+    },
+    "pushwoosh.rpc_v2.feature_flags.FeatureFlagsService_FailedPreconditions": {
+        "type": "E",
+        "values": [
+            "FP_UNSPECIFIED",
+            "FEATURE_FLAGS_NOT_ALLOWED",
+            "FLAGS_LIMIT",
+            "VERSION_CONFLICT",
+            "PAYLOAD_TOO_LARGE",
+            "STATUS_CONFLICT"
+        ]
+    },
+    "pushwoosh.rpc_v2.feature_flags.FeatureFlagsService": {
+        "type": "S",
+        "key": "featureFlags",
+        "methods": {
+            "List": {
+                "request": "pushwoosh.rpc_v2.feature_flags.ListFeatureFlagsRequest",
+                "response": "pushwoosh.rpc_v2.feature_flags.ListFeatureFlagsResponse",
+                "method": "get",
+                "path": "/api/applications/{application_code}/feature_flags"
+            },
+            "Get": {
+                "request": "pushwoosh.rpc_v2.feature_flags.GetFeatureFlagRequest",
+                "response": "pushwoosh.rpc_v2.feature_flags.GetFeatureFlagResponse",
+                "method": "get",
+                "path": "/api/applications/{application_code}/feature_flags/{key}"
+            },
+            "Create": {
+                "request": "pushwoosh.rpc_v2.feature_flags.CreateFeatureFlagRequest",
+                "response": "pushwoosh.rpc_v2.feature_flags.CreateFeatureFlagResponse",
+                "method": "post",
+                "path": "/api/applications/{application_code}/feature_flags"
+            },
+            "Update": {
+                "request": "pushwoosh.rpc_v2.feature_flags.UpdateFeatureFlagRequest",
+                "response": "pushwoosh.rpc_v2.feature_flags.UpdateFeatureFlagResponse",
+                "method": "post",
+                "path": "/api/applications/{application_code}/feature_flags/{key}"
+            },
+            "SetRulePercent": {
+                "request": "pushwoosh.rpc_v2.feature_flags.SetFeatureFlagRulePercentRequest",
+                "response": "pushwoosh.rpc_v2.feature_flags.SetFeatureFlagRulePercentResponse",
+                "method": "post",
+                "path": "/api/applications/{application_code}/feature_flags/{key}/rules/{rule_id}/percent"
+            },
+            "Kill": {
+                "request": "pushwoosh.rpc_v2.feature_flags.KillFeatureFlagRequest",
+                "response": "pushwoosh.rpc_v2.feature_flags.KillFeatureFlagResponse",
+                "method": "post",
+                "path": "/api/applications/{application_code}/feature_flags/{key}/kill"
+            },
+            "Unkill": {
+                "request": "pushwoosh.rpc_v2.feature_flags.UnkillFeatureFlagRequest",
+                "response": "pushwoosh.rpc_v2.feature_flags.UnkillFeatureFlagResponse",
+                "method": "post",
+                "path": "/api/applications/{application_code}/feature_flags/{key}/unkill"
+            },
+            "Archive": {
+                "request": "pushwoosh.rpc_v2.feature_flags.ArchiveFeatureFlagRequest",
+                "response": "pushwoosh.rpc_v2.feature_flags.ArchiveFeatureFlagResponse",
+                "method": "post",
+                "path": "/api/applications/{application_code}/feature_flags/{key}/archive"
+            },
+            "Restore": {
+                "request": "pushwoosh.rpc_v2.feature_flags.RestoreFeatureFlagRequest",
+                "response": "pushwoosh.rpc_v2.feature_flags.RestoreFeatureFlagResponse",
+                "method": "post",
+                "path": "/api/applications/{application_code}/feature_flags/{key}/restore"
+            },
+            "Reshuffle": {
+                "request": "pushwoosh.rpc_v2.feature_flags.ReshuffleFeatureFlagRequest",
+                "response": "pushwoosh.rpc_v2.feature_flags.ReshuffleFeatureFlagResponse",
+                "method": "post",
+                "path": "/api/applications/{application_code}/feature_flags/{key}/reshuffle"
+            }
+        }
+    },
+    "pushwoosh.rpc_v2.feature_flags.FeatureFlagProperty": {
+        "type": "I",
+        "fields": {
+            "key": {
+                "type": "string"
+            },
+            "type": {
+                "type": "string"
+            }
+        }
+    },
+    "pushwoosh.rpc_v2.feature_flags.FeatureFlagRule": {
+        "type": "I",
+        "fields": {
+            "ruleId": {
+                "type": "string"
+            },
+            "name": {
+                "type": "string"
+            },
+            "filterCode": {
+                "type": "string"
+            },
+            "percentBp": {
+                "type": "number"
+            },
+            "overrides": {
+                "type": "object"
+            }
+        }
+    },
+    "pushwoosh.rpc_v2.feature_flags.FeatureFlag": {
+        "type": "I",
+        "fields": {
+            "applicationCode": {
+                "type": "string"
+            },
+            "key": {
+                "type": "string"
+            },
+            "name": {
+                "type": "string"
+            },
+            "description": {
+                "type": "string"
+            },
+            "status": {
+                "type": "string"
+            },
+            "properties": {
+                "type": "pushwoosh.rpc_v2.feature_flags.FeatureFlagProperty",
+                "array": true
+            },
+            "defaults": {
+                "type": "object"
+            },
+            "rules": {
+                "type": "pushwoosh.rpc_v2.feature_flags.FeatureFlagRule",
+                "array": true
+            },
+            "version": {
+                "type": "number"
+            },
+            "created": {
+                "type": "Date"
+            },
+            "updated": {
+                "type": "Date"
+            },
+            "lastModifiedByUserId": {
+                "type": "number"
+            }
+        }
+    },
+    "pushwoosh.rpc_v2.feature_flags.ListFeatureFlagsRequest": {
+        "type": "I",
+        "fields": {
+            "applicationCode": {
+                "type": "string"
+            },
+            "status": {
+                "type": "string"
+            }
+        }
+    },
+    "pushwoosh.rpc_v2.feature_flags.ListFeatureFlagsResponse": {
+        "type": "I",
+        "fields": {
+            "flags": {
+                "type": "pushwoosh.rpc_v2.feature_flags.FeatureFlag",
+                "array": true
+            }
+        }
+    },
+    "pushwoosh.rpc_v2.feature_flags.GetFeatureFlagRequest": {
+        "type": "I",
+        "fields": {
+            "applicationCode": {
+                "type": "string"
+            },
+            "key": {
+                "type": "string"
+            }
+        }
+    },
+    "pushwoosh.rpc_v2.feature_flags.GetFeatureFlagResponse": {
+        "type": "I",
+        "fields": {
+            "flag": {
+                "type": "pushwoosh.rpc_v2.feature_flags.FeatureFlag"
+            }
+        }
+    },
+    "pushwoosh.rpc_v2.feature_flags.CreateFeatureFlagRequest": {
+        "type": "I",
+        "fields": {
+            "applicationCode": {
+                "type": "string"
+            },
+            "key": {
+                "type": "string"
+            },
+            "name": {
+                "type": "string"
+            },
+            "description": {
+                "type": "string"
+            },
+            "properties": {
+                "type": "pushwoosh.rpc_v2.feature_flags.FeatureFlagProperty",
+                "array": true
+            },
+            "defaults": {
+                "type": "object"
+            },
+            "rules": {
+                "type": "pushwoosh.rpc_v2.feature_flags.FeatureFlagRule",
+                "array": true
+            }
+        }
+    },
+    "pushwoosh.rpc_v2.feature_flags.CreateFeatureFlagResponse": {
+        "type": "I",
+        "fields": {
+            "flag": {
+                "type": "pushwoosh.rpc_v2.feature_flags.FeatureFlag"
+            }
+        }
+    },
+    "pushwoosh.rpc_v2.feature_flags.UpdateFeatureFlagRequest": {
+        "type": "I",
+        "fields": {
+            "applicationCode": {
+                "type": "string"
+            },
+            "key": {
+                "type": "string"
+            },
+            "version": {
+                "type": "number"
+            },
+            "name": {
+                "type": "string"
+            },
+            "description": {
+                "type": "string"
+            },
+            "properties": {
+                "type": "pushwoosh.rpc_v2.feature_flags.FeatureFlagProperty",
+                "array": true
+            },
+            "defaults": {
+                "type": "object"
+            },
+            "rules": {
+                "type": "pushwoosh.rpc_v2.feature_flags.FeatureFlagRule",
+                "array": true
+            }
+        }
+    },
+    "pushwoosh.rpc_v2.feature_flags.UpdateFeatureFlagResponse": {
+        "type": "I",
+        "fields": {
+            "flag": {
+                "type": "pushwoosh.rpc_v2.feature_flags.FeatureFlag"
+            }
+        }
+    },
+    "pushwoosh.rpc_v2.feature_flags.SetFeatureFlagRulePercentRequest": {
+        "type": "I",
+        "fields": {
+            "applicationCode": {
+                "type": "string"
+            },
+            "key": {
+                "type": "string"
+            },
+            "ruleId": {
+                "type": "string"
+            },
+            "percentBp": {
+                "type": "number"
+            },
+            "version": {
+                "type": "number"
+            }
+        }
+    },
+    "pushwoosh.rpc_v2.feature_flags.SetFeatureFlagRulePercentResponse": {
+        "type": "I",
+        "fields": {
+            "flag": {
+                "type": "pushwoosh.rpc_v2.feature_flags.FeatureFlag"
+            }
+        }
+    },
+    "pushwoosh.rpc_v2.feature_flags.KillFeatureFlagRequest": {
+        "type": "I",
+        "fields": {
+            "applicationCode": {
+                "type": "string"
+            },
+            "key": {
+                "type": "string"
+            }
+        }
+    },
+    "pushwoosh.rpc_v2.feature_flags.KillFeatureFlagResponse": {
+        "type": "I",
+        "fields": {
+            "flag": {
+                "type": "pushwoosh.rpc_v2.feature_flags.FeatureFlag"
+            }
+        }
+    },
+    "pushwoosh.rpc_v2.feature_flags.UnkillFeatureFlagRequest": {
+        "type": "I",
+        "fields": {
+            "applicationCode": {
+                "type": "string"
+            },
+            "key": {
+                "type": "string"
+            }
+        }
+    },
+    "pushwoosh.rpc_v2.feature_flags.UnkillFeatureFlagResponse": {
+        "type": "I",
+        "fields": {
+            "flag": {
+                "type": "pushwoosh.rpc_v2.feature_flags.FeatureFlag"
+            }
+        }
+    },
+    "pushwoosh.rpc_v2.feature_flags.ArchiveFeatureFlagRequest": {
+        "type": "I",
+        "fields": {
+            "applicationCode": {
+                "type": "string"
+            },
+            "key": {
+                "type": "string"
+            }
+        }
+    },
+    "pushwoosh.rpc_v2.feature_flags.ArchiveFeatureFlagResponse": {
+        "type": "I",
+        "fields": {
+            "flag": {
+                "type": "pushwoosh.rpc_v2.feature_flags.FeatureFlag"
+            }
+        }
+    },
+    "pushwoosh.rpc_v2.feature_flags.RestoreFeatureFlagRequest": {
+        "type": "I",
+        "fields": {
+            "applicationCode": {
+                "type": "string"
+            },
+            "key": {
+                "type": "string"
+            }
+        }
+    },
+    "pushwoosh.rpc_v2.feature_flags.RestoreFeatureFlagResponse": {
+        "type": "I",
+        "fields": {
+            "flag": {
+                "type": "pushwoosh.rpc_v2.feature_flags.FeatureFlag"
+            }
+        }
+    },
+    "pushwoosh.rpc_v2.feature_flags.ReshuffleFeatureFlagRequest": {
+        "type": "I",
+        "fields": {
+            "applicationCode": {
+                "type": "string"
+            },
+            "key": {
+                "type": "string"
+            },
+            "confirm": {
+                "type": "boolean"
+            },
+            "version": {
+                "type": "number"
+            }
+        }
+    },
+    "pushwoosh.rpc_v2.feature_flags.ReshuffleFeatureFlagResponse": {
+        "type": "I",
+        "fields": {
+            "flag": {
+                "type": "pushwoosh.rpc_v2.feature_flags.FeatureFlag"
+            }
+        }
+    },
     "pushwoosh.rpc_v2.filters.FiltersService": {
         "type": "S",
         "key": "filters",
@@ -32974,7 +33430,8 @@ export const data = {
             "FILTER_EXPRESSION_HIGH_SPEED_NO_DAYS_AGO",
             "FILTER_EXPRESSION_INVALID_COUNTRY_TAG_VALUE",
             "FILTER_EXPRESSION_INVALID_LANGUAGE_TAG_VALUE",
-            "FILTER_EXPRESSION_EXTERNAL_SEGMENT_NOT_ALLOWED"
+            "FILTER_EXPRESSION_EXTERNAL_SEGMENT_NOT_ALLOWED",
+            "FILTER_EXPRESSION_FEATURE_FLAG_NOT_ALLOWED"
         ],
         "valuesArgs": {
             "NAME_TOO_LONG": [

package/feature_flags.d.ts

@@ -0,0 +1,313 @@
+import { RpcMethod } from './commonTypes';
+export type FeatureFlagsService_FieldViolations = {
+    reason: 'FV_UNSPECIFIED';
+    field: string;
+    description: string;
+} | {
+    reason: 'KEY_INVALID';
+    field: string;
+    description: string;
+    args: {
+        pattern: string;
+    };
+} | {
+    reason: 'KEY_TAKEN';
+    field: string;
+    description: string;
+    args: {
+        key: string;
+    };
+} | {
+    reason: 'TEXT_INVALID';
+    field: string;
+    description: string;
+} | {
+    reason: 'PROPERTIES_LIMIT';
+    field: string;
+    description: string;
+    args: {
+        max: string;
+    };
+} | {
+    reason: 'PROPERTY_KEY_INVALID';
+    field: string;
+    description: string;
+} | {
+    reason: 'PROPERTY_TYPE_INVALID';
+    field: string;
+    description: string;
+} | {
+    reason: 'PROPERTY_TYPE_IMMUTABLE';
+    field: string;
+    description: string;
+    args: {
+        key: string;
+    };
+} | {
+    reason: 'VALUE_INVALID';
+    field: string;
+    description: string;
+} | {
+    reason: 'PROPERTIES_TOO_LARGE';
+    field: string;
+    description: string;
+    args: {
+        size: string;
+    };
+} | {
+    reason: 'RULES_LIMIT';
+    field: string;
+    description: string;
+    args: {
+        max: string;
+    };
+} | {
+    reason: 'RULE_NOT_FOUND';
+    field: string;
+    description: string;
+    args: {
+        rule_id: string;
+    };
+} | {
+    reason: 'PERCENT_INVALID';
+    field: string;
+    description: string;
+} | {
+    reason: 'OVERRIDE_UNKNOWN_PROPERTY';
+    field: string;
+    description: string;
+    args: {
+        key: string;
+    };
+} | {
+    reason: 'SEGMENT_NOT_FOUND';
+    field: string;
+    description: string;
+    args: {
+        filter_code: string;
+    };
+} | {
+    reason: 'INVALID_SEGMENT_TYPE';
+    field: string;
+    description: string;
+    args: {
+        leaf: string;
+    };
+} | {
+    reason: 'FLAG_DEPENDENCY';
+    field: string;
+    description: string;
+    args: {
+        filter_code: string;
+    };
+} | {
+    reason: 'CONFIRM_REQUIRED';
+    field: string;
+    description: string;
+} | {
+    reason: 'TAG_CONFLICT';
+    field: string;
+    description: string;
+    args: {
+        tag: string;
+    };
+};
+export type FeatureFlagsService_FailedPreconditions = {
+    type: 'FP_UNSPECIFIED';
+    description: string;
+} | {
+    type: 'FEATURE_FLAGS_NOT_ALLOWED';
+    description: string;
+} | {
+    type: 'FLAGS_LIMIT';
+    description: string;
+} | {
+    type: 'VERSION_CONFLICT';
+    description: string;
+} | {
+    type: 'PAYLOAD_TOO_LARGE';
+    description: string;
+} | {
+    type: 'STATUS_CONFLICT';
+    description: string;
+};
+export type FeatureFlagsService_List = RpcMethod<ListFeatureFlagsRequest, ListFeatureFlagsResponse>;
+export type FeatureFlagsService_Get = RpcMethod<GetFeatureFlagRequest, GetFeatureFlagResponse>;
+export type FeatureFlagsService_Create = RpcMethod<CreateFeatureFlagRequest, CreateFeatureFlagResponse>;
+export type FeatureFlagsService_Update = RpcMethod<UpdateFeatureFlagRequest, UpdateFeatureFlagResponse>;
+export type FeatureFlagsService_SetRulePercent = RpcMethod<SetFeatureFlagRulePercentRequest, SetFeatureFlagRulePercentResponse>;
+export type FeatureFlagsService_Kill = RpcMethod<KillFeatureFlagRequest, KillFeatureFlagResponse>;
+export type FeatureFlagsService_Unkill = RpcMethod<UnkillFeatureFlagRequest, UnkillFeatureFlagResponse>;
+export type FeatureFlagsService_Archive = RpcMethod<ArchiveFeatureFlagRequest, ArchiveFeatureFlagResponse>;
+export type FeatureFlagsService_Restore = RpcMethod<RestoreFeatureFlagRequest, RestoreFeatureFlagResponse>;
+export type FeatureFlagsService_Reshuffle = RpcMethod<ReshuffleFeatureFlagRequest, ReshuffleFeatureFlagResponse>;
+/**
+ * Feature flags: remotely configured switches and properties an application reads through the SDK.
+ *
+ * A flag is identified by its application and key. Rules are evaluated in order; the first rule
+ * whose segment matches the device decides, and its percent_bp rolls the flag out to that share of users.
+ * Every write that carries a form takes the version the caller read and fails with VERSION_CONFLICT
+ * when the flag changed since. Kill, Unkill, Archive and Restore change only the status.
+ */
+export interface FeatureFlagsService {
+    /** Lists the feature flags of an application, optionally only those in the given status. Use to see which flags exist before reading or changing one. */
+    List: FeatureFlagsService_List;
+    /** Returns one feature flag with its properties, rules and the version to send back with the next change. */
+    Get: FeatureFlagsService_Get;
+    /** Creates an active feature flag with its properties and ordered rules. Rule ids are generated by the server. Rule segments may hold only tag, geo, application and list conditions. */
+    Create: FeatureFlagsService_Create;
+    /** Replaces the name, description, properties and rules of a flag; the status is never changed here. Send the version from the last read; a changed flag is refused with VERSION_CONFLICT. Rules keep their rule_id; a rule without one is new. */
+    Update: FeatureFlagsService_Update;
+    /** Changes the rollout percentage of one rule. Users already in the rollout stay in it when the percentage grows. Send the version from the last read. */
+    SetRulePercent: FeatureFlagsService_SetRulePercent;
+    /** Kill switch: turns the flag off for every device, which then gets the default property values. Rules and properties are kept; unkill restores them. */
+    Kill: FeatureFlagsService_Kill;
+    /** Turns a killed flag back on with its rules as they were. */
+    Unkill: FeatureFlagsService_Unkill;
+    /** Archives a flag: devices stop receiving it and it no longer counts against the plan limit. The key stays reserved. */
+    Archive: FeatureFlagsService_Archive;
+    /** Brings an archived flag back as killed, so it never turns on by itself; unkill it to roll it out again. */
+    Restore: FeatureFlagsService_Restore;
+    /** Draws a new salt, so every user lands in a new bucket and the rollout picks a different sample. Requires confirm=true and the version from the last read. */
+    Reshuffle: FeatureFlagsService_Reshuffle;
+}
+export type FeatureFlagProperty = {
+    /** Property key, ^[A-Za-z0-9_]{1,64}$, unique within the flag. */
+    key: string;
+    /** One of string, number, boolean, json. Cannot change once the property exists. */
+    type: string;
+};
+export type FeatureFlagRule = {
+    /** Server-generated id (r_ followed by 8 hex digits), stable across updates. Leave empty for a new rule. */
+    ruleId: string;
+    name: string;
+    /** Segment code the device must match; empty means every device. */
+    filterCode: string;
+    /** Share of matching users the flag is on for, in basis points: 0..10000. */
+    percentBp: number;
+    /** Property values that replace the defaults for devices this rule turns on, keyed by property key. */
+    overrides: object;
+};
+export type FeatureFlag = {
+    applicationCode: string;
+    key: string;
+    name: string;
+    description: string;
+    /** One of active, killed, archived. */
+    status: string;
+    properties: FeatureFlagProperty[];
+    /** Value of every property for devices the flag is off for, keyed by property key. */
+    defaults: object;
+    rules: FeatureFlagRule[];
+    /** Send back with Update, SetRulePercent and Reshuffle. */
+    version: number;
+    created: Date;
+    updated: Date;
+    lastModifiedByUserId: number;
+};
+export type ListFeatureFlagsRequest = {
+    /** Application code (XXXXX-XXXXX). */
+    applicationCode?: string;
+    /** Keep only flags in this status: active, killed or archived. Empty lists all. */
+    status?: string;
+};
+export type ListFeatureFlagsResponse = {
+    flags: FeatureFlag[];
+};
+export type GetFeatureFlagRequest = {
+    /** Application code (XXXXX-XXXXX). */
+    applicationCode?: string;
+    key?: string;
+};
+export type GetFeatureFlagResponse = {
+    flag: FeatureFlag;
+};
+export type CreateFeatureFlagRequest = {
+    /** Application code (XXXXX-XXXXX). */
+    applicationCode?: string;
+    /** ^[A-Za-z0-9_.-]{1,58}$, unique in the application including archived flags. */
+    key?: string;
+    name?: string;
+    description?: string;
+    properties?: FeatureFlagProperty[];
+    /** Value of every property for devices the flag is off for, keyed by property key. Each value must match the property type. */
+    defaults?: object;
+    /** Ordered rules, at most 10. */
+    rules?: FeatureFlagRule[];
+};
+export type CreateFeatureFlagResponse = {
+    flag: FeatureFlag;
+};
+export type UpdateFeatureFlagRequest = {
+    /** Application code (XXXXX-XXXXX). */
+    applicationCode?: string;
+    key?: string;
+    /** Version from the last read of the flag. */
+    version?: number;
+    name?: string;
+    description?: string;
+    properties?: FeatureFlagProperty[];
+    /** Value of every property for devices the flag is off for, keyed by property key. */
+    defaults?: object;
+    rules?: FeatureFlagRule[];
+};
+export type UpdateFeatureFlagResponse = {
+    flag: FeatureFlag;
+};
+export type SetFeatureFlagRulePercentRequest = {
+    /** Application code (XXXXX-XXXXX). */
+    applicationCode?: string;
+    key?: string;
+    ruleId?: string;
+    /** 0..10000 basis points. */
+    percentBp?: number;
+    /** Version from the last read of the flag. */
+    version?: number;
+};
+export type SetFeatureFlagRulePercentResponse = {
+    flag: FeatureFlag;
+};
+export type KillFeatureFlagRequest = {
+    /** Application code (XXXXX-XXXXX). */
+    applicationCode?: string;
+    key?: string;
+};
+export type KillFeatureFlagResponse = {
+    flag: FeatureFlag;
+};
+export type UnkillFeatureFlagRequest = {
+    /** Application code (XXXXX-XXXXX). */
+    applicationCode?: string;
+    key?: string;
+};
+export type UnkillFeatureFlagResponse = {
+    flag: FeatureFlag;
+};
+export type ArchiveFeatureFlagRequest = {
+    /** Application code (XXXXX-XXXXX). */
+    applicationCode?: string;
+    key?: string;
+};
+export type ArchiveFeatureFlagResponse = {
+    flag: FeatureFlag;
+};
+export type RestoreFeatureFlagRequest = {
+    /** Application code (XXXXX-XXXXX). */
+    applicationCode?: string;
+    key?: string;
+};
+export type RestoreFeatureFlagResponse = {
+    flag: FeatureFlag;
+};
+export type ReshuffleFeatureFlagRequest = {
+    /** Application code (XXXXX-XXXXX). */
+    applicationCode?: string;
+    key?: string;
+    /** Must be true: a reshuffle moves users between the on and off groups. */
+    confirm?: boolean;
+    /** Version from the last read of the flag. */
+    version?: number;
+};
+export type ReshuffleFeatureFlagResponse = {
+    flag: FeatureFlag;
+};

package/feature_flags.js

@@ -0,0 +1,3 @@
+/* eslint-disable */
+/* Autogenerated code */
+export {};

package/index.d.ts

@@ -36,6 +36,7 @@ import { EmailsConfigurationsService as pushwoosh_rpc_v2_emails_configurations_E
 import { EventsService as pushwoosh_rpc_v2_events_EventsService } from './events';
 import { ExportStatisticsService as pushwoosh_rpc_v2_export_messages_ExportStatisticsService } from './export_messages';
 import { ExternalSegmentsService as pushwoosh_rpc_external_segments_v3_ExternalSegmentsService } from './pushwoosh_rpc_external_segments_v3';
+import { FeatureFlagsService as pushwoosh_rpc_v2_feature_flags_FeatureFlagsService } from './feature_flags';
 import { FiltersService as pushwoosh_rpc_v2_filters_FiltersService } from './filters';
 import { FrequencyCappingService as pushwoosh_rpc_v2_frequency_capping_FrequencyCappingService } from './frequency_capping';
 import { FrequencyCappingDisabledUsersService as pushwoosh_rpc_frequency_capping_disabled_users_v3_FrequencyCappingDisabledUsersService } from './pushwoosh_rpc_frequency_capping_disabled_users_v3';
@@ -114,6 +115,7 @@ export type API = {
     events: pushwoosh_rpc_v2_events_EventsService;
     exportStatistics: pushwoosh_rpc_v2_export_messages_ExportStatisticsService;
     externalSegments: pushwoosh_rpc_external_segments_v3_ExternalSegmentsService;
+    featureFlags: pushwoosh_rpc_v2_feature_flags_FeatureFlagsService;
     filters: pushwoosh_rpc_v2_filters_FiltersService;
     frequencyCapping: pushwoosh_rpc_v2_frequency_capping_FrequencyCappingService;
     frequencyCappingDisabledUsers: pushwoosh_rpc_frequency_capping_disabled_users_v3_FrequencyCappingDisabledUsersService;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pushwoosh/rpc-v2-http-api-data",
-  "version": "0.2.376",
+  "version": "0.2.378",
   "description": "RPC V2 HTTP API Types and Data",
   "main": "index.js",
   "module": "index.js",

package/pushwoosh_rpc_segments_v3.d.ts

@@ -82,6 +82,10 @@ export type SegmentsService_Create_FieldViolations = {
     reason: 'FILTER_EXPRESSION_EXTERNAL_SEGMENT_NOT_ALLOWED';
     field: string;
     description: string;
+} | {
+    reason: 'FILTER_EXPRESSION_FEATURE_FLAG_NOT_ALLOWED';
+    field: string;
+    description: string;
 };
 export type SegmentsService_Delete_FailedPreconditions = {
     type: 'FP_DELETE_UNSPECIFIED';