@guardian/bridget 2.4.0 → 2.6.0

package/Environment.d.ts

@@ -20,6 +20,19 @@ export declare class NativeThriftPackageVersion__Args extends thrift.StructLike
     static write(args: INativeThriftPackageVersion__ArgsArgs, output: thrift.TProtocol): void;
     write(output: thrift.TProtocol): void;
 }
+export interface IIsMyGuardianEnabled__Args {
+}
+export interface IIsMyGuardianEnabled__ArgsArgs {
+}
+export declare const IsMyGuardianEnabled__ArgsCodec: thrift.IStructCodec<IIsMyGuardianEnabled__ArgsArgs, IIsMyGuardianEnabled__Args>;
+export declare class IsMyGuardianEnabled__Args extends thrift.StructLike implements IIsMyGuardianEnabled__Args {
+    readonly _annotations: thrift.IThriftAnnotations;
+    readonly _fieldAnnotations: thrift.IFieldAnnotations;
+    constructor(args?: IIsMyGuardianEnabled__ArgsArgs);
+    static read(input: thrift.TProtocol): IsMyGuardianEnabled__Args;
+    static write(args: IIsMyGuardianEnabled__ArgsArgs, output: thrift.TProtocol): void;
+    write(output: thrift.TProtocol): void;
+}
 export interface INativeThriftPackageVersion__Result {
     success?: string;
 }
@@ -36,6 +49,22 @@ export declare class NativeThriftPackageVersion__Result extends thrift.StructLik
     static write(args: INativeThriftPackageVersion__ResultArgs, output: thrift.TProtocol): void;
     write(output: thrift.TProtocol): void;
 }
+export interface IIsMyGuardianEnabled__Result {
+    success?: boolean;
+}
+export interface IIsMyGuardianEnabled__ResultArgs {
+    success?: boolean;
+}
+export declare const IsMyGuardianEnabled__ResultCodec: thrift.IStructCodec<IIsMyGuardianEnabled__ResultArgs, IIsMyGuardianEnabled__Result>;
+export declare class IsMyGuardianEnabled__Result extends thrift.StructLike implements IIsMyGuardianEnabled__Result {
+    success?: boolean;
+    readonly _annotations: thrift.IThriftAnnotations;
+    readonly _fieldAnnotations: thrift.IFieldAnnotations;
+    constructor(args?: IIsMyGuardianEnabled__ResultArgs);
+    static read(input: thrift.TProtocol): IsMyGuardianEnabled__Result;
+    static write(args: IIsMyGuardianEnabled__ResultArgs, output: thrift.TProtocol): void;
+    write(output: thrift.TProtocol): void;
+}
 export declare class Client<Context = any> extends thrift.ThriftClient<Context> {
     static readonly serviceName: string;
     static readonly annotations: thrift.IThriftAnnotations;
@@ -49,9 +78,11 @@ export declare class Client<Context = any> extends thrift.ThriftClient<Context>
         [methodName: string]: number;
     };
     nativeThriftPackageVersion(context?: Context): Promise<string>;
+    isMyGuardianEnabled(context?: Context): Promise<boolean>;
 }
 export interface IHandler<Context = any> {
     nativeThriftPackageVersion(context?: Context): string | Promise<string>;
+    isMyGuardianEnabled(context?: Context): boolean | Promise<boolean>;
 }
 export declare class Processor<Context = any> extends thrift.ThriftProcessor<Context, IHandler<Context>> {
     protected readonly _handler: IHandler<Context>;
@@ -66,4 +97,5 @@ export declare class Processor<Context = any> extends thrift.ThriftProcessor<Con
     constructor(handler: IHandler<Context>);
     process(input: thrift.TProtocol, output: thrift.TProtocol, context: Context): Promise<Buffer>;
     process_nativeThriftPackageVersion(requestId: number, input: thrift.TProtocol, output: thrift.TProtocol, context: Context): Promise<Buffer>;
+    process_isMyGuardianEnabled(requestId: number, input: thrift.TProtocol, output: thrift.TProtocol, context: Context): Promise<Buffer>;
 }

package/Environment.js

@@ -20,11 +20,16 @@ exports.methodAnnotations = {
     nativeThriftPackageVersion: {
         annotations: {},
         fieldAnnotations: {}
+    },
+    isMyGuardianEnabled: {
+        annotations: {},
+        fieldAnnotations: {}
     }
 };
