@calcom/atoms 1.0.35 → 1.0.36

package/dist/index-psDs_9O0.js

@@ -0,0 +1,4 @@
+import { U as i } from "./UnpublishedEntity-6AN6CU-I.js";
+export {
+  i as UnpublishedEntity
+};

package/dist/{index-0P289PZn.js → index-sA_u6z9V.js}

@@ -1,4 +1,4 @@
-import { T as m, b as n } from "./index-YVMeafN8.js";
+import { T as m, b as n } from "./index-My3dnUlx.js";
 export {
   m as TimezoneSelect,
   n as TimezoneSelectComponent

package/dist/{index-dVp-Ebnc.js → index-zWVUe7ha.js}

@@ -1,6 +1,6 @@
 import { memo as j, useState as T } from "react";
-import { an as k, aH as g, aq as t, aI as U, aJ as N, aK as C, au as b, ar as n, aD as v } from "./index-YVMeafN8.js";
-import { C as A } from "./Card-YXRwzLYs.js";
+import { am as k, aG as g, ap as t, aH as U, aI as N, aJ as C, at as b, aq as n, aC as v } from "./index-My3dnUlx.js";
+import { C as A } from "./Card-soWSbQyc.js";
 const I = [{
   id: 13,
   thumbnailUrl: "https://img.youtube.com/vi/ihE8OYTdklg/0.jpg",

package/dist/{isSupportedCountry-0hC9cf87.js → isSupportedCountry-HO7hQD0z.js}

@@ -1,4 +1,4 @@
-import { aF as t, aG as r } from "./index-YVMeafN8.js";
+import { aE as t, aF as r } from "./index-My3dnUlx.js";
 function o() {
   return t(r, arguments);
 }

package/dist/packages/app-store/_utils/getParsedAppKeysFromSlug.d.ts

@@ -1,4 +1,5 @@
 import type Zod from "zod";
-export declare function getParsedAppKeysFromSlug(slug: string, schema: Zod.Schema): Promise<any>;
+import type z from "zod";
+export declare function getParsedAppKeysFromSlug<T extends Zod.Schema>(slug: string, schema: T): Promise<z.infer<T>>;
 export default getParsedAppKeysFromSlug;
 //# sourceMappingURL=getParsedAppKeysFromSlug.d.ts.map

package/dist/packages/app-store/_utils/getParsedAppKeysFromSlug.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"getParsedAppKeysFromSlug.d.ts","sourceRoot":"","sources":["../../../../../../app-store/_utils/getParsedAppKeysFromSlug.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,GAAG,MAAM,KAAK,CAAC;AAI3B,wBAAsB,wBAAwB,CAAC,IAAI,EAAE,MAAM,EAAE,MAAM,EAAE,GAAG,CAAC,MAAM,gBAG9E;AAED,eAAe,wBAAwB,CAAC"}
+{"version":3,"file":"getParsedAppKeysFromSlug.d.ts","sourceRoot":"","sources":["../../../../../../app-store/_utils/getParsedAppKeysFromSlug.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,GAAG,MAAM,KAAK,CAAC;AAC3B,OAAO,KAAK,CAAC,MAAM,KAAK,CAAC;AAIzB,wBAAsB,wBAAwB,CAAC,CAAC,SAAS,GAAG,CAAC,MAAM,EACjE,IAAI,EAAE,MAAM,EACZ,MAAM,EAAE,CAAC,GACR,OAAO,CAAC,CAAC,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC,CAGrB;AAED,eAAe,wBAAwB,CAAC"}

package/dist/packages/app-store/_utils/invalidateCredential.d.ts

@@ -0,0 +1,3 @@
+import type { CredentialPayload } from "@calcom/types/Credential";
+export declare const invalidateCredential: (credentialId: CredentialPayload["id"]) => Promise<void>;
+//# sourceMappingURL=invalidateCredential.d.ts.map

package/dist/packages/app-store/_utils/invalidateCredential.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"invalidateCredential.d.ts","sourceRoot":"","sources":["../../../../../../app-store/_utils/invalidateCredential.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,0BAA0B,CAAC;AAElE,eAAO,MAAM,oBAAoB,iBAAwB,iBAAiB,CAAC,IAAI,CAAC,kBAiB/E,CAAC"}

package/dist/packages/app-store/_utils/oauth/AxiosLikeResponseToFetchResponse.d.ts

@@ -0,0 +1,13 @@
+/**
+ * This class is used to convert axios like response to fetch response
+ */
+export declare class AxiosLikeResponseToFetchResponse<T extends {
+    status: number;
+    statusText: string;
+    data: unknown;
+}> extends Response {
+    body: any;
+    constructor(axiomResponse: T);
+    json(): Promise<T["data"]>;
+}
+//# sourceMappingURL=AxiosLikeResponseToFetchResponse.d.ts.map

package/dist/packages/app-store/_utils/oauth/AxiosLikeResponseToFetchResponse.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"AxiosLikeResponseToFetchResponse.d.ts","sourceRoot":"","sources":["../../../../../../../app-store/_utils/oauth/AxiosLikeResponseToFetchResponse.ts"],"names":[],"mappings":"AAAA;;GAEG;AACH,qBAAa,gCAAgC,CAC3C,CAAC,SAAS;IACR,MAAM,EAAE,MAAM,CAAC;IACf,UAAU,EAAE,MAAM,CAAC;IACnB,IAAI,EAAE,OAAO,CAAC;CACf,CACD,SAAQ,QAAQ;IAEhB,IAAI,EAAE,GAAG,CAAC;gBACE,aAAa,EAAE,CAAC;IAMtB,IAAI;CAGX"}

package/dist/packages/app-store/_utils/oauth/OAuthManager.d.ts

@@ -0,0 +1,168 @@
+/**
+ * Manages OAuth2.0 tokens for an app and resourceOwner. It automatically refreshes the token when needed.
+ * It is aware of the credential sync endpoint and can sync the token from the third party source.
+ * It is unaware of Prisma and App logic. It is just a utility to manage OAuth2.0 tokens with life cycle methods
+ *
+ * For a recommended usage example, see Zoom VideoApiAdapter.ts
+ */
+import type { z } from "zod";
+import type { AxiosLikeResponseToFetchResponse } from "./AxiosLikeResponseToFetchResponse";
+import type { OAuth2UniversalSchema } from "./universalSchema";
+import { OAuth2UniversalSchemaWithCalcomBackwardCompatibility } from "./universalSchema";
+export declare const enum TokenStatus {
+    UNUSABLE_TOKEN_OBJECT = 0,
+    UNUSABLE_ACCESS_TOKEN = 1,
+    INCONCLUSIVE = 2,
+    VALID = 3
+}
+type ResourceOwner = {
+    id: number | null;
+    type: "team";
+} | {
+    id: number | null;
+    type: "user";
+};
+type FetchNewTokenObject = ({ refreshToken }: {
+    refreshToken: string | null;
+}) => Promise<Response | null>;
+type UpdateTokenObject = (token: z.infer<typeof OAuth2UniversalSchemaWithCalcomBackwardCompatibility>) => Promise<void>;
+type isTokenObjectUnusable = (response: Response) => Promise<{
+    reason: string;
+} | null>;
+type isAccessTokenUnusable = (response: Response) => Promise<{
+    reason: string;
+} | null>;
+type IsTokenExpired = (token: z.infer<typeof OAuth2UniversalSchema>) => Promise<boolean> | boolean;
+type InvalidateTokenObject = () => Promise<void>;
+type ExpireAccessToken = () => Promise<void>;
+type CredentialSyncVariables = {
+    /**
+     * The secret required to access the credential sync endpoint
+     */
+    CREDENTIAL_SYNC_SECRET: string | undefined;
+    /**
+     * The header name that the secret should be passed in
+     */
+    CREDENTIAL_SYNC_SECRET_HEADER_NAME: string;
+    /**
+     * The endpoint where the credential sync should happen
+     */
+    CREDENTIAL_SYNC_ENDPOINT: string | undefined;
+    APP_CREDENTIAL_SHARING_ENABLED: boolean;
+};
+/**
+ * Manages OAuth2.0 tokens for an app and resourceOwner
+ * If expiry_date or expires_in isn't provided in token then it is considered expired immediately(if credential sync is not enabled)
+ * If credential sync is enabled, the token is considered expired after a year. It is expected to be refreshed by the API request from the credential source(as it knows when the token is expired)
+ */
+export declare class OAuthManager {
+    private currentTokenObject;
+    private resourceOwner;
+    private appSlug;
+    private fetchNewTokenObject;
+    private updateTokenObject;
+    private isTokenObjectUnusable;
+    private isAccessTokenUnusable;
+    private isTokenExpired;
+    private invalidateTokenObject;
+    private expireAccessToken;
+    private credentialSyncVariables;
+    private useCredentialSync;
+    private autoCheckTokenExpiryOnRequest;
+    constructor({ resourceOwner, appSlug, currentTokenObject, fetchNewTokenObject, updateTokenObject, isTokenObjectUnusable, isAccessTokenUnusable, invalidateTokenObject, expireAccessToken, credentialSyncVariables, autoCheckTokenExpiryOnRequest, isTokenExpired, }: {
+        /**
+         * The resource owner for which the token is being managed
+         */
+        resourceOwner: ResourceOwner;
+        /**
+         * Does response for any request contain information that refresh_token became invalid and thus the entire token object become unusable
+         * Note: Right now, the implementations of this function makes it so that the response is considered invalid(sometimes) even if just access_token is revoked or invalid. In that case, regenerating access token should work. So, we shouldn't mark the token as invalid in that case.
+         * We should instead mark the token as expired. We could do that by introducing isAccessTokenInvalid function
+         *
+         * @param response
+         * @returns
+         */
+        isTokenObjectUnusable: isTokenObjectUnusable;
+        /**
+         *
+         */
+        isAccessTokenUnusable: isAccessTokenUnusable;
+        /**
+         * The current token object.
+         */
+        currentTokenObject: z.infer<typeof OAuth2UniversalSchema>;
+        /**
+         * The unique identifier of the app that the token is for. It is required to do credential syncing in self-hosting
+         */
+        appSlug: string;
+        /**
+         *
+         * It could be null in case refresh_token isn't available. This is possible when credential sync happens from a third party who doesn't want to share refresh_token and credential syncing has been disabled after the sync has happened.
+         * If credential syncing is still enabled `fetchNewTokenObject` wouldn't be called
+         */
+        fetchNewTokenObject: FetchNewTokenObject;
+        /**
+         * update token object
+         */
+        updateTokenObject: UpdateTokenObject;
+        /**
+         * Handler to invalidate the token object. It is called when the token object is invalid and credential syncing is disabled
+         */
+        invalidateTokenObject: InvalidateTokenObject;
+        expireAccessToken: ExpireAccessToken;
+        /**
+         * The variables required for credential syncing
+         */
+        credentialSyncVariables: CredentialSyncVariables;
+        /**
+         * If the token should be checked for expiry before sending a request
+         */
+        autoCheckTokenExpiryOnRequest?: boolean;
+        /**
+         * If there is a different way to check if the token is expired(and not the standard way of checking expiry_date)
+         */
+        isTokenExpired?: IsTokenExpired;
+    });
+    private isResponseNotOkay;
+    getTokenObjectOrFetch(): Promise<{
+        token: z.objectOutputType<{
+            access_token: z.ZodString;
+            refresh_token: z.ZodOptional<z.ZodString>;
+            token_type: z.ZodOptional<z.ZodString>;
+            scope: z.ZodOptional<z.ZodString>;
+            expiry_date: z.ZodOptional<z.ZodNumber>;
+            expires_in: z.ZodOptional<z.ZodNumber>;
+        }, z.ZodTypeAny, "passthrough">;
+        isUpdated: boolean;
+    }>;
+    request(arg: {
+        url: string;
+        options: RequestInit;
+    }): Promise<{
+        tokenStatus: TokenStatus;
+        json: unknown;
+    }>;
+    request<T>(customFetch: () => Promise<AxiosLikeResponseToFetchResponse<{
+        status: number;
+        statusText: string;
+        data: T;
+    }>>): Promise<{
+        tokenStatus: TokenStatus;
+        json: T;
+    }>;
+    /**
+     * It doesn't automatically detect the response for tokenObject and accessToken becoming invalid
+     * Could be used when you expect a possible non JSON response as well.
+     */
+    requestRaw({ url, options }: {
+        url: string;
+        options: RequestInit;
+    }): Promise<Response>;
+    private onInconclusiveResponse;
+    private invalidate;
+    private normalizeNewlyReceivedToken;
+    private refreshOAuthToken;
+    private getAndValidateOAuth2Response;
+}
+export {};
+//# sourceMappingURL=OAuthManager.d.ts.map

package/dist/packages/app-store/_utils/oauth/OAuthManager.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"OAuthManager.d.ts","sourceRoot":"","sources":["../../../../../../../app-store/_utils/oauth/OAuthManager.ts"],"names":[],"mappings":"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"}

package/dist/packages/app-store/_utils/oauth/OAuthManager.test.d.ts

@@ -0,0 +1 @@
+//# sourceMappingURL=OAuthManager.test.d.ts.map

package/dist/packages/app-store/_utils/oauth/OAuthManager.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"OAuthManager.test.d.ts","sourceRoot":"","sources":["../../../../../../../app-store/_utils/oauth/OAuthManager.test.ts"],"names":[],"mappings":"AAEA,OAAO,mBAAmB,CAAC"}

package/dist/packages/app-store/_utils/oauth/getTokenObjectFromCredential.d.ts

@@ -0,0 +1,10 @@
+import type { CredentialPayload } from "@calcom/types/Credential";
+export declare function getTokenObjectFromCredential(credential: CredentialPayload): import("zod").objectOutputType<{
+    access_token: import("zod").ZodString;
+    refresh_token: import("zod").ZodOptional<import("zod").ZodString>;
+    token_type: import("zod").ZodOptional<import("zod").ZodString>;
+    scope: import("zod").ZodOptional<import("zod").ZodString>;
+    expiry_date: import("zod").ZodOptional<import("zod").ZodNumber>;
+    expires_in: import("zod").ZodOptional<import("zod").ZodNumber>;
+}, import("zod").ZodTypeAny, "passthrough">;
+//# sourceMappingURL=getTokenObjectFromCredential.d.ts.map

package/dist/packages/app-store/_utils/oauth/getTokenObjectFromCredential.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"getTokenObjectFromCredential.d.ts","sourceRoot":"","sources":["../../../../../../../app-store/_utils/oauth/getTokenObjectFromCredential.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,0BAA0B,CAAC;AAIlE,wBAAgB,4BAA4B,CAAC,UAAU,EAAE,iBAAiB;;;;;;;4CAiBzE"}

package/dist/packages/app-store/_utils/oauth/markTokenAsExpired.d.ts

@@ -0,0 +1,3 @@
+import type { CredentialPayload } from "@calcom/types/Credential";
+export declare const markTokenAsExpired: (credential: CredentialPayload) => Promise<void>;
+//# sourceMappingURL=markTokenAsExpired.d.ts.map

package/dist/packages/app-store/_utils/oauth/markTokenAsExpired.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"markTokenAsExpired.d.ts","sourceRoot":"","sources":["../../../../../../../app-store/_utils/oauth/markTokenAsExpired.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,0BAA0B,CAAC;AAIlE,eAAO,MAAM,kBAAkB,eAAsB,iBAAiB,kBAerE,CAAC"}

package/dist/packages/app-store/_utils/oauth/oAuthManagerHelper.d.ts

@@ -0,0 +1,41 @@
+import { getTokenObjectFromCredential } from "./getTokenObjectFromCredential";
+export declare const credentialSyncVariables: {
+    APP_CREDENTIAL_SHARING_ENABLED: boolean;
+    CREDENTIAL_SYNC_ENDPOINT: string | undefined;
+    CREDENTIAL_SYNC_SECRET: string | undefined;
+    CREDENTIAL_SYNC_SECRET_HEADER_NAME: string;
+};
+export declare const oAuthManagerHelper: {
+    updateTokenObject: ({ tokenObject, credentialId, }: {
+        tokenObject: import("zod").objectOutputType<{
+            access_token: import("zod").ZodString;
+            refresh_token: import("zod").ZodOptional<import("zod").ZodString>;
+            token_type: import("zod").ZodOptional<import("zod").ZodString>;
+            scope: import("zod").ZodOptional<import("zod").ZodString>;
+            expiry_date: import("zod").ZodOptional<import("zod").ZodNumber>;
+            expires_in: import("zod").ZodOptional<import("zod").ZodNumber>;
+        }, import("zod").ZodTypeAny, "passthrough">;
+        credentialId: number;
+    }) => Promise<void>;
+    markTokenAsExpired: (credential: {
+        type: string;
+        user: {
+            email: string;
+        } | null;
+        id: number;
+        userId: number | null;
+        invalid: boolean | null;
+        key: import(".prisma/client").Prisma.JsonValue;
+        teamId: number | null;
+        appId: string | null;
+    }) => Promise<void>;
+    invalidateCredential: (credentialId: number) => Promise<void>;
+    getTokenObjectFromCredential: typeof getTokenObjectFromCredential;
+    credentialSyncVariables: {
+        APP_CREDENTIAL_SHARING_ENABLED: boolean;
+        CREDENTIAL_SYNC_ENDPOINT: string | undefined;
+        CREDENTIAL_SYNC_SECRET: string | undefined;
+        CREDENTIAL_SYNC_SECRET_HEADER_NAME: string;
+    };
+};
+//# sourceMappingURL=oAuthManagerHelper.d.ts.map

package/dist/packages/app-store/_utils/oauth/oAuthManagerHelper.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"oAuthManagerHelper.d.ts","sourceRoot":"","sources":["../../../../../../../app-store/_utils/oauth/oAuthManagerHelper.ts"],"names":[],"mappings":"AAQA,OAAO,EAAE,4BAA4B,EAAE,MAAM,gCAAgC,CAAC;AAI9E,eAAO,MAAM,uBAAuB;;;;;CAKnC,CAAC;AAEF,eAAO,MAAM,kBAAkB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAM9B,CAAC"}

