dgc-core 0.0.0-stage → 2.0.1

package/README.md

@@ -1,3 +1,85 @@
-# Temporary Holding Version
+# dgc-core
 
-This version is a temporary placeholder for this package. An operational version to replace this has been submitted for review and is awaiting a staged release.
+Shared DGC contracts, business rules and backend helpers. This package combines
+`opticedge-types` and `opticedge-cloud-utils` without depending on either package.
+
+## Imports
+
+Use the package root in server code:
+
+```ts
+import { connectToMongo3, GiveawayRepository, HttpError } from 'dgc-core'
+import type { FbUser, GiveawayEntry } from 'dgc-core'
+```
+
+Use `dgc-core/types` in browser components, mobile clients and other shared code:
+
+```ts
+import { UserCollectorType } from 'dgc-core/types'
+import type { GiveawayPublic, GiveawayEntryStatus } from 'dgc-core/types'
+```
+
+The types entry includes the existing enums and constants as well as TypeScript
+contracts. It loads no Node builtins, MongoDB or Google Cloud SDKs. The root also
+exports those contracts, alongside server helpers, and loads server dependencies.
+Browser code must use the types entry even when it only needs a runtime enum.
+
+In a Next.js application, keep root imports in server modules and add `dgc-core`
+to `serverExternalPackages` if the application previously externalized
+`opticedge-cloud-utils`.
+
+## Migrating
+
+| Previous import                             | New import                     |
+| ------------------------------------------- | ------------------------------ |
+| `opticedge-cloud-utils`                     | `dgc-core`                     |
+| `opticedge-types` in browser or shared code | `dgc-core/types`               |
+| `opticedge-types` in server code            | `dgc-core/types` or `dgc-core` |
+
+Replace the two previous dependencies with `dgc-core`. Build and test each
+consumer after updating its imports, mocks and lockfile. Build and publish this
+package through the existing release process before using `dgc-core@1.0.0` in a
+fresh registry installation. Existing source repositories and published package
+versions remain independent until their consumers migrate.
+
+## Included code
+
+- Contracts for Firebase users, cards, grading, payments, notifications and
+  giveaways, plus the existing enums and constants.
+- MongoDB connection helpers, including connection caching per URI in
+  `connectToMongo3` and retry after a failed connection.
+- Cloud Tasks, Pub/Sub, Secret Manager and request verification helpers.
+- Retry, logging, parsing, validation, IDs, HTTP errors and other existing
+  backend utilities.
+- Giveaway validation, lifecycle and entry rules, winner assignment, CSV export
+  and the transactional MongoDB repository.
+
+Giveaway services instantiate `new GiveawayRepository(database, client)` using
+their own connection. Configuration, authentication, HTTP handlers and delivery
+adapters stay in the application. Collection and index provisioning stays in
+`dgc-db-ops`.
+
+Giveaway documents use MongoDB ObjectIds, serialized as 24-character hexadecimal
+strings in APIs; entry IDs use 12 decimal characters and preserve leading zeros.
+Firebase `userId` identifies each entrant. Collector type is informational and
+never changes eligibility. Administrative entry and winner records contain
+personal information and require authorized access; use `GiveawayPublic` for
+public app responses. `DomainError` and `HttpError` refer to the same constructor.
+
+## Development
+
+```sh
+npm ci
+npm run build
+npm test
+```
+
+Build before running the package entry tests so they inspect the same compiled
+files consumers use. The existing utility and giveaway tests remain, with
+additional checks for the public root export, the browser import boundary and
+compiled TypeScript contracts. Tests use local fixtures and mocks; they do not
+send notifications or connect to a live database.
+
+## Giveaway MVP v2
+
+One ticket per Firebase account, one winner per giveaway, saved random/manual selection and explicit confirmation. Physical address and contact number are collected at claim only. Credit rewards snapshot `creditAmount` and use `fulfillGiveawayCredits` to atomically change Firebase `instantCredits` plus a permanent per-giveaway marker. Status reads reconcile without issuing credits. See dgc-giveaways/docs/api.md and integration.md for contracts and release order.

package/dist/auth.d.ts