-exports.methodNames = ["nativeThriftPackageVersion"];
+exports.methodNames = ["nativeThriftPackageVersion", "isMyGuardianEnabled"];
 exports.methodParameters = {
-    nativeThriftPackageVersion: 1
+    nativeThriftPackageVersion: 1,
+    isMyGuardianEnabled: 1
 };
 exports.NativeThriftPackageVersion__ArgsCodec = {
     encode(args, output) {
@@ -70,6 +75,50 @@ class NativeThriftPackageVersion__Args extends thrift.StructLike {
     }
 }
 exports.NativeThriftPackageVersion__Args = NativeThriftPackageVersion__Args;
+exports.IsMyGuardianEnabled__ArgsCodec = {
+    encode(args, output) {
+        output.writeStructBegin("IsMyGuardianEnabled__Args");
+        output.writeFieldStop();
+        output.writeStructEnd();
+        return;
+    },
+    decode(input) {
+        input.readStructBegin();
+        while (true) {
+            const ret = input.readFieldBegin();
+            const fieldType = ret.fieldType;
+            const fieldId = ret.fieldId;
+            if (fieldType === thrift.TType.STOP) {
+                break;
+            }
+            switch (fieldId) {
+                default: {
+                    input.skip(fieldType);
+                }
+            }
+            input.readFieldEnd();
+        }
+        input.readStructEnd();
+        return {};
+    }
+};
+class IsMyGuardianEnabled__Args extends thrift.StructLike {
+    constructor(args = {}) {
+        super();
+        this._annotations = {};
+        this._fieldAnnotations = {};
+    }
+    static read(input) {
+        return new IsMyGuardianEnabled__Args(exports.IsMyGuardianEnabled__ArgsCodec.decode(input));
+    }
+    static write(args, output) {
+        return exports.IsMyGuardianEnabled__ArgsCodec.encode(args, output);
+    }
+    write(output) {
+        return exports.IsMyGuardianEnabled__ArgsCodec.encode(this, output);
+    }
+}
+exports.IsMyGuardianEnabled__Args = IsMyGuardianEnabled__Args;
 exports.NativeThriftPackageVersion__ResultCodec = {
     encode(args, output) {
         const obj = {
@@ -138,6 +187,74 @@ class NativeThriftPackageVersion__Result extends thrift.StructLike {
     }
 }
 exports.NativeThriftPackageVersion__Result = NativeThriftPackageVersion__Result;
+exports.IsMyGuardianEnabled__ResultCodec = {
+    encode(args, output) {
+        const obj = {
+            success: args.success
+        };
+        output.writeStructBegin("IsMyGuardianEnabled__Result");
+        if (obj.success != null) {
+            output.writeFieldBegin("success", thrift.TType.BOOL, 0);
+            output.writeBool(obj.success);
+            output.writeFieldEnd();
+        }
+        output.writeFieldStop();
+        output.writeStructEnd();
+        return;
+    },
+    decode(input) {
+        let _args = {};
+        input.readStructBegin();
+        while (true) {
+            const ret = input.readFieldBegin();
+            const fieldType = ret.fieldType;
+            const fieldId = ret.fieldId;
+            if (fieldType === thrift.TType.STOP) {
+                break;
+            }
+            switch (fieldId) {
+                case 0:
+                    if (fieldType === thrift.TType.BOOL) {
+                        const value_3 = input.readBool();
+                        _args.success = value_3;
+                    }
+                    else {
+                        input.skip(fieldType);
+                    }
+                    break;
+                default: {
+                    input.skip(fieldType);
+                }
+            }
+            input.readFieldEnd();
+        }
+        input.readStructEnd();
+        return {
+            success: _args.success
+        };
+    }
+};
+class IsMyGuardianEnabled__Result extends thrift.StructLike {
+    constructor(args = {}) {
+        super();
+        this._annotations = {};
+        this._fieldAnnotations = {};
+        if (args.success != null) {
+            const value_4 = args.success;
+            this.success = value_4;
+        }
+    }
+    static read(input) {
+        return new IsMyGuardianEnabled__Result(exports.IsMyGuardianEnabled__ResultCodec.decode(input));
+    }
+    static write(args, output) {
+        return exports.IsMyGuardianEnabled__ResultCodec.encode(args, output);
+    }
+    write(output) {
+        return exports.IsMyGuardianEnabled__ResultCodec.encode(this, output);
+    }
+}
+exports.IsMyGuardianEnabled__Result = IsMyGuardianEnabled__Result;
 class Client extends thrift.ThriftClient {
     constructor() {
         super(...arguments);
@@ -185,6 +302,44 @@ class Client extends thrift.ThriftClient {
             }
         });
     }
+    isMyGuardianEnabled(context) {
+        const writer = new this.transport();
+        const output = new this.protocol(writer);
+        output.writeMessageBegin("isMyGuardianEnabled", thrift.MessageType.CALL, this.incrementRequestId());
+        const args = {};
+        exports.IsMyGuardianEnabled__ArgsCodec.encode(args, output);
+        output.writeMessageEnd();
+        return this.connection.send(writer.flush(), context).then((data) => {
+            const reader = this.transport.receiver(data);
+            const input = new this.protocol(reader);
+            try {
+                const { fieldName: fieldName, messageType: messageType } = input.readMessageBegin();
+                if (fieldName === "isMyGuardianEnabled") {
+                    if (messageType === thrift.MessageType.EXCEPTION) {
+                        const err = thrift.TApplicationExceptionCodec.decode(input);
+                        input.readMessageEnd();
+                        return Promise.reject(err);
+                    }
+                    else {
+                        const result = exports.IsMyGuardianEnabled__ResultCodec.decode(input);
+                        input.readMessageEnd();
+                        if (result.success != null) {
+                            return Promise.resolve(result.success);
+                        }
+                        else {
+                            return Promise.reject(new thrift.TApplicationException(thrift.TApplicationExceptionType.UNKNOWN, "isMyGuardianEnabled failed: unknown result"));
+                        }
+                    }
+                }
+                else {
+                    return Promise.reject(new thrift.TApplicationException(thrift.TApplicationExceptionType.WRONG_METHOD_NAME, "Received a response to an unknown RPC function: " + fieldName));
+                }
+            }
+            catch (err) {
+                return Promise.reject(err);
+            }
+        });
+    }
 }
 exports.Client = Client;
 Client.serviceName = exports.serviceName;
@@ -211,6 +366,10 @@ class Processor extends thrift.ThriftProcessor {
                     resolve(this.process_nativeThriftPackageVersion(requestId, input, output, context));
                     break;
                 }
+                case "process_isMyGuardianEnabled": {
+                    resolve(this.process_isMyGuardianEnabled(requestId, input, output, context));
+                    break;
+                }
                 default: {
                     input.skip(thrift.TType.STRUCT);
                     input.readMessageEnd();
@@ -248,6 +407,29 @@ class Processor extends thrift.ThriftProcessor {
             return output.flush();
         });
     }