package/dist/packages/app-store/_utils/oauth/universalSchema.d.ts

@@ -0,0 +1,110 @@
+import { z } from "zod";
+/**
+ * We should be able to work with just the access token.
+ * access_token allows us to access the resources
+ */
+export declare const OAuth2BareMinimumUniversalSchema: z.ZodObject<{
+    access_token: z.ZodString;
+    /**
+     * It is usually 'Bearer'
+     */
+    token_type: z.ZodOptional<z.ZodString>;
+}, "passthrough", z.ZodTypeAny, z.objectOutputType<{
+    access_token: z.ZodString;
+    /**
+     * It is usually 'Bearer'
+     */
+    token_type: z.ZodOptional<z.ZodString>;
+}, z.ZodTypeAny, "passthrough">, z.objectInputType<{
+    access_token: z.ZodString;
+    /**
+     * It is usually 'Bearer'
+     */
+    token_type: z.ZodOptional<z.ZodString>;
+}, z.ZodTypeAny, "passthrough">>;
+export declare const OAuth2UniversalSchema: z.ZodObject<{
+    access_token: z.ZodString;
+    token_type: z.ZodOptional<z.ZodString>;
+    refresh_token: z.ZodOptional<z.ZodString>;
+    scope: z.ZodOptional<z.ZodString>;
+    expiry_date: z.ZodOptional<z.ZodNumber>;
+}, "passthrough", z.ZodTypeAny, z.objectOutputType<{
+    access_token: z.ZodString;
+    token_type: z.ZodOptional<z.ZodString>;
+    refresh_token: z.ZodOptional<z.ZodString>;
+    scope: z.ZodOptional<z.ZodString>;
+    expiry_date: z.ZodOptional<z.ZodNumber>;
+}, z.ZodTypeAny, "passthrough">, z.objectInputType<{
+    access_token: z.ZodString;
+    token_type: z.ZodOptional<z.ZodString>;
+    refresh_token: z.ZodOptional<z.ZodString>;
+    scope: z.ZodOptional<z.ZodString>;
+    expiry_date: z.ZodOptional<z.ZodNumber>;
+}, z.ZodTypeAny, "passthrough">>;
+export declare const OAuth2UniversalSchemaWithCalcomBackwardCompatibility: z.ZodObject<{
+    access_token: z.ZodString;
+    refresh_token: z.ZodOptional<z.ZodString>;
+    token_type: z.ZodOptional<z.ZodString>;
+    scope: z.ZodOptional<z.ZodString>;
+    expiry_date: z.ZodOptional<z.ZodNumber>;
+    expires_in: z.ZodOptional<z.ZodNumber>;
+}, "passthrough", z.ZodTypeAny, z.objectOutputType<{
+    access_token: z.ZodString;
+    refresh_token: z.ZodOptional<z.ZodString>;
+    token_type: z.ZodOptional<z.ZodString>;
+    scope: z.ZodOptional<z.ZodString>;
+    expiry_date: z.ZodOptional<z.ZodNumber>;
+    expires_in: z.ZodOptional<z.ZodNumber>;
+}, z.ZodTypeAny, "passthrough">, z.objectInputType<{
+    access_token: z.ZodString;
+    refresh_token: z.ZodOptional<z.ZodString>;
+    token_type: z.ZodOptional<z.ZodString>;
+    scope: z.ZodOptional<z.ZodString>;
+    expiry_date: z.ZodOptional<z.ZodNumber>;
+    expires_in: z.ZodOptional<z.ZodNumber>;
+}, z.ZodTypeAny, "passthrough">>;
+export declare const OAuth2TokenResponseInDbWhenExistsSchema: z.ZodObject<{
+    access_token: z.ZodString;
+    refresh_token: z.ZodOptional<z.ZodString>;
+    token_type: z.ZodOptional<z.ZodString>;
+    scope: z.ZodOptional<z.ZodString>;
+    expiry_date: z.ZodOptional<z.ZodNumber>;
+    expires_in: z.ZodOptional<z.ZodNumber>;
+}, "passthrough", z.ZodTypeAny, z.objectOutputType<{
+    access_token: z.ZodString;
+    refresh_token: z.ZodOptional<z.ZodString>;
+    token_type: z.ZodOptional<z.ZodString>;
+    scope: z.ZodOptional<z.ZodString>;
+    expiry_date: z.ZodOptional<z.ZodNumber>;
+    expires_in: z.ZodOptional<z.ZodNumber>;
+}, z.ZodTypeAny, "passthrough">, z.objectInputType<{
+    access_token: z.ZodString;
+    refresh_token: z.ZodOptional<z.ZodString>;
+    token_type: z.ZodOptional<z.ZodString>;
+    scope: z.ZodOptional<z.ZodString>;
+    expiry_date: z.ZodOptional<z.ZodNumber>;
+    expires_in: z.ZodOptional<z.ZodNumber>;
+}, z.ZodTypeAny, "passthrough">>;
+export declare const OAuth2TokenResponseInDbSchema: z.ZodNullable<z.ZodObject<{
+    access_token: z.ZodString;
+    refresh_token: z.ZodOptional<z.ZodString>;
+    token_type: z.ZodOptional<z.ZodString>;
+    scope: z.ZodOptional<z.ZodString>;
+    expiry_date: z.ZodOptional<z.ZodNumber>;
+    expires_in: z.ZodOptional<z.ZodNumber>;
+}, "passthrough", z.ZodTypeAny, z.objectOutputType<{
+    access_token: z.ZodString;
+    refresh_token: z.ZodOptional<z.ZodString>;
+    token_type: z.ZodOptional<z.ZodString>;
+    scope: z.ZodOptional<z.ZodString>;
+    expiry_date: z.ZodOptional<z.ZodNumber>;
+    expires_in: z.ZodOptional<z.ZodNumber>;
+}, z.ZodTypeAny, "passthrough">, z.objectInputType<{
+    access_token: z.ZodString;
+    refresh_token: z.ZodOptional<z.ZodString>;
+    token_type: z.ZodOptional<z.ZodString>;
+    scope: z.ZodOptional<z.ZodString>;
+    expiry_date: z.ZodOptional<z.ZodNumber>;
+    expires_in: z.ZodOptional<z.ZodNumber>;
+}, z.ZodTypeAny, "passthrough">>>;
+//# sourceMappingURL=universalSchema.d.ts.map