@@ -0,0 +1,7 @@
+import { Request } from '@google-cloud/functions-framework';
+interface VerifyOptions {
+    allowedAudience: string;
+    allowedServiceAccount: string;
+}
+export declare function verifyRequest(req: Request, options: VerifyOptions): Promise<boolean>;
+export {};

package/dist/auth.js

@@ -0,0 +1,23 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.verifyRequest = verifyRequest;
+const google_auth_library_1 = require("google-auth-library");
+async function verifyRequest(req, options) {
+    const authHeader = req.headers['authorization'];
+    if (!authHeader || !authHeader.startsWith('Bearer ')) {
+        return false;
+    }
+    const token = authHeader.split(' ')[1];
+    const client = new google_auth_library_1.OAuth2Client();
+    try {
+        const ticket = await client.verifyIdToken({
+            idToken: token,
+            audience: options.allowedAudience
+        });
+        const payload = ticket.getPayload();
+        return payload?.email === options.allowedServiceAccount;
+    }
+    catch {
+        return false;
+    }
+}

package/dist/chunk.d.ts

@@ -0,0 +1 @@
+export declare function chunkByBytes(arr: any[], maxBytes?: number): any[][];

package/dist/chunk.js

@@ -0,0 +1,37 @@
+"use strict";
+/* eslint-disable @typescript-eslint/no-explicit-any */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.chunkByBytes = chunkByBytes;
+function chunkByBytes(arr, maxBytes = 700000) {
+    // 700KB safe default
+    const chunks = [];
+    let current = [];
+    let curBytes = 0;
+    for (const item of arr) {
+        const s = JSON.stringify(item);
+        const b = Buffer.byteLength(s, 'utf8');
+        // if a single item exceeds maxBytes, push it alone (or skip)
+        if (b > maxBytes) {
+            // optionally log and skip - here we'll push as its own chunk
+            if (current.length) {
+                chunks.push(current);
+                current = [];
+                curBytes = 0;
+            }
+            chunks.push([item]);
+            continue;
+        }
+        if (curBytes + b > maxBytes) {
+            chunks.push(current);
+            current = [item];
+            curBytes = b;
+        }
+        else {
+            current.push(item);
+            curBytes += b;
+        }
+    }
+    if (current.length)
+        chunks.push(current);
+    return chunks;
+}

package/dist/constants/card-languages.json

@@ -0,0 +1,12 @@
+[
+    "Chinese",
+    "English",
+    "French",
+    "German",
+    "Italian",
+    "Japanese",
+    "Korean",
+    "Portuguese",
+    "Russian",
+    "Spanish"
+]

package/dist/constants/card.d.ts

@@ -0,0 +1,4 @@
+import { CardGradingType } from '../enums/card';
+export declare const ON_DEMAND_ELIGIBLE_GRADING_TYPES: CardGradingType[];
+export declare const POST_GRADING_ELIGIBLE_GRADING_TYPES: CardGradingType[];
+export declare const PENDING_GRADING = -1;

package/dist/constants/card.js

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PENDING_GRADING = exports.POST_GRADING_ELIGIBLE_GRADING_TYPES = exports.ON_DEMAND_ELIGIBLE_GRADING_TYPES = void 0;
+const card_1 = require("../enums/card");
+exports.ON_DEMAND_ELIGIBLE_GRADING_TYPES = [
+    card_1.CardGradingType.DEEP_2024,
+    card_1.CardGradingType.DEEP,
+    card_1.CardGradingType.INSTANT,
+    card_1.CardGradingType.DEEP_INSTANT
+];
+exports.POST_GRADING_ELIGIBLE_GRADING_TYPES = [
+    card_1.CardGradingType.DEEP,
+    card_1.CardGradingType.INSTANT,
+    card_1.CardGradingType.DEEP_INSTANT
+];
+exports.PENDING_GRADING = -1;

package/dist/constants/giveaway.d.ts

@@ -0,0 +1,2 @@
+/** UTC boundaries used by the giveaway editor and scheduling rules. */
+export declare const GIVEAWAY_TIME_STEP_MINUTES = 10;

package/dist/constants/giveaway.js

@@ -0,0 +1,5 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.GIVEAWAY_TIME_STEP_MINUTES = void 0;
+/** UTC boundaries used by the giveaway editor and scheduling rules. */
+exports.GIVEAWAY_TIME_STEP_MINUTES = 10;

