@guardian/bridget 8.4.0 → 8.5.0

package/Environment.d.ts

@@ -34,6 +34,19 @@ export declare class IsMyGuardianEnabled__Args extends thrift.StructLike impleme
     static write(args: IIsMyGuardianEnabled__ArgsArgs, output: thrift.TProtocol): void;
     write(output: thrift.TProtocol): void;
 }
+export interface IIsListenToArticleEnabled__Args {
+}
+export interface IIsListenToArticleEnabled__ArgsArgs {
+}
+export declare const IsListenToArticleEnabled__ArgsCodec: thrift.IStructCodec<IIsListenToArticleEnabled__ArgsArgs, IIsListenToArticleEnabled__Args>;
+export declare class IsListenToArticleEnabled__Args extends thrift.StructLike implements IIsListenToArticleEnabled__Args {
+    readonly _annotations: thrift.IThriftAnnotations;
+    readonly _fieldAnnotations: thrift.IFieldAnnotations;
+    constructor(args?: IIsListenToArticleEnabled__ArgsArgs);
+    static read(input: thrift.TProtocol): IsListenToArticleEnabled__Args;
+    static write(args: IIsListenToArticleEnabled__ArgsArgs, output: thrift.TProtocol): void;
+    write(output: thrift.TProtocol): void;
+}
 export interface INativeThriftPackageVersion__Result {
     success?: string;
 }
@@ -66,6 +79,22 @@ export declare class IsMyGuardianEnabled__Result extends thrift.StructLike imple
     static write(args: IIsMyGuardianEnabled__ResultArgs, output: thrift.TProtocol): void;
     write(output: thrift.TProtocol): void;
 }
+export interface IIsListenToArticleEnabled__Result {
+    success?: boolean;
+}
+export interface IIsListenToArticleEnabled__ResultArgs {
+    success?: boolean;
+}
+export declare const IsListenToArticleEnabled__ResultCodec: thrift.IStructCodec<IIsListenToArticleEnabled__ResultArgs, IIsListenToArticleEnabled__Result>;
+export declare class IsListenToArticleEnabled__Result extends thrift.StructLike implements IIsListenToArticleEnabled__Result {
+    success?: boolean;
+    readonly _annotations: thrift.IThriftAnnotations;
+    readonly _fieldAnnotations: thrift.IFieldAnnotations;
+    constructor(args?: IIsListenToArticleEnabled__ResultArgs);
+    static read(input: thrift.TProtocol): IsListenToArticleEnabled__Result;
+    static write(args: IIsListenToArticleEnabled__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;
@@ -80,10 +109,12 @@ export declare class Client<Context = any> extends thrift.ThriftClient<Context>
     };
     nativeThriftPackageVersion(context?: Context): Promise<string>;
     isMyGuardianEnabled(context?: Context): Promise<boolean>;
+    isListenToArticleEnabled(context?: Context): Promise<boolean>;
 }
 export interface IHandler<Context = any> {
     nativeThriftPackageVersion(context?: Context): string | Promise<string>;
     isMyGuardianEnabled(context?: Context): boolean | Promise<boolean>;
+    isListenToArticleEnabled(context?: Context): boolean | Promise<boolean>;
 }
 export declare class Processor<Context = any> extends thrift.ThriftProcessor<Context, IHandler<Context>> {
     protected readonly _handler: IHandler<Context>;
@@ -99,4 +130,5 @@ export declare class Processor<Context = any> extends thrift.ThriftProcessor<Con
     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>;
+    process_isListenToArticleEnabled(requestId: number, input: thrift.TProtocol, output: thrift.TProtocol, context: Context): Promise<Buffer>;
 }