+    process_isMyGuardianEnabled(requestId, input, output, context) {
+        return new Promise((resolve, reject) => {
+            try {
+                input.readMessageEnd();
+                resolve(this._handler.isMyGuardianEnabled(context));
+            }
+            catch (err) {
+                reject(err);
+            }
+        }).then((data) => {
+            const result = { success: data };
+            output.writeMessageBegin("isMyGuardianEnabled", thrift.MessageType.REPLY, requestId);
+            exports.IsMyGuardianEnabled__ResultCodec.encode(result, output);
+            output.writeMessageEnd();
+            return output.flush();
+        }).catch((err) => {
+            const result = new thrift.TApplicationException(thrift.TApplicationExceptionType.UNKNOWN, err.message);
+            output.writeMessageBegin("isMyGuardianEnabled", thrift.MessageType.EXCEPTION, requestId);
+            thrift.TApplicationExceptionCodec.encode(result, output);
+            output.writeMessageEnd();
+            return output.flush();
+        });
+    }
 }
 exports.Processor = Processor;
 Processor.serviceName = exports.serviceName;

package/Tag.d.ts

@@ -0,0 +1,143 @@
+/// <reference types="node" />
+import * as thrift from "@creditkarma/thrift-server-core";
+import * as Topic from "./Topic";
+export declare const serviceName: string;
+export declare const annotations: thrift.IThriftAnnotations;
+export declare const methodAnnotations: thrift.IMethodAnnotations;
+export declare const methodNames: Array<string>;
+export declare const methodParameters: {
+    [methodName: string]: number;
+};
+export interface IFollow__Args {
+    topic: Topic.ITopic;
+}
+export interface IFollow__ArgsArgs {
+    topic: Topic.ITopicArgs;
+}
+export declare const Follow__ArgsCodec: thrift.IStructCodec<IFollow__ArgsArgs, IFollow__Args>;
+export declare class Follow__Args extends thrift.StructLike implements IFollow__Args {
+    topic: Topic.ITopic;
+    readonly _annotations: thrift.IThriftAnnotations;
+    readonly _fieldAnnotations: thrift.IFieldAnnotations;
+    constructor(args: IFollow__ArgsArgs);
+    static read(input: thrift.TProtocol): Follow__Args;
+    static write(args: IFollow__ArgsArgs, output: thrift.TProtocol): void;
+    write(output: thrift.TProtocol): void;
+}
+export interface IUnfollow__Args {
+    topic: Topic.ITopic;
+}
+export interface IUnfollow__ArgsArgs {
+    topic: Topic.ITopicArgs;
+}
+export declare const Unfollow__ArgsCodec: thrift.IStructCodec<IUnfollow__ArgsArgs, IUnfollow__Args>;
+export declare class Unfollow__Args extends thrift.StructLike implements IUnfollow__Args {
+    topic: Topic.ITopic;
+    readonly _annotations: thrift.IThriftAnnotations;
+    readonly _fieldAnnotations: thrift.IFieldAnnotations;
+    constructor(args: IUnfollow__ArgsArgs);
+    static read(input: thrift.TProtocol): Unfollow__Args;
+    static write(args: IUnfollow__ArgsArgs, output: thrift.TProtocol): void;
+    write(output: thrift.TProtocol): void;
+}
+export interface IIsFollowing__Args {
+    topic: Topic.ITopic;
+}
+export interface IIsFollowing__ArgsArgs {
+    topic: Topic.ITopicArgs;
+}
+export declare const IsFollowing__ArgsCodec: thrift.IStructCodec<IIsFollowing__ArgsArgs, IIsFollowing__Args>;
+export declare class IsFollowing__Args extends thrift.StructLike implements IIsFollowing__Args {
+    topic: Topic.ITopic;
+    readonly _annotations: thrift.IThriftAnnotations;
+    readonly _fieldAnnotations: thrift.IFieldAnnotations;
+    constructor(args: IIsFollowing__ArgsArgs);
+    static read(input: thrift.TProtocol): IsFollowing__Args;
+    static write(args: IIsFollowing__ArgsArgs, output: thrift.TProtocol): void;
+    write(output: thrift.TProtocol): void;
+}
+export interface IFollow__Result {
+    success?: boolean;
+}
+export interface IFollow__ResultArgs {
+    success?: boolean;
+}
+export declare const Follow__ResultCodec: thrift.IStructCodec<IFollow__ResultArgs, IFollow__Result>;
+export declare class Follow__Result extends thrift.StructLike implements IFollow__Result {
+    success?: boolean;
+    readonly _annotations: thrift.IThriftAnnotations;
+    readonly _fieldAnnotations: thrift.IFieldAnnotations;
+    constructor(args?: IFollow__ResultArgs);
+    static read(input: thrift.TProtocol): Follow__Result;
+    static write(args: IFollow__ResultArgs, output: thrift.TProtocol): void;
+    write(output: thrift.TProtocol): void;
+}
+export interface IUnfollow__Result {
+    success?: boolean;
+}
+export interface IUnfollow__ResultArgs {
+    success?: boolean;
+}
+export declare const Unfollow__ResultCodec: thrift.IStructCodec<IUnfollow__ResultArgs, IUnfollow__Result>;
+export declare class Unfollow__Result extends thrift.StructLike implements IUnfollow__Result {
+    success?: boolean;
+    readonly _annotations: thrift.IThriftAnnotations;
+    readonly _fieldAnnotations: thrift.IFieldAnnotations;
+    constructor(args?: IUnfollow__ResultArgs);
+    static read(input: thrift.TProtocol): Unfollow__Result;
+    static write(args: IUnfollow__ResultArgs, output: thrift.TProtocol): void;
+    write(output: thrift.TProtocol): void;
+}
+export interface IIsFollowing__Result {
+    success?: boolean;
+}
+export interface IIsFollowing__ResultArgs {
+    success?: boolean;
+}
+export declare const IsFollowing__ResultCodec: thrift.IStructCodec<IIsFollowing__ResultArgs, IIsFollowing__Result>;
+export declare class IsFollowing__Result extends thrift.StructLike implements IIsFollowing__Result {
+    success?: boolean;
+    readonly _annotations: thrift.IThriftAnnotations;
+    readonly _fieldAnnotations: thrift.IFieldAnnotations;
+    constructor(args?: IIsFollowing__ResultArgs);
+    static read(input: thrift.TProtocol): IsFollowing__Result;
+    static write(args: IIsFollowing__ResultArgs, output: thrift.TProtocol): void;
+    write(output: thrift.TProtocol): void;
+}
+export declare class Client<Context = any> extends thrift.ThriftClient<Context> {
+    static readonly serviceName: string;
+    static readonly annotations: thrift.IThriftAnnotations;
+    static readonly methodAnnotations: thrift.IMethodAnnotations;
+    static readonly methodNames: Array<string>;
+    readonly _serviceName: string;
+    readonly _annotations: thrift.IThriftAnnotations;
+    readonly _methodAnnotations: thrift.IMethodAnnotations;
+    readonly _methodNames: Array<string>;
+    readonly _methodParameters?: {
+        [methodName: string]: number;
+    };
+    follow(topic: Topic.ITopicArgs, context?: Context): Promise<boolean>;
+    unfollow(topic: Topic.ITopicArgs, context?: Context): Promise<boolean>;
+    isFollowing(topic: Topic.ITopicArgs, context?: Context): Promise<boolean>;
+}
+export interface IHandler<Context = any> {
+    follow(topic: Topic.ITopic, context?: Context): boolean | Promise<boolean>;
+    unfollow(topic: Topic.ITopic, context?: Context): boolean | Promise<boolean>;
+    isFollowing(topic: Topic.ITopic, context?: Context): boolean | Promise<boolean>;
+}
+export declare class Processor<Context = any> extends thrift.ThriftProcessor<Context, IHandler<Context>> {
+    protected readonly _handler: IHandler<Context>;
+    static readonly serviceName: string;
+    static readonly annotations: thrift.IThriftAnnotations;
+    static readonly methodAnnotations: thrift.IMethodAnnotations;
+    static readonly methodNames: Array<string>;
+    readonly _serviceName: string;
+    readonly _annotations: thrift.IThriftAnnotations;
+    readonly _methodAnnotations: thrift.IMethodAnnotations;
+    readonly _methodNames: Array<string>;
+    constructor(handler: IHandler<Context>);
+    process(input: thrift.TProtocol, output: thrift.TProtocol, context: Context): Promise<Buffer>;
+    process_follow(requestId: number, input: thrift.TProtocol, output: thrift.TProtocol, context: Context): Promise<Buffer>;
+    process_unfollow(requestId: number, input: thrift.TProtocol, output: thrift.TProtocol, context: Context): Promise<Buffer>;
+    process_isFollowing(requestId: number, input: thrift.TProtocol, output: thrift.TProtocol, context: Context): Promise<Buffer>;
+}

