@guardian/bridget 7.0.0 → 8.1.0

package/Interaction.d.ts

@@ -0,0 +1,73 @@
+/// <reference types="node" />
+/// <reference types="node" />
+import * as thrift from "@creditkarma/thrift-server-core";
+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 IDisableArticleSwipe__Args {
+    disableSwipe: boolean;
+}
+export interface IDisableArticleSwipe__ArgsArgs {
+    disableSwipe: boolean;
+}
+export declare const DisableArticleSwipe__ArgsCodec: thrift.IStructCodec<IDisableArticleSwipe__ArgsArgs, IDisableArticleSwipe__Args>;
+export declare class DisableArticleSwipe__Args extends thrift.StructLike implements IDisableArticleSwipe__Args {
+    disableSwipe: boolean;
+    readonly _annotations: thrift.IThriftAnnotations;
+    readonly _fieldAnnotations: thrift.IFieldAnnotations;
+    constructor(args: IDisableArticleSwipe__ArgsArgs);
+    static read(input: thrift.TProtocol): DisableArticleSwipe__Args;
+    static write(args: IDisableArticleSwipe__ArgsArgs, output: thrift.TProtocol): void;
+    write(output: thrift.TProtocol): void;
+}
+export interface IDisableArticleSwipe__Result {
+    success?: void;
+}
+export interface IDisableArticleSwipe__ResultArgs {
+    success?: void;
+}
+export declare const DisableArticleSwipe__ResultCodec: thrift.IStructCodec<IDisableArticleSwipe__ResultArgs, IDisableArticleSwipe__Result>;
+export declare class DisableArticleSwipe__Result extends thrift.StructLike implements IDisableArticleSwipe__Result {
+    success?: void;
+    readonly _annotations: thrift.IThriftAnnotations;
+    readonly _fieldAnnotations: thrift.IFieldAnnotations;
+    constructor(args?: IDisableArticleSwipe__ResultArgs);
+    static read(input: thrift.TProtocol): DisableArticleSwipe__Result;
+    static write(args: IDisableArticleSwipe__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;
+    };
+    disableArticleSwipe(disableSwipe: boolean, context?: Context): Promise<void>;
+}
+export interface IHandler<Context = any> {
+    disableArticleSwipe(disableSwipe: boolean, context?: Context): void | Promise<void>;
+}
+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_disableArticleSwipe(requestId: number, input: thrift.TProtocol, output: thrift.TProtocol, context: Context): Promise<Buffer>;
+}

package/Interaction.js