package/Environment.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.IsMyGuardianEnabled__Result = exports.IsMyGuardianEnabled__ResultCodec = exports.NativeThriftPackageVersion__Result = exports.NativeThriftPackageVersion__ResultCodec = exports.IsMyGuardianEnabled__Args = exports.IsMyGuardianEnabled__ArgsCodec = exports.NativeThriftPackageVersion__Args = exports.NativeThriftPackageVersion__ArgsCodec = exports.methodParameters = exports.methodNames = exports.methodAnnotations = exports.annotations = exports.serviceName = void 0;
+exports.Processor = exports.Client = exports.IsListenToArticleEnabled__Result = exports.IsListenToArticleEnabled__ResultCodec = exports.IsMyGuardianEnabled__Result = exports.IsMyGuardianEnabled__ResultCodec = exports.NativeThriftPackageVersion__Result = exports.NativeThriftPackageVersion__ResultCodec = exports.IsListenToArticleEnabled__Args = exports.IsListenToArticleEnabled__ArgsCodec = exports.IsMyGuardianEnabled__Args = exports.IsMyGuardianEnabled__ArgsCodec = exports.NativeThriftPackageVersion__Args = exports.NativeThriftPackageVersion__ArgsCodec = exports.methodParameters = exports.methodNames = exports.methodAnnotations = exports.annotations = exports.serviceName = void 0;
 /* tslint:disable */
 /* eslint-disable */
 /*
@@ -41,12 +41,17 @@ exports.methodAnnotations = {
     isMyGuardianEnabled: {
         annotations: {},
         fieldAnnotations: {}
+    },
+    isListenToArticleEnabled: {
+        annotations: {},
+        fieldAnnotations: {}
     }
 };
-exports.methodNames = ["nativeThriftPackageVersion", "isMyGuardianEnabled"];
+exports.methodNames = ["nativeThriftPackageVersion", "isMyGuardianEnabled", "isListenToArticleEnabled"];
 exports.methodParameters = {
     nativeThriftPackageVersion: 1,
-    isMyGuardianEnabled: 1
+    isMyGuardianEnabled: 1,
+    isListenToArticleEnabled: 1
 };
 exports.NativeThriftPackageVersion__ArgsCodec = {
     encode(args, output) {
@@ -136,6 +141,50 @@ class IsMyGuardianEnabled__Args extends thrift.StructLike {
     }
 }
 exports.IsMyGuardianEnabled__Args = IsMyGuardianEnabled__Args;
+exports.IsListenToArticleEnabled__ArgsCodec = {
+    encode(args, output) {
+        output.writeStructBegin("IsListenToArticleEnabled__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 IsListenToArticleEnabled__Args extends thrift.StructLike {
+    constructor(args = {}) {
+        super();
+        this._annotations = {};
+        this._fieldAnnotations = {};
+    }
+    static read(input) {
+        return new IsListenToArticleEnabled__Args(exports.IsListenToArticleEnabled__ArgsCodec.decode(input));
+    }
+    static write(args, output) {
+        return exports.IsListenToArticleEnabled__ArgsCodec.encode(args, output);
+    }
+    write(output) {
+        return exports.IsListenToArticleEnabled__ArgsCodec.encode(this, output);
+    }
+}
+exports.IsListenToArticleEnabled__Args = IsListenToArticleEnabled__Args;
 exports.NativeThriftPackageVersion__ResultCodec = {
     encode(args, output) {
         const obj = {
@@ -272,6 +321,74 @@ class IsMyGuardianEnabled__Result extends thrift.StructLike {
     }
 }
 exports.IsMyGuardianEnabled__Result = IsMyGuardianEnabled__Result;
+exports.IsListenToArticleEnabled__ResultCodec = {
+    encode(args, output) {
+        const obj = {
+            success: args.success
+        };
+        output.writeStructBegin("IsListenToArticleEnabled__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_5 = input.readBool();
+                        _args.success = value_5;
+                    }
+                    else {
+                        input.skip(fieldType);
+                    }
+                    break;
+                default: {
+                    input.skip(fieldType);
+                }
+            }
+            input.readFieldEnd();
+        }
+        input.readStructEnd();
+        return {
+            success: _args.success
+        };
+    }
+};
+class IsListenToArticleEnabled__Result extends thrift.StructLike {
+    constructor(args = {}) {
+        super();
+        this._annotations = {};
+        this._fieldAnnotations = {};
+        if (args.success != null) {
+            const value_6 = args.success;
+            this.success = value_6;
+        }
+    }
+    static read(input) {
+        return new IsListenToArticleEnabled__Result(exports.IsListenToArticleEnabled__ResultCodec.decode(input));
+    }
+    static write(args, output) {
+        return exports.IsListenToArticleEnabled__ResultCodec.encode(args, output);
+    }
+    write(output) {
+        return exports.IsListenToArticleEnabled__ResultCodec.encode(this, output);
+    }
+}
+exports.IsListenToArticleEnabled__Result = IsListenToArticleEnabled__Result;
 class Client extends thrift.ThriftClient {
     constructor() {
         super(...arguments);
@@ -357,6 +474,44 @@ class Client extends thrift.ThriftClient {
             }
         });
     }
+    isListenToArticleEnabled(context) {
+        const writer = new this.transport();
+        const output = new this.protocol(writer);
+        output.writeMessageBegin("isListenToArticleEnabled", thrift.MessageType.CALL, this.incrementRequestId());
+        const args = {};
+        exports.IsListenToArticleEnabled__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 === "isListenToArticleEnabled") {
+                    if (messageType === thrift.MessageType.EXCEPTION) {
+                        const err = thrift.TApplicationExceptionCodec.decode(input);
+                        input.readMessageEnd();
+                        return Promise.reject(err);
+                    }
+                    else {
+                        const result = exports.IsListenToArticleEnabled__ResultCodec.decode(input);
+                        input.readMessageEnd();
+                        if (result.success != null) {
+                            return Promise.resolve(result.success);
+                        }
+                        else {
+                            return Promise.reject(new thrift.TApplicationException(thrift.TApplicationExceptionType.UNKNOWN, "isListenToArticleEnabled 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;
@@ -387,6 +542,10 @@ class Processor extends thrift.ThriftProcessor {
                     resolve(this.process_isMyGuardianEnabled(requestId, input, output, context));
                     break;
                 }
+                case "process_isListenToArticleEnabled": {
+                    resolve(this.process_isListenToArticleEnabled(requestId, input, output, context));
+                    break;
+                }
                 default: {
                     input.skip(thrift.TType.STRUCT);
                     input.readMessageEnd();
@@ -447,6 +606,29 @@ class Processor extends thrift.ThriftProcessor {
             return output.flush();
         });
     }
+    process_isListenToArticleEnabled(requestId, input, output, context) {
+        return new Promise((resolve, reject) => {
+            try {
+                input.readMessageEnd();
+                resolve(this._handler.isListenToArticleEnabled(context));
+            }
+            catch (err) {
+                reject(err);
+            }
+        }).then((data) => {
+            const result = { success: data };
+            output.writeMessageBegin("isListenToArticleEnabled", thrift.MessageType.REPLY, requestId);
+            exports.IsListenToArticleEnabled__ResultCodec.encode(result, output);
+            output.writeMessageEnd();
+            return output.flush();
+        }).catch((err) => {
+            const result = new thrift.TApplicationException(thrift.TApplicationExceptionType.UNKNOWN, err.message);
+            output.writeMessageBegin("isListenToArticleEnabled", thrift.MessageType.EXCEPTION, requestId);
+            thrift.TApplicationExceptionCodec.encode(result, output);
+            output.writeMessageEnd();
+            return output.flush();
+        });
+    }
 }
 exports.Processor = Processor;
 Processor.serviceName = exports.serviceName;

package/ListenToArticle.d.ts

@@ -0,0 +1,178 @@
+/// <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 IIsAvailable__Args {
+    articleId: string;
+}
+export interface IIsAvailable__ArgsArgs {
+    articleId: string;
+}
+export declare const IsAvailable__ArgsCodec: thrift.IStructCodec<IIsAvailable__ArgsArgs, IIsAvailable__Args>;
+export declare class IsAvailable__Args extends thrift.StructLike implements IIsAvailable__Args {
+    articleId: string;
+    readonly _annotations: thrift.IThriftAnnotations;
+    readonly _fieldAnnotations: thrift.IFieldAnnotations;
+    constructor(args: IIsAvailable__ArgsArgs);
+    static read(input: thrift.TProtocol): IsAvailable__Args;
+    static write(args: IIsAvailable__ArgsArgs, output: thrift.TProtocol): void;
+    write(output: thrift.TProtocol): void;
+}
+export interface IPlay__Args {
+    articleId: string;
+}
+export interface IPlay__ArgsArgs {
+    articleId: string;
+}
+export declare const Play__ArgsCodec: thrift.IStructCodec<IPlay__ArgsArgs, IPlay__Args>;
+export declare class Play__Args extends thrift.StructLike implements IPlay__Args {
+    articleId: string;
+    readonly _annotations: thrift.IThriftAnnotations;
+    readonly _fieldAnnotations: thrift.IFieldAnnotations;
+    constructor(args: IPlay__ArgsArgs);
+    static read(input: thrift.TProtocol): Play__Args;
+    static write(args: IPlay__ArgsArgs, output: thrift.TProtocol): void;
+    write(output: thrift.TProtocol): void;
+}
+export interface IIsPlaying__Args {
+    articleId: string;
+}
+export interface IIsPlaying__ArgsArgs {
+    articleId: string;
+}
+export declare const IsPlaying__ArgsCodec: thrift.IStructCodec<IIsPlaying__ArgsArgs, IIsPlaying__Args>;
+export declare class IsPlaying__Args extends thrift.StructLike implements IIsPlaying__Args {
+    articleId: string;
+    readonly _annotations: thrift.IThriftAnnotations;
+    readonly _fieldAnnotations: thrift.IFieldAnnotations;
+    constructor(args: IIsPlaying__ArgsArgs);
+    static read(input: thrift.TProtocol): IsPlaying__Args;
+    static write(args: IIsPlaying__ArgsArgs, output: thrift.TProtocol): void;
+    write(output: thrift.TProtocol): void;
+}
+export interface IPause__Args {
+    articleId: string;
+}
+export interface IPause__ArgsArgs {
+    articleId: string;
+}
+export declare const Pause__ArgsCodec: thrift.IStructCodec<IPause__ArgsArgs, IPause__Args>;
+export declare class Pause__Args extends thrift.StructLike implements IPause__Args {
+    articleId: string;
+    readonly _annotations: thrift.IThriftAnnotations;
+    readonly _fieldAnnotations: thrift.IFieldAnnotations;
+    constructor(args: IPause__ArgsArgs);
+    static read(input: thrift.TProtocol): Pause__Args;
+    static write(args: IPause__ArgsArgs, output: thrift.TProtocol): void;
+    write(output: thrift.TProtocol): void;
+}
+export interface IIsAvailable__Result {
+    success?: boolean;
+}
+export interface IIsAvailable__ResultArgs {
+    success?: boolean;
+}
+export declare const IsAvailable__ResultCodec: thrift.IStructCodec<IIsAvailable__ResultArgs, IIsAvailable__Result>;
+export declare class IsAvailable__Result extends thrift.StructLike implements IIsAvailable__Result {
+    success?: boolean;
+    readonly _annotations: thrift.IThriftAnnotations;
+    readonly _fieldAnnotations: thrift.IFieldAnnotations;
+    constructor(args?: IIsAvailable__ResultArgs);
+    static read(input: thrift.TProtocol): IsAvailable__Result;
+    static write(args: IIsAvailable__ResultArgs, output: thrift.TProtocol): void;
+    write(output: thrift.TProtocol): void;
+}
+export interface IPlay__Result {
+    success?: boolean;
+}
+export interface IPlay__ResultArgs {
+    success?: boolean;
+}
+export declare const Play__ResultCodec: thrift.IStructCodec<IPlay__ResultArgs, IPlay__Result>;
+export declare class Play__Result extends thrift.StructLike implements IPlay__Result {
+    success?: boolean;
+    readonly _annotations: thrift.IThriftAnnotations;
+    readonly _fieldAnnotations: thrift.IFieldAnnotations;
+    constructor(args?: IPlay__ResultArgs);
+    static read(input: thrift.TProtocol): Play__Result;
+    static write(args: IPlay__ResultArgs, output: thrift.TProtocol): void;
+    write(output: thrift.TProtocol): void;
+}
+export interface IIsPlaying__Result {
+    success?: boolean;
+}
+export interface IIsPlaying__ResultArgs {
+    success?: boolean;
+}
+export declare const IsPlaying__ResultCodec: thrift.IStructCodec<IIsPlaying__ResultArgs, IIsPlaying__Result>;
+export declare class IsPlaying__Result extends thrift.StructLike implements IIsPlaying__Result {
+    success?: boolean;
+    readonly _annotations: thrift.IThriftAnnotations;
+    readonly _fieldAnnotations: thrift.IFieldAnnotations;
+    constructor(args?: IIsPlaying__ResultArgs);
+    static read(input: thrift.TProtocol): IsPlaying__Result;
+    static write(args: IIsPlaying__ResultArgs, output: thrift.TProtocol): void;
+    write(output: thrift.TProtocol): void;
+}
+export interface IPause__Result {
+    success?: boolean;
+}
+export interface IPause__ResultArgs {
+    success?: boolean;
+}
+export declare const Pause__ResultCodec: thrift.IStructCodec<IPause__ResultArgs, IPause__Result>;
+export declare class Pause__Result extends thrift.StructLike implements IPause__Result {
+    success?: boolean;
+    readonly _annotations: thrift.IThriftAnnotations;
+    readonly _fieldAnnotations: thrift.IFieldAnnotations;
+    constructor(args?: IPause__ResultArgs);
+    static read(input: thrift.TProtocol): Pause__Result;
+    static write(args: IPause__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;
+    };
+    isAvailable(articleId: string, context?: Context): Promise<boolean>;
+    play(articleId: string, context?: Context): Promise<boolean>;
+    isPlaying(articleId: string, context?: Context): Promise<boolean>;
+    pause(articleId: string, context?: Context): Promise<boolean>;
+}
+export interface IHandler<Context = any> {
+    isAvailable(articleId: string, context?: Context): boolean | Promise<boolean>;
+    play(articleId: string, context?: Context): boolean | Promise<boolean>;
+    isPlaying(articleId: string, context?: Context): boolean | Promise<boolean>;
+    pause(articleId: string, 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_isAvailable(requestId: number, input: thrift.TProtocol, output: thrift.TProtocol, context: Context): Promise<Buffer>;
+    process_play(requestId: number, input: thrift.TProtocol, output: thrift.TProtocol, context: Context): Promise<Buffer>;
+    process_isPlaying(requestId: number, input: thrift.TProtocol, output: thrift.TProtocol, context: Context): Promise<Buffer>;
+    process_pause(requestId: number, input: thrift.TProtocol, output: thrift.TProtocol, context: Context): Promise<Buffer>;
+}