package/dist/constants/payment.d.ts

@@ -0,0 +1,3 @@
+import { ChainId } from '../types/blockchain';
+import { PaymentEnvironment } from '../types/payment';
+export declare const CHAIN_PAYMENTENV_MAP: Record<ChainId, PaymentEnvironment>;

package/dist/constants/payment.js

@@ -0,0 +1,7 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CHAIN_PAYMENTENV_MAP = void 0;
+exports.CHAIN_PAYMENTENV_MAP = {
+    80002: 'SANDBOX',
+    137: 'PRODUCTION'
+};

package/dist/db/mongo.d.ts

@@ -0,0 +1,5 @@
+import { Db, Collection, Document } from 'mongodb';
+export declare function connectToMongo(uri: string, dbName: string): Promise<void>;
+export declare function getDb(): Db;
+export declare function getCollection<T extends Document = Document>(name: string): Collection<T>;
+export declare function closeMongo(): Promise<void>;

package/dist/db/mongo.js

@@ -0,0 +1,40 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.connectToMongo = connectToMongo;
+exports.getDb = getDb;
+exports.getCollection = getCollection;
+exports.closeMongo = closeMongo;
+const mongodb_1 = require("mongodb");
+let client;
+let db;
+let connectPromise;
+async function connectToMongo(uri, dbName) {
+    if (db)
+        return; // already connected
+    if (!connectPromise) {
+        connectPromise = (async () => {
+            client = new mongodb_1.MongoClient(uri);
+            await client.connect();
+            db = client.db(dbName);
+        })();
+    }
+    await connectPromise;
+}
+function getDb() {
+    if (!db)
+        throw new Error('Mongo not initialized. Call connectToMongo(...) first.');
+    return db;
+}
+function getCollection(name) {
+    if (!db)
+        throw new Error('Mongo not initialized');
+    return db.collection(name);
+}
+async function closeMongo() {
+    if (!client)
+        return;
+    await client.close();
+    client = undefined;
+    db = undefined;
+    connectPromise = undefined;
+}

package/dist/db/mongo2.d.ts

@@ -0,0 +1,5 @@
+import { Db, Collection, Document } from 'mongodb';
+export declare function connectToMongo2(uri: string): Promise<void>;
+export declare function getDb2(dbName: string): Db;
+export declare function getCollection2<T extends Document = Document>(dbName: string, collectionName: string): Collection<T>;
+export declare function closeMongo2(): Promise<void>;

package/dist/db/mongo2.js

@@ -0,0 +1,36 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.connectToMongo2 = connectToMongo2;
+exports.getDb2 = getDb2;
+exports.getCollection2 = getCollection2;
+exports.closeMongo2 = closeMongo2;
+// Multi DB safe util
+const mongodb_1 = require("mongodb");
+let client;
+let connectPromise;
+async function connectToMongo2(uri) {
+    if (client)
+        return; // already connected
+    if (!connectPromise) {
+        connectPromise = (async () => {
+            client = new mongodb_1.MongoClient(uri);
+            await client.connect();
+        })();
+    }
+    await connectPromise;
+}
+function getDb2(dbName) {
+    if (!client)
+        throw new Error('Mongo not initialized');
+    return client.db(dbName);
+}
+function getCollection2(dbName, collectionName) {
+    return getDb2(dbName).collection(collectionName);
+}
+async function closeMongo2() {
+    if (!client)
+        return;
+    await client.close();
+    client = undefined;
+    connectPromise = undefined;
+}

package/dist/db/mongo3.d.ts

@@ -0,0 +1,8 @@
+import { MongoClient, Db, Collection, Document } from 'mongodb';
+export declare function connectToMongo3(uri: string): Promise<MongoClient>;
+export declare function getDb3(uri: string, dbName: string): Db;
+export declare function getCollection3<T extends Document = Document>(uri: string, dbName: string, collectionName: string): Collection<T>;
+export declare function closeMongo3(uri: string): Promise<void>;
+export declare function closeAllMongo3(): Promise<void>;
+export declare const __mongoClients: Map<string, MongoClient>;
+export declare const __connectPromises: Map<string, Promise<void>>;

package/dist/db/mongo3.js