package/dist/packages/app-store/_utils/oauth/universalSchema.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"universalSchema.d.ts","sourceRoot":"","sources":["../../../../../../../app-store/_utils/oauth/universalSchema.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAExB;;;GAGG;AACH,eAAO,MAAM,gCAAgC;;IAGzC;;OAEG;;;;IAFH;;OAEG;;;;IAFH;;OAEG;;gCAIS,CAAC;AAEjB,eAAO,MAAM,qBAAqB;;;;;;;;;;;;;;;;;;gCAgBhC,CAAC;AAEH,eAAO,MAAM,oDAAoD;;;;;;;;;;;;;;;;;;;;;gCAM/D,CAAC;AAEH,eAAO,MAAM,uCAAuC;;;;;;;;;;;;;;;;;;;;;gCAAuD,CAAC;AAC5G,eAAO,MAAM,6BAA6B;;;;;;;;;;;;;;;;;;;;;iCAAkE,CAAC"}

package/dist/packages/app-store/_utils/oauth/updateTokenObject.d.ts

@@ -0,0 +1,7 @@
+import type z from "zod";
+import type { OAuth2UniversalSchemaWithCalcomBackwardCompatibility } from "./universalSchema";
+export declare const updateTokenObject: ({ tokenObject, credentialId, }: {
+    tokenObject: z.infer<typeof OAuth2UniversalSchemaWithCalcomBackwardCompatibility>;
+    credentialId: number;
+}) => Promise<void>;
+//# sourceMappingURL=updateTokenObject.d.ts.map

