@8ms/helpers 2.2.26 → 2.3.2

package/googleAds/keywordPlanner/server/googleAdsKeywordPlanner.d.ts

@@ -0,0 +1,41 @@
+import { z } from "zod/v4";
+export declare const Network: {
+    readonly GOOGLE_SEARCH_ONLY: 2;
+    readonly GOOGLE_SEARCH_AND_PARTNERS: 3;
+};
+export type Network = typeof Network[keyof typeof Network];
+export declare const requestSchema: z.ZodObject<{
+    countries: z.ZodOptional<z.ZodArray<z.ZodNumber>>;
+    customerId: z.ZodOptional<z.ZodString>;
+    historicalMetricsOptions: z.ZodOptional<z.ZodObject<{
+        startMonth: z.ZodString;
+        startYear: z.ZodNumber;
+        endMonth: z.ZodString;
+        endYear: z.ZodNumber;
+    }, z.core.$strip>>;
+    includeAdultKeywords: z.ZodOptional<z.ZodBoolean>;
+    keywordPlanNetwork: z.ZodOptional<z.ZodNumber>;
+    queries: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    language: z.ZodOptional<z.ZodNumber>;
+    url: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+export type RequestSchemaType = z.infer<typeof requestSchema>;
+export declare const defaultRequest: RequestSchemaType;
+export declare const responseSchema: z.ZodObject<{
+    payload: z.ZodObject<{}, z.core.$strip>;
+    keyword: z.ZodString;
+    avgCpc: z.ZodNumber;
+    avgSearchVolume: z.ZodNumber;
+    competition: z.ZodNumber;
+    competitionIndex: z.ZodNumber;
+    months: z.ZodArray<z.ZodObject<{
+        date: z.ZodString;
+        month: z.ZodNumber;
+        searchVolume: z.ZodNumber;
+        year: z.ZodNumber;
+    }, z.core.$strip>>;
+    topOfPageBidHigh: z.ZodNumber;
+    topOfPageBidLow: z.ZodNumber;
+    totalSearchVolume: z.ZodNumber;
+}, z.core.$strip>;
+export type ResponseSchemaType = z.infer<typeof responseSchema>;

package/googleAds/keywordPlanner/server/googleAdsKeywordPlanner.js

@@ -0,0 +1,55 @@
+import { z } from "zod/v4";
+export const Network = {
+    GOOGLE_SEARCH_ONLY: 2,
+    GOOGLE_SEARCH_AND_PARTNERS: 3,
+};
+export const requestSchema = z.object({
+    countries: z.array(z.number())
+        .optional(),
+    customerId: z.string()
+        .optional(),
+    historicalMetricsOptions: z.object({
+        startMonth: z.string(),
+        startYear: z.number(),
+        endMonth: z.string(),
+        endYear: z.number(),
+    })
+        .optional(),
+    includeAdultKeywords: z.boolean()
+        .optional(),
+    keywordPlanNetwork: z.number()
+        .optional(),
+    queries: z.array(z.string())
+        .optional(),
+    language: z.number()
+        .optional(),
+    url: z.string()
+        .optional(),
+});
+export const defaultRequest = {
+    countries: [],
+    customerId: "",
+    historicalMetricsOptions: null,
+    includeAdultKeywords: false,
+    keywordPlanNetwork: Network.GOOGLE_SEARCH_ONLY,
+    queries: [],
+    language: null,
+};
+export const responseSchema = z.object({
+    payload: z.object(),
+    keyword: z.string(),
+    avgCpc: z.number(),
+    avgSearchVolume: z.number(),
+    competition: z.number(),
+    competitionIndex: z.number(),
+    months: z.object({
+        date: z.string(),
+        month: z.number(),
+        searchVolume: z.number(),
+        year: z.number(),
+    })
+        .array(),
+    topOfPageBidHigh: z.number(),
+    topOfPageBidLow: z.number(),
+    totalSearchVolume: z.number(),
+});

package/googleAds/keywordPlanner/server/index.d.ts

@@ -1,41 +1 @@
-import { z } from "zod/v4";
-export declare const Network: {
-    readonly GOOGLE_SEARCH_ONLY: 2;
-    readonly GOOGLE_SEARCH_AND_PARTNERS: 3;
-};
-export type Network = typeof Network[keyof typeof Network];
-export declare const requestSchema: z.ZodObject<{
-    countries: z.ZodOptional<z.ZodArray<z.ZodNumber>>;
-    customerId: z.ZodOptional<z.ZodString>;
-    historicalMetricsOptions: z.ZodOptional<z.ZodObject<{
-        startMonth: z.ZodString;
-        startYear: z.ZodNumber;
-        endMonth: z.ZodString;
-        endYear: z.ZodNumber;
-    }, z.core.$strip>>;
-    includeAdultKeywords: z.ZodOptional<z.ZodBoolean>;
-    keywordPlanNetwork: z.ZodOptional<z.ZodNumber>;
-    queries: z.ZodOptional<z.ZodArray<z.ZodString>>;
-    language: z.ZodOptional<z.ZodNumber>;
-    url: z.ZodOptional<z.ZodString>;
-}, z.core.$strip>;
-export type RequestSchemaType = z.infer<typeof requestSchema>;
-export declare const defaultRequest: RequestSchemaType;
-export declare const responseSchema: z.ZodObject<{
-    payload: z.ZodObject<{}, z.core.$strip>;
-    keyword: z.ZodString;
-    avgCpc: z.ZodNumber;
-    avgSearchVolume: z.ZodNumber;
-    competition: z.ZodNumber;
-    competitionIndex: z.ZodNumber;
-    months: z.ZodArray<z.ZodObject<{
-        date: z.ZodString;
-        month: z.ZodNumber;
-        searchVolume: z.ZodNumber;
-        year: z.ZodNumber;
-    }, z.core.$strip>>;
-    topOfPageBidHigh: z.ZodNumber;
-    topOfPageBidLow: z.ZodNumber;
-    totalSearchVolume: z.ZodNumber;
-}, z.core.$strip>;
-export type ResponseSchemaType = z.infer<typeof responseSchema>;
+export * from "./googleAdsKeywordPlanner";

package/googleAds/keywordPlanner/server/index.js

@@ -1,55 +1 @@
-import { z } from "zod/v4";
-export const Network = {
-    GOOGLE_SEARCH_ONLY: 2,
-    GOOGLE_SEARCH_AND_PARTNERS: 3,
-};
-export const requestSchema = z.object({
-    countries: z.array(z.number())
-        .optional(),
-    customerId: z.string()
-        .optional(),
-    historicalMetricsOptions: z.object({
-        startMonth: z.string(),
-        startYear: z.number(),
-        endMonth: z.string(),
-        endYear: z.number(),
-    })
-        .optional(),
-    includeAdultKeywords: z.boolean()
-        .optional(),
-    keywordPlanNetwork: z.number()
-        .optional(),
-    queries: z.array(z.string())
-        .optional(),
-    language: z.number()
-        .optional(),
-    url: z.string()
-        .optional(),
-});
-export const defaultRequest = {
-    countries: [],
-    customerId: "",
-    historicalMetricsOptions: null,
-    includeAdultKeywords: false,
-    keywordPlanNetwork: Network.GOOGLE_SEARCH_ONLY,
-    queries: [],
-    language: null,
-};
-export const responseSchema = z.object({
-    payload: z.object(),
-    keyword: z.string(),
-    avgCpc: z.number(),
-    avgSearchVolume: z.number(),
-    competition: z.number(),
-    competitionIndex: z.number(),
-    months: z.object({
-        date: z.string(),
-        month: z.number(),
-        searchVolume: z.number(),
-        year: z.number(),
-    })
-        .array(),
-    topOfPageBidHigh: z.number(),
-    topOfPageBidLow: z.number(),
-    totalSearchVolume: z.number(),
-});
+export * from "./googleAdsKeywordPlanner";

package/googleAds/server/googleAds.d.ts

@@ -0,0 +1,11 @@
+import { GoogleAdsNamespace } from "./GoogleAdsNamespace";
+export type Config = {
+    client: {
+        clientId: string;
+        clientSecret: string;
+        developerToken: string;
+    };
+    mccAccountId: string;
+    refreshToken: string;
+};
+export declare const googleAdsClient: (key?: string, config?: Config, vaultId?: string, itemId?: string) => Promise<GoogleAdsNamespace>;

package/googleAds/server/googleAds.js

@@ -0,0 +1,26 @@
+import { GoogleAdsNamespace } from "./GoogleAdsNamespace";
+import { onePasswordClient } from "../../onePassword/server";
+const googleAdsNamespaces = new Map();
+export const googleAdsClient = async (key = "default", config, vaultId, itemId) => {
+    if (googleAdsNamespaces.has(key)) {
+        return googleAdsNamespaces.get(key);
+    }
+    let instanceConfig;
+    if (config) {
+        instanceConfig = config;
+    }
+    else if (vaultId && itemId) {
+        instanceConfig = await (await onePasswordClient())
+            .getJsonNote(vaultId, itemId);
+    }
+    else if (process.env.GOOGLE_ADS_VAULT_ID && process.env.GOOGLE_ADS_ITEM_ID) {
+        instanceConfig = await (await onePasswordClient())
+            .getJsonNote(process.env.GOOGLE_ADS_VAULT_ID, process.env.GOOGLE_ADS_ITEM_ID);
+    }
+    else {
+        throw new Error(`Config required for namespace '${key}'`);
+    }
+    const namespace = new GoogleAdsNamespace(key, instanceConfig);
+    googleAdsNamespaces.set(key, namespace);
+    return namespace;
+};

package/googleAds/server/index.d.ts

@@ -1,11 +1,2 @@
-import { GoogleAdsNamespace } from "./GoogleAdsNamespace";
-export type Config = {
-    client: {
-        clientId: string;
-        clientSecret: string;
-        developerToken: string;
-    };
-    mccAccountId: string;
-    refreshToken: string;
-};
-export declare const googleAdsClient: (key?: string, config?: Config, vaultId?: string, itemId?: string) => Promise<GoogleAdsNamespace>;
+export * from "./googleAds";
+export * from "./GoogleAdsNamespace";

package/googleAds/server/index.js

@@ -1,26 +1,2 @@
-import { GoogleAdsNamespace } from "./GoogleAdsNamespace";
-import { onePasswordClient } from "../../onePassword/server";
-const googleAdsNamespaces = new Map();
-export const googleAdsClient = async (key = "default", config, vaultId, itemId) => {
-    if (googleAdsNamespaces.has(key)) {
-        return googleAdsNamespaces.get(key);
-    }
-    let instanceConfig;
-    if (config) {
-        instanceConfig = config;
-    }
-    else if (vaultId && itemId) {
-        instanceConfig = await (await onePasswordClient())
-            .getJsonNote(vaultId, itemId);
-    }
-    else if (process.env.GOOGLE_ADS_VAULT_ID && process.env.GOOGLE_ADS_ITEM_ID) {
-        instanceConfig = await (await onePasswordClient())
-            .getJsonNote(process.env.GOOGLE_ADS_VAULT_ID, process.env.GOOGLE_ADS_ITEM_ID);
-    }
-    else {
-        throw new Error(`Config required for namespace '${key}'`);
-    }
-    const namespace = new GoogleAdsNamespace(key, instanceConfig);
-    googleAdsNamespaces.set(key, namespace);
-    return namespace;
-};
+export * from "./googleAds";
+export * from "./GoogleAdsNamespace";

package/{google/bigquery/server/GoogleBigqueryNamespace.d.ts → googleCloud/bigquery/server/GoogleCloudBigqueryNamespace.d.ts}

@@ -14,7 +14,7 @@ type Dataset = {
 type Table = {
     id: string;
 };
-export declare class GoogleBigqueryNamespace extends BaseNamespace {
+export declare class GoogleCloudBigqueryNamespace extends BaseNamespace {
     client: BigQuery;
     config: GoogleCloudConfig & {
         projectId?: string;

package/{google/bigquery/server/GoogleBigqueryNamespace.js → googleCloud/bigquery/server/GoogleCloudBigqueryNamespace.js}

@@ -1,6 +1,6 @@
 import { BaseNamespace } from "../../../_class";
 import { getConfig } from "../../server";
-export class GoogleBigqueryNamespace extends BaseNamespace {
+export class GoogleCloudBigqueryNamespace extends BaseNamespace {
     ensureInit = async () => {
         if (!this.client) {
             try {

package/googleCloud/bigquery/server/googleCloudBigquery.d.ts

@@ -0,0 +1,5 @@
+import { GoogleCloudBigqueryNamespace } from "./GoogleCloudBigqueryNamespace";
+export type { GoogleCloudBigqueryNamespace } from "./GoogleCloudBigqueryNamespace";
+import type { GoogleAuthOptions } from "@google-cloud/common";
+export declare const googleCloudBigqueryClient: (key?: string, projectId?: string, config?: GoogleAuthOptions, vaultId?: string, itemId?: string) => Promise<GoogleCloudBigqueryNamespace>;
+export declare const getHandlerPath: (input: string) => string;

package/{google/bigquery/server/index.js → googleCloud/bigquery/server/googleCloudBigquery.js}

@@ -1,9 +1,9 @@
-import { GoogleBigqueryNamespace } from "./GoogleBigqueryNamespace";
+import { GoogleCloudBigqueryNamespace } from "./GoogleCloudBigqueryNamespace";
 import { onePasswordClient } from "../../../onePassword/server";
-const googleBigqueryNamespaces = new Map();
-export const googleBigqueryClient = async (key = "default", projectId, config, vaultId, itemId) => {
-    if (googleBigqueryNamespaces.has(key)) {
-        return googleBigqueryNamespaces.get(key);
+const googleCloudBigqueryNamespaces = new Map();
+export const googleCloudBigqueryClient = async (key = "default", projectId, config, vaultId, itemId) => {
+    if (googleCloudBigqueryNamespaces.has(key)) {
+        return googleCloudBigqueryNamespaces.get(key);
     }
     let instanceConfig;
     if (config) {
@@ -31,12 +31,11 @@ export const googleBigqueryClient = async (key = "default", projectId, config, v
     else {
         throw new Error(`Config required for namespace '${key}'`);
     }
-    const namespace = new GoogleBigqueryNamespace(key, instanceConfig);
-    googleBigqueryNamespaces.set(key, namespace);
+    const namespace = new GoogleCloudBigqueryNamespace(key, instanceConfig);
+    googleCloudBigqueryNamespaces.set(key, namespace);
     return namespace;
 };
 export const getHandlerPath = (input) => {
     return `${input.split(process.cwd())[1].substring(1)
         .replace(/\\/g, "/")}`;
 };
-export { loadData } from "./loadData";

package/googleCloud/bigquery/server/index.d.ts

@@ -0,0 +1,3 @@
+export * from "./googleCloudBigquery";
+export * from "./GoogleCloudBigqueryNamespace";
+export * from "./loadData";

package/googleCloud/bigquery/server/index.js

@@ -0,0 +1,3 @@
+export * from "./googleCloudBigquery";
+export * from "./GoogleCloudBigqueryNamespace";
+export * from "./loadData";

package/{google → googleCloud}/bigquery/server/loadData.d.ts

@@ -1,6 +1,6 @@
-import { GoogleBigqueryNamespace } from "./GoogleBigqueryNamespace";
+import { GoogleCloudBigqueryNamespace } from "./GoogleCloudBigqueryNamespace";
 type LoadData = {
-    googleBigqueryClient: GoogleBigqueryNamespace;
+    googleCloudBigqueryClient: GoogleCloudBigqueryNamespace;
     googleCloudStorageClient: any;
     file: {
         bucket: string;
@@ -15,5 +15,5 @@ type LoadData = {
 /**
  * Load data into a given table using Google Cloud Storage.
  */
-export declare const loadData: ({ file, googleBigqueryClient, googleCloudStorageClient, table }: LoadData) => Promise<void>;
+export declare const loadData: ({ file, googleCloudBigqueryClient, googleCloudStorageClient, table }: LoadData) => Promise<void>;
 export {};

package/{google → googleCloud}/bigquery/server/loadData.js

@@ -1,10 +1,10 @@
 /**
  * Load data into a given table using Google Cloud Storage.
  */
-export const loadData = async ({ file, googleBigqueryClient, googleCloudStorageClient, table }) => {
-    const tableExists = await googleBigqueryClient.tableExists(table.datasetId, table.tableId);
+export const loadData = async ({ file, googleCloudBigqueryClient, googleCloudStorageClient, table }) => {
+    const tableExists = await googleCloudBigqueryClient.tableExists(table.datasetId, table.tableId);
     if (tableExists) {
-        await googleBigqueryClient.client
+        await googleCloudBigqueryClient.client
             .dataset(table.datasetId)
             .table(table.tableId)
             .load(googleCloudStorageClient.client

package/googleCloud/server/index.d.ts

@@ -0,0 +1 @@
+export * from "./googleCloud";

package/googleCloud/server/index.js

@@ -0,0 +1 @@
+export * from "./googleCloud";

package/{google/sheets/server/GoogleSheetsNamespace.d.ts → googleCloud/sheets/server/GoogleCloudSheetsNamespace.d.ts}

@@ -7,7 +7,7 @@ type GetBatchDataProps = {
     dateTimeRender?: string;
     valueRender?: string;
 };
-export declare class GoogleSheetsNamespace extends BaseNamespace {
+export declare class GoogleCloudSheetsNamespace extends BaseNamespace {
     client: GoogleAuth;
     config: GoogleCloudConfig & {
         projectId?: string;

package/{google/sheets/server/GoogleSheetsNamespace.js → googleCloud/sheets/server/GoogleCloudSheetsNamespace.js}

@@ -1,6 +1,6 @@
 import { BaseNamespace } from "../../../_class";
 import { getConfig } from "../../server";
-export class GoogleSheetsNamespace extends BaseNamespace {
+export class GoogleCloudSheetsNamespace extends BaseNamespace {
     ensureInit = async () => {
         if (!this.client) {
             try {

package/googleCloud/sheets/server/index.d.ts

@@ -0,0 +1 @@
+export * from "./GoogleCloudSheetsNamespace";

package/googleCloud/sheets/server/index.js

@@ -0,0 +1 @@
+export * from "./GoogleCloudSheetsNamespace";

package/googleCloud/storage/server/index.d.ts

@@ -0,0 +1,2 @@
+export * from "./googleCloudStorage";
+export * from "./GoogleCloudStorageNamespace";

package/googleCloud/storage/server/index.js

@@ -0,0 +1,2 @@
+export * from "./googleCloudStorage";
+export * from "./GoogleCloudStorageNamespace";

package/googlePageSpeed/server/googlePageSpeed.d.ts

@@ -0,0 +1,19 @@
+import { GooglePageSpeedNamespace } from "./GooglePageSpeedNamespace";
+export type GooglePageSpeedConfig = {
+    apiKey: string;
+};
+export declare const googlePageSpeedClient: (key?: string, config?: GooglePageSpeedConfig, vaultId?: string, itemId?: string) => Promise<GooglePageSpeedNamespace>;
+export declare const Category: {
+    readonly CATEGORY_UNSPECIFIED: "CATEGORY_UNSPECIFIED";
+    readonly ACCESSIBILITY: "ACCESSIBILITY";
+    readonly BEST_PRACTICES: "BEST_PRACTICES";
+    readonly PERFORMANCE: "PERFORMANCE";
+    readonly SEO: "SEO";
+};
+export type Category = typeof Category[keyof typeof Category];
+export declare const Strategy: {
+    readonly STRATEGY_UNSPECIFIED: "STRATEGY_UNSPECIFIED";
+    readonly DESKTOP: "DESKTOP";
+    readonly MOBILE: "MOBILE";
+};
+export type Strategy = typeof Strategy[keyof typeof Strategy];

package/googlePageSpeed/server/googlePageSpeed.js

@@ -0,0 +1,38 @@
+import { GooglePageSpeedNamespace } from "./GooglePageSpeedNamespace";
+import { onePasswordClient } from "../../onePassword/server";
+const googlePageSpeedNamespaces = new Map();
+export const googlePageSpeedClient = async (key = "default", config, vaultId, itemId) => {
+    if (googlePageSpeedNamespaces.has(key)) {
+        return googlePageSpeedNamespaces.get(key);
+    }
+    let instanceConfig;
+    if (config) {
+        instanceConfig = config;
+    }
+    else if (vaultId && itemId) {
+        instanceConfig = await (await onePasswordClient())
+            .getJsonNote(vaultId, itemId);
+    }
+    else if (process.env.GOOGLE_PAGE_SPEED_VAULT_ID && process.env.GOOGLE_PAGE_SPEED_ITEM_ID) {
+        instanceConfig = await (await onePasswordClient())
+            .getJsonNote(process.env.GOOGLE_PAGE_SPEED_VAULT_ID, process.env.GOOGLE_PAGE_SPEED_ITEM_ID);
+    }
+    else {
+        throw new Error(`Config required for namespace '${key}'`);
+    }
+    const namespace = new GooglePageSpeedNamespace(key, instanceConfig);
+    googlePageSpeedNamespaces.set(key, namespace);
+    return namespace;
+};
+export const Category = {
+    CATEGORY_UNSPECIFIED: "CATEGORY_UNSPECIFIED",
+    ACCESSIBILITY: "ACCESSIBILITY",
+    BEST_PRACTICES: "BEST_PRACTICES",
+    PERFORMANCE: "PERFORMANCE",
+    SEO: "SEO",
+};
+export const Strategy = {
+    STRATEGY_UNSPECIFIED: "STRATEGY_UNSPECIFIED",
+    DESKTOP: "DESKTOP",
+    MOBILE: "MOBILE",
+};

package/googlePageSpeed/server/index.d.ts

@@ -1,19 +1,2 @@
-import { GooglePageSpeedNamespace } from "./GooglePageSpeedNamespace";
-export type GooglePageSpeedConfig = {
-    apiKey: string;
-};
-export declare const googlePageSpeedClient: (key?: string, config?: GooglePageSpeedConfig, vaultId?: string, itemId?: string) => Promise<GooglePageSpeedNamespace>;
-export declare const Category: {
-    readonly CATEGORY_UNSPECIFIED: "CATEGORY_UNSPECIFIED";
-    readonly ACCESSIBILITY: "ACCESSIBILITY";
-    readonly BEST_PRACTICES: "BEST_PRACTICES";
-    readonly PERFORMANCE: "PERFORMANCE";
-    readonly SEO: "SEO";
-};
-export type Category = typeof Category[keyof typeof Category];
-export declare const Strategy: {
-    readonly STRATEGY_UNSPECIFIED: "STRATEGY_UNSPECIFIED";
-    readonly DESKTOP: "DESKTOP";
-    readonly MOBILE: "MOBILE";
-};
-export type Strategy = typeof Strategy[keyof typeof Strategy];
+export * from "./googlePageSpeed";
+export * from "./GooglePageSpeedNamespace";

package/googlePageSpeed/server/index.js

@@ -1,38 +1,2 @@
-import { GooglePageSpeedNamespace } from "./GooglePageSpeedNamespace";
-import { onePasswordClient } from "../../onePassword/server";
-const googlePageSpeedNamespaces = new Map();
-export const googlePageSpeedClient = async (key = "default", config, vaultId, itemId) => {
-    if (googlePageSpeedNamespaces.has(key)) {
-        return googlePageSpeedNamespaces.get(key);
-    }
-    let instanceConfig;
-    if (config) {
-        instanceConfig = config;
-    }
-    else if (vaultId && itemId) {
-        instanceConfig = await (await onePasswordClient())
-            .getJsonNote(vaultId, itemId);
-    }
-    else if (process.env.GOOGLE_PAGE_SPEED_VAULT_ID && process.env.GOOGLE_PAGE_SPEED_ITEM_ID) {
-        instanceConfig = await (await onePasswordClient())
-            .getJsonNote(process.env.GOOGLE_PAGE_SPEED_VAULT_ID, process.env.GOOGLE_PAGE_SPEED_ITEM_ID);
-    }
-    else {
-        throw new Error(`Config required for namespace '${key}'`);
-    }
-    const namespace = new GooglePageSpeedNamespace(key, instanceConfig);
-    googlePageSpeedNamespaces.set(key, namespace);
-    return namespace;
-};
-export const Category = {
-    CATEGORY_UNSPECIFIED: "CATEGORY_UNSPECIFIED",
-    ACCESSIBILITY: "ACCESSIBILITY",
-    BEST_PRACTICES: "BEST_PRACTICES",
-    PERFORMANCE: "PERFORMANCE",
-    SEO: "SEO",
-};
-export const Strategy = {
-    STRATEGY_UNSPECIFIED: "STRATEGY_UNSPECIFIED",
-    DESKTOP: "DESKTOP",
-    MOBILE: "MOBILE",
-};
+export * from "./googlePageSpeed";
+export * from "./GooglePageSpeedNamespace";

package/googleSearchIncidents/server/googleSearchIncidents.d.ts

@@ -0,0 +1,69 @@
+import { z } from "zod/v4";
+/**
+ * https://status.search.google.com/summary
+ */
+export declare const getReport: () => Promise<any>;
+export declare const updateSchema: z.ZodObject<{
+    created: z.ZodString;
+    modified: z.ZodString;
+    when: z.ZodString;
+    text: z.ZodString;
+    status: z.ZodEnum<{
+        AVAILABLE: "AVAILABLE";
+        SERVICE_DISRUPTION: "SERVICE_DISRUPTION";
+        SERVICE_INFORMATION: "SERVICE_INFORMATION";
+    }>;
+}, z.core.$strip>;
+export type UpdateSchemaType = z.infer<typeof updateSchema>;
+export declare const incidentSchema: z.ZodArray<z.ZodObject<{
+    id: z.ZodString;
+    number: z.ZodString;
+    begin: z.ZodString;
+    created: z.ZodString;
+    end: z.ZodOptional<z.ZodString>;
+    modified: z.ZodString;
+    external_desc: z.ZodString;
+    updates: z.ZodArray<z.ZodObject<{
+        created: z.ZodString;
+        modified: z.ZodString;
+        when: z.ZodString;
+        text: z.ZodString;
+        status: z.ZodEnum<{
+            AVAILABLE: "AVAILABLE";
+            SERVICE_DISRUPTION: "SERVICE_DISRUPTION";
+            SERVICE_INFORMATION: "SERVICE_INFORMATION";
+        }>;
+    }, z.core.$strip>>;
+    most_recent_update: z.ZodObject<{
+        created: z.ZodString;
+        modified: z.ZodString;
+        when: z.ZodString;
+        text: z.ZodString;
+        status: z.ZodEnum<{
+            AVAILABLE: "AVAILABLE";
+            SERVICE_DISRUPTION: "SERVICE_DISRUPTION";
+            SERVICE_INFORMATION: "SERVICE_INFORMATION";
+        }>;
+    }, z.core.$strip>;
+    status_impact: z.ZodEnum<{
+        SERVICE_DISRUPTION: "SERVICE_DISRUPTION";
+        SERVICE_INFORMATION: "SERVICE_INFORMATION";
+    }>;
+    severity: z.ZodEnum<{
+        high: "high";
+        low: "low";
+        medium: "medium";
+    }>;
+    service_key: z.ZodString;
+    service_name: z.ZodEnum<{
+        Indexing: "Indexing";
+        Ranking: "Ranking";
+        Serving: "Serving";
+    }>;
+    affected_products: z.ZodArray<z.ZodObject<{
+        title: z.ZodString;
+        id: z.ZodString;
+    }, z.core.$strip>>;
+    uri: z.ZodString;
+}, z.core.$strip>>;
+export type IncidentSchemaType = z.infer<typeof incidentSchema>;

package/googleSearchIncidents/server/googleSearchIncidents.js

@@ -0,0 +1,42 @@
+import { get } from "../../axios";
+import { z } from "zod/v4";
+/**
+ * https://status.search.google.com/summary
+ */
+export const getReport = async () => {
+    const url = "https://status.search.google.com/incidents.json";
+    const apiResponse = await get(url);
+    if (apiResponse.isSuccess()) {
+        return apiResponse.getBody();
+    }
+    return null;
+};
+export const updateSchema = z.object({
+    created: z.string(),
+    modified: z.string(),
+    when: z.string(),
+    text: z.string(),
+    status: z.enum(["AVAILABLE", "SERVICE_DISRUPTION", "SERVICE_INFORMATION"]),
+});
+export const incidentSchema = z.object({
+    id: z.string(),
+    number: z.string(),
+    begin: z.string(),
+    created: z.string(),
+    end: z.string().optional(),
+    modified: z.string(),
+    external_desc: z.string(),
+    updates: updateSchema.array(),
+    most_recent_update: updateSchema,
+    status_impact: z.enum(["SERVICE_DISRUPTION", "SERVICE_INFORMATION"]),
+    severity: z.enum(["low", "medium", "high"]),
+    service_key: z.string(),
+    service_name: z.enum(["Indexing", "Ranking", "Serving"]),
+    affected_products: z.object({
+        title: z.string(),
+        id: z.string(),
+    })
+        .array(),
+    uri: z.string(),
+})
+    .array();