@@ -0,0 +1,61 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.__connectPromises = exports.__mongoClients = void 0;
+exports.connectToMongo3 = connectToMongo3;
+exports.getDb3 = getDb3;
+exports.getCollection3 = getCollection3;
+exports.closeMongo3 = closeMongo3;
+exports.closeAllMongo3 = closeAllMongo3;
+// Multi cluster safe util
+const mongodb_1 = require("mongodb");
+const clients = new Map();
+const connectPromises = new Map();
+async function connectToMongo3(uri) {
+    if (!connectPromises.has(uri)) {
+        const client = new mongodb_1.MongoClient(uri);
+        const promise = Promise.resolve().then(async () => {
+            try {
+                await client.connect();
+                clients.set(uri, client);
+            }
+            catch (error) {
+                connectPromises.delete(uri);
+                try {
+                    await client.close();
+                }
+                catch {
+                    // Preserve the original connection failure if cleanup also fails.
+                }
+                throw error;
+            }
+        });
+        connectPromises.set(uri, promise);
+    }
+    await connectPromises.get(uri);
+    return clients.get(uri);
+}
+function getDb3(uri, dbName) {
+    const client = clients.get(uri);
+    if (!client) {
+        throw new Error(`Mongo client not initialized`);
+    }
+    return client.db(dbName);
+}
+function getCollection3(uri, dbName, collectionName) {
+    return getDb3(uri, dbName).collection(collectionName);
+}
+async function closeMongo3(uri) {
+    const client = clients.get(uri);
+    if (client) {
+        await client.close();
+    }
+    clients.delete(uri);
+    connectPromises.delete(uri);
+}
+async function closeAllMongo3() {
+    await Promise.all(Array.from(clients.values()).map(client => client.close()));
+    clients.clear();
+    connectPromises.clear();
+}
+exports.__mongoClients = clients;
+exports.__connectPromises = connectPromises;

package/dist/enums/card.d.ts

@@ -0,0 +1,74 @@
+export declare enum TradingCardType {
+    POKEMON = "pokemon",
+    LORCANA = "lorcana",
+    MAGIC = "magic",
+    YUGIOH = "yugioh",
+    DIGIMON = "digimon",
+    DRAGON_BALL = "dragon_ball",
+    ONE_PIECE = "one_piece",
+    STAR_WARS = "star_wars",
+    MARVEL = "marvel",
+    GARBAGE_PAIL = "garbage_pail",
+    OTHER_TCG = "other_tcg",
+    OTHER_NON_TCG = "other"
+}
+export declare enum SportsCardType {
+    BASEBALL = "baseball",
+    BASKETBALL = "basketball",
+    FOOTBALL = "football",
+    HOCKEY = "hockey",
+    SOCCER = "soccer",
+    RACING = "racing",
+    WRESTLING = "wrestling",
+    UFC = "ufc",
+    BOXING = "boxing",
+    GOLF = "golf",
+    TENNIS = "tennis"
+}
+export type CardType = TradingCardType | SportsCardType;
+export declare enum CardCategory {
+    TRADING = "trading",
+    SPORTS = "sports"
+}
+export declare enum CardApprovalStatus {
+    Rescan = -2,
+    Pending = -1,
+    Failed = 0,
+    Approved = 1,
+    PendingInstant = 3,
+    Approving = 999
+}
+export declare enum CardRejectType {
+    INVALID_CARD = "Invalid card",
+    FAKE_HIGHRISK = "Fake - High Risk",
+    REPEAT = "Repeat",
+    MODEL_FAILURE = "Model failure"
+}
+export declare enum CardRescanType {
+    ENVIRONMENT_LOW_SCORE = "Environment - Low Score",
+    ACCURACY_LOW_SCORE = "Accuracy - Low Score",
+    ENVIRONMENT_LIGHTING = "Environment - Lighting",
+    ENVIRONMENT_ARTEFACTS = "Environment - Artefacts",
+    CARD_IN_SLAB_SLEEVE = "Card in Slab/Sleeve",
+    CARD_OBSTRUCTION = "Card - Obstruction",
+    CARD_ARTIFACTS = "CARD-ARTIFACTS",
+    SCAN_PROCESS_FAILURE = "Scan Process Failure"
+}
+export declare enum CardGradingType {
+    DEEP_2024 = 0,
+    DEEP = 1,
+    ADDED = 2,
+    SOLD = 3,
+    INSTANT = 4,
+    DEEP_INSTANT = 5,
+    CARD_CENTERING = 6
+}
+export declare enum CardInstantGradeType {
+    OVERALL = 0,
+    SUBGRADES = 1,
+    OVERALL_TO_SUBGRADES = 2
+}
+export declare enum CardVersions {
+    DEFAULT = "0.0",
+    VERSION_1_0 = "1.0"
+}