package/dist/packages/app-store/_utils/oauth/updateTokenObject.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"updateTokenObject.d.ts","sourceRoot":"","sources":["../../../../../../../app-store/_utils/oauth/updateTokenObject.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,CAAC,MAAM,KAAK,CAAC;AAIzB,OAAO,KAAK,EAAE,oDAAoD,EAAE,MAAM,mBAAmB,CAAC;AAE9F,eAAO,MAAM,iBAAiB;iBAIf,EAAE,KAAK,CAAC,2DAA2D,CAAC;kBACnE,MAAM;mBAUrB,CAAC"}

package/dist/packages/app-store/_utils/testUtils.d.ts

@@ -0,0 +1,19 @@
+export declare function generateJsonResponse({ json, status, statusText, }: {
+    json: unknown;
+    status?: number;
+    statusText?: string;
+}): Response;
+export declare function internalServerErrorResponse({ json, }: {
+    json: unknown;
+    status?: number;
+    statusText?: string;
+}): Response;
+export declare function generateTextResponse({ text, status, statusText, }: {
+    text: string;
+    status?: number;
+    statusText?: string;
+}): Response;
+export declare function successResponse({ json }: {
+    json: unknown;
+}): Response;
+//# sourceMappingURL=testUtils.d.ts.map

package/dist/packages/app-store/_utils/testUtils.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"testUtils.d.ts","sourceRoot":"","sources":["../../../../../../app-store/_utils/testUtils.ts"],"names":[],"mappings":"AAAA,wBAAgB,oBAAoB,CAAC,EACnC,IAAI,EACJ,MAAY,EACZ,UAAiB,GAClB,EAAE;IACD,IAAI,EAAE,OAAO,CAAC;IACd,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,UAAU,CAAC,EAAE,MAAM,CAAC;CACrB,YAKA;AAED,wBAAgB,2BAA2B,CAAC,EAC1C,IAAI,GACL,EAAE;IACD,IAAI,EAAE,OAAO,CAAC;IACd,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,UAAU,CAAC,EAAE,MAAM,CAAC;CACrB,YAEA;AAED,wBAAgB,oBAAoB,CAAC,EACnC,IAAI,EACJ,MAAY,EACZ,UAAiB,GAClB,EAAE;IACD,IAAI,EAAE,MAAM,CAAC;IACb,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,UAAU,CAAC,EAAE,MAAM,CAAC;CACrB,YAKA;AAED,wBAAgB,eAAe,CAAC,EAAE,IAAI,EAAE,EAAE;IAAE,IAAI,EAAE,OAAO,CAAA;CAAE,YAE1D"}

