twilio 5.3.7 → 5.4.1

package/README.md

@@ -58,6 +58,13 @@ After a brief delay, you will receive the text message on your phone.
 > **Warning**
 > It's okay to hardcode your credentials when testing locally, but you should use environment variables to keep them secret before committing any code or deploying to production. Check out [How to Set Environment Variables](https://www.twilio.com/blog/2017/01/how-to-set-environment-variables.html) for more information.
 
+## OAuth Feature for Twilio APIs
+We are introducing Client Credentials Flow-based OAuth 2.0 authentication. This feature is currently in beta and its implementation is subject to change.
+
+API examples [here](https://github.com/twilio/twilio-node/blob/main/examples/public_oauth.js)
+
+Organisation API examples [here](https://github.com/twilio/twilio-node/blob/main/examples/orgs_api.js)
+
 ## Usage
 
 Check out these [code examples](examples) in JavaScript and TypeScript to get up and running quickly.

package/lib/auth_strategy/AuthStrategy.d.ts

@@ -0,0 +1,7 @@
+export default abstract class AuthStrategy {
+    private authType;
+    protected constructor(authType: string);
+    getAuthType(): string;
+    abstract getAuthString(): Promise<string>;
+    abstract requiresAuthentication(): boolean;
+}

package/lib/auth_strategy/AuthStrategy.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+class AuthStrategy {
+    constructor(authType) {
+        this.authType = authType;
+    }
+    getAuthType() {
+        return this.authType;
+    }
+}
+exports.default = AuthStrategy;

package/lib/auth_strategy/BasicAuthStrategy.d.ts

@@ -0,0 +1,8 @@
+import AuthStrategy from "./AuthStrategy";
+export default class BasicAuthStrategy extends AuthStrategy {
+    private username;
+    private password;
+    constructor(username: string, password: string);
+    getAuthString(): Promise<string>;
+    requiresAuthentication(): boolean;
+}

package/lib/auth_strategy/BasicAuthStrategy.js

@@ -0,0 +1,21 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const AuthStrategy_1 = __importDefault(require("./AuthStrategy"));
+class BasicAuthStrategy extends AuthStrategy_1.default {
+    constructor(username, password) {
+        super("basic");
+        this.username = username;
+        this.password = password;
+    }
+    getAuthString() {
+        const auth = Buffer.from(this.username + ":" + this.password).toString("base64");
+        return Promise.resolve(`Basic ${auth}`);
+    }
+    requiresAuthentication() {
+        return true;
+    }
+}
+exports.default = BasicAuthStrategy;

package/lib/auth_strategy/NoAuthStrategy.d.ts

@@ -0,0 +1,6 @@
+import AuthStrategy from "./AuthStrategy";
+export default class NoAuthStrategy extends AuthStrategy {
+    constructor();
+    getAuthString(): Promise<string>;
+    requiresAuthentication(): boolean;
+}

package/lib/auth_strategy/NoAuthStrategy.js

@@ -0,0 +1,18 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const AuthStrategy_1 = __importDefault(require("./AuthStrategy"));
+class NoAuthStrategy extends AuthStrategy_1.default {
+    constructor() {
+        super("noauth");
+    }
+    getAuthString() {
+        return Promise.resolve("");
+    }
+    requiresAuthentication() {
+        return false;
+    }
+}
+exports.default = NoAuthStrategy;

package/lib/auth_strategy/TokenAuthStrategy.d.ts

@@ -0,0 +1,16 @@
+import AuthStrategy from "./AuthStrategy";
+import TokenManager from "../http/bearer_token/TokenManager";
+export default class TokenAuthStrategy extends AuthStrategy {
+    private token;
+    private tokenManager;
+    constructor(tokenManager: TokenManager);
+    getAuthString(): Promise<string>;
+    requiresAuthentication(): boolean;
+    fetchToken(): Promise<string>;
+    /**
+     * Function to check if the token is expired with a buffer of 30 seconds.
+     * @param token - The JWT token as a string.
+     * @returns Boolean indicating if the token is expired.
+     */
+    isTokenExpired(token: string): boolean;
+}

package/lib/auth_strategy/TokenAuthStrategy.js

@@ -0,0 +1,60 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const AuthStrategy_1 = __importDefault(require("./AuthStrategy"));
+const jsonwebtoken_1 = __importDefault(require("jsonwebtoken"));
+class TokenAuthStrategy extends AuthStrategy_1.default {
+    constructor(tokenManager) {
+        super("token");
+        this.token = "";
+        this.tokenManager = tokenManager;
+    }
+    async getAuthString() {
+        return this.fetchToken()
+            .then((token) => {
+            this.token = token;
+            return `Bearer ${this.token}`;
+        })
+            .catch((error) => {
+            throw new Error(`Failed to fetch access token: ${error.message}`);
+        });
+    }
+    requiresAuthentication() {
+        return true;
+    }
+    async fetchToken() {
+        if (this.token == null ||
+            this.token.length === 0 ||
+            this.isTokenExpired(this.token)) {
+            return this.tokenManager.fetchToken();
+        }
+        return Promise.resolve(this.token);
+    }
+    /**
+     * Function to check if the token is expired with a buffer of 30 seconds.
+     * @param token - The JWT token as a string.
+     * @returns Boolean indicating if the token is expired.
+     */
+    isTokenExpired(token) {
+        try {
+            // Decode the token without verifying the signature, as we only want to read the expiration for this check
+            const decoded = jsonwebtoken_1.default.decode(token);
+            if (!decoded || !decoded.exp) {
+                // If the token doesn't have an expiration, consider it expired
+                return true;
+            }
+            const expiresAt = decoded.exp * 1000;
+            const bufferMilliseconds = 30 * 1000;
+            const bufferExpiresAt = expiresAt - bufferMilliseconds;
+            // Return true if the current time is after the expiration time with buffer
+            return Date.now() > bufferExpiresAt;
+        }
+        catch (error) {
+            // If there's an error decoding the token, consider it expired
+            return true;
+        }
+    }
+}
+exports.default = TokenAuthStrategy;

package/lib/base/BaseTwilio.d.ts

@@ -4,6 +4,8 @@
 import RequestClient from "./RequestClient";
 import { HttpMethod } from "../interfaces";
 import { Headers } from "../http/request";
+import AuthStrategy from "../auth_strategy/AuthStrategy";
+import CredentialProvider from "../credential_provider/CredentialProvider";
 declare namespace Twilio {
     interface ClientOpts {
         httpClient?: RequestClient;
@@ -34,6 +36,7 @@ declare namespace Twilio {
         uri?: string;
         username?: string;
         password?: string;
+        authStrategy?: AuthStrategy;
         headers?: Headers;
         params?: object;
         data?: object;
@@ -45,9 +48,10 @@ declare namespace Twilio {
      * Parent class for Twilio Client that implements request & validation logic
      */
     class Client {
-        username: string;
-        password: string;
+        username?: string;
+        password?: string;
         accountSid: string;
+        credentialProvider?: CredentialProvider;
         opts?: ClientOpts;
         env?: NodeJS.ProcessEnv;
         edge?: string;
@@ -83,6 +87,11 @@ declare namespace Twilio {
          * @returns A new instance of BaseTwilio
          */
         constructor(username?: string, password?: string, opts?: ClientOpts);
+        setOpts(opts?: ClientOpts): void;
+        setAccountSid(accountSid?: string): void;
+        setCredentialProvider(credentialProvider: CredentialProvider): void;
+        invalidateBasicAuth(): void;
+        invalidateOAuth(): void;
         get httpClient(): RequestClient;
         /**
          * Makes a request to the Twilio API using the configured http client.

package/lib/base/BaseTwilio.js

@@ -32,23 +32,22 @@ var Twilio;
          */
         /* jshint ignore:end */
         constructor(username, password, opts) {
-            this.opts = opts || {};
-            this.env = this.opts.env || {};
+            this.setOpts(opts);
             this.username =
                 username ??
-                    this.env.TWILIO_ACCOUNT_SID ??
-                    process.env.TWILIO_ACCOUNT_SID ??
-                    (() => {
-                        throw new Error("username is required");
-                    })();
+                    this.env?.TWILIO_ACCOUNT_SID ??
+                    process.env.TWILIO_ACCOUNT_SID;
             this.password =
                 password ??
-                    this.env.TWILIO_AUTH_TOKEN ??
-                    process.env.TWILIO_AUTH_TOKEN ??
-                    (() => {
-                        throw new Error("password is required");
-                    })();
-            this.accountSid = this.opts.accountSid || this.username;
+                    this.env?.TWILIO_AUTH_TOKEN ??
+                    process.env.TWILIO_AUTH_TOKEN;
+            this.accountSid = "";
+            this.setAccountSid(this.opts?.accountSid || this.username);
+            this.invalidateOAuth();
+        }
+        setOpts(opts) {
+            this.opts = opts || {};
+            this.env = this.opts.env || {};
             this.edge =
                 this.opts.edge ?? this.env.TWILIO_EDGE ?? process.env.TWILIO_EDGE;
             this.region =
@@ -73,13 +72,28 @@ var Twilio;
             if (this.opts.lazyLoading === false) {
                 this._httpClient = this.httpClient;
             }
-            if (!this.accountSid.startsWith("AC")) {
-                const apiKeyMsg = this.accountSid.startsWith("SK")
+        }
+        setAccountSid(accountSid) {
+            this.accountSid = accountSid || "";
+            if (this.accountSid && !this.accountSid?.startsWith("AC")) {
+                const apiKeyMsg = this.accountSid?.startsWith("SK")
                     ? ". The given SID indicates an API Key which requires the accountSid to be passed as an additional option"
                     : "";
                 throw new Error("accountSid must start with AC" + apiKeyMsg);
             }
         }
+        setCredentialProvider(credentialProvider) {
+            this.credentialProvider = credentialProvider;
+            this.accountSid = "";
+            this.invalidateBasicAuth();
+        }
+        invalidateBasicAuth() {
+            this.username = undefined;
+            this.password = undefined;
+        }
+        invalidateOAuth() {
+            this.credentialProvider = undefined;
+        }
         get httpClient() {
             if (!this._httpClient) {
                 this._httpClient = new RequestClient_1.default({
@@ -116,6 +130,19 @@ var Twilio;
             }
             const username = opts.username || this.username;
             const password = opts.password || this.password;
+            const authStrategy = opts.authStrategy || this.credentialProvider?.toAuthStrategy();
+            if (!authStrategy) {
+                if (!username) {
+                    (() => {
+                        throw new Error("username is required");
+                    })();
+                }
+                if (!password) {
+                    (() => {
+                        throw new Error("password is required");
+                    })();
+                }
+            }
             const headers = opts.headers || {};
             const pkgVersion = moduleInfo.version;
             const osName = os.platform();
@@ -130,7 +157,7 @@ var Twilio;
                 !headers["Content-Type"]) {
                 headers["Content-Type"] = "application/x-www-form-urlencoded";
             }
-            if (!headers["Accept"]) {
+            if (opts.method !== "delete" && !headers["Accept"]) {
                 headers["Accept"] = "application/json";
             }
             var uri = new url.URL(opts.uri);
@@ -140,6 +167,7 @@ var Twilio;
                 uri: uri.href,
                 username: username,
                 password: password,
+                authStrategy: authStrategy,
                 headers: headers,
                 params: opts.params,
                 data: opts.data,

package/lib/base/Page.js

@@ -153,6 +153,9 @@ class Page {
         if (keys.length === 1) {
             return payload[keys[0]];
         }
+        for (const key of keys)
+            if (Array.isArray(payload[key]))
+                return payload[key];
         throw new Error("Page Records cannot be deserialized");
     }
     forOwn(obj, iteratee) {

package/lib/base/RequestClient.d.ts

@@ -4,6 +4,7 @@ import { HttpMethod } from "../interfaces";
 import { AxiosInstance } from "axios";
 import Response from "../http/response";
 import Request, { Headers } from "../http/request";
+import AuthStrategy from "../auth_strategy/AuthStrategy";
 declare class RequestClient {
     defaultTimeout: number;
     axios: AxiosInstance;
@@ -35,6 +36,7 @@ declare class RequestClient {
      * @param opts.uri - The request uri
      * @param opts.username - The username used for auth
      * @param opts.password - The password used for auth
+     * @param opts.authStrategy - The authStrategy for API call
      * @param opts.headers - The request headers
      * @param opts.params - The request params
      * @param opts.data - The request data
@@ -65,6 +67,10 @@ declare namespace RequestClient {
          * The password used for auth
          */
         password?: string;
+        /**
+         * The AuthStrategy for API Call
+         */
+        authStrategy?: AuthStrategy;
         /**
          * The request headers
          */

package/lib/base/RequestClient.js

@@ -126,6 +126,7 @@ class RequestClient {
      * @param opts.uri - The request uri
      * @param opts.username - The username used for auth
      * @param opts.password - The password used for auth
+     * @param opts.authStrategy - The authStrategy for API call
      * @param opts.headers - The request headers
      * @param opts.params - The request params
      * @param opts.data - The request data
@@ -134,7 +135,7 @@ class RequestClient {
      * @param opts.forever - Set to true to use the forever-agent
      * @param opts.logLevel - Show debug logs
      */
-    request(opts) {
+    async request(opts) {
         if (!opts.method) {
             throw new Error("http method is required");
         }
@@ -149,6 +150,9 @@ class RequestClient {
             auth = Buffer.from(opts.username + ":" + opts.password).toString("base64");
             headers.Authorization = "Basic " + auth;
         }
+        else if (opts.authStrategy) {
+            headers.Authorization = await opts.authStrategy.getAuthString();
+        }
         const options = {
             timeout: opts.timeout || this.defaultTimeout,
             maxRedirects: opts.allowRedirects ? 10 : 0,

package/lib/credential_provider/ClientCredentialProvider.d.ts

@@ -0,0 +1,22 @@
+import CredentialProvider from "./CredentialProvider";
+import TokenManager from "../http/bearer_token/TokenManager";
+import AuthStrategy from "../auth_strategy/AuthStrategy";
+declare class ClientCredentialProvider extends CredentialProvider {
+    grantType: string;
+    clientId: string;
+    clientSecret: string;
+    tokenManager: TokenManager | null;
+    constructor();
+    toAuthStrategy(): AuthStrategy;
+}
+declare namespace ClientCredentialProvider {
+    class ClientCredentialProviderBuilder {
+        private readonly instance;
+        constructor();
+        setClientId(clientId: string): ClientCredentialProviderBuilder;
+        setClientSecret(clientSecret: string): ClientCredentialProviderBuilder;
+        setTokenManager(tokenManager: TokenManager): ClientCredentialProviderBuilder;
+        build(): ClientCredentialProvider;
+    }
+}
+export = ClientCredentialProvider;

package/lib/credential_provider/ClientCredentialProvider.js

@@ -0,0 +1,50 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+const CredentialProvider_1 = __importDefault(require("./CredentialProvider"));
+const ApiTokenManager_1 = __importDefault(require("../http/bearer_token/ApiTokenManager"));
+const TokenAuthStrategy_1 = __importDefault(require("../auth_strategy/TokenAuthStrategy"));
+class ClientCredentialProvider extends CredentialProvider_1.default {
+    constructor() {
+        super("client-credentials");
+        this.grantType = "client_credentials";
+        this.clientId = "";
+        this.clientSecret = "";
+        this.tokenManager = null;
+    }
+    toAuthStrategy() {
+        if (this.tokenManager == null) {
+            this.tokenManager = new ApiTokenManager_1.default({
+                grantType: this.grantType,
+                clientId: this.clientId,
+                clientSecret: this.clientSecret,
+            });
+        }
+        return new TokenAuthStrategy_1.default(this.tokenManager);
+    }
+}
+(function (ClientCredentialProvider) {
+    class ClientCredentialProviderBuilder {
+        constructor() {
+            this.instance = new ClientCredentialProvider();
+        }
+        setClientId(clientId) {
+            this.instance.clientId = clientId;
+            return this;
+        }
+        setClientSecret(clientSecret) {
+            this.instance.clientSecret = clientSecret;
+            return this;
+        }
+        setTokenManager(tokenManager) {
+            this.instance.tokenManager = tokenManager;
+            return this;
+        }
+        build() {
+            return this.instance;
+        }
+    }
+    ClientCredentialProvider.ClientCredentialProviderBuilder = ClientCredentialProviderBuilder;
+})(ClientCredentialProvider || (ClientCredentialProvider = {}));
+module.exports = ClientCredentialProvider;

package/lib/credential_provider/CredentialProvider.d.ts

@@ -0,0 +1,7 @@
+import AuthStrategy from "../auth_strategy/AuthStrategy";
+export default abstract class CredentialProvider {
+    private authType;
+    protected constructor(authType: string);
+    getAuthType(): string;
+    abstract toAuthStrategy(): AuthStrategy;
+}

package/lib/credential_provider/CredentialProvider.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+class CredentialProvider {
+    constructor(authType) {
+        this.authType = authType;
+    }
+    getAuthType() {
+        return this.authType;
+    }
+}
+exports.default = CredentialProvider;

package/lib/credential_provider/NoAuthCredentialProvider.d.ts

@@ -0,0 +1,9 @@
+import CredentialProvider from "./CredentialProvider";
+import AuthStrategy from "../auth_strategy/AuthStrategy";
+declare namespace NoAuthCredentialProvider {
+    class NoAuthCredentialProvider extends CredentialProvider {
+        constructor();
+        toAuthStrategy(): AuthStrategy;
+    }
+}
+export = NoAuthCredentialProvider;

package/lib/credential_provider/NoAuthCredentialProvider.js

@@ -0,0 +1,19 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+const CredentialProvider_1 = __importDefault(require("./CredentialProvider"));
+const NoAuthStrategy_1 = __importDefault(require("../auth_strategy/NoAuthStrategy"));
+var NoAuthCredentialProvider;
+(function (NoAuthCredentialProvider_1) {
+    class NoAuthCredentialProvider extends CredentialProvider_1.default {
+        constructor() {
+            super("noauth");
+        }
+        toAuthStrategy() {
+            return new NoAuthStrategy_1.default();
+        }
+    }
+    NoAuthCredentialProvider_1.NoAuthCredentialProvider = NoAuthCredentialProvider;
+})(NoAuthCredentialProvider || (NoAuthCredentialProvider = {}));
+module.exports = NoAuthCredentialProvider;

package/lib/credential_provider/OrgsCredentialProvider.d.ts

@@ -0,0 +1,22 @@
+import CredentialProvider from "./CredentialProvider";
+import TokenManager from "../http/bearer_token/TokenManager";
+import AuthStrategy from "../auth_strategy/AuthStrategy";
+declare class OrgsCredentialProvider extends CredentialProvider {
+    grantType: string;
+    clientId: string;
+    clientSecret: string;
+    tokenManager: TokenManager | null;
+    constructor();
+    toAuthStrategy(): AuthStrategy;
+}
+declare namespace OrgsCredentialProvider {
+    class OrgsCredentialProviderBuilder {
+        private readonly instance;
+        constructor();
+        setClientId(clientId: string): OrgsCredentialProviderBuilder;
+        setClientSecret(clientSecret: string): OrgsCredentialProviderBuilder;
+        setTokenManager(tokenManager: TokenManager): OrgsCredentialProviderBuilder;
+        build(): OrgsCredentialProvider;
+    }
+}
+export = OrgsCredentialProvider;

package/lib/credential_provider/OrgsCredentialProvider.js

@@ -0,0 +1,50 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+const CredentialProvider_1 = __importDefault(require("./CredentialProvider"));
+const OrgsTokenManager_1 = __importDefault(require("../http/bearer_token/OrgsTokenManager"));
+const TokenAuthStrategy_1 = __importDefault(require("../auth_strategy/TokenAuthStrategy"));
+class OrgsCredentialProvider extends CredentialProvider_1.default {
+    constructor() {
+        super("client-credentials");
+        this.grantType = "client_credentials";
+        this.clientId = "";
+        this.clientSecret = "";
+        this.tokenManager = null;
+    }
+    toAuthStrategy() {
+        if (this.tokenManager == null) {
+            this.tokenManager = new OrgsTokenManager_1.default({
+                grantType: this.grantType,
+                clientId: this.clientId,
+                clientSecret: this.clientSecret,
+            });
+        }
+        return new TokenAuthStrategy_1.default(this.tokenManager);
+    }
+}
+(function (OrgsCredentialProvider) {
+    class OrgsCredentialProviderBuilder {
+        constructor() {
+            this.instance = new OrgsCredentialProvider();
+        }
+        setClientId(clientId) {
+            this.instance.clientId = clientId;
+            return this;
+        }
+        setClientSecret(clientSecret) {
+            this.instance.clientSecret = clientSecret;
+            return this;
+        }
+        setTokenManager(tokenManager) {
+            this.instance.tokenManager = tokenManager;
+            return this;
+        }
+        build() {
+            return this.instance;
+        }
+    }
+    OrgsCredentialProvider.OrgsCredentialProviderBuilder = OrgsCredentialProviderBuilder;
+})(OrgsCredentialProvider || (OrgsCredentialProvider = {}));
+module.exports = OrgsCredentialProvider;

package/lib/http/bearer_token/ApiTokenManager.d.ts

@@ -0,0 +1,8 @@
+import TokenManager from "./TokenManager";
+import { TokenListInstanceCreateOptions } from "../../rest/previewIam/v1/token";
+export default class ApiTokenManager implements TokenManager {
+    private params;
+    constructor(params: TokenListInstanceCreateOptions);
+    getParams(): TokenListInstanceCreateOptions;
+    fetchToken(): Promise<string>;
+}

package/lib/http/bearer_token/ApiTokenManager.js

@@ -0,0 +1,33 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const token_1 = require("../../rest/previewIam/v1/token");
+const PreviewIamBase_1 = __importDefault(require("../../rest/PreviewIamBase"));
+const V1_1 = __importDefault(require("../../rest/previewIam/V1"));
+const NoAuthCredentialProvider_1 = __importDefault(require("../../credential_provider/NoAuthCredentialProvider"));
+const BaseTwilio_1 = require("../../base/BaseTwilio");
+class ApiTokenManager {
+    constructor(params) {
+        this.params = params;
+    }
+    getParams() {
+        return this.params;
+    }
+    async fetchToken() {
+        const noAuthCredentialProvider = new NoAuthCredentialProvider_1.default.NoAuthCredentialProvider();
+        const client = new BaseTwilio_1.Client();
+        client.setCredentialProvider(noAuthCredentialProvider);
+        const tokenListInstance = (0, token_1.TokenListInstance)(new V1_1.default(new PreviewIamBase_1.default(client)));
+        return tokenListInstance
+            .create(this.params)
+            .then((token) => {
+            return token.accessToken;
+        })
+            .catch((error) => {
+            throw new Error(`Error Status Code: ${error.status}\nFailed to fetch access token: ${error.message}`);
+        });
+    }
+}
+exports.default = ApiTokenManager;

package/lib/http/bearer_token/OrgsTokenManager.d.ts

@@ -0,0 +1,8 @@
+import TokenManager from "./TokenManager";
+import { TokenListInstanceCreateOptions } from "../../rest/previewIam/v1/token";
+export default class OrgsTokenManager implements TokenManager {
+    private readonly params;
+    constructor(params: TokenListInstanceCreateOptions);
+    getParams(): TokenListInstanceCreateOptions;
+    fetchToken(): Promise<string>;
+}