package/dist/enums/card.js

@@ -0,0 +1,85 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CardVersions = exports.CardInstantGradeType = exports.CardGradingType = exports.CardRescanType = exports.CardRejectType = exports.CardApprovalStatus = exports.CardCategory = exports.SportsCardType = exports.TradingCardType = void 0;
+var TradingCardType;
+(function (TradingCardType) {
+    TradingCardType["POKEMON"] = "pokemon";
+    TradingCardType["LORCANA"] = "lorcana";
+    TradingCardType["MAGIC"] = "magic";
+    TradingCardType["YUGIOH"] = "yugioh";
+    TradingCardType["DIGIMON"] = "digimon";
+    TradingCardType["DRAGON_BALL"] = "dragon_ball";
+    TradingCardType["ONE_PIECE"] = "one_piece";
+    TradingCardType["STAR_WARS"] = "star_wars";
+    TradingCardType["MARVEL"] = "marvel";
+    TradingCardType["GARBAGE_PAIL"] = "garbage_pail";
+    TradingCardType["OTHER_TCG"] = "other_tcg";
+    TradingCardType["OTHER_NON_TCG"] = "other";
+})(TradingCardType || (exports.TradingCardType = TradingCardType = {}));
+var SportsCardType;
+(function (SportsCardType) {
+    SportsCardType["BASEBALL"] = "baseball";
+    SportsCardType["BASKETBALL"] = "basketball";
+    SportsCardType["FOOTBALL"] = "football";
+    SportsCardType["HOCKEY"] = "hockey";
+    SportsCardType["SOCCER"] = "soccer";
+    SportsCardType["RACING"] = "racing";
+    SportsCardType["WRESTLING"] = "wrestling";
+    SportsCardType["UFC"] = "ufc";
+    SportsCardType["BOXING"] = "boxing";
+    SportsCardType["GOLF"] = "golf";
+    SportsCardType["TENNIS"] = "tennis";
+})(SportsCardType || (exports.SportsCardType = SportsCardType = {}));
+var CardCategory;
+(function (CardCategory) {
+    CardCategory["TRADING"] = "trading";
+    CardCategory["SPORTS"] = "sports";
+})(CardCategory || (exports.CardCategory = CardCategory = {}));
+var CardApprovalStatus;
+(function (CardApprovalStatus) {
+    CardApprovalStatus[CardApprovalStatus["Rescan"] = -2] = "Rescan";
+    CardApprovalStatus[CardApprovalStatus["Pending"] = -1] = "Pending";
+    CardApprovalStatus[CardApprovalStatus["Failed"] = 0] = "Failed";
+    CardApprovalStatus[CardApprovalStatus["Approved"] = 1] = "Approved";
+    CardApprovalStatus[CardApprovalStatus["PendingInstant"] = 3] = "PendingInstant";
+    CardApprovalStatus[CardApprovalStatus["Approving"] = 999] = "Approving";
+})(CardApprovalStatus || (exports.CardApprovalStatus = CardApprovalStatus = {}));
+var CardRejectType;
+(function (CardRejectType) {
+    CardRejectType["INVALID_CARD"] = "Invalid card";
+    CardRejectType["FAKE_HIGHRISK"] = "Fake - High Risk";
+    CardRejectType["REPEAT"] = "Repeat";
+    CardRejectType["MODEL_FAILURE"] = "Model failure";
+})(CardRejectType || (exports.CardRejectType = CardRejectType = {}));
+var CardRescanType;
+(function (CardRescanType) {
+    CardRescanType["ENVIRONMENT_LOW_SCORE"] = "Environment - Low Score";
+    CardRescanType["ACCURACY_LOW_SCORE"] = "Accuracy - Low Score";
+    CardRescanType["ENVIRONMENT_LIGHTING"] = "Environment - Lighting";
+    CardRescanType["ENVIRONMENT_ARTEFACTS"] = "Environment - Artefacts";
+    CardRescanType["CARD_IN_SLAB_SLEEVE"] = "Card in Slab/Sleeve";
+    CardRescanType["CARD_OBSTRUCTION"] = "Card - Obstruction";
+    CardRescanType["CARD_ARTIFACTS"] = "CARD-ARTIFACTS";
+    CardRescanType["SCAN_PROCESS_FAILURE"] = "Scan Process Failure";
+})(CardRescanType || (exports.CardRescanType = CardRescanType = {}));
+var CardGradingType;
+(function (CardGradingType) {
+    CardGradingType[CardGradingType["DEEP_2024"] = 0] = "DEEP_2024";
+    CardGradingType[CardGradingType["DEEP"] = 1] = "DEEP";
+    CardGradingType[CardGradingType["ADDED"] = 2] = "ADDED";
+    CardGradingType[CardGradingType["SOLD"] = 3] = "SOLD";
+    CardGradingType[CardGradingType["INSTANT"] = 4] = "INSTANT";
+    CardGradingType[CardGradingType["DEEP_INSTANT"] = 5] = "DEEP_INSTANT";
+    CardGradingType[CardGradingType["CARD_CENTERING"] = 6] = "CARD_CENTERING";
+})(CardGradingType || (exports.CardGradingType = CardGradingType = {}));
+var CardInstantGradeType;
+(function (CardInstantGradeType) {
+    CardInstantGradeType[CardInstantGradeType["OVERALL"] = 0] = "OVERALL";
+    CardInstantGradeType[CardInstantGradeType["SUBGRADES"] = 1] = "SUBGRADES";
+    CardInstantGradeType[CardInstantGradeType["OVERALL_TO_SUBGRADES"] = 2] = "OVERALL_TO_SUBGRADES";
+})(CardInstantGradeType || (exports.CardInstantGradeType = CardInstantGradeType = {}));
+var CardVersions;
+(function (CardVersions) {
+    CardVersions["DEFAULT"] = "0.0";
+    CardVersions["VERSION_1_0"] = "1.0";
+})(CardVersions || (exports.CardVersions = CardVersions = {}));