@@ -0,0 +1,295 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Processor = exports.Client = exports.DisableArticleSwipe__Result = exports.DisableArticleSwipe__ResultCodec = exports.DisableArticleSwipe__Args = exports.DisableArticleSwipe__ArgsCodec = exports.methodParameters = exports.methodNames = exports.methodAnnotations = exports.annotations = exports.serviceName = void 0;
+/* 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"));
+exports.serviceName = "Interaction";
+exports.annotations = {};
+exports.methodAnnotations = {
+    disableArticleSwipe: {
+        annotations: {},
+        fieldAnnotations: {}
+    }
+};
+exports.methodNames = ["disableArticleSwipe"];
+exports.methodParameters = {
+    disableArticleSwipe: 2
+};
+exports.DisableArticleSwipe__ArgsCodec = {
+    encode(args, output) {
+        const obj = {
+            disableSwipe: args.disableSwipe
+        };
+        output.writeStructBegin("DisableArticleSwipe__Args");
+        if (obj.disableSwipe != null) {
+            output.writeFieldBegin("disableSwipe", thrift.TType.BOOL, 1);
+            output.writeBool(obj.disableSwipe);
+            output.writeFieldEnd();
+        }
+        else {
+            throw new thrift.TProtocolException(thrift.TProtocolExceptionType.UNKNOWN, "Required field[disableSwipe] 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.BOOL) {
+                        const value_1 = input.readBool();
+                        _args.disableSwipe = value_1;
+                    }
+                    else {
+                        input.skip(fieldType);
+                    }
+                    break;
+                default: {
+                    input.skip(fieldType);
+                }
+            }
+            input.readFieldEnd();
+        }
+        input.readStructEnd();
+        if (_args.disableSwipe !== undefined) {
+            return {
+                disableSwipe: _args.disableSwipe
+            };
+        }
+        else {
+            throw new thrift.TProtocolException(thrift.TProtocolExceptionType.UNKNOWN, "Unable to read DisableArticleSwipe__Args from input");
+        }
+    }
+};
+class DisableArticleSwipe__Args extends thrift.StructLike {
+    constructor(args) {
+        super();
+        this._annotations = {};
+        this._fieldAnnotations = {};
+        if (args.disableSwipe != null) {
+            const value_2 = args.disableSwipe;
+            this.disableSwipe = value_2;
+        }
+        else {
+            throw new thrift.TProtocolException(thrift.TProtocolExceptionType.UNKNOWN, "Required field[disableSwipe] is unset!");
+        }
+    }
+    static read(input) {
+        return new DisableArticleSwipe__Args(exports.DisableArticleSwipe__ArgsCodec.decode(input));
+    }
+    static write(args, output) {
+        return exports.DisableArticleSwipe__ArgsCodec.encode(args, output);
+    }
+    write(output) {
+        return exports.DisableArticleSwipe__ArgsCodec.encode(this, output);
+    }
+}
+exports.DisableArticleSwipe__Args = DisableArticleSwipe__Args;
+exports.DisableArticleSwipe__ResultCodec = {
+    encode(args, output) {
+        output.writeStructBegin("DisableArticleSwipe__Result");
+        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.VOID) {
+                        input.skip(fieldType);
+                    }
+                    else {
+                        input.skip(fieldType);
+                    }
+                    break;
+                default: {
+                    input.skip(fieldType);
+                }
+            }
+            input.readFieldEnd();
+        }
+        input.readStructEnd();
+        return {
+            success: _args.success
+        };
+    }
+};
+class DisableArticleSwipe__Result extends thrift.StructLike {
+    constructor(args = {}) {
+        super();
+        this._annotations = {};
+        this._fieldAnnotations = {};
+        if (args.success != null) {
+            const value_3 = undefined;
+            this.success = value_3;
+        }
+    }
+    static read(input) {
+        return new DisableArticleSwipe__Result(exports.DisableArticleSwipe__ResultCodec.decode(input));
+    }
+    static write(args, output) {
+        return exports.DisableArticleSwipe__ResultCodec.encode(args, output);
+    }
+    write(output) {
+        return exports.DisableArticleSwipe__ResultCodec.encode(this, output);
+    }
+}
+exports.DisableArticleSwipe__Result = DisableArticleSwipe__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;
+    }
+    disableArticleSwipe(disableSwipe, context) {
+        const writer = new this.transport();
+        const output = new this.protocol(writer);
+        output.writeMessageBegin("disableArticleSwipe", thrift.MessageType.CALL, this.incrementRequestId());
+        const args = { disableSwipe };
+        exports.DisableArticleSwipe__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 === "disableArticleSwipe") {
+                    if (messageType === thrift.MessageType.EXCEPTION) {
+                        const err = thrift.TApplicationExceptionCodec.decode(input);
+                        input.readMessageEnd();
+                        return Promise.reject(err);
+                    }
+                    else {
+                        const result = exports.DisableArticleSwipe__ResultCodec.decode(input);
+                        input.readMessageEnd();
+                        return Promise.resolve(result.success);
+                    }
+                }
+                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_disableArticleSwipe": {
+                    resolve(this.process_disableArticleSwipe(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_disableArticleSwipe(requestId, input, output, context) {
+        return new Promise((resolve, reject) => {
+            try {
+                const args = exports.DisableArticleSwipe__ArgsCodec.decode(input);
+                input.readMessageEnd();
+                resolve(this._handler.disableArticleSwipe(args.disableSwipe, context));
+            }
+            catch (err) {
+                reject(err);
+            }
+        }).then((data) => {
+            const result = { success: data };
+            output.writeMessageBegin("disableArticleSwipe", thrift.MessageType.REPLY, requestId);
+            exports.DisableArticleSwipe__ResultCodec.encode(result, output);
+            output.writeMessageEnd();
+            return output.flush();
+        }).catch((err) => {
+            const result = new thrift.TApplicationException(thrift.TApplicationExceptionType.UNKNOWN, err.message);
+            output.writeMessageBegin("disableArticleSwipe", 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/Videos.d.ts

@@ -58,17 +58,20 @@ export declare class SendVideoEvent__Args extends thrift.StructLike implements I
     static write(args: ISendVideoEvent__ArgsArgs, output: thrift.TProtocol): void;
     write(output: thrift.TProtocol): void;
 }
-export interface IFullscreen__Args {
+export interface ISetFullscreen__Args {
+    isFullscreen: boolean;
 }
-export interface IFullscreen__ArgsArgs {
+export interface ISetFullscreen__ArgsArgs {
+    isFullscreen: boolean;
 }
-export declare const Fullscreen__ArgsCodec: thrift.IStructCodec<IFullscreen__ArgsArgs, IFullscreen__Args>;
-export declare class Fullscreen__Args extends thrift.StructLike implements IFullscreen__Args {
+export declare const SetFullscreen__ArgsCodec: thrift.IStructCodec<ISetFullscreen__ArgsArgs, ISetFullscreen__Args>;
+export declare class SetFullscreen__Args extends thrift.StructLike implements ISetFullscreen__Args {
+    isFullscreen: boolean;
     readonly _annotations: thrift.IThriftAnnotations;
     readonly _fieldAnnotations: thrift.IFieldAnnotations;
-    constructor(args?: IFullscreen__ArgsArgs);
-    static read(input: thrift.TProtocol): Fullscreen__Args;
-    static write(args: IFullscreen__ArgsArgs, output: thrift.TProtocol): void;
+    constructor(args: ISetFullscreen__ArgsArgs);
+    static read(input: thrift.TProtocol): SetFullscreen__Args;
+    static write(args: ISetFullscreen__ArgsArgs, output: thrift.TProtocol): void;
     write(output: thrift.TProtocol): void;
 }
 export interface IInsertVideos__Result {
@@ -119,20 +122,20 @@ export declare class SendVideoEvent__Result extends thrift.StructLike implements
     static write(args: ISendVideoEvent__ResultArgs, output: thrift.TProtocol): void;
     write(output: thrift.TProtocol): void;
 }
-export interface IFullscreen__Result {
-    success?: void;
+export interface ISetFullscreen__Result {
+    success?: boolean;
 }
-export interface IFullscreen__ResultArgs {
-    success?: void;
+export interface ISetFullscreen__ResultArgs {
+    success?: boolean;
 }
-export declare const Fullscreen__ResultCodec: thrift.IStructCodec<IFullscreen__ResultArgs, IFullscreen__Result>;
-export declare class Fullscreen__Result extends thrift.StructLike implements IFullscreen__Result {
-    success?: void;
+export declare const SetFullscreen__ResultCodec: thrift.IStructCodec<ISetFullscreen__ResultArgs, ISetFullscreen__Result>;
+export declare class SetFullscreen__Result extends thrift.StructLike implements ISetFullscreen__Result {
+    success?: boolean;
     readonly _annotations: thrift.IThriftAnnotations;
     readonly _fieldAnnotations: thrift.IFieldAnnotations;
-    constructor(args?: IFullscreen__ResultArgs);
-    static read(input: thrift.TProtocol): Fullscreen__Result;
-    static write(args: IFullscreen__ResultArgs, output: thrift.TProtocol): void;
+    constructor(args?: ISetFullscreen__ResultArgs);
+    static read(input: thrift.TProtocol): SetFullscreen__Result;
+    static write(args: ISetFullscreen__ResultArgs, output: thrift.TProtocol): void;
     write(output: thrift.TProtocol): void;
 }
 export declare class Client<Context = any> extends thrift.ThriftClient<Context> {
@@ -150,13 +153,13 @@ export declare class Client<Context = any> extends thrift.ThriftClient<Context>
     insertVideos(videoSlots: Array<VideoSlot.IVideoSlotArgs>, context?: Context): Promise<void>;
     updateVideos(videoSlots: Array<VideoSlot.IVideoSlotArgs>, context?: Context): Promise<void>;
     sendVideoEvent(videoEvent: VideoEvent.IVideoEventArgs, context?: Context): Promise<void>;
-    fullscreen(context?: Context): Promise<void>;
+    setFullscreen(isFullscreen: boolean, context?: Context): Promise<boolean>;
 }
 export interface IHandler<Context = any> {
     insertVideos(videoSlots: Array<VideoSlot.IVideoSlot>, context?: Context): void | Promise<void>;
     updateVideos(videoSlots: Array<VideoSlot.IVideoSlot>, context?: Context): void | Promise<void>;
     sendVideoEvent(videoEvent: VideoEvent.IVideoEvent, context?: Context): void | Promise<void>;
-    fullscreen(context?: Context): void | Promise<void>;
+    setFullscreen(isFullscreen: boolean, context?: Context): boolean | Promise<boolean>;
 }
 export declare class Processor<Context = any> extends thrift.ThriftProcessor<Context, IHandler<Context>> {
     protected readonly _handler: IHandler<Context>;
@@ -173,5 +176,5 @@ export declare class Processor<Context = any> extends thrift.ThriftProcessor<Con
     process_insertVideos(requestId: number, input: thrift.TProtocol, output: thrift.TProtocol, context: Context): Promise<Buffer>;
     process_updateVideos(requestId: number, input: thrift.TProtocol, output: thrift.TProtocol, context: Context): Promise<Buffer>;
     process_sendVideoEvent(requestId: number, input: thrift.TProtocol, output: thrift.TProtocol, context: Context): Promise<Buffer>;
-    process_fullscreen(requestId: number, input: thrift.TProtocol, output: thrift.TProtocol, context: Context): Promise<Buffer>;
+    process_setFullscreen(requestId: number, input: thrift.TProtocol, output: thrift.TProtocol, context: Context): Promise<Buffer>;
 }

package/Videos.js

@@ -23,7 +23,7 @@ var __importStar = (this && this.__importStar) || function (mod) {
     return result;
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.Processor = exports.Client = exports.Fullscreen__Result = exports.Fullscreen__ResultCodec = exports.SendVideoEvent__Result = exports.SendVideoEvent__ResultCodec = exports.UpdateVideos__Result = exports.UpdateVideos__ResultCodec = exports.InsertVideos__Result = exports.InsertVideos__ResultCodec = exports.Fullscreen__Args = exports.Fullscreen__ArgsCodec = exports.SendVideoEvent__Args = exports.SendVideoEvent__ArgsCodec = exports.UpdateVideos__Args = exports.UpdateVideos__ArgsCodec = exports.InsertVideos__Args = exports.InsertVideos__ArgsCodec = exports.methodParameters = exports.methodNames = exports.methodAnnotations = exports.annotations = exports.serviceName = void 0;
+exports.Processor = exports.Client = exports.SetFullscreen__Result = exports.SetFullscreen__ResultCodec = exports.SendVideoEvent__Result = exports.SendVideoEvent__ResultCodec = exports.UpdateVideos__Result = exports.UpdateVideos__ResultCodec = exports.InsertVideos__Result = exports.InsertVideos__ResultCodec = exports.SetFullscreen__Args = exports.SetFullscreen__ArgsCodec = exports.SendVideoEvent__Args = exports.SendVideoEvent__ArgsCodec = exports.UpdateVideos__Args = exports.UpdateVideos__ArgsCodec = exports.InsertVideos__Args = exports.InsertVideos__ArgsCodec = exports.methodParameters = exports.methodNames = exports.methodAnnotations = exports.annotations = exports.serviceName = void 0;
 /* tslint:disable */
 /* eslint-disable */
 /*
@@ -48,17 +48,17 @@ exports.methodAnnotations = {
         annotations: {},
         fieldAnnotations: {}
     },
-    fullscreen: {
+    setFullscreen: {
         annotations: {},
         fieldAnnotations: {}
     }
 };
-exports.methodNames = ["insertVideos", "updateVideos", "sendVideoEvent", "fullscreen"];
+exports.methodNames = ["insertVideos", "updateVideos", "sendVideoEvent", "setFullscreen"];
 exports.methodParameters = {
     insertVideos: 2,
     updateVideos: 2,
     sendVideoEvent: 2,
-    fullscreen: 1
+    setFullscreen: 2
 };
 exports.InsertVideos__ArgsCodec = {
     encode(args, output) {
@@ -327,14 +327,26 @@ class SendVideoEvent__Args extends thrift.StructLike {
     }
 }
 exports.SendVideoEvent__Args = SendVideoEvent__Args;
-exports.Fullscreen__ArgsCodec = {
+exports.SetFullscreen__ArgsCodec = {
     encode(args, output) {
-        output.writeStructBegin("Fullscreen__Args");
+        const obj = {
+            isFullscreen: args.isFullscreen
+        };
+        output.writeStructBegin("SetFullscreen__Args");
+        if (obj.isFullscreen != null) {
+            output.writeFieldBegin("isFullscreen", thrift.TType.BOOL, 1);
+            output.writeBool(obj.isFullscreen);
+            output.writeFieldEnd();
+        }
+        else {
+            throw new thrift.TProtocolException(thrift.TProtocolExceptionType.UNKNOWN, "Required field[isFullscreen] is unset!");
+        }
         output.writeFieldStop();
         output.writeStructEnd();
         return;
     },
     decode(input) {
+        let _args = {};
         input.readStructBegin();
         while (true) {
             const ret = input.readFieldBegin();
@@ -344,6 +356,15 @@ exports.Fullscreen__ArgsCodec = {
                 break;
             }
             switch (fieldId) {
+                case 1:
+                    if (fieldType === thrift.TType.BOOL) {
+                        const value_15 = input.readBool();
+                        _args.isFullscreen = value_15;
+                    }
+                    else {
+                        input.skip(fieldType);
+                    }
+                    break;
                 default: {
                     input.skip(fieldType);
                 }
@@ -351,26 +372,40 @@ exports.Fullscreen__ArgsCodec = {
             input.readFieldEnd();
         }
         input.readStructEnd();
-        return {};
+        if (_args.isFullscreen !== undefined) {
+            return {
+                isFullscreen: _args.isFullscreen
+            };
+        }
+        else {
+            throw new thrift.TProtocolException(thrift.TProtocolExceptionType.UNKNOWN, "Unable to read SetFullscreen__Args from input");
+        }
     }
 };
-class Fullscreen__Args extends thrift.StructLike {
-    constructor(args = {}) {
+class SetFullscreen__Args extends thrift.StructLike {
+    constructor(args) {
         super();
         this._annotations = {};
         this._fieldAnnotations = {};
+        if (args.isFullscreen != null) {
+            const value_16 = args.isFullscreen;
+            this.isFullscreen = value_16;
+        }
+        else {
+            throw new thrift.TProtocolException(thrift.TProtocolExceptionType.UNKNOWN, "Required field[isFullscreen] is unset!");
+        }
     }
     static read(input) {
-        return new Fullscreen__Args(exports.Fullscreen__ArgsCodec.decode(input));
+        return new SetFullscreen__Args(exports.SetFullscreen__ArgsCodec.decode(input));
     }
     static write(args, output) {
-        return exports.Fullscreen__ArgsCodec.encode(args, output);
+        return exports.SetFullscreen__ArgsCodec.encode(args, output);
     }
     write(output) {
-        return exports.Fullscreen__ArgsCodec.encode(this, output);
+        return exports.SetFullscreen__ArgsCodec.encode(this, output);
     }
 }
-exports.Fullscreen__Args = Fullscreen__Args;
+exports.SetFullscreen__Args = SetFullscreen__Args;
 exports.InsertVideos__ResultCodec = {
     encode(args, output) {
         output.writeStructBegin("InsertVideos__Result");
@@ -415,8 +450,8 @@ class InsertVideos__Result extends thrift.StructLike {
         this._annotations = {};
         this._fieldAnnotations = {};
         if (args.success != null) {
-            const value_15 = undefined;
-            this.success = value_15;
+            const value_17 = undefined;
+            this.success = value_17;
         }
     }
     static read(input) {
@@ -474,8 +509,8 @@ class UpdateVideos__Result extends thrift.StructLike {
         this._annotations = {};
         this._fieldAnnotations = {};
         if (args.success != null) {
-            const value_16 = undefined;
-            this.success = value_16;
+            const value_18 = undefined;
+            this.success = value_18;
         }
     }
     static read(input) {
@@ -533,8 +568,8 @@ class SendVideoEvent__Result extends thrift.StructLike {
         this._annotations = {};
         this._fieldAnnotations = {};
         if (args.success != null) {
-            const value_17 = undefined;
-            this.success = value_17;
+            const value_19 = undefined;
+            this.success = value_19;
         }
     }
     static read(input) {
@@ -548,9 +583,17 @@ class SendVideoEvent__Result extends thrift.StructLike {
     }
 }
 exports.SendVideoEvent__Result = SendVideoEvent__Result;
-exports.Fullscreen__ResultCodec = {
+exports.SetFullscreen__ResultCodec = {
     encode(args, output) {
-        output.writeStructBegin("Fullscreen__Result");
+        const obj = {
+            success: args.success
+        };
+        output.writeStructBegin("SetFullscreen__Result");
+        if (obj.success != null) {
+            output.writeFieldBegin("success", thrift.TType.BOOL, 0);
+            output.writeBool(obj.success);
+            output.writeFieldEnd();
+        }
         output.writeFieldStop();
         output.writeStructEnd();
         return;
@@ -567,8 +610,9 @@ exports.Fullscreen__ResultCodec = {
             }
             switch (fieldId) {
                 case 0:
-                    if (fieldType === thrift.TType.VOID) {
-                        input.skip(fieldType);
+                    if (fieldType === thrift.TType.BOOL) {
+                        const value_20 = input.readBool();
+                        _args.success = value_20;
                     }
                     else {
                         input.skip(fieldType);
@@ -586,27 +630,27 @@ exports.Fullscreen__ResultCodec = {
         };
     }
 };
-class Fullscreen__Result extends thrift.StructLike {
+class SetFullscreen__Result extends thrift.StructLike {
     constructor(args = {}) {
         super();
         this._annotations = {};
         this._fieldAnnotations = {};
         if (args.success != null) {
-            const value_18 = undefined;
-            this.success = value_18;
+            const value_21 = args.success;
+            this.success = value_21;
         }
     }
     static read(input) {
-        return new Fullscreen__Result(exports.Fullscreen__ResultCodec.decode(input));
+        return new SetFullscreen__Result(exports.SetFullscreen__ResultCodec.decode(input));
     }
     static write(args, output) {
-        return exports.Fullscreen__ResultCodec.encode(args, output);
+        return exports.SetFullscreen__ResultCodec.encode(args, output);
     }
     write(output) {
-        return exports.Fullscreen__ResultCodec.encode(this, output);
+        return exports.SetFullscreen__ResultCodec.encode(this, output);
     }
 }
-exports.Fullscreen__Result = Fullscreen__Result;
+exports.SetFullscreen__Result = SetFullscreen__Result;
 class Client extends thrift.ThriftClient {
     constructor() {
         super(...arguments);
@@ -715,28 +759,33 @@ class Client extends thrift.ThriftClient {
             }
         });
     }
-    fullscreen(context) {
+    setFullscreen(isFullscreen, context) {
         const writer = new this.transport();
         const output = new this.protocol(writer);
-        output.writeMessageBegin("fullscreen", thrift.MessageType.CALL, this.incrementRequestId());
-        const args = {};
-        exports.Fullscreen__ArgsCodec.encode(args, output);
+        output.writeMessageBegin("setFullscreen", thrift.MessageType.CALL, this.incrementRequestId());
+        const args = { isFullscreen };
+        exports.SetFullscreen__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 === "fullscreen") {
+                if (fieldName === "setFullscreen") {
                     if (messageType === thrift.MessageType.EXCEPTION) {
                         const err = thrift.TApplicationExceptionCodec.decode(input);
                         input.readMessageEnd();
                         return Promise.reject(err);
                     }
                     else {
-                        const result = exports.Fullscreen__ResultCodec.decode(input);
+                        const result = exports.SetFullscreen__ResultCodec.decode(input);
                         input.readMessageEnd();
-                        return Promise.resolve(result.success);
+                        if (result.success != null) {
+                            return Promise.resolve(result.success);
+                        }
+                        else {
+                            return Promise.reject(new thrift.TApplicationException(thrift.TApplicationExceptionType.UNKNOWN, "setFullscreen failed: unknown result"));
+                        }
                     }
                 }
                 else {
@@ -782,8 +831,8 @@ class Processor extends thrift.ThriftProcessor {
                     resolve(this.process_sendVideoEvent(requestId, input, output, context));
                     break;
                 }
-                case "process_fullscreen": {
-                    resolve(this.process_fullscreen(requestId, input, output, context));
+                case "process_setFullscreen": {
+                    resolve(this.process_setFullscreen(requestId, input, output, context));
                     break;
                 }
                 default: {
@@ -872,24 +921,25 @@ class Processor extends thrift.ThriftProcessor {
             return output.flush();
         });
     }
-    process_fullscreen(requestId, input, output, context) {
+    process_setFullscreen(requestId, input, output, context) {
         return new Promise((resolve, reject) => {
             try {
+                const args = exports.SetFullscreen__ArgsCodec.decode(input);
                 input.readMessageEnd();
-                resolve(this._handler.fullscreen(context));
+                resolve(this._handler.setFullscreen(args.isFullscreen, context));
             }
             catch (err) {
                 reject(err);
             }
         }).then((data) => {
             const result = { success: data };
-            output.writeMessageBegin("fullscreen", thrift.MessageType.REPLY, requestId);
-            exports.Fullscreen__ResultCodec.encode(result, output);
+            output.writeMessageBegin("setFullscreen", thrift.MessageType.REPLY, requestId);
+            exports.SetFullscreen__ResultCodec.encode(result, output);
             output.writeMessageEnd();
             return output.flush();
         }).catch((err) => {
             const result = new thrift.TApplicationException(thrift.TApplicationExceptionType.UNKNOWN, err.message);
-            output.writeMessageBegin("fullscreen", thrift.MessageType.EXCEPTION, requestId);
+            output.writeMessageBegin("setFullscreen", thrift.MessageType.EXCEPTION, requestId);
             thrift.TApplicationExceptionCodec.encode(result, output);
             output.writeMessageEnd();
             return output.flush();

package/index.d.ts

@@ -41,3 +41,5 @@ import * as Navigation from "./Navigation";
 export { Navigation as Navigation };
 import * as Newsletters from "./Newsletters";
 export { Newsletters as Newsletters };
+import * as Interaction from "./Interaction";
+export { Interaction as Interaction };

package/index.js

@@ -26,7 +26,7 @@ var __importStar = (this && this.__importStar) || function (mod) {
     return result;
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.Newsletters = exports.Navigation = exports.Analytics = exports.Discussion = exports.Metrics = exports.Videos = exports.Gallery = exports.User = exports.Notifications = exports.Tag = exports.Acquisitions = exports.Commercial = exports.Environment = void 0;
+exports.Interaction = exports.Newsletters = exports.Navigation = exports.Analytics = exports.Discussion = exports.Metrics = exports.Videos = exports.Gallery = exports.User = exports.Notifications = exports.Tag = exports.Acquisitions = exports.Commercial = exports.Environment = void 0;
 /* tslint:disable */
 /* eslint-disable */
 /*
@@ -76,3 +76,5 @@ const Navigation = __importStar(require("./Navigation"));
 exports.Navigation = Navigation;
 const Newsletters = __importStar(require("./Newsletters"));
 exports.Newsletters = Newsletters;
+const Interaction = __importStar(require("./Interaction"));
+exports.Interaction = Interaction;

package/package.json

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