package/dist/packages/app-store/apps.metadata.generated.d.ts

@@ -137,6 +137,22 @@ export declare const appStoreMetadata: {
             };
         };
     };
+    clic: {
+        "/*": string;
+        name: string;
+        slug: string;
+        type: string;
+        logo: string;
+        url: string;
+        variant: string;
+        categories: string[];
+        publisher: string;
+        email: string;
+        description: string;
+        isTemplate: boolean;
+        __createdUsingCli: boolean;
+        __template: string;
+    };
     closecom: {
         "/*": string;
         name: string;

package/dist/packages/app-store/apps.metadata.generated.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"apps.metadata.generated.d.ts","sourceRoot":"","sources":["../../../../../app-store/apps.metadata.generated.ts"],"names":[],"mappings":"AAyFA,eAAO,MAAM,gBAAgB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAqF5B,CAAC"}
+{"version":3,"file":"apps.metadata.generated.d.ts","sourceRoot":"","sources":["../../../../../app-store/apps.metadata.generated.ts"],"names":[],"mappings":"AA0FA,eAAO,MAAM,gBAAgB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAsF5B,CAAC"}

package/dist/packages/app-store/apps.server.generated.d.ts

@@ -12,6 +12,7 @@ export declare const apiHandlers: {
     "cal-ai": Promise<typeof import("./cal-ai/api")>;
     caldavcalendar: Promise<typeof import("./caldavcalendar/api")>;
     campfire: Promise<typeof import("./campfire/api")>;
+    clic: Promise<typeof import("./clic/api")>;
     closecom: Promise<typeof import("./closecom/api")>;
     cron: Promise<typeof import("./cron/api")>;
     deel: Promise<typeof import("./deel/api")>;

package/dist/packages/app-store/apps.server.generated.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"apps.server.generated.d.ts","sourceRoot":"","sources":["../../../../../app-store/apps.server.generated.ts"],"names":[],"mappings":"AAAA;;;GAGG;AACH,eAAO,MAAM,WAAW;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAoFvB,CAAC"}
+{"version":3,"file":"apps.server.generated.d.ts","sourceRoot":"","sources":["../../../../../app-store/apps.server.generated.ts"],"names":[],"mappings":"AAAA;;;GAGG;AACH,eAAO,MAAM,WAAW;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAqFvB,CAAC"}