package/dist/enums/giveaway.d.ts

@@ -0,0 +1,61 @@
+/** Stable string values are shared by MongoDB records, APIs and browser code. */
+export declare enum GiveawayStatus {
+    Draft = "draft",
+    Scheduled = "scheduled",
+    Live = "live",
+    Closed = "closed",
+    AwaitingClaim = "awaiting_claim",
+    Completed = "completed",
+    Cancelled = "cancelled",
+    Archived = "archived"
+}
+export declare enum GiveawayCategory {
+    Products = "products",
+    Credits = "credits"
+}
+export declare enum GiveawaySelectionMethod {
+    Random = "random",
+    Manual = "manual"
+}
+export declare enum GiveawayWinnerStatus {
+    AwaitingClaim = "awaiting_claim",
+    AwaitingDispatch = "awaiting_dispatch",
+    Dispatched = "dispatched",
+    Delivered = "delivered",
+    Processing = "processing",
+    Credited = "credited",
+    Failed = "failed"
+}
+export declare enum GiveawayNotificationKind {
+    Launch = "launch",
+    Closing = "closing",
+    Results = "results"
+}
+export declare enum GiveawayNotificationAudience {
+    All = "all",
+    Entrants = "entrants"
+}
+export declare enum GiveawayNotificationStatus {
+    Pending = "pending",
+    Delivering = "delivering",
+    Sent = "sent",
+    Failed = "failed"
+}
+export declare enum GiveawayNotificationDeliveryStatus {
+    Pending = "pending",
+    Queued = "queued"
+}
+export declare enum GiveawayTicketResult {
+    Pending = "pending",
+    Won = "won",
+    NotSelected = "not_selected"
+}
+export declare enum GiveawayAction {
+    Publish = "publish",
+    Schedule = "schedule",
+    Cancel = "cancel",
+    Archive = "archive"
+}
+export declare enum GiveawayNotificationChannel {
+    Push = "push"
+}