package/Tag.js

@@ -0,0 +1,729 @@
+"use strict";
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (Object.hasOwnProperty.call(mod, k)) result[k] = mod[k];
+    result["default"] = mod;
+    return result;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+/* tslint:disable */
+/* eslint-disable */
+/*
+ * Autogenerated by @creditkarma/thrift-typescript v3.7.6
+ * DO NOT EDIT UNLESS YOU ARE SURE THAT YOU KNOW WHAT YOU ARE DOING
+*/
+const thrift = __importStar(require("@creditkarma/thrift-server-core"));
+const Topic = __importStar(require("./Topic"));
+exports.serviceName = "Tag";
+exports.annotations = {};
+exports.methodAnnotations = {
+    follow: {
+        annotations: {},
+        fieldAnnotations: {}
+    },
+    unfollow: {
+        annotations: {},
+        fieldAnnotations: {}
+    },
+    isFollowing: {
+        annotations: {},
+        fieldAnnotations: {}
+    }
+};
+exports.methodNames = ["follow", "unfollow", "isFollowing"];
+exports.methodParameters = {
+    follow: 2,
+    unfollow: 2,
+    isFollowing: 2
+};
+exports.Follow__ArgsCodec = {
+    encode(args, output) {
+        const obj = {
+            topic: args.topic
+        };
+        output.writeStructBegin("Follow__Args");
+        if (obj.topic != null) {
+            output.writeFieldBegin("topic", thrift.TType.STRUCT, 1);
+            Topic.TopicCodec.encode(obj.topic, output);
+            output.writeFieldEnd();
+        }
+        else {
+            throw new thrift.TProtocolException(thrift.TProtocolExceptionType.UNKNOWN, "Required field[topic] is unset!");
+        }
+        output.writeFieldStop();
+        output.writeStructEnd();
+        return;
+    },
+    decode(input) {
+        let _args = {};
+        input.readStructBegin();
+        while (true) {
+            const ret = input.readFieldBegin();
+            const fieldType = ret.fieldType;
+            const fieldId = ret.fieldId;
+            if (fieldType === thrift.TType.STOP) {
+                break;
+            }
+            switch (fieldId) {
+                case 1:
+                    if (fieldType === thrift.TType.STRUCT) {
+                        const value_1 = Topic.TopicCodec.decode(input);
+                        _args.topic = value_1;
+                    }
+                    else {
+                        input.skip(fieldType);
+                    }
+                    break;
+                default: {
+                    input.skip(fieldType);
+                }
+            }
+            input.readFieldEnd();
+        }
+        input.readStructEnd();
+        if (_args.topic !== undefined) {
+            return {
+                topic: _args.topic
+            };
+        }
+        else {
+            throw new thrift.TProtocolException(thrift.TProtocolExceptionType.UNKNOWN, "Unable to read Follow__Args from input");
+        }
+    }
+};
+class Follow__Args extends thrift.StructLike {
+    constructor(args) {
+        super();
+        this._annotations = {};
+        this._fieldAnnotations = {};
+        if (args.topic != null) {
+            const value_2 = new Topic.Topic(args.topic);
+            this.topic = value_2;
+        }
+        else {
+            throw new thrift.TProtocolException(thrift.TProtocolExceptionType.UNKNOWN, "Required field[topic] is unset!");
+        }
+    }
+    static read(input) {
+        return new Follow__Args(exports.Follow__ArgsCodec.decode(input));
+    }
+    static write(args, output) {
+        return exports.Follow__ArgsCodec.encode(args, output);
+    }
+    write(output) {
+        return exports.Follow__ArgsCodec.encode(this, output);
+    }
+}
+exports.Follow__Args = Follow__Args;
+exports.Unfollow__ArgsCodec = {
+    encode(args, output) {
+        const obj = {
+            topic: args.topic
+        };
+        output.writeStructBegin("Unfollow__Args");
+        if (obj.topic != null) {
+            output.writeFieldBegin("topic", thrift.TType.STRUCT, 1);
+            Topic.TopicCodec.encode(obj.topic, output);
+            output.writeFieldEnd();
+        }
+        else {
+            throw new thrift.TProtocolException(thrift.TProtocolExceptionType.UNKNOWN, "Required field[topic] is unset!");
+        }
+        output.writeFieldStop();
+        output.writeStructEnd();
+        return;
+    },
+    decode(input) {
+        let _args = {};
+        input.readStructBegin();
+        while (true) {
+            const ret = input.readFieldBegin();
+            const fieldType = ret.fieldType;
+            const fieldId = ret.fieldId;
+            if (fieldType === thrift.TType.STOP) {
+                break;
+            }
+            switch (fieldId) {
+                case 1:
+                    if (fieldType === thrift.TType.STRUCT) {
+                        const value_3 = Topic.TopicCodec.decode(input);
+                        _args.topic = value_3;
+                    }
+                    else {
+                        input.skip(fieldType);
+                    }
+                    break;
+                default: {
+                    input.skip(fieldType);
+                }
+            }
+            input.readFieldEnd();
+        }
+        input.readStructEnd();
+        if (_args.topic !== undefined) {
+            return {
+                topic: _args.topic
+            };
+        }
+        else {
+            throw new thrift.TProtocolException(thrift.TProtocolExceptionType.UNKNOWN, "Unable to read Unfollow__Args from input");
+        }
+    }
+};
+class Unfollow__Args extends thrift.StructLike {
+    constructor(args) {
+        super();
+        this._annotations = {};
+        this._fieldAnnotations = {};
+        if (args.topic != null) {
+            const value_4 = new Topic.Topic(args.topic);
+            this.topic = value_4;
+        }
+        else {
+            throw new thrift.TProtocolException(thrift.TProtocolExceptionType.UNKNOWN, "Required field[topic] is unset!");
+        }
+    }
+    static read(input) {
+        return new Unfollow__Args(exports.Unfollow__ArgsCodec.decode(input));
+    }
+    static write(args, output) {
+        return exports.Unfollow__ArgsCodec.encode(args, output);
+    }
+    write(output) {
+        return exports.Unfollow__ArgsCodec.encode(this, output);
+    }
+}
+exports.Unfollow__Args = Unfollow__Args;
+exports.IsFollowing__ArgsCodec = {
+    encode(args, output) {
+        const obj = {
+            topic: args.topic
+        };
+        output.writeStructBegin("IsFollowing__Args");
+        if (obj.topic != null) {
+            output.writeFieldBegin("topic", thrift.TType.STRUCT, 1);
+            Topic.TopicCodec.encode(obj.topic, output);
+            output.writeFieldEnd();
+        }
+        else {
+            throw new thrift.TProtocolException(thrift.TProtocolExceptionType.UNKNOWN, "Required field[topic] is unset!");
+        }
+        output.writeFieldStop();
+        output.writeStructEnd();
+        return;
+    },
+    decode(input) {
+        let _args = {};
+        input.readStructBegin();
+        while (true) {
+            const ret = input.readFieldBegin();
+            const fieldType = ret.fieldType;
+            const fieldId = ret.fieldId;
+            if (fieldType === thrift.TType.STOP) {
+                break;
+            }
+            switch (fieldId) {
+                case 1:
+                    if (fieldType === thrift.TType.STRUCT) {
+                        const value_5 = Topic.TopicCodec.decode(input);
+                        _args.topic = value_5;
+                    }
+                    else {
+                        input.skip(fieldType);
+                    }
+                    break;
+                default: {
+                    input.skip(fieldType);
+                }
+            }
+            input.readFieldEnd();
+        }
+        input.readStructEnd();
+        if (_args.topic !== undefined) {
+            return {
+                topic: _args.topic
+            };
+        }
+        else {
+            throw new thrift.TProtocolException(thrift.TProtocolExceptionType.UNKNOWN, "Unable to read IsFollowing__Args from input");
+        }
+    }
+};
+class IsFollowing__Args extends thrift.StructLike {
+    constructor(args) {
+        super();
+        this._annotations = {};
+        this._fieldAnnotations = {};
+        if (args.topic != null) {
+            const value_6 = new Topic.Topic(args.topic);
+            this.topic = value_6;
+        }
+        else {
+            throw new thrift.TProtocolException(thrift.TProtocolExceptionType.UNKNOWN, "Required field[topic] is unset!");
+        }
+    }
+    static read(input) {
+        return new IsFollowing__Args(exports.IsFollowing__ArgsCodec.decode(input));
+    }
+    static write(args, output) {
+        return exports.IsFollowing__ArgsCodec.encode(args, output);
+    }
+    write(output) {
+        return exports.IsFollowing__ArgsCodec.encode(this, output);
+    }
+}
+exports.IsFollowing__Args = IsFollowing__Args;
+exports.Follow__ResultCodec = {
+    encode(args, output) {
+        const obj = {
+            success: args.success
+        };
+        output.writeStructBegin("Follow__Result");
+        if (obj.success != null) {
+            output.writeFieldBegin("success", thrift.TType.BOOL, 0);
+            output.writeBool(obj.success);
+            output.writeFieldEnd();
+        }
+        output.writeFieldStop();
+        output.writeStructEnd();
+        return;
+    },
+    decode(input) {
+        let _args = {};
+        input.readStructBegin();
+        while (true) {
+            const ret = input.readFieldBegin();
+            const fieldType = ret.fieldType;
+            const fieldId = ret.fieldId;
+            if (fieldType === thrift.TType.STOP) {
+                break;
+            }
+            switch (fieldId) {
+                case 0:
+                    if (fieldType === thrift.TType.BOOL) {
+                        const value_7 = input.readBool();
+                        _args.success = value_7;
+                    }
+                    else {
+                        input.skip(fieldType);
+                    }
+                    break;
+                default: {
+                    input.skip(fieldType);
+                }
+            }
+            input.readFieldEnd();
+        }
+        input.readStructEnd();
+        return {
+            success: _args.success
+        };
+    }
+};
+class Follow__Result extends thrift.StructLike {
+    constructor(args = {}) {
+        super();
+        this._annotations = {};
+        this._fieldAnnotations = {};
+        if (args.success != null) {
+            const value_8 = args.success;
+            this.success = value_8;
+        }
+    }
+    static read(input) {
+        return new Follow__Result(exports.Follow__ResultCodec.decode(input));
+    }
+    static write(args, output) {
+        return exports.Follow__ResultCodec.encode(args, output);
+    }
+    write(output) {
+        return exports.Follow__ResultCodec.encode(this, output);
+    }
+}
+exports.Follow__Result = Follow__Result;
+exports.Unfollow__ResultCodec = {
+    encode(args, output) {
+        const obj = {
+            success: args.success
+        };
+        output.writeStructBegin("Unfollow__Result");
+        if (obj.success != null) {
+            output.writeFieldBegin("success", thrift.TType.BOOL, 0);
+            output.writeBool(obj.success);
+            output.writeFieldEnd();
+        }
+        output.writeFieldStop();
+        output.writeStructEnd();
+        return;
+    },
+    decode(input) {
+        let _args = {};
+        input.readStructBegin();
+        while (true) {
+            const ret = input.readFieldBegin();
+            const fieldType = ret.fieldType;
+            const fieldId = ret.fieldId;
+            if (fieldType === thrift.TType.STOP) {
+                break;
+            }
+            switch (fieldId) {
+                case 0:
+                    if (fieldType === thrift.TType.BOOL) {
+                        const value_9 = input.readBool();
+                        _args.success = value_9;
+                    }
+                    else {
+                        input.skip(fieldType);
+                    }
+                    break;
+                default: {
+                    input.skip(fieldType);
+                }
+            }
+            input.readFieldEnd();
+        }
+        input.readStructEnd();
+        return {
+            success: _args.success
+        };
+    }
+};
+class Unfollow__Result extends thrift.StructLike {
+    constructor(args = {}) {
+        super();
+        this._annotations = {};
+        this._fieldAnnotations = {};
+        if (args.success != null) {
+            const value_10 = args.success;
+            this.success = value_10;
+        }
+    }
+    static read(input) {
+        return new Unfollow__Result(exports.Unfollow__ResultCodec.decode(input));
+    }
+    static write(args, output) {
+        return exports.Unfollow__ResultCodec.encode(args, output);
+    }
+    write(output) {
+        return exports.Unfollow__ResultCodec.encode(this, output);
+    }
+}
+exports.Unfollow__Result = Unfollow__Result;
+exports.IsFollowing__ResultCodec = {
+    encode(args, output) {
+        const obj = {
+            success: args.success
+        };
+        output.writeStructBegin("IsFollowing__Result");
+        if (obj.success != null) {
+            output.writeFieldBegin("success", thrift.TType.BOOL, 0);
+            output.writeBool(obj.success);
+            output.writeFieldEnd();
+        }
+        output.writeFieldStop();
+        output.writeStructEnd();
+        return;
+    },
+    decode(input) {
+        let _args = {};
+        input.readStructBegin();
+        while (true) {
+            const ret = input.readFieldBegin();
+            const fieldType = ret.fieldType;
+            const fieldId = ret.fieldId;
+            if (fieldType === thrift.TType.STOP) {
+                break;
+            }
+            switch (fieldId) {
+                case 0:
+                    if (fieldType === thrift.TType.BOOL) {
+                        const value_11 = input.readBool();
+                        _args.success = value_11;
+                    }
+                    else {
+                        input.skip(fieldType);
+                    }
+                    break;
+                default: {
+                    input.skip(fieldType);
+                }
+            }
+            input.readFieldEnd();
+        }
+        input.readStructEnd();
+        return {
+            success: _args.success
+        };
+    }
+};
+class IsFollowing__Result extends thrift.StructLike {
+    constructor(args = {}) {
+        super();
+        this._annotations = {};
+        this._fieldAnnotations = {};
+        if (args.success != null) {
+            const value_12 = args.success;
+            this.success = value_12;
+        }
+    }
+    static read(input) {
+        return new IsFollowing__Result(exports.IsFollowing__ResultCodec.decode(input));
+    }
+    static write(args, output) {
+        return exports.IsFollowing__ResultCodec.encode(args, output);
+    }
+    write(output) {
+        return exports.IsFollowing__ResultCodec.encode(this, output);
+    }
+}
+exports.IsFollowing__Result = IsFollowing__Result;
+class Client extends thrift.ThriftClient {
+    constructor() {
+        super(...arguments);
+        this._serviceName = exports.serviceName;
+        this._annotations = exports.annotations;
+        this._methodAnnotations = exports.methodAnnotations;
+        this._methodNames = exports.methodNames;
+        this._methodParameters = exports.methodParameters;
+    }
+    follow(topic, context) {
+        const writer = new this.transport();
+        const output = new this.protocol(writer);
+        output.writeMessageBegin("follow", thrift.MessageType.CALL, this.incrementRequestId());
+        const args = { topic };
+        exports.Follow__ArgsCodec.encode(args, output);
+        output.writeMessageEnd();
+        return this.connection.send(writer.flush(), context).then((data) => {
+            const reader = this.transport.receiver(data);
+            const input = new this.protocol(reader);
+            try {
+                const { fieldName: fieldName, messageType: messageType } = input.readMessageBegin();
+                if (fieldName === "follow") {
+                    if (messageType === thrift.MessageType.EXCEPTION) {
+                        const err = thrift.TApplicationExceptionCodec.decode(input);
+                        input.readMessageEnd();
+                        return Promise.reject(err);
+                    }
+                    else {
+                        const result = exports.Follow__ResultCodec.decode(input);
+                        input.readMessageEnd();
+                        if (result.success != null) {
+                            return Promise.resolve(result.success);
+                        }
+                        else {
+                            return Promise.reject(new thrift.TApplicationException(thrift.TApplicationExceptionType.UNKNOWN, "follow failed: unknown result"));
+                        }
+                    }
+                }
+                else {
+                    return Promise.reject(new thrift.TApplicationException(thrift.TApplicationExceptionType.WRONG_METHOD_NAME, "Received a response to an unknown RPC function: " + fieldName));
+                }
+            }
+            catch (err) {
+                return Promise.reject(err);
+            }
+        });
+    }
+    unfollow(topic, context) {
+        const writer = new this.transport();
+        const output = new this.protocol(writer);
+        output.writeMessageBegin("unfollow", thrift.MessageType.CALL, this.incrementRequestId());
+        const args = { topic };
+        exports.Unfollow__ArgsCodec.encode(args, output);
+        output.writeMessageEnd();
+        return this.connection.send(writer.flush(), context).then((data) => {
+            const reader = this.transport.receiver(data);
+            const input = new this.protocol(reader);
+            try {
+                const { fieldName: fieldName, messageType: messageType } = input.readMessageBegin();
+                if (fieldName === "unfollow") {
+                    if (messageType === thrift.MessageType.EXCEPTION) {
+                        const err = thrift.TApplicationExceptionCodec.decode(input);
+                        input.readMessageEnd();
+                        return Promise.reject(err);
+                    }
+                    else {
+                        const result = exports.Unfollow__ResultCodec.decode(input);
+                        input.readMessageEnd();
+                        if (result.success != null) {
+                            return Promise.resolve(result.success);
+                        }
+                        else {
+                            return Promise.reject(new thrift.TApplicationException(thrift.TApplicationExceptionType.UNKNOWN, "unfollow failed: unknown result"));
+                        }
+                    }
+                }
+                else {
+                    return Promise.reject(new thrift.TApplicationException(thrift.TApplicationExceptionType.WRONG_METHOD_NAME, "Received a response to an unknown RPC function: " + fieldName));
+                }
+            }
+            catch (err) {
+                return Promise.reject(err);
+            }
+        });
+    }
+    isFollowing(topic, context) {
+        const writer = new this.transport();
+        const output = new this.protocol(writer);
+        output.writeMessageBegin("isFollowing", thrift.MessageType.CALL, this.incrementRequestId());
+        const args = { topic };
+        exports.IsFollowing__ArgsCodec.encode(args, output);
+        output.writeMessageEnd();
+        return this.connection.send(writer.flush(), context).then((data) => {
+            const reader = this.transport.receiver(data);
+            const input = new this.protocol(reader);
+            try {
+                const { fieldName: fieldName, messageType: messageType } = input.readMessageBegin();
+                if (fieldName === "isFollowing") {
+                    if (messageType === thrift.MessageType.EXCEPTION) {
+                        const err = thrift.TApplicationExceptionCodec.decode(input);
+                        input.readMessageEnd();
+                        return Promise.reject(err);
+                    }
+                    else {
+                        const result = exports.IsFollowing__ResultCodec.decode(input);
+                        input.readMessageEnd();
+                        if (result.success != null) {
+                            return Promise.resolve(result.success);
+                        }
+                        else {
+                            return Promise.reject(new thrift.TApplicationException(thrift.TApplicationExceptionType.UNKNOWN, "isFollowing failed: unknown result"));
+                        }
+                    }
+                }
+                else {
+                    return Promise.reject(new thrift.TApplicationException(thrift.TApplicationExceptionType.WRONG_METHOD_NAME, "Received a response to an unknown RPC function: " + fieldName));
+                }
+            }
+            catch (err) {
+                return Promise.reject(err);
+            }
+        });
+    }
+}
+exports.Client = Client;
+Client.serviceName = exports.serviceName;
+Client.annotations = exports.annotations;
+Client.methodAnnotations = exports.methodAnnotations;
+Client.methodNames = exports.methodNames;
+class Processor extends thrift.ThriftProcessor {
+    constructor(handler) {
+        super();
+        this._serviceName = exports.serviceName;
+        this._annotations = exports.annotations;
+        this._methodAnnotations = exports.methodAnnotations;
+        this._methodNames = exports.methodNames;
+        this._handler = handler;
+    }
+    process(input, output, context) {
+        return new Promise((resolve, reject) => {
+            const metadata = input.readMessageBegin();
+            const fieldName = metadata.fieldName;
+            const requestId = metadata.requestId;
+            const methodName = "process_" + fieldName;
+            switch (methodName) {
+                case "process_follow": {
+                    resolve(this.process_follow(requestId, input, output, context));
+                    break;
+                }
+                case "process_unfollow": {
+                    resolve(this.process_unfollow(requestId, input, output, context));
+                    break;
+                }
+                case "process_isFollowing": {
+                    resolve(this.process_isFollowing(requestId, input, output, context));
+                    break;
+                }
+                default: {
+                    input.skip(thrift.TType.STRUCT);
+                    input.readMessageEnd();
+                    const errMessage = "Unknown function " + fieldName;
+                    const err = new thrift.TApplicationException(thrift.TApplicationExceptionType.UNKNOWN_METHOD, errMessage);
+                    output.writeMessageBegin(fieldName, thrift.MessageType.EXCEPTION, requestId);
+                    thrift.TApplicationExceptionCodec.encode(err, output);
+                    output.writeMessageEnd();
+                    resolve(output.flush());
+                    break;
+                }
+            }
+        });
+    }
+    process_follow(requestId, input, output, context) {
+        return new Promise((resolve, reject) => {
+            try {
+                const args = exports.Follow__ArgsCodec.decode(input);
+                input.readMessageEnd();
+                resolve(this._handler.follow(args.topic, context));
+            }
+            catch (err) {
+                reject(err);
+            }
+        }).then((data) => {
+            const result = { success: data };
+            output.writeMessageBegin("follow", thrift.MessageType.REPLY, requestId);
+            exports.Follow__ResultCodec.encode(result, output);
+            output.writeMessageEnd();
+            return output.flush();
+        }).catch((err) => {
+            const result = new thrift.TApplicationException(thrift.TApplicationExceptionType.UNKNOWN, err.message);
+            output.writeMessageBegin("follow", thrift.MessageType.EXCEPTION, requestId);
+            thrift.TApplicationExceptionCodec.encode(result, output);
+            output.writeMessageEnd();
+            return output.flush();
+        });
+    }
+    process_unfollow(requestId, input, output, context) {
+        return new Promise((resolve, reject) => {
+            try {
+                const args = exports.Unfollow__ArgsCodec.decode(input);
+                input.readMessageEnd();
+                resolve(this._handler.unfollow(args.topic, context));
+            }
+            catch (err) {
+                reject(err);
+            }
+        }).then((data) => {
+            const result = { success: data };
+            output.writeMessageBegin("unfollow", thrift.MessageType.REPLY, requestId);
+            exports.Unfollow__ResultCodec.encode(result, output);
+            output.writeMessageEnd();
+            return output.flush();
+        }).catch((err) => {
+            const result = new thrift.TApplicationException(thrift.TApplicationExceptionType.UNKNOWN, err.message);
+            output.writeMessageBegin("unfollow", thrift.MessageType.EXCEPTION, requestId);
+            thrift.TApplicationExceptionCodec.encode(result, output);
+            output.writeMessageEnd();
+            return output.flush();
+        });
+    }
+    process_isFollowing(requestId, input, output, context) {
+        return new Promise((resolve, reject) => {
+            try {
+                const args = exports.IsFollowing__ArgsCodec.decode(input);
+                input.readMessageEnd();
+                resolve(this._handler.isFollowing(args.topic, context));
+            }
+            catch (err) {
+                reject(err);
+            }
+        }).then((data) => {
+            const result = { success: data };
+            output.writeMessageBegin("isFollowing", thrift.MessageType.REPLY, requestId);
+            exports.IsFollowing__ResultCodec.encode(result, output);
+            output.writeMessageEnd();
+            return output.flush();
+        }).catch((err) => {
+            const result = new thrift.TApplicationException(thrift.TApplicationExceptionType.UNKNOWN, err.message);
+            output.writeMessageBegin("isFollowing", thrift.MessageType.EXCEPTION, requestId);
+            thrift.TApplicationExceptionCodec.encode(result, output);
+            output.writeMessageEnd();
+            return output.flush();
+        });
+    }
+}
+exports.Processor = Processor;
+Processor.serviceName = exports.serviceName;
+Processor.annotations = exports.annotations;
+Processor.methodAnnotations = exports.methodAnnotations;
+Processor.methodNames = exports.methodNames;

package/index.d.ts

@@ -16,6 +16,8 @@ import * as Commercial from "./Commercial";
 export { Commercial as Commercial };
 import * as Acquisitions from "./Acquisitions";
 export { Acquisitions as Acquisitions };
+import * as Tag from "./Tag";
+export { Tag as Tag };
 import * as Notifications from "./Notifications";
 export { Notifications as Notifications };
 import * as User from "./User";

package/index.js

@@ -34,6 +34,8 @@ const Commercial = __importStar(require("./Commercial"));
 exports.Commercial = Commercial;
 const Acquisitions = __importStar(require("./Acquisitions"));
 exports.Acquisitions = Acquisitions;
+const Tag = __importStar(require("./Tag"));
+exports.Tag = Tag;
 const Notifications = __importStar(require("./Notifications"));
 exports.Notifications = Notifications;
 const User = __importStar(require("./User"));

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@guardian/bridget",
-  "version": "2.4.0",
+  "version": "2.6.0",
   "description": "",
   "main": "index.js",
   "scripts": {