package/dist/packages/app-store/clic/api/add.d.ts

@@ -0,0 +1,4 @@
+import type { AppDeclarativeHandler } from "@calcom/types/AppHandler";
+declare const handler: AppDeclarativeHandler;
+export default handler;
+//# sourceMappingURL=add.d.ts.map

package/dist/packages/app-store/clic/api/add.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"add.d.ts","sourceRoot":"","sources":["../../../../../../../app-store/clic/api/add.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,qBAAqB,EAAE,MAAM,0BAA0B,CAAC;AAItE,QAAA,MAAM,OAAO,EAAE,qBAYd,CAAC;AAEF,eAAe,OAAO,CAAC"}

package/dist/packages/app-store/clic/api/index.d.ts

@@ -0,0 +1,2 @@
+export { default as add } from "./add";
+//# sourceMappingURL=index.d.ts.map

package/dist/packages/app-store/clic/api/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../../../app-store/clic/api/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,OAAO,IAAI,GAAG,EAAE,MAAM,OAAO,CAAC"}

package/dist/packages/app-store/clic/config.json.d.ts

@@ -0,0 +1,19 @@
+declare const _default: {
+  "/*": "Don't modify slug - If required, do it using cli edit command",
+  "name": "Clic",
+  "slug": "clic",
+  "type": "check_in_automation",
+  "logo": "icon.svg",
+  "url": "https://clicis.vercel.app",
+  "variant": "automation",
+  "categories": ["automation"],
+  "publisher": "Chris Pacheco",
+  "email": "chrispacheco430@gmail.com",
+  "description": "Create, List and Interact with Your Cal.com links and connections easily.\r\r",
+  "isTemplate": false,
+  "__createdUsingCli": true,
+  "__template": "link-as-an-app"
+}
+;
+
+export default _default;

package/dist/packages/app-store/clic/index.d.ts

@@ -0,0 +1,2 @@
+export * as api from "./api";
+//# sourceMappingURL=index.d.ts.map

package/dist/packages/app-store/clic/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../../app-store/clic/index.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,GAAG,MAAM,OAAO,CAAC"}

package/dist/packages/app-store/googlecalendar/lib/CalendarService.d.ts

@@ -6,8 +6,11 @@ export default class GoogleCalendarService implements Calendar {
     private auth;
     private log;
     private credential;
+    private myGoogleAuth;
+    private oAuthManagerInstance;
     constructor(credential: CredentialPayload);
-    private googleAuth;
+    private getMyGoogleAuthSingleton;
+    private initGoogleAuth;
     authedCalendar: () => Promise<calendar_v3.Calendar>;
     private getAttendees;
     createEvent(calEventRaw: CalendarEvent, credentialId: number): Promise<NewCalendarEventType>;

package/dist/packages/app-store/googlecalendar/lib/CalendarService.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"CalendarService.d.ts","sourceRoot":"","sources":["../../../../../../../app-store/googlecalendar/lib/CalendarService.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,YAAY,CAAC;AAa9C,OAAO,KAAK,EACV,QAAQ,EACR,aAAa,EACb,aAAa,EACb,mBAAmB,EACnB,oBAAoB,EACrB,MAAM,wBAAwB,CAAC;AAChC,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,0BAA0B,CAAC;AA0ClE,MAAM,CAAC,OAAO,OAAO,qBAAsB,YAAW,QAAQ;IAC5D,OAAO,CAAC,eAAe,CAAM;IAC7B,OAAO,CAAC,IAAI,CAA4C;IACxD,OAAO,CAAC,GAAG,CAAgB;IAC3B,OAAO,CAAC,UAAU,CAAoB;gBAE1B,UAAU,EAAE,iBAAiB;IAQzC,OAAO,CAAC,UAAU,CA0DhB;IAEK,cAAc,sCAOnB;IAEF,OAAO,CAAC,YAAY,CAwClB;IAEI,WAAW,CAAC,WAAW,EAAE,aAAa,EAAE,YAAY,EAAE,MAAM,GAAG,OAAO,CAAC,oBAAoB,CAAC;IA8I5F,yBAAyB,CAC7B,gBAAgB,EAAE,MAAM,GAAG,IAAI,GAAG,SAAS,EAC3C,gBAAgB,EAAE,MAAM,EACxB,QAAQ,EAAE,WAAW,CAAC,QAAQ,GAC7B,OAAO,CAAC,WAAW,CAAC,YAAY,CAAC;IAa9B,WAAW,CAAC,GAAG,EAAE,MAAM,EAAE,KAAK,EAAE,aAAa,EAAE,kBAAkB,EAAE,MAAM,GAAG,OAAO,CAAC,GAAG,CAAC;IAyFxF,WAAW,CAAC,GAAG,EAAE,MAAM,EAAE,KAAK,EAAE,aAAa,EAAE,kBAAkB,CAAC,EAAE,MAAM,GAAG,IAAI,GAAG,OAAO,CAAC,IAAI,CAAC;IAiCjG,2BAA2B,CAAC,IAAI,EAAE;QACtC,OAAO,EAAE,MAAM,CAAC;QAChB,OAAO,EAAE,MAAM,CAAC;QAChB,KAAK,EAAE;YAAE,EAAE,EAAE,MAAM,CAAA;SAAE,EAAE,CAAC;KACzB,GAAG,OAAO,CAAC,aAAa,EAAE,GAAG,IAAI,CAAC;IAuE7B,eAAe,CACnB,QAAQ,EAAE,MAAM,EAChB,MAAM,EAAE,MAAM,EACd,iBAAiB,EAAE,mBAAmB,EAAE,GACvC,OAAO,CAAC,aAAa,EAAE,CAAC;IAiErB,aAAa,IAAI,OAAO,CAAC,mBAAmB,EAAE,CAAC;CAqBtD"}
+{"version":3,"file":"CalendarService.d.ts","sourceRoot":"","sources":["../../../../../../../app-store/googlecalendar/lib/CalendarService.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,YAAY,CAAC;AAmB9C,OAAO,KAAK,EACV,QAAQ,EACR,aAAa,EACb,aAAa,EACb,mBAAmB,EACnB,oBAAoB,EACrB,MAAM,wBAAwB,CAAC;AAChC,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,0BAA0B,CAAC;AA+ClE,MAAM,CAAC,OAAO,OAAO,qBAAsB,YAAW,QAAQ;IAC5D,OAAO,CAAC,eAAe,CAAM;IAC7B,OAAO,CAAC,IAAI,CAAyC;IACrD,OAAO,CAAC,GAAG,CAAgB;IAC3B,OAAO,CAAC,UAAU,CAAoB;IACtC,OAAO,CAAC,YAAY,CAAgB;IACpC,OAAO,CAAC,oBAAoB,CAAgB;gBAChC,UAAU,EAAE,iBAAiB;YAO3B,wBAAwB;IAWtC,OAAO,CAAC,cAAc,CAkFpB;IAEK,cAAc,sCAOnB;IAEF,OAAO,CAAC,YAAY,CAwClB;IAEI,WAAW,CAAC,WAAW,EAAE,aAAa,EAAE,YAAY,EAAE,MAAM,GAAG,OAAO,CAAC,oBAAoB,CAAC;IA+I5F,yBAAyB,CAC7B,gBAAgB,EAAE,MAAM,GAAG,IAAI,GAAG,SAAS,EAC3C,gBAAgB,EAAE,MAAM,EACxB,QAAQ,EAAE,WAAW,CAAC,QAAQ,GAC7B,OAAO,CAAC,WAAW,CAAC,YAAY,CAAC;IAa9B,WAAW,CAAC,GAAG,EAAE,MAAM,EAAE,KAAK,EAAE,aAAa,EAAE,kBAAkB,EAAE,MAAM,GAAG,OAAO,CAAC,GAAG,CAAC;IAyFxF,WAAW,CAAC,GAAG,EAAE,MAAM,EAAE,KAAK,EAAE,aAAa,EAAE,kBAAkB,CAAC,EAAE,MAAM,GAAG,IAAI,GAAG,OAAO,CAAC,IAAI,CAAC;IAiCjG,2BAA2B,CAAC,IAAI,EAAE;QACtC,OAAO,EAAE,MAAM,CAAC;QAChB,OAAO,EAAE,MAAM,CAAC;QAChB,KAAK,EAAE;YAAE,EAAE,EAAE,MAAM,CAAA;SAAE,EAAE,CAAC;KACzB,GAAG,OAAO,CAAC,aAAa,EAAE,GAAG,IAAI,CAAC;IA6E7B,eAAe,CACnB,QAAQ,EAAE,MAAM,EAChB,MAAM,EAAE,MAAM,EACd,iBAAiB,EAAE,mBAAmB,EAAE,GACvC,OAAO,CAAC,aAAa,EAAE,CAAC;IAkErB,aAAa,IAAI,OAAO,CAAC,mBAAmB,EAAE,CAAC;CA4BtD"}

package/dist/packages/app-store/googlecalendar/lib/getGoogleAppKeys.d.ts

@@ -1,2 +1,6 @@
-export declare const getGoogleAppKeys: () => Promise<any>;
+export declare const getGoogleAppKeys: () => Promise<{
+    client_id: string;
+    client_secret: string;
+    redirect_uris: string[];
+}>;
 //# sourceMappingURL=getGoogleAppKeys.d.ts.map

package/dist/packages/app-store/googlecalendar/lib/getGoogleAppKeys.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"getGoogleAppKeys.d.ts","sourceRoot":"","sources":["../../../../../../../app-store/googlecalendar/lib/getGoogleAppKeys.ts"],"names":[],"mappings":"AAUA,eAAO,MAAM,gBAAgB,oBAE5B,CAAC"}
+{"version":3,"file":"getGoogleAppKeys.d.ts","sourceRoot":"","sources":["../../../../../../../app-store/googlecalendar/lib/getGoogleAppKeys.ts"],"names":[],"mappings":"AAUA,eAAO,MAAM,gBAAgB;;;;EAE5B,CAAC"}

package/dist/packages/app-store/office365calendar/lib/CalendarService.d.ts

@@ -4,10 +4,7 @@ export default class Office365CalendarService implements Calendar {
     private url;
     private integrationName;
     private log;
-    private accessToken;
-    auth: {
-        getToken: () => Promise<string>;
-    };
+    private auth;
     private apiGraphUrl;
     private credential;
     constructor(credential: CredentialPayload);
@@ -16,7 +13,6 @@ export default class Office365CalendarService implements Calendar {
     deleteEvent(uid: string): Promise<void>;
     getAvailability(dateFrom: string, dateTo: string, selectedCalendars: IntegrationCalendar[]): Promise<EventBusyDate[]>;
     listCalendars(): Promise<IntegrationCalendar[]>;
-    private o365Auth;
     private translateEvent;
     private fetcher;
     private fetchResponsesWithNextLink;