@aion2hub/shared-schemas 1.1.10 → 1.1.11

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
Files changed (5) hide show
  1. package/dist/content-schema.d.ts +2103 -0
  2. package/dist/content-schema.d.ts.map +1 -1
  3. package/dist/content-schema.js +202 -1
  4. package/dist/content-schema.js.map +1 -1
  5. package/package.json +1 -1
package/dist/content-schema.d.ts CHANGED
@@ -2438,4 +2438,2107 @@ export declare const rssArticles: import("drizzle-orm/pg-core").PgTableWithColum
2438
2438
  };
2439
2439
  dialect: "pg";
2440
2440
  }>;
2441
+ export declare const youtubeSourceConfigs: import("drizzle-orm/pg-core").PgTableWithColumns<{
2442
+ name: "youtube_source_config";
2443
+ schema: undefined;
2444
+ columns: {
2445
+ id: import("drizzle-orm/pg-core").PgColumn<{
2446
+ name: "id";
2447
+ tableName: "youtube_source_config";
2448
+ dataType: "string";
2449
+ columnType: "PgText";
2450
+ data: string;
2451
+ driverParam: string;
2452
+ notNull: true;
2453
+ hasDefault: false;
2454
+ isPrimaryKey: true;
2455
+ isAutoincrement: false;
2456
+ hasRuntimeDefault: false;
2457
+ enumValues: [string, ...string[]];
2458
+ baseColumn: never;
2459
+ identity: undefined;
2460
+ generated: undefined;
2461
+ }, {}, {}>;
2462
+ channelId: import("drizzle-orm/pg-core").PgColumn<{
2463
+ name: "channel_id";
2464
+ tableName: "youtube_source_config";
2465
+ dataType: "string";
2466
+ columnType: "PgText";
2467
+ data: string;
2468
+ driverParam: string;
2469
+ notNull: true;
2470
+ hasDefault: false;
2471
+ isPrimaryKey: false;
2472
+ isAutoincrement: false;
2473
+ hasRuntimeDefault: false;
2474
+ enumValues: [string, ...string[]];
2475
+ baseColumn: never;
2476
+ identity: undefined;
2477
+ generated: undefined;
2478
+ }, {}, {}>;
2479
+ channelName: import("drizzle-orm/pg-core").PgColumn<{
2480
+ name: "channel_name";
2481
+ tableName: "youtube_source_config";
2482
+ dataType: "string";
2483
+ columnType: "PgText";
2484
+ data: string;
2485
+ driverParam: string;
2486
+ notNull: true;
2487
+ hasDefault: false;
2488
+ isPrimaryKey: false;
2489
+ isAutoincrement: false;
2490
+ hasRuntimeDefault: false;
2491
+ enumValues: [string, ...string[]];
2492
+ baseColumn: never;
2493
+ identity: undefined;
2494
+ generated: undefined;
2495
+ }, {}, {}>;
2496
+ description: import("drizzle-orm/pg-core").PgColumn<{
2497
+ name: "description";
2498
+ tableName: "youtube_source_config";
2499
+ dataType: "string";
2500
+ columnType: "PgText";
2501
+ data: string;
2502
+ driverParam: string;
2503
+ notNull: false;
2504
+ hasDefault: false;
2505
+ isPrimaryKey: false;
2506
+ isAutoincrement: false;
2507
+ hasRuntimeDefault: false;
2508
+ enumValues: [string, ...string[]];
2509
+ baseColumn: never;
2510
+ identity: undefined;
2511
+ generated: undefined;
2512
+ }, {}, {}>;
2513
+ tier: import("drizzle-orm/pg-core").PgColumn<{
2514
+ name: "tier";
2515
+ tableName: "youtube_source_config";
2516
+ dataType: "number";
2517
+ columnType: "PgInteger";
2518
+ data: number;
2519
+ driverParam: string | number;
2520
+ notNull: true;
2521
+ hasDefault: true;
2522
+ isPrimaryKey: false;
2523
+ isAutoincrement: false;
2524
+ hasRuntimeDefault: false;
2525
+ enumValues: undefined;
2526
+ baseColumn: never;
2527
+ identity: undefined;
2528
+ generated: undefined;
2529
+ }, {}, {}>;
2530
+ language: import("drizzle-orm/pg-core").PgColumn<{
2531
+ name: "language";
2532
+ tableName: "youtube_source_config";
2533
+ dataType: "string";
2534
+ columnType: "PgText";
2535
+ data: string;
2536
+ driverParam: string;
2537
+ notNull: true;
2538
+ hasDefault: true;
2539
+ isPrimaryKey: false;
2540
+ isAutoincrement: false;
2541
+ hasRuntimeDefault: false;
2542
+ enumValues: [string, ...string[]];
2543
+ baseColumn: never;
2544
+ identity: undefined;
2545
+ generated: undefined;
2546
+ }, {}, {}>;
2547
+ isOfficial: import("drizzle-orm/pg-core").PgColumn<{
2548
+ name: "is_official";
2549
+ tableName: "youtube_source_config";
2550
+ dataType: "boolean";
2551
+ columnType: "PgBoolean";
2552
+ data: boolean;
2553
+ driverParam: boolean;
2554
+ notNull: true;
2555
+ hasDefault: true;
2556
+ isPrimaryKey: false;
2557
+ isAutoincrement: false;
2558
+ hasRuntimeDefault: false;
2559
+ enumValues: undefined;
2560
+ baseColumn: never;
2561
+ identity: undefined;
2562
+ generated: undefined;
2563
+ }, {}, {}>;
2564
+ isActive: import("drizzle-orm/pg-core").PgColumn<{
2565
+ name: "is_active";
2566
+ tableName: "youtube_source_config";
2567
+ dataType: "boolean";
2568
+ columnType: "PgBoolean";
2569
+ data: boolean;
2570
+ driverParam: boolean;
2571
+ notNull: true;
2572
+ hasDefault: true;
2573
+ isPrimaryKey: false;
2574
+ isAutoincrement: false;
2575
+ hasRuntimeDefault: false;
2576
+ enumValues: undefined;
2577
+ baseColumn: never;
2578
+ identity: undefined;
2579
+ generated: undefined;
2580
+ }, {}, {}>;
2581
+ isPaused: import("drizzle-orm/pg-core").PgColumn<{
2582
+ name: "is_paused";
2583
+ tableName: "youtube_source_config";
2584
+ dataType: "boolean";
2585
+ columnType: "PgBoolean";
2586
+ data: boolean;
2587
+ driverParam: boolean;
2588
+ notNull: true;
2589
+ hasDefault: true;
2590
+ isPrimaryKey: false;
2591
+ isAutoincrement: false;
2592
+ hasRuntimeDefault: false;
2593
+ enumValues: undefined;
2594
+ baseColumn: never;
2595
+ identity: undefined;
2596
+ generated: undefined;
2597
+ }, {}, {}>;
2598
+ schedulingEnabled: import("drizzle-orm/pg-core").PgColumn<{
2599
+ name: "scheduling_enabled";
2600
+ tableName: "youtube_source_config";
2601
+ dataType: "boolean";
2602
+ columnType: "PgBoolean";
2603
+ data: boolean;
2604
+ driverParam: boolean;
2605
+ notNull: true;
2606
+ hasDefault: true;
2607
+ isPrimaryKey: false;
2608
+ isAutoincrement: false;
2609
+ hasRuntimeDefault: false;
2610
+ enumValues: undefined;
2611
+ baseColumn: never;
2612
+ identity: undefined;
2613
+ generated: undefined;
2614
+ }, {}, {}>;
2615
+ checkFrequencyMinutes: import("drizzle-orm/pg-core").PgColumn<{
2616
+ name: "check_frequency_minutes";
2617
+ tableName: "youtube_source_config";
2618
+ dataType: "number";
2619
+ columnType: "PgInteger";
2620
+ data: number;
2621
+ driverParam: string | number;
2622
+ notNull: true;
2623
+ hasDefault: true;
2624
+ isPrimaryKey: false;
2625
+ isAutoincrement: false;
2626
+ hasRuntimeDefault: false;
2627
+ enumValues: undefined;
2628
+ baseColumn: never;
2629
+ identity: undefined;
2630
+ generated: undefined;
2631
+ }, {}, {}>;
2632
+ maxVideos: import("drizzle-orm/pg-core").PgColumn<{
2633
+ name: "max_videos";
2634
+ tableName: "youtube_source_config";
2635
+ dataType: "number";
2636
+ columnType: "PgInteger";
2637
+ data: number;
2638
+ driverParam: string | number;
2639
+ notNull: true;
2640
+ hasDefault: true;
2641
+ isPrimaryKey: false;
2642
+ isAutoincrement: false;
2643
+ hasRuntimeDefault: false;
2644
+ enumValues: undefined;
2645
+ baseColumn: never;
2646
+ identity: undefined;
2647
+ generated: undefined;
2648
+ }, {}, {}>;
2649
+ minViews: import("drizzle-orm/pg-core").PgColumn<{
2650
+ name: "min_views";
2651
+ tableName: "youtube_source_config";
2652
+ dataType: "number";
2653
+ columnType: "PgInteger";
2654
+ data: number;
2655
+ driverParam: string | number;
2656
+ notNull: false;
2657
+ hasDefault: true;
2658
+ isPrimaryKey: false;
2659
+ isAutoincrement: false;
2660
+ hasRuntimeDefault: false;
2661
+ enumValues: undefined;
2662
+ baseColumn: never;
2663
+ identity: undefined;
2664
+ generated: undefined;
2665
+ }, {}, {}>;
2666
+ minRelevanceScore: import("drizzle-orm/pg-core").PgColumn<{
2667
+ name: "min_relevance_score";
2668
+ tableName: "youtube_source_config";
2669
+ dataType: "string";
2670
+ columnType: "PgNumeric";
2671
+ data: string;
2672
+ driverParam: string;
2673
+ notNull: false;
2674
+ hasDefault: true;
2675
+ isPrimaryKey: false;
2676
+ isAutoincrement: false;
2677
+ hasRuntimeDefault: false;
2678
+ enumValues: undefined;
2679
+ baseColumn: never;
2680
+ identity: undefined;
2681
+ generated: undefined;
2682
+ }, {}, {}>;
2683
+ contentTypes: import("drizzle-orm/pg-core").PgColumn<{
2684
+ name: "content_types";
2685
+ tableName: "youtube_source_config";
2686
+ dataType: "array";
2687
+ columnType: "PgArray";
2688
+ data: string[];
2689
+ driverParam: string | string[];
2690
+ notNull: false;
2691
+ hasDefault: true;
2692
+ isPrimaryKey: false;
2693
+ isAutoincrement: false;
2694
+ hasRuntimeDefault: false;
2695
+ enumValues: [string, ...string[]];
2696
+ baseColumn: import("drizzle-orm").Column<{
2697
+ name: "content_types";
2698
+ tableName: "youtube_source_config";
2699
+ dataType: "string";
2700
+ columnType: "PgText";
2701
+ data: string;
2702
+ driverParam: string;
2703
+ notNull: false;
2704
+ hasDefault: false;
2705
+ isPrimaryKey: false;
2706
+ isAutoincrement: false;
2707
+ hasRuntimeDefault: false;
2708
+ enumValues: [string, ...string[]];
2709
+ baseColumn: never;
2710
+ identity: undefined;
2711
+ generated: undefined;
2712
+ }, {}, {}>;
2713
+ identity: undefined;
2714
+ generated: undefined;
2715
+ }, {}, {
2716
+ baseBuilder: import("drizzle-orm/pg-core").PgColumnBuilder<{
2717
+ name: "content_types";
2718
+ dataType: "string";
2719
+ columnType: "PgText";
2720
+ data: string;
2721
+ enumValues: [string, ...string[]];
2722
+ driverParam: string;
2723
+ }, {}, {}, import("drizzle-orm").ColumnBuilderExtraConfig>;
2724
+ size: undefined;
2725
+ }>;
2726
+ addedBy: import("drizzle-orm/pg-core").PgColumn<{
2727
+ name: "added_by";
2728
+ tableName: "youtube_source_config";
2729
+ dataType: "string";
2730
+ columnType: "PgText";
2731
+ data: string;
2732
+ driverParam: string;
2733
+ notNull: true;
2734
+ hasDefault: true;
2735
+ isPrimaryKey: false;
2736
+ isAutoincrement: false;
2737
+ hasRuntimeDefault: false;
2738
+ enumValues: [string, ...string[]];
2739
+ baseColumn: never;
2740
+ identity: undefined;
2741
+ generated: undefined;
2742
+ }, {}, {}>;
2743
+ notes: import("drizzle-orm/pg-core").PgColumn<{
2744
+ name: "notes";
2745
+ tableName: "youtube_source_config";
2746
+ dataType: "string";
2747
+ columnType: "PgText";
2748
+ data: string;
2749
+ driverParam: string;
2750
+ notNull: false;
2751
+ hasDefault: false;
2752
+ isPrimaryKey: false;
2753
+ isAutoincrement: false;
2754
+ hasRuntimeDefault: false;
2755
+ enumValues: [string, ...string[]];
2756
+ baseColumn: never;
2757
+ identity: undefined;
2758
+ generated: undefined;
2759
+ }, {}, {}>;
2760
+ totalVideosFound: import("drizzle-orm/pg-core").PgColumn<{
2761
+ name: "total_videos_found";
2762
+ tableName: "youtube_source_config";
2763
+ dataType: "number";
2764
+ columnType: "PgInteger";
2765
+ data: number;
2766
+ driverParam: string | number;
2767
+ notNull: true;
2768
+ hasDefault: true;
2769
+ isPrimaryKey: false;
2770
+ isAutoincrement: false;
2771
+ hasRuntimeDefault: false;
2772
+ enumValues: undefined;
2773
+ baseColumn: never;
2774
+ identity: undefined;
2775
+ generated: undefined;
2776
+ }, {}, {}>;
2777
+ totalVideosCreated: import("drizzle-orm/pg-core").PgColumn<{
2778
+ name: "total_videos_created";
2779
+ tableName: "youtube_source_config";
2780
+ dataType: "number";
2781
+ columnType: "PgInteger";
2782
+ data: number;
2783
+ driverParam: string | number;
2784
+ notNull: true;
2785
+ hasDefault: true;
2786
+ isPrimaryKey: false;
2787
+ isAutoincrement: false;
2788
+ hasRuntimeDefault: false;
2789
+ enumValues: undefined;
2790
+ baseColumn: never;
2791
+ identity: undefined;
2792
+ generated: undefined;
2793
+ }, {}, {}>;
2794
+ successCount: import("drizzle-orm/pg-core").PgColumn<{
2795
+ name: "success_count";
2796
+ tableName: "youtube_source_config";
2797
+ dataType: "number";
2798
+ columnType: "PgInteger";
2799
+ data: number;
2800
+ driverParam: string | number;
2801
+ notNull: true;
2802
+ hasDefault: true;
2803
+ isPrimaryKey: false;
2804
+ isAutoincrement: false;
2805
+ hasRuntimeDefault: false;
2806
+ enumValues: undefined;
2807
+ baseColumn: never;
2808
+ identity: undefined;
2809
+ generated: undefined;
2810
+ }, {}, {}>;
2811
+ errorCount: import("drizzle-orm/pg-core").PgColumn<{
2812
+ name: "error_count";
2813
+ tableName: "youtube_source_config";
2814
+ dataType: "number";
2815
+ columnType: "PgInteger";
2816
+ data: number;
2817
+ driverParam: string | number;
2818
+ notNull: true;
2819
+ hasDefault: true;
2820
+ isPrimaryKey: false;
2821
+ isAutoincrement: false;
2822
+ hasRuntimeDefault: false;
2823
+ enumValues: undefined;
2824
+ baseColumn: never;
2825
+ identity: undefined;
2826
+ generated: undefined;
2827
+ }, {}, {}>;
2828
+ apiCallsToday: import("drizzle-orm/pg-core").PgColumn<{
2829
+ name: "api_calls_today";
2830
+ tableName: "youtube_source_config";
2831
+ dataType: "number";
2832
+ columnType: "PgInteger";
2833
+ data: number;
2834
+ driverParam: string | number;
2835
+ notNull: true;
2836
+ hasDefault: true;
2837
+ isPrimaryKey: false;
2838
+ isAutoincrement: false;
2839
+ hasRuntimeDefault: false;
2840
+ enumValues: undefined;
2841
+ baseColumn: never;
2842
+ identity: undefined;
2843
+ generated: undefined;
2844
+ }, {}, {}>;
2845
+ lastVideoFoundAt: import("drizzle-orm/pg-core").PgColumn<{
2846
+ name: "last_video_found_at";
2847
+ tableName: "youtube_source_config";
2848
+ dataType: "date";
2849
+ columnType: "PgTimestamp";
2850
+ data: Date;
2851
+ driverParam: string;
2852
+ notNull: false;
2853
+ hasDefault: false;
2854
+ isPrimaryKey: false;
2855
+ isAutoincrement: false;
2856
+ hasRuntimeDefault: false;
2857
+ enumValues: undefined;
2858
+ baseColumn: never;
2859
+ identity: undefined;
2860
+ generated: undefined;
2861
+ }, {}, {}>;
2862
+ lastCheckedAt: import("drizzle-orm/pg-core").PgColumn<{
2863
+ name: "last_checked_at";
2864
+ tableName: "youtube_source_config";
2865
+ dataType: "date";
2866
+ columnType: "PgTimestamp";
2867
+ data: Date;
2868
+ driverParam: string;
2869
+ notNull: false;
2870
+ hasDefault: false;
2871
+ isPrimaryKey: false;
2872
+ isAutoincrement: false;
2873
+ hasRuntimeDefault: false;
2874
+ enumValues: undefined;
2875
+ baseColumn: never;
2876
+ identity: undefined;
2877
+ generated: undefined;
2878
+ }, {}, {}>;
2879
+ lastSuccessfulCheck: import("drizzle-orm/pg-core").PgColumn<{
2880
+ name: "last_successful_check";
2881
+ tableName: "youtube_source_config";
2882
+ dataType: "date";
2883
+ columnType: "PgTimestamp";
2884
+ data: Date;
2885
+ driverParam: string;
2886
+ notNull: false;
2887
+ hasDefault: false;
2888
+ isPrimaryKey: false;
2889
+ isAutoincrement: false;
2890
+ hasRuntimeDefault: false;
2891
+ enumValues: undefined;
2892
+ baseColumn: never;
2893
+ identity: undefined;
2894
+ generated: undefined;
2895
+ }, {}, {}>;
2896
+ lastError: import("drizzle-orm/pg-core").PgColumn<{
2897
+ name: "last_error";
2898
+ tableName: "youtube_source_config";
2899
+ dataType: "string";
2900
+ columnType: "PgText";
2901
+ data: string;
2902
+ driverParam: string;
2903
+ notNull: false;
2904
+ hasDefault: false;
2905
+ isPrimaryKey: false;
2906
+ isAutoincrement: false;
2907
+ hasRuntimeDefault: false;
2908
+ enumValues: [string, ...string[]];
2909
+ baseColumn: never;
2910
+ identity: undefined;
2911
+ generated: undefined;
2912
+ }, {}, {}>;
2913
+ lastRunAt: import("drizzle-orm/pg-core").PgColumn<{
2914
+ name: "last_run_at";
2915
+ tableName: "youtube_source_config";
2916
+ dataType: "date";
2917
+ columnType: "PgTimestamp";
2918
+ data: Date;
2919
+ driverParam: string;
2920
+ notNull: false;
2921
+ hasDefault: false;
2922
+ isPrimaryKey: false;
2923
+ isAutoincrement: false;
2924
+ hasRuntimeDefault: false;
2925
+ enumValues: undefined;
2926
+ baseColumn: never;
2927
+ identity: undefined;
2928
+ generated: undefined;
2929
+ }, {}, {}>;
2930
+ lastRunStatus: import("drizzle-orm/pg-core").PgColumn<{
2931
+ name: "last_run_status";
2932
+ tableName: "youtube_source_config";
2933
+ dataType: "string";
2934
+ columnType: "PgText";
2935
+ data: string;
2936
+ driverParam: string;
2937
+ notNull: false;
2938
+ hasDefault: false;
2939
+ isPrimaryKey: false;
2940
+ isAutoincrement: false;
2941
+ hasRuntimeDefault: false;
2942
+ enumValues: [string, ...string[]];
2943
+ baseColumn: never;
2944
+ identity: undefined;
2945
+ generated: undefined;
2946
+ }, {}, {}>;
2947
+ nextRunAt: import("drizzle-orm/pg-core").PgColumn<{
2948
+ name: "next_run_at";
2949
+ tableName: "youtube_source_config";
2950
+ dataType: "date";
2951
+ columnType: "PgTimestamp";
2952
+ data: Date;
2953
+ driverParam: string;
2954
+ notNull: false;
2955
+ hasDefault: false;
2956
+ isPrimaryKey: false;
2957
+ isAutoincrement: false;
2958
+ hasRuntimeDefault: false;
2959
+ enumValues: undefined;
2960
+ baseColumn: never;
2961
+ identity: undefined;
2962
+ generated: undefined;
2963
+ }, {}, {}>;
2964
+ lastSuccessAt: import("drizzle-orm/pg-core").PgColumn<{
2965
+ name: "last_success_at";
2966
+ tableName: "youtube_source_config";
2967
+ dataType: "date";
2968
+ columnType: "PgTimestamp";
2969
+ data: Date;
2970
+ driverParam: string;
2971
+ notNull: false;
2972
+ hasDefault: false;
2973
+ isPrimaryKey: false;
2974
+ isAutoincrement: false;
2975
+ hasRuntimeDefault: false;
2976
+ enumValues: undefined;
2977
+ baseColumn: never;
2978
+ identity: undefined;
2979
+ generated: undefined;
2980
+ }, {}, {}>;
2981
+ lastErrorAt: import("drizzle-orm/pg-core").PgColumn<{
2982
+ name: "last_error_at";
2983
+ tableName: "youtube_source_config";
2984
+ dataType: "date";
2985
+ columnType: "PgTimestamp";
2986
+ data: Date;
2987
+ driverParam: string;
2988
+ notNull: false;
2989
+ hasDefault: false;
2990
+ isPrimaryKey: false;
2991
+ isAutoincrement: false;
2992
+ hasRuntimeDefault: false;
2993
+ enumValues: undefined;
2994
+ baseColumn: never;
2995
+ identity: undefined;
2996
+ generated: undefined;
2997
+ }, {}, {}>;
2998
+ lastErrorMessage: import("drizzle-orm/pg-core").PgColumn<{
2999
+ name: "last_error_message";
3000
+ tableName: "youtube_source_config";
3001
+ dataType: "string";
3002
+ columnType: "PgText";
3003
+ data: string;
3004
+ driverParam: string;
3005
+ notNull: false;
3006
+ hasDefault: false;
3007
+ isPrimaryKey: false;
3008
+ isAutoincrement: false;
3009
+ hasRuntimeDefault: false;
3010
+ enumValues: [string, ...string[]];
3011
+ baseColumn: never;
3012
+ identity: undefined;
3013
+ generated: undefined;
3014
+ }, {}, {}>;
3015
+ lastRunDuration: import("drizzle-orm/pg-core").PgColumn<{
3016
+ name: "last_run_duration";
3017
+ tableName: "youtube_source_config";
3018
+ dataType: "number";
3019
+ columnType: "PgInteger";
3020
+ data: number;
3021
+ driverParam: string | number;
3022
+ notNull: false;
3023
+ hasDefault: false;
3024
+ isPrimaryKey: false;
3025
+ isAutoincrement: false;
3026
+ hasRuntimeDefault: false;
3027
+ enumValues: undefined;
3028
+ baseColumn: never;
3029
+ identity: undefined;
3030
+ generated: undefined;
3031
+ }, {}, {}>;
3032
+ createdAt: import("drizzle-orm/pg-core").PgColumn<{
3033
+ name: "created_at";
3034
+ tableName: "youtube_source_config";
3035
+ dataType: "date";
3036
+ columnType: "PgTimestamp";
3037
+ data: Date;
3038
+ driverParam: string;
3039
+ notNull: true;
3040
+ hasDefault: true;
3041
+ isPrimaryKey: false;
3042
+ isAutoincrement: false;
3043
+ hasRuntimeDefault: false;
3044
+ enumValues: undefined;
3045
+ baseColumn: never;
3046
+ identity: undefined;
3047
+ generated: undefined;
3048
+ }, {}, {}>;
3049
+ updatedAt: import("drizzle-orm/pg-core").PgColumn<{
3050
+ name: "updated_at";
3051
+ tableName: "youtube_source_config";
3052
+ dataType: "date";
3053
+ columnType: "PgTimestamp";
3054
+ data: Date;
3055
+ driverParam: string;
3056
+ notNull: true;
3057
+ hasDefault: true;
3058
+ isPrimaryKey: false;
3059
+ isAutoincrement: false;
3060
+ hasRuntimeDefault: false;
3061
+ enumValues: undefined;
3062
+ baseColumn: never;
3063
+ identity: undefined;
3064
+ generated: undefined;
3065
+ }, {}, {}>;
3066
+ };
3067
+ dialect: "pg";
3068
+ }>;
3069
+ export declare const youtubeVideos: import("drizzle-orm/pg-core").PgTableWithColumns<{
3070
+ name: "youtube_videos";
3071
+ schema: undefined;
3072
+ columns: {
3073
+ id: import("drizzle-orm/pg-core").PgColumn<{
3074
+ name: "id";
3075
+ tableName: "youtube_videos";
3076
+ dataType: "string";
3077
+ columnType: "PgText";
3078
+ data: string;
3079
+ driverParam: string;
3080
+ notNull: true;
3081
+ hasDefault: false;
3082
+ isPrimaryKey: true;
3083
+ isAutoincrement: false;
3084
+ hasRuntimeDefault: false;
3085
+ enumValues: [string, ...string[]];
3086
+ baseColumn: never;
3087
+ identity: undefined;
3088
+ generated: undefined;
3089
+ }, {}, {}>;
3090
+ videoId: import("drizzle-orm/pg-core").PgColumn<{
3091
+ name: "video_id";
3092
+ tableName: "youtube_videos";
3093
+ dataType: "string";
3094
+ columnType: "PgText";
3095
+ data: string;
3096
+ driverParam: string;
3097
+ notNull: true;
3098
+ hasDefault: false;
3099
+ isPrimaryKey: false;
3100
+ isAutoincrement: false;
3101
+ hasRuntimeDefault: false;
3102
+ enumValues: [string, ...string[]];
3103
+ baseColumn: never;
3104
+ identity: undefined;
3105
+ generated: undefined;
3106
+ }, {}, {}>;
3107
+ title: import("drizzle-orm/pg-core").PgColumn<{
3108
+ name: "title";
3109
+ tableName: "youtube_videos";
3110
+ dataType: "string";
3111
+ columnType: "PgText";
3112
+ data: string;
3113
+ driverParam: string;
3114
+ notNull: true;
3115
+ hasDefault: false;
3116
+ isPrimaryKey: false;
3117
+ isAutoincrement: false;
3118
+ hasRuntimeDefault: false;
3119
+ enumValues: [string, ...string[]];
3120
+ baseColumn: never;
3121
+ identity: undefined;
3122
+ generated: undefined;
3123
+ }, {}, {}>;
3124
+ description: import("drizzle-orm/pg-core").PgColumn<{
3125
+ name: "description";
3126
+ tableName: "youtube_videos";
3127
+ dataType: "string";
3128
+ columnType: "PgText";
3129
+ data: string;
3130
+ driverParam: string;
3131
+ notNull: false;
3132
+ hasDefault: false;
3133
+ isPrimaryKey: false;
3134
+ isAutoincrement: false;
3135
+ hasRuntimeDefault: false;
3136
+ enumValues: [string, ...string[]];
3137
+ baseColumn: never;
3138
+ identity: undefined;
3139
+ generated: undefined;
3140
+ }, {}, {}>;
3141
+ channelId: import("drizzle-orm/pg-core").PgColumn<{
3142
+ name: "channel_id";
3143
+ tableName: "youtube_videos";
3144
+ dataType: "string";
3145
+ columnType: "PgText";
3146
+ data: string;
3147
+ driverParam: string;
3148
+ notNull: true;
3149
+ hasDefault: false;
3150
+ isPrimaryKey: false;
3151
+ isAutoincrement: false;
3152
+ hasRuntimeDefault: false;
3153
+ enumValues: [string, ...string[]];
3154
+ baseColumn: never;
3155
+ identity: undefined;
3156
+ generated: undefined;
3157
+ }, {}, {}>;
3158
+ channelName: import("drizzle-orm/pg-core").PgColumn<{
3159
+ name: "channel_name";
3160
+ tableName: "youtube_videos";
3161
+ dataType: "string";
3162
+ columnType: "PgText";
3163
+ data: string;
3164
+ driverParam: string;
3165
+ notNull: true;
3166
+ hasDefault: false;
3167
+ isPrimaryKey: false;
3168
+ isAutoincrement: false;
3169
+ hasRuntimeDefault: false;
3170
+ enumValues: [string, ...string[]];
3171
+ baseColumn: never;
3172
+ identity: undefined;
3173
+ generated: undefined;
3174
+ }, {}, {}>;
3175
+ channelUrl: import("drizzle-orm/pg-core").PgColumn<{
3176
+ name: "channel_url";
3177
+ tableName: "youtube_videos";
3178
+ dataType: "string";
3179
+ columnType: "PgText";
3180
+ data: string;
3181
+ driverParam: string;
3182
+ notNull: false;
3183
+ hasDefault: false;
3184
+ isPrimaryKey: false;
3185
+ isAutoincrement: false;
3186
+ hasRuntimeDefault: false;
3187
+ enumValues: [string, ...string[]];
3188
+ baseColumn: never;
3189
+ identity: undefined;
3190
+ generated: undefined;
3191
+ }, {}, {}>;
3192
+ publishedAt: import("drizzle-orm/pg-core").PgColumn<{
3193
+ name: "published_at";
3194
+ tableName: "youtube_videos";
3195
+ dataType: "date";
3196
+ columnType: "PgTimestamp";
3197
+ data: Date;
3198
+ driverParam: string;
3199
+ notNull: true;
3200
+ hasDefault: false;
3201
+ isPrimaryKey: false;
3202
+ isAutoincrement: false;
3203
+ hasRuntimeDefault: false;
3204
+ enumValues: undefined;
3205
+ baseColumn: never;
3206
+ identity: undefined;
3207
+ generated: undefined;
3208
+ }, {}, {}>;
3209
+ duration: import("drizzle-orm/pg-core").PgColumn<{
3210
+ name: "duration";
3211
+ tableName: "youtube_videos";
3212
+ dataType: "string";
3213
+ columnType: "PgText";
3214
+ data: string;
3215
+ driverParam: string;
3216
+ notNull: false;
3217
+ hasDefault: false;
3218
+ isPrimaryKey: false;
3219
+ isAutoincrement: false;
3220
+ hasRuntimeDefault: false;
3221
+ enumValues: [string, ...string[]];
3222
+ baseColumn: never;
3223
+ identity: undefined;
3224
+ generated: undefined;
3225
+ }, {}, {}>;
3226
+ viewCount: import("drizzle-orm/pg-core").PgColumn<{
3227
+ name: "view_count";
3228
+ tableName: "youtube_videos";
3229
+ dataType: "number";
3230
+ columnType: "PgBigInt53";
3231
+ data: number;
3232
+ driverParam: string | number;
3233
+ notNull: false;
3234
+ hasDefault: false;
3235
+ isPrimaryKey: false;
3236
+ isAutoincrement: false;
3237
+ hasRuntimeDefault: false;
3238
+ enumValues: undefined;
3239
+ baseColumn: never;
3240
+ identity: undefined;
3241
+ generated: undefined;
3242
+ }, {}, {}>;
3243
+ likeCount: import("drizzle-orm/pg-core").PgColumn<{
3244
+ name: "like_count";
3245
+ tableName: "youtube_videos";
3246
+ dataType: "number";
3247
+ columnType: "PgInteger";
3248
+ data: number;
3249
+ driverParam: string | number;
3250
+ notNull: false;
3251
+ hasDefault: false;
3252
+ isPrimaryKey: false;
3253
+ isAutoincrement: false;
3254
+ hasRuntimeDefault: false;
3255
+ enumValues: undefined;
3256
+ baseColumn: never;
3257
+ identity: undefined;
3258
+ generated: undefined;
3259
+ }, {}, {}>;
3260
+ commentCount: import("drizzle-orm/pg-core").PgColumn<{
3261
+ name: "comment_count";
3262
+ tableName: "youtube_videos";
3263
+ dataType: "number";
3264
+ columnType: "PgInteger";
3265
+ data: number;
3266
+ driverParam: string | number;
3267
+ notNull: false;
3268
+ hasDefault: false;
3269
+ isPrimaryKey: false;
3270
+ isAutoincrement: false;
3271
+ hasRuntimeDefault: false;
3272
+ enumValues: undefined;
3273
+ baseColumn: never;
3274
+ identity: undefined;
3275
+ generated: undefined;
3276
+ }, {}, {}>;
3277
+ thumbnailUrl: import("drizzle-orm/pg-core").PgColumn<{
3278
+ name: "thumbnail_url";
3279
+ tableName: "youtube_videos";
3280
+ dataType: "string";
3281
+ columnType: "PgText";
3282
+ data: string;
3283
+ driverParam: string;
3284
+ notNull: false;
3285
+ hasDefault: false;
3286
+ isPrimaryKey: false;
3287
+ isAutoincrement: false;
3288
+ hasRuntimeDefault: false;
3289
+ enumValues: [string, ...string[]];
3290
+ baseColumn: never;
3291
+ identity: undefined;
3292
+ generated: undefined;
3293
+ }, {}, {}>;
3294
+ thumbnails: import("drizzle-orm/pg-core").PgColumn<{
3295
+ name: "thumbnails";
3296
+ tableName: "youtube_videos";
3297
+ dataType: "json";
3298
+ columnType: "PgJson";
3299
+ data: unknown;
3300
+ driverParam: unknown;
3301
+ notNull: false;
3302
+ hasDefault: false;
3303
+ isPrimaryKey: false;
3304
+ isAutoincrement: false;
3305
+ hasRuntimeDefault: false;
3306
+ enumValues: undefined;
3307
+ baseColumn: never;
3308
+ identity: undefined;
3309
+ generated: undefined;
3310
+ }, {}, {}>;
3311
+ language: import("drizzle-orm/pg-core").PgColumn<{
3312
+ name: "language";
3313
+ tableName: "youtube_videos";
3314
+ dataType: "string";
3315
+ columnType: "PgText";
3316
+ data: string;
3317
+ driverParam: string;
3318
+ notNull: false;
3319
+ hasDefault: true;
3320
+ isPrimaryKey: false;
3321
+ isAutoincrement: false;
3322
+ hasRuntimeDefault: false;
3323
+ enumValues: [string, ...string[]];
3324
+ baseColumn: never;
3325
+ identity: undefined;
3326
+ generated: undefined;
3327
+ }, {}, {}>;
3328
+ contentType: import("drizzle-orm/pg-core").PgColumn<{
3329
+ name: "content_type";
3330
+ tableName: "youtube_videos";
3331
+ dataType: "string";
3332
+ columnType: "PgText";
3333
+ data: string;
3334
+ driverParam: string;
3335
+ notNull: false;
3336
+ hasDefault: false;
3337
+ isPrimaryKey: false;
3338
+ isAutoincrement: false;
3339
+ hasRuntimeDefault: false;
3340
+ enumValues: [string, ...string[]];
3341
+ baseColumn: never;
3342
+ identity: undefined;
3343
+ generated: undefined;
3344
+ }, {}, {}>;
3345
+ relevanceScore: import("drizzle-orm/pg-core").PgColumn<{
3346
+ name: "relevance_score";
3347
+ tableName: "youtube_videos";
3348
+ dataType: "string";
3349
+ columnType: "PgNumeric";
3350
+ data: string;
3351
+ driverParam: string;
3352
+ notNull: false;
3353
+ hasDefault: false;
3354
+ isPrimaryKey: false;
3355
+ isAutoincrement: false;
3356
+ hasRuntimeDefault: false;
3357
+ enumValues: undefined;
3358
+ baseColumn: never;
3359
+ identity: undefined;
3360
+ generated: undefined;
3361
+ }, {}, {}>;
3362
+ qualityScore: import("drizzle-orm/pg-core").PgColumn<{
3363
+ name: "quality_score";
3364
+ tableName: "youtube_videos";
3365
+ dataType: "string";
3366
+ columnType: "PgNumeric";
3367
+ data: string;
3368
+ driverParam: string;
3369
+ notNull: false;
3370
+ hasDefault: false;
3371
+ isPrimaryKey: false;
3372
+ isAutoincrement: false;
3373
+ hasRuntimeDefault: false;
3374
+ enumValues: undefined;
3375
+ baseColumn: never;
3376
+ identity: undefined;
3377
+ generated: undefined;
3378
+ }, {}, {}>;
3379
+ tags: import("drizzle-orm/pg-core").PgColumn<{
3380
+ name: "tags";
3381
+ tableName: "youtube_videos";
3382
+ dataType: "array";
3383
+ columnType: "PgArray";
3384
+ data: string[];
3385
+ driverParam: string | string[];
3386
+ notNull: false;
3387
+ hasDefault: true;
3388
+ isPrimaryKey: false;
3389
+ isAutoincrement: false;
3390
+ hasRuntimeDefault: false;
3391
+ enumValues: [string, ...string[]];
3392
+ baseColumn: import("drizzle-orm").Column<{
3393
+ name: "tags";
3394
+ tableName: "youtube_videos";
3395
+ dataType: "string";
3396
+ columnType: "PgText";
3397
+ data: string;
3398
+ driverParam: string;
3399
+ notNull: false;
3400
+ hasDefault: false;
3401
+ isPrimaryKey: false;
3402
+ isAutoincrement: false;
3403
+ hasRuntimeDefault: false;
3404
+ enumValues: [string, ...string[]];
3405
+ baseColumn: never;
3406
+ identity: undefined;
3407
+ generated: undefined;
3408
+ }, {}, {}>;
3409
+ identity: undefined;
3410
+ generated: undefined;
3411
+ }, {}, {
3412
+ baseBuilder: import("drizzle-orm/pg-core").PgColumnBuilder<{
3413
+ name: "tags";
3414
+ dataType: "string";
3415
+ columnType: "PgText";
3416
+ data: string;
3417
+ enumValues: [string, ...string[]];
3418
+ driverParam: string;
3419
+ }, {}, {}, import("drizzle-orm").ColumnBuilderExtraConfig>;
3420
+ size: undefined;
3421
+ }>;
3422
+ categoryId: import("drizzle-orm/pg-core").PgColumn<{
3423
+ name: "category_id";
3424
+ tableName: "youtube_videos";
3425
+ dataType: "number";
3426
+ columnType: "PgInteger";
3427
+ data: number;
3428
+ driverParam: string | number;
3429
+ notNull: false;
3430
+ hasDefault: false;
3431
+ isPrimaryKey: false;
3432
+ isAutoincrement: false;
3433
+ hasRuntimeDefault: false;
3434
+ enumValues: undefined;
3435
+ baseColumn: never;
3436
+ identity: undefined;
3437
+ generated: undefined;
3438
+ }, {}, {}>;
3439
+ isOfficial: import("drizzle-orm/pg-core").PgColumn<{
3440
+ name: "is_official";
3441
+ tableName: "youtube_videos";
3442
+ dataType: "boolean";
3443
+ columnType: "PgBoolean";
3444
+ data: boolean;
3445
+ driverParam: boolean;
3446
+ notNull: true;
3447
+ hasDefault: true;
3448
+ isPrimaryKey: false;
3449
+ isAutoincrement: false;
3450
+ hasRuntimeDefault: false;
3451
+ enumValues: undefined;
3452
+ baseColumn: never;
3453
+ identity: undefined;
3454
+ generated: undefined;
3455
+ }, {}, {}>;
3456
+ isFeatured: import("drizzle-orm/pg-core").PgColumn<{
3457
+ name: "is_featured";
3458
+ tableName: "youtube_videos";
3459
+ dataType: "boolean";
3460
+ columnType: "PgBoolean";
3461
+ data: boolean;
3462
+ driverParam: boolean;
3463
+ notNull: true;
3464
+ hasDefault: true;
3465
+ isPrimaryKey: false;
3466
+ isAutoincrement: false;
3467
+ hasRuntimeDefault: false;
3468
+ enumValues: undefined;
3469
+ baseColumn: never;
3470
+ identity: undefined;
3471
+ generated: undefined;
3472
+ }, {}, {}>;
3473
+ aiClassified: import("drizzle-orm/pg-core").PgColumn<{
3474
+ name: "ai_classified";
3475
+ tableName: "youtube_videos";
3476
+ dataType: "boolean";
3477
+ columnType: "PgBoolean";
3478
+ data: boolean;
3479
+ driverParam: boolean;
3480
+ notNull: true;
3481
+ hasDefault: true;
3482
+ isPrimaryKey: false;
3483
+ isAutoincrement: false;
3484
+ hasRuntimeDefault: false;
3485
+ enumValues: undefined;
3486
+ baseColumn: never;
3487
+ identity: undefined;
3488
+ generated: undefined;
3489
+ }, {}, {}>;
3490
+ aiConfidence: import("drizzle-orm/pg-core").PgColumn<{
3491
+ name: "ai_confidence";
3492
+ tableName: "youtube_videos";
3493
+ dataType: "string";
3494
+ columnType: "PgNumeric";
3495
+ data: string;
3496
+ driverParam: string;
3497
+ notNull: false;
3498
+ hasDefault: false;
3499
+ isPrimaryKey: false;
3500
+ isAutoincrement: false;
3501
+ hasRuntimeDefault: false;
3502
+ enumValues: undefined;
3503
+ baseColumn: never;
3504
+ identity: undefined;
3505
+ generated: undefined;
3506
+ }, {}, {}>;
3507
+ aiReason: import("drizzle-orm/pg-core").PgColumn<{
3508
+ name: "ai_reason";
3509
+ tableName: "youtube_videos";
3510
+ dataType: "string";
3511
+ columnType: "PgText";
3512
+ data: string;
3513
+ driverParam: string;
3514
+ notNull: false;
3515
+ hasDefault: false;
3516
+ isPrimaryKey: false;
3517
+ isAutoincrement: false;
3518
+ hasRuntimeDefault: false;
3519
+ enumValues: [string, ...string[]];
3520
+ baseColumn: never;
3521
+ identity: undefined;
3522
+ generated: undefined;
3523
+ }, {}, {}>;
3524
+ isAion2Related: import("drizzle-orm/pg-core").PgColumn<{
3525
+ name: "is_aion2_related";
3526
+ tableName: "youtube_videos";
3527
+ dataType: "boolean";
3528
+ columnType: "PgBoolean";
3529
+ data: boolean;
3530
+ driverParam: boolean;
3531
+ notNull: true;
3532
+ hasDefault: true;
3533
+ isPrimaryKey: false;
3534
+ isAutoincrement: false;
3535
+ hasRuntimeDefault: false;
3536
+ enumValues: undefined;
3537
+ baseColumn: never;
3538
+ identity: undefined;
3539
+ generated: undefined;
3540
+ }, {}, {}>;
3541
+ classificationFilters: import("drizzle-orm/pg-core").PgColumn<{
3542
+ name: "classification_filters";
3543
+ tableName: "youtube_videos";
3544
+ dataType: "array";
3545
+ columnType: "PgArray";
3546
+ data: string[];
3547
+ driverParam: string | string[];
3548
+ notNull: false;
3549
+ hasDefault: true;
3550
+ isPrimaryKey: false;
3551
+ isAutoincrement: false;
3552
+ hasRuntimeDefault: false;
3553
+ enumValues: [string, ...string[]];
3554
+ baseColumn: import("drizzle-orm").Column<{
3555
+ name: "classification_filters";
3556
+ tableName: "youtube_videos";
3557
+ dataType: "string";
3558
+ columnType: "PgText";
3559
+ data: string;
3560
+ driverParam: string;
3561
+ notNull: false;
3562
+ hasDefault: false;
3563
+ isPrimaryKey: false;
3564
+ isAutoincrement: false;
3565
+ hasRuntimeDefault: false;
3566
+ enumValues: [string, ...string[]];
3567
+ baseColumn: never;
3568
+ identity: undefined;
3569
+ generated: undefined;
3570
+ }, {}, {}>;
3571
+ identity: undefined;
3572
+ generated: undefined;
3573
+ }, {}, {
3574
+ baseBuilder: import("drizzle-orm/pg-core").PgColumnBuilder<{
3575
+ name: "classification_filters";
3576
+ dataType: "string";
3577
+ columnType: "PgText";
3578
+ data: string;
3579
+ enumValues: [string, ...string[]];
3580
+ driverParam: string;
3581
+ }, {}, {}, import("drizzle-orm").ColumnBuilderExtraConfig>;
3582
+ size: undefined;
3583
+ }>;
3584
+ filterMatchDetails: import("drizzle-orm/pg-core").PgColumn<{
3585
+ name: "filter_match_details";
3586
+ tableName: "youtube_videos";
3587
+ dataType: "json";
3588
+ columnType: "PgJsonb";
3589
+ data: unknown;
3590
+ driverParam: unknown;
3591
+ notNull: false;
3592
+ hasDefault: false;
3593
+ isPrimaryKey: false;
3594
+ isAutoincrement: false;
3595
+ hasRuntimeDefault: false;
3596
+ enumValues: undefined;
3597
+ baseColumn: never;
3598
+ identity: undefined;
3599
+ generated: undefined;
3600
+ }, {}, {}>;
3601
+ classificationVersion: import("drizzle-orm/pg-core").PgColumn<{
3602
+ name: "classification_version";
3603
+ tableName: "youtube_videos";
3604
+ dataType: "string";
3605
+ columnType: "PgText";
3606
+ data: string;
3607
+ driverParam: string;
3608
+ notNull: false;
3609
+ hasDefault: true;
3610
+ isPrimaryKey: false;
3611
+ isAutoincrement: false;
3612
+ hasRuntimeDefault: false;
3613
+ enumValues: [string, ...string[]];
3614
+ baseColumn: never;
3615
+ identity: undefined;
3616
+ generated: undefined;
3617
+ }, {}, {}>;
3618
+ classificationKeywords: import("drizzle-orm/pg-core").PgColumn<{
3619
+ name: "classification_keywords";
3620
+ tableName: "youtube_videos";
3621
+ dataType: "array";
3622
+ columnType: "PgArray";
3623
+ data: string[];
3624
+ driverParam: string | string[];
3625
+ notNull: false;
3626
+ hasDefault: true;
3627
+ isPrimaryKey: false;
3628
+ isAutoincrement: false;
3629
+ hasRuntimeDefault: false;
3630
+ enumValues: [string, ...string[]];
3631
+ baseColumn: import("drizzle-orm").Column<{
3632
+ name: "classification_keywords";
3633
+ tableName: "youtube_videos";
3634
+ dataType: "string";
3635
+ columnType: "PgText";
3636
+ data: string;
3637
+ driverParam: string;
3638
+ notNull: false;
3639
+ hasDefault: false;
3640
+ isPrimaryKey: false;
3641
+ isAutoincrement: false;
3642
+ hasRuntimeDefault: false;
3643
+ enumValues: [string, ...string[]];
3644
+ baseColumn: never;
3645
+ identity: undefined;
3646
+ generated: undefined;
3647
+ }, {}, {}>;
3648
+ identity: undefined;
3649
+ generated: undefined;
3650
+ }, {}, {
3651
+ baseBuilder: import("drizzle-orm/pg-core").PgColumnBuilder<{
3652
+ name: "classification_keywords";
3653
+ dataType: "string";
3654
+ columnType: "PgText";
3655
+ data: string;
3656
+ enumValues: [string, ...string[]];
3657
+ driverParam: string;
3658
+ }, {}, {}, import("drizzle-orm").ColumnBuilderExtraConfig>;
3659
+ size: undefined;
3660
+ }>;
3661
+ titleTranslated: import("drizzle-orm/pg-core").PgColumn<{
3662
+ name: "title_translated";
3663
+ tableName: "youtube_videos";
3664
+ dataType: "string";
3665
+ columnType: "PgText";
3666
+ data: string;
3667
+ driverParam: string;
3668
+ notNull: false;
3669
+ hasDefault: false;
3670
+ isPrimaryKey: false;
3671
+ isAutoincrement: false;
3672
+ hasRuntimeDefault: false;
3673
+ enumValues: [string, ...string[]];
3674
+ baseColumn: never;
3675
+ identity: undefined;
3676
+ generated: undefined;
3677
+ }, {}, {}>;
3678
+ descriptionTranslated: import("drizzle-orm/pg-core").PgColumn<{
3679
+ name: "description_translated";
3680
+ tableName: "youtube_videos";
3681
+ dataType: "string";
3682
+ columnType: "PgText";
3683
+ data: string;
3684
+ driverParam: string;
3685
+ notNull: false;
3686
+ hasDefault: false;
3687
+ isPrimaryKey: false;
3688
+ isAutoincrement: false;
3689
+ hasRuntimeDefault: false;
3690
+ enumValues: [string, ...string[]];
3691
+ baseColumn: never;
3692
+ identity: undefined;
3693
+ generated: undefined;
3694
+ }, {}, {}>;
3695
+ translatedAt: import("drizzle-orm/pg-core").PgColumn<{
3696
+ name: "translated_at";
3697
+ tableName: "youtube_videos";
3698
+ dataType: "date";
3699
+ columnType: "PgTimestamp";
3700
+ data: Date;
3701
+ driverParam: string;
3702
+ notNull: false;
3703
+ hasDefault: false;
3704
+ isPrimaryKey: false;
3705
+ isAutoincrement: false;
3706
+ hasRuntimeDefault: false;
3707
+ enumValues: undefined;
3708
+ baseColumn: never;
3709
+ identity: undefined;
3710
+ generated: undefined;
3711
+ }, {}, {}>;
3712
+ translationConfidence: import("drizzle-orm/pg-core").PgColumn<{
3713
+ name: "translation_confidence";
3714
+ tableName: "youtube_videos";
3715
+ dataType: "string";
3716
+ columnType: "PgNumeric";
3717
+ data: string;
3718
+ driverParam: string;
3719
+ notNull: false;
3720
+ hasDefault: false;
3721
+ isPrimaryKey: false;
3722
+ isAutoincrement: false;
3723
+ hasRuntimeDefault: false;
3724
+ enumValues: undefined;
3725
+ baseColumn: never;
3726
+ identity: undefined;
3727
+ generated: undefined;
3728
+ }, {}, {}>;
3729
+ isTranslated: import("drizzle-orm/pg-core").PgColumn<{
3730
+ name: "is_translated";
3731
+ tableName: "youtube_videos";
3732
+ dataType: "boolean";
3733
+ columnType: "PgBoolean";
3734
+ data: boolean;
3735
+ driverParam: boolean;
3736
+ notNull: true;
3737
+ hasDefault: true;
3738
+ isPrimaryKey: false;
3739
+ isAutoincrement: false;
3740
+ hasRuntimeDefault: false;
3741
+ enumValues: undefined;
3742
+ baseColumn: never;
3743
+ identity: undefined;
3744
+ generated: undefined;
3745
+ }, {}, {}>;
3746
+ status: import("drizzle-orm/pg-core").PgColumn<{
3747
+ name: "status";
3748
+ tableName: "youtube_videos";
3749
+ dataType: "string";
3750
+ columnType: "PgEnumColumn";
3751
+ data: "PENDING" | "PROCESSING" | "COMPLETED" | "FAILED" | "REJECTED" | "PUBLISHED";
3752
+ driverParam: string;
3753
+ notNull: true;
3754
+ hasDefault: true;
3755
+ isPrimaryKey: false;
3756
+ isAutoincrement: false;
3757
+ hasRuntimeDefault: false;
3758
+ enumValues: ["PENDING", "PROCESSING", "COMPLETED", "PUBLISHED", "FAILED", "REJECTED"];
3759
+ baseColumn: never;
3760
+ identity: undefined;
3761
+ generated: undefined;
3762
+ }, {}, {}>;
3763
+ processingNotes: import("drizzle-orm/pg-core").PgColumn<{
3764
+ name: "processing_notes";
3765
+ tableName: "youtube_videos";
3766
+ dataType: "string";
3767
+ columnType: "PgText";
3768
+ data: string;
3769
+ driverParam: string;
3770
+ notNull: false;
3771
+ hasDefault: false;
3772
+ isPrimaryKey: false;
3773
+ isAutoincrement: false;
3774
+ hasRuntimeDefault: false;
3775
+ enumValues: [string, ...string[]];
3776
+ baseColumn: never;
3777
+ identity: undefined;
3778
+ generated: undefined;
3779
+ }, {}, {}>;
3780
+ sourceConfigId: import("drizzle-orm/pg-core").PgColumn<{
3781
+ name: "source_config_id";
3782
+ tableName: "youtube_videos";
3783
+ dataType: "string";
3784
+ columnType: "PgText";
3785
+ data: string;
3786
+ driverParam: string;
3787
+ notNull: false;
3788
+ hasDefault: false;
3789
+ isPrimaryKey: false;
3790
+ isAutoincrement: false;
3791
+ hasRuntimeDefault: false;
3792
+ enumValues: [string, ...string[]];
3793
+ baseColumn: never;
3794
+ identity: undefined;
3795
+ generated: undefined;
3796
+ }, {}, {}>;
3797
+ createdAt: import("drizzle-orm/pg-core").PgColumn<{
3798
+ name: "created_at";
3799
+ tableName: "youtube_videos";
3800
+ dataType: "date";
3801
+ columnType: "PgTimestamp";
3802
+ data: Date;
3803
+ driverParam: string;
3804
+ notNull: true;
3805
+ hasDefault: true;
3806
+ isPrimaryKey: false;
3807
+ isAutoincrement: false;
3808
+ hasRuntimeDefault: false;
3809
+ enumValues: undefined;
3810
+ baseColumn: never;
3811
+ identity: undefined;
3812
+ generated: undefined;
3813
+ }, {}, {}>;
3814
+ updatedAt: import("drizzle-orm/pg-core").PgColumn<{
3815
+ name: "updated_at";
3816
+ tableName: "youtube_videos";
3817
+ dataType: "date";
3818
+ columnType: "PgTimestamp";
3819
+ data: Date;
3820
+ driverParam: string;
3821
+ notNull: true;
3822
+ hasDefault: true;
3823
+ isPrimaryKey: false;
3824
+ isAutoincrement: false;
3825
+ hasRuntimeDefault: false;
3826
+ enumValues: undefined;
3827
+ baseColumn: never;
3828
+ identity: undefined;
3829
+ generated: undefined;
3830
+ }, {}, {}>;
3831
+ };
3832
+ dialect: "pg";
3833
+ }>;
3834
+ export declare const youtubeSearchQueries: import("drizzle-orm/pg-core").PgTableWithColumns<{
3835
+ name: "youtube_search_queries";
3836
+ schema: undefined;
3837
+ columns: {
3838
+ id: import("drizzle-orm/pg-core").PgColumn<{
3839
+ name: "id";
3840
+ tableName: "youtube_search_queries";
3841
+ dataType: "string";
3842
+ columnType: "PgText";
3843
+ data: string;
3844
+ driverParam: string;
3845
+ notNull: true;
3846
+ hasDefault: false;
3847
+ isPrimaryKey: true;
3848
+ isAutoincrement: false;
3849
+ hasRuntimeDefault: false;
3850
+ enumValues: [string, ...string[]];
3851
+ baseColumn: never;
3852
+ identity: undefined;
3853
+ generated: undefined;
3854
+ }, {}, {}>;
3855
+ query: import("drizzle-orm/pg-core").PgColumn<{
3856
+ name: "query";
3857
+ tableName: "youtube_search_queries";
3858
+ dataType: "string";
3859
+ columnType: "PgText";
3860
+ data: string;
3861
+ driverParam: string;
3862
+ notNull: true;
3863
+ hasDefault: false;
3864
+ isPrimaryKey: false;
3865
+ isAutoincrement: false;
3866
+ hasRuntimeDefault: false;
3867
+ enumValues: [string, ...string[]];
3868
+ baseColumn: never;
3869
+ identity: undefined;
3870
+ generated: undefined;
3871
+ }, {}, {}>;
3872
+ language: import("drizzle-orm/pg-core").PgColumn<{
3873
+ name: "language";
3874
+ tableName: "youtube_search_queries";
3875
+ dataType: "string";
3876
+ columnType: "PgText";
3877
+ data: string;
3878
+ driverParam: string;
3879
+ notNull: true;
3880
+ hasDefault: true;
3881
+ isPrimaryKey: false;
3882
+ isAutoincrement: false;
3883
+ hasRuntimeDefault: false;
3884
+ enumValues: [string, ...string[]];
3885
+ baseColumn: never;
3886
+ identity: undefined;
3887
+ generated: undefined;
3888
+ }, {}, {}>;
3889
+ isActive: import("drizzle-orm/pg-core").PgColumn<{
3890
+ name: "is_active";
3891
+ tableName: "youtube_search_queries";
3892
+ dataType: "boolean";
3893
+ columnType: "PgBoolean";
3894
+ data: boolean;
3895
+ driverParam: boolean;
3896
+ notNull: true;
3897
+ hasDefault: true;
3898
+ isPrimaryKey: false;
3899
+ isAutoincrement: false;
3900
+ hasRuntimeDefault: false;
3901
+ enumValues: undefined;
3902
+ baseColumn: never;
3903
+ identity: undefined;
3904
+ generated: undefined;
3905
+ }, {}, {}>;
3906
+ totalVideosFound: import("drizzle-orm/pg-core").PgColumn<{
3907
+ name: "total_videos_found";
3908
+ tableName: "youtube_search_queries";
3909
+ dataType: "number";
3910
+ columnType: "PgInteger";
3911
+ data: number;
3912
+ driverParam: string | number;
3913
+ notNull: true;
3914
+ hasDefault: true;
3915
+ isPrimaryKey: false;
3916
+ isAutoincrement: false;
3917
+ hasRuntimeDefault: false;
3918
+ enumValues: undefined;
3919
+ baseColumn: never;
3920
+ identity: undefined;
3921
+ generated: undefined;
3922
+ }, {}, {}>;
3923
+ lastSearchAt: import("drizzle-orm/pg-core").PgColumn<{
3924
+ name: "last_search_at";
3925
+ tableName: "youtube_search_queries";
3926
+ dataType: "date";
3927
+ columnType: "PgTimestamp";
3928
+ data: Date;
3929
+ driverParam: string;
3930
+ notNull: false;
3931
+ hasDefault: false;
3932
+ isPrimaryKey: false;
3933
+ isAutoincrement: false;
3934
+ hasRuntimeDefault: false;
3935
+ enumValues: undefined;
3936
+ baseColumn: never;
3937
+ identity: undefined;
3938
+ generated: undefined;
3939
+ }, {}, {}>;
3940
+ createdAt: import("drizzle-orm/pg-core").PgColumn<{
3941
+ name: "created_at";
3942
+ tableName: "youtube_search_queries";
3943
+ dataType: "date";
3944
+ columnType: "PgTimestamp";
3945
+ data: Date;
3946
+ driverParam: string;
3947
+ notNull: true;
3948
+ hasDefault: true;
3949
+ isPrimaryKey: false;
3950
+ isAutoincrement: false;
3951
+ hasRuntimeDefault: false;
3952
+ enumValues: undefined;
3953
+ baseColumn: never;
3954
+ identity: undefined;
3955
+ generated: undefined;
3956
+ }, {}, {}>;
3957
+ updatedAt: import("drizzle-orm/pg-core").PgColumn<{
3958
+ name: "updated_at";
3959
+ tableName: "youtube_search_queries";
3960
+ dataType: "date";
3961
+ columnType: "PgTimestamp";
3962
+ data: Date;
3963
+ driverParam: string;
3964
+ notNull: true;
3965
+ hasDefault: true;
3966
+ isPrimaryKey: false;
3967
+ isAutoincrement: false;
3968
+ hasRuntimeDefault: false;
3969
+ enumValues: undefined;
3970
+ baseColumn: never;
3971
+ identity: undefined;
3972
+ generated: undefined;
3973
+ }, {}, {}>;
3974
+ };
3975
+ dialect: "pg";
3976
+ }>;
3977
+ export declare const youtubeQuotaUsage: import("drizzle-orm/pg-core").PgTableWithColumns<{
3978
+ name: "youtube_quota_usage";
3979
+ schema: undefined;
3980
+ columns: {
3981
+ id: import("drizzle-orm/pg-core").PgColumn<{
3982
+ name: "id";
3983
+ tableName: "youtube_quota_usage";
3984
+ dataType: "string";
3985
+ columnType: "PgText";
3986
+ data: string;
3987
+ driverParam: string;
3988
+ notNull: true;
3989
+ hasDefault: false;
3990
+ isPrimaryKey: true;
3991
+ isAutoincrement: false;
3992
+ hasRuntimeDefault: false;
3993
+ enumValues: [string, ...string[]];
3994
+ baseColumn: never;
3995
+ identity: undefined;
3996
+ generated: undefined;
3997
+ }, {}, {}>;
3998
+ date: import("drizzle-orm/pg-core").PgColumn<{
3999
+ name: "date";
4000
+ tableName: "youtube_quota_usage";
4001
+ dataType: "date";
4002
+ columnType: "PgTimestamp";
4003
+ data: Date;
4004
+ driverParam: string;
4005
+ notNull: true;
4006
+ hasDefault: false;
4007
+ isPrimaryKey: false;
4008
+ isAutoincrement: false;
4009
+ hasRuntimeDefault: false;
4010
+ enumValues: undefined;
4011
+ baseColumn: never;
4012
+ identity: undefined;
4013
+ generated: undefined;
4014
+ }, {}, {}>;
4015
+ quotaUsed: import("drizzle-orm/pg-core").PgColumn<{
4016
+ name: "quota_used";
4017
+ tableName: "youtube_quota_usage";
4018
+ dataType: "number";
4019
+ columnType: "PgInteger";
4020
+ data: number;
4021
+ driverParam: string | number;
4022
+ notNull: true;
4023
+ hasDefault: true;
4024
+ isPrimaryKey: false;
4025
+ isAutoincrement: false;
4026
+ hasRuntimeDefault: false;
4027
+ enumValues: undefined;
4028
+ baseColumn: never;
4029
+ identity: undefined;
4030
+ generated: undefined;
4031
+ }, {}, {}>;
4032
+ quotaLimit: import("drizzle-orm/pg-core").PgColumn<{
4033
+ name: "quota_limit";
4034
+ tableName: "youtube_quota_usage";
4035
+ dataType: "number";
4036
+ columnType: "PgInteger";
4037
+ data: number;
4038
+ driverParam: string | number;
4039
+ notNull: true;
4040
+ hasDefault: true;
4041
+ isPrimaryKey: false;
4042
+ isAutoincrement: false;
4043
+ hasRuntimeDefault: false;
4044
+ enumValues: undefined;
4045
+ baseColumn: never;
4046
+ identity: undefined;
4047
+ generated: undefined;
4048
+ }, {}, {}>;
4049
+ operationType: import("drizzle-orm/pg-core").PgColumn<{
4050
+ name: "operation_type";
4051
+ tableName: "youtube_quota_usage";
4052
+ dataType: "string";
4053
+ columnType: "PgText";
4054
+ data: string;
4055
+ driverParam: string;
4056
+ notNull: true;
4057
+ hasDefault: false;
4058
+ isPrimaryKey: false;
4059
+ isAutoincrement: false;
4060
+ hasRuntimeDefault: false;
4061
+ enumValues: [string, ...string[]];
4062
+ baseColumn: never;
4063
+ identity: undefined;
4064
+ generated: undefined;
4065
+ }, {}, {}>;
4066
+ createdAt: import("drizzle-orm/pg-core").PgColumn<{
4067
+ name: "created_at";
4068
+ tableName: "youtube_quota_usage";
4069
+ dataType: "date";
4070
+ columnType: "PgTimestamp";
4071
+ data: Date;
4072
+ driverParam: string;
4073
+ notNull: true;
4074
+ hasDefault: true;
4075
+ isPrimaryKey: false;
4076
+ isAutoincrement: false;
4077
+ hasRuntimeDefault: false;
4078
+ enumValues: undefined;
4079
+ baseColumn: never;
4080
+ identity: undefined;
4081
+ generated: undefined;
4082
+ }, {}, {}>;
4083
+ updatedAt: import("drizzle-orm/pg-core").PgColumn<{
4084
+ name: "updated_at";
4085
+ tableName: "youtube_quota_usage";
4086
+ dataType: "date";
4087
+ columnType: "PgTimestamp";
4088
+ data: Date;
4089
+ driverParam: string;
4090
+ notNull: true;
4091
+ hasDefault: true;
4092
+ isPrimaryKey: false;
4093
+ isAutoincrement: false;
4094
+ hasRuntimeDefault: false;
4095
+ enumValues: undefined;
4096
+ baseColumn: never;
4097
+ identity: undefined;
4098
+ generated: undefined;
4099
+ }, {}, {}>;
4100
+ };
4101
+ dialect: "pg";
4102
+ }>;
4103
+ export declare const youtubeChannelExtensions: import("drizzle-orm/pg-core").PgTableWithColumns<{
4104
+ name: "youtube_channel_extensions";
4105
+ schema: undefined;
4106
+ columns: {
4107
+ id: import("drizzle-orm/pg-core").PgColumn<{
4108
+ name: "id";
4109
+ tableName: "youtube_channel_extensions";
4110
+ dataType: "string";
4111
+ columnType: "PgText";
4112
+ data: string;
4113
+ driverParam: string;
4114
+ notNull: true;
4115
+ hasDefault: true;
4116
+ isPrimaryKey: true;
4117
+ isAutoincrement: false;
4118
+ hasRuntimeDefault: true;
4119
+ enumValues: [string, ...string[]];
4120
+ baseColumn: never;
4121
+ identity: undefined;
4122
+ generated: undefined;
4123
+ }, {}, {}>;
4124
+ sourceConfigId: import("drizzle-orm/pg-core").PgColumn<{
4125
+ name: "source_config_id";
4126
+ tableName: "youtube_channel_extensions";
4127
+ dataType: "string";
4128
+ columnType: "PgText";
4129
+ data: string;
4130
+ driverParam: string;
4131
+ notNull: true;
4132
+ hasDefault: false;
4133
+ isPrimaryKey: false;
4134
+ isAutoincrement: false;
4135
+ hasRuntimeDefault: false;
4136
+ enumValues: [string, ...string[]];
4137
+ baseColumn: never;
4138
+ identity: undefined;
4139
+ generated: undefined;
4140
+ }, {}, {}>;
4141
+ addedBy: import("drizzle-orm/pg-core").PgColumn<{
4142
+ name: "added_by";
4143
+ tableName: "youtube_channel_extensions";
4144
+ dataType: "string";
4145
+ columnType: "PgText";
4146
+ data: string;
4147
+ driverParam: string;
4148
+ notNull: true;
4149
+ hasDefault: false;
4150
+ isPrimaryKey: false;
4151
+ isAutoincrement: false;
4152
+ hasRuntimeDefault: false;
4153
+ enumValues: [string, ...string[]];
4154
+ baseColumn: never;
4155
+ identity: undefined;
4156
+ generated: undefined;
4157
+ }, {}, {}>;
4158
+ userNotes: import("drizzle-orm/pg-core").PgColumn<{
4159
+ name: "user_notes";
4160
+ tableName: "youtube_channel_extensions";
4161
+ dataType: "string";
4162
+ columnType: "PgText";
4163
+ data: string;
4164
+ driverParam: string;
4165
+ notNull: false;
4166
+ hasDefault: false;
4167
+ isPrimaryKey: false;
4168
+ isAutoincrement: false;
4169
+ hasRuntimeDefault: false;
4170
+ enumValues: [string, ...string[]];
4171
+ baseColumn: never;
4172
+ identity: undefined;
4173
+ generated: undefined;
4174
+ }, {}, {}>;
4175
+ customTags: import("drizzle-orm/pg-core").PgColumn<{
4176
+ name: "custom_tags";
4177
+ tableName: "youtube_channel_extensions";
4178
+ dataType: "array";
4179
+ columnType: "PgArray";
4180
+ data: string[];
4181
+ driverParam: string | string[];
4182
+ notNull: false;
4183
+ hasDefault: true;
4184
+ isPrimaryKey: false;
4185
+ isAutoincrement: false;
4186
+ hasRuntimeDefault: false;
4187
+ enumValues: [string, ...string[]];
4188
+ baseColumn: import("drizzle-orm").Column<{
4189
+ name: "custom_tags";
4190
+ tableName: "youtube_channel_extensions";
4191
+ dataType: "string";
4192
+ columnType: "PgText";
4193
+ data: string;
4194
+ driverParam: string;
4195
+ notNull: false;
4196
+ hasDefault: false;
4197
+ isPrimaryKey: false;
4198
+ isAutoincrement: false;
4199
+ hasRuntimeDefault: false;
4200
+ enumValues: [string, ...string[]];
4201
+ baseColumn: never;
4202
+ identity: undefined;
4203
+ generated: undefined;
4204
+ }, {}, {}>;
4205
+ identity: undefined;
4206
+ generated: undefined;
4207
+ }, {}, {
4208
+ baseBuilder: import("drizzle-orm/pg-core").PgColumnBuilder<{
4209
+ name: "custom_tags";
4210
+ dataType: "string";
4211
+ columnType: "PgText";
4212
+ data: string;
4213
+ enumValues: [string, ...string[]];
4214
+ driverParam: string;
4215
+ }, {}, {}, import("drizzle-orm").ColumnBuilderExtraConfig>;
4216
+ size: undefined;
4217
+ }>;
4218
+ aiDescription: import("drizzle-orm/pg-core").PgColumn<{
4219
+ name: "ai_description";
4220
+ tableName: "youtube_channel_extensions";
4221
+ dataType: "string";
4222
+ columnType: "PgText";
4223
+ data: string;
4224
+ driverParam: string;
4225
+ notNull: false;
4226
+ hasDefault: false;
4227
+ isPrimaryKey: false;
4228
+ isAutoincrement: false;
4229
+ hasRuntimeDefault: false;
4230
+ enumValues: [string, ...string[]];
4231
+ baseColumn: never;
4232
+ identity: undefined;
4233
+ generated: undefined;
4234
+ }, {}, {}>;
4235
+ contentCategories: import("drizzle-orm/pg-core").PgColumn<{
4236
+ name: "content_categories";
4237
+ tableName: "youtube_channel_extensions";
4238
+ dataType: "array";
4239
+ columnType: "PgArray";
4240
+ data: string[];
4241
+ driverParam: string | string[];
4242
+ notNull: false;
4243
+ hasDefault: true;
4244
+ isPrimaryKey: false;
4245
+ isAutoincrement: false;
4246
+ hasRuntimeDefault: false;
4247
+ enumValues: [string, ...string[]];
4248
+ baseColumn: import("drizzle-orm").Column<{
4249
+ name: "content_categories";
4250
+ tableName: "youtube_channel_extensions";
4251
+ dataType: "string";
4252
+ columnType: "PgText";
4253
+ data: string;
4254
+ driverParam: string;
4255
+ notNull: false;
4256
+ hasDefault: false;
4257
+ isPrimaryKey: false;
4258
+ isAutoincrement: false;
4259
+ hasRuntimeDefault: false;
4260
+ enumValues: [string, ...string[]];
4261
+ baseColumn: never;
4262
+ identity: undefined;
4263
+ generated: undefined;
4264
+ }, {}, {}>;
4265
+ identity: undefined;
4266
+ generated: undefined;
4267
+ }, {}, {
4268
+ baseBuilder: import("drizzle-orm/pg-core").PgColumnBuilder<{
4269
+ name: "content_categories";
4270
+ dataType: "string";
4271
+ columnType: "PgText";
4272
+ data: string;
4273
+ enumValues: [string, ...string[]];
4274
+ driverParam: string;
4275
+ }, {}, {}, import("drizzle-orm").ColumnBuilderExtraConfig>;
4276
+ size: undefined;
4277
+ }>;
4278
+ uploadFrequency: import("drizzle-orm/pg-core").PgColumn<{
4279
+ name: "upload_frequency";
4280
+ tableName: "youtube_channel_extensions";
4281
+ dataType: "string";
4282
+ columnType: "PgText";
4283
+ data: string;
4284
+ driverParam: string;
4285
+ notNull: false;
4286
+ hasDefault: false;
4287
+ isPrimaryKey: false;
4288
+ isAutoincrement: false;
4289
+ hasRuntimeDefault: false;
4290
+ enumValues: [string, ...string[]];
4291
+ baseColumn: never;
4292
+ identity: undefined;
4293
+ generated: undefined;
4294
+ }, {}, {}>;
4295
+ averageVideoLength: import("drizzle-orm/pg-core").PgColumn<{
4296
+ name: "average_video_length";
4297
+ tableName: "youtube_channel_extensions";
4298
+ dataType: "number";
4299
+ columnType: "PgInteger";
4300
+ data: number;
4301
+ driverParam: string | number;
4302
+ notNull: false;
4303
+ hasDefault: false;
4304
+ isPrimaryKey: false;
4305
+ isAutoincrement: false;
4306
+ hasRuntimeDefault: false;
4307
+ enumValues: undefined;
4308
+ baseColumn: never;
4309
+ identity: undefined;
4310
+ generated: undefined;
4311
+ }, {}, {}>;
4312
+ primaryLanguage: import("drizzle-orm/pg-core").PgColumn<{
4313
+ name: "primary_language";
4314
+ tableName: "youtube_channel_extensions";
4315
+ dataType: "string";
4316
+ columnType: "PgText";
4317
+ data: string;
4318
+ driverParam: string;
4319
+ notNull: false;
4320
+ hasDefault: false;
4321
+ isPrimaryKey: false;
4322
+ isAutoincrement: false;
4323
+ hasRuntimeDefault: false;
4324
+ enumValues: [string, ...string[]];
4325
+ baseColumn: never;
4326
+ identity: undefined;
4327
+ generated: undefined;
4328
+ }, {}, {}>;
4329
+ contentTags: import("drizzle-orm/pg-core").PgColumn<{
4330
+ name: "content_tags";
4331
+ tableName: "youtube_channel_extensions";
4332
+ dataType: "array";
4333
+ columnType: "PgArray";
4334
+ data: string[];
4335
+ driverParam: string | string[];
4336
+ notNull: false;
4337
+ hasDefault: true;
4338
+ isPrimaryKey: false;
4339
+ isAutoincrement: false;
4340
+ hasRuntimeDefault: false;
4341
+ enumValues: [string, ...string[]];
4342
+ baseColumn: import("drizzle-orm").Column<{
4343
+ name: "content_tags";
4344
+ tableName: "youtube_channel_extensions";
4345
+ dataType: "string";
4346
+ columnType: "PgText";
4347
+ data: string;
4348
+ driverParam: string;
4349
+ notNull: false;
4350
+ hasDefault: false;
4351
+ isPrimaryKey: false;
4352
+ isAutoincrement: false;
4353
+ hasRuntimeDefault: false;
4354
+ enumValues: [string, ...string[]];
4355
+ baseColumn: never;
4356
+ identity: undefined;
4357
+ generated: undefined;
4358
+ }, {}, {}>;
4359
+ identity: undefined;
4360
+ generated: undefined;
4361
+ }, {}, {
4362
+ baseBuilder: import("drizzle-orm/pg-core").PgColumnBuilder<{
4363
+ name: "content_tags";
4364
+ dataType: "string";
4365
+ columnType: "PgText";
4366
+ data: string;
4367
+ enumValues: [string, ...string[]];
4368
+ driverParam: string;
4369
+ }, {}, {}, import("drizzle-orm").ColumnBuilderExtraConfig>;
4370
+ size: undefined;
4371
+ }>;
4372
+ createdAt: import("drizzle-orm/pg-core").PgColumn<{
4373
+ name: "created_at";
4374
+ tableName: "youtube_channel_extensions";
4375
+ dataType: "date";
4376
+ columnType: "PgTimestamp";
4377
+ data: Date;
4378
+ driverParam: string;
4379
+ notNull: true;
4380
+ hasDefault: true;
4381
+ isPrimaryKey: false;
4382
+ isAutoincrement: false;
4383
+ hasRuntimeDefault: false;
4384
+ enumValues: undefined;
4385
+ baseColumn: never;
4386
+ identity: undefined;
4387
+ generated: undefined;
4388
+ }, {}, {}>;
4389
+ updatedAt: import("drizzle-orm/pg-core").PgColumn<{
4390
+ name: "updated_at";
4391
+ tableName: "youtube_channel_extensions";
4392
+ dataType: "date";
4393
+ columnType: "PgTimestamp";
4394
+ data: Date;
4395
+ driverParam: string;
4396
+ notNull: true;
4397
+ hasDefault: true;
4398
+ isPrimaryKey: false;
4399
+ isAutoincrement: false;
4400
+ hasRuntimeDefault: false;
4401
+ enumValues: undefined;
4402
+ baseColumn: never;
4403
+ identity: undefined;
4404
+ generated: undefined;
4405
+ }, {}, {}>;
4406
+ };
4407
+ dialect: "pg";
4408
+ }>;
4409
+ export declare const youtubeChannelSubscriptions: import("drizzle-orm/pg-core").PgTableWithColumns<{
4410
+ name: "youtube_channel_subscriptions";
4411
+ schema: undefined;
4412
+ columns: {
4413
+ id: import("drizzle-orm/pg-core").PgColumn<{
4414
+ name: "id";
4415
+ tableName: "youtube_channel_subscriptions";
4416
+ dataType: "string";
4417
+ columnType: "PgText";
4418
+ data: string;
4419
+ driverParam: string;
4420
+ notNull: true;
4421
+ hasDefault: true;
4422
+ isPrimaryKey: true;
4423
+ isAutoincrement: false;
4424
+ hasRuntimeDefault: true;
4425
+ enumValues: [string, ...string[]];
4426
+ baseColumn: never;
4427
+ identity: undefined;
4428
+ generated: undefined;
4429
+ }, {}, {}>;
4430
+ userId: import("drizzle-orm/pg-core").PgColumn<{
4431
+ name: "user_id";
4432
+ tableName: "youtube_channel_subscriptions";
4433
+ dataType: "string";
4434
+ columnType: "PgText";
4435
+ data: string;
4436
+ driverParam: string;
4437
+ notNull: true;
4438
+ hasDefault: false;
4439
+ isPrimaryKey: false;
4440
+ isAutoincrement: false;
4441
+ hasRuntimeDefault: false;
4442
+ enumValues: [string, ...string[]];
4443
+ baseColumn: never;
4444
+ identity: undefined;
4445
+ generated: undefined;
4446
+ }, {}, {}>;
4447
+ sourceConfigId: import("drizzle-orm/pg-core").PgColumn<{
4448
+ name: "source_config_id";
4449
+ tableName: "youtube_channel_subscriptions";
4450
+ dataType: "string";
4451
+ columnType: "PgText";
4452
+ data: string;
4453
+ driverParam: string;
4454
+ notNull: true;
4455
+ hasDefault: false;
4456
+ isPrimaryKey: false;
4457
+ isAutoincrement: false;
4458
+ hasRuntimeDefault: false;
4459
+ enumValues: [string, ...string[]];
4460
+ baseColumn: never;
4461
+ identity: undefined;
4462
+ generated: undefined;
4463
+ }, {}, {}>;
4464
+ notificationEnabled: import("drizzle-orm/pg-core").PgColumn<{
4465
+ name: "notification_enabled";
4466
+ tableName: "youtube_channel_subscriptions";
4467
+ dataType: "boolean";
4468
+ columnType: "PgBoolean";
4469
+ data: boolean;
4470
+ driverParam: boolean;
4471
+ notNull: true;
4472
+ hasDefault: true;
4473
+ isPrimaryKey: false;
4474
+ isAutoincrement: false;
4475
+ hasRuntimeDefault: false;
4476
+ enumValues: undefined;
4477
+ baseColumn: never;
4478
+ identity: undefined;
4479
+ generated: undefined;
4480
+ }, {}, {}>;
4481
+ filterProfileId: import("drizzle-orm/pg-core").PgColumn<{
4482
+ name: "filter_profile_id";
4483
+ tableName: "youtube_channel_subscriptions";
4484
+ dataType: "string";
4485
+ columnType: "PgUUID";
4486
+ data: string;
4487
+ driverParam: string;
4488
+ notNull: false;
4489
+ hasDefault: false;
4490
+ isPrimaryKey: false;
4491
+ isAutoincrement: false;
4492
+ hasRuntimeDefault: false;
4493
+ enumValues: undefined;
4494
+ baseColumn: never;
4495
+ identity: undefined;
4496
+ generated: undefined;
4497
+ }, {}, {}>;
4498
+ subscribedAt: import("drizzle-orm/pg-core").PgColumn<{
4499
+ name: "subscribed_at";
4500
+ tableName: "youtube_channel_subscriptions";
4501
+ dataType: "date";
4502
+ columnType: "PgTimestamp";
4503
+ data: Date;
4504
+ driverParam: string;
4505
+ notNull: true;
4506
+ hasDefault: true;
4507
+ isPrimaryKey: false;
4508
+ isAutoincrement: false;
4509
+ hasRuntimeDefault: false;
4510
+ enumValues: undefined;
4511
+ baseColumn: never;
4512
+ identity: undefined;
4513
+ generated: undefined;
4514
+ }, {}, {}>;
4515
+ };
4516
+ dialect: "pg";
4517
+ }>;
4518
+ export declare const aiModelsRelations: import("drizzle-orm").Relations<"AIModel", {
4519
+ translations: import("drizzle-orm").Many<"ContentTranslation">;
4520
+ }>;
4521
+ export declare const contentTranslationsRelations: import("drizzle-orm").Relations<"ContentTranslation", {
4522
+ model: import("drizzle-orm").One<"AIModel", true>;
4523
+ }>;
4524
+ export declare const rssFeedsRelations: import("drizzle-orm").Relations<"rss_feeds", {
4525
+ articles: import("drizzle-orm").Many<"rss_articles">;
4526
+ }>;
4527
+ export declare const rssArticlesRelations: import("drizzle-orm").Relations<"rss_articles", {
4528
+ feed: import("drizzle-orm").One<"rss_feeds", true>;
4529
+ }>;
4530
+ export declare const youtubeSourceConfigsRelations: import("drizzle-orm").Relations<"youtube_source_config", {
4531
+ videos: import("drizzle-orm").Many<"youtube_videos">;
4532
+ extensions: import("drizzle-orm").Many<"youtube_channel_extensions">;
4533
+ subscriptions: import("drizzle-orm").Many<"youtube_channel_subscriptions">;
4534
+ }>;
4535
+ export declare const youtubeVideosRelations: import("drizzle-orm").Relations<"youtube_videos", {
4536
+ sourceConfig: import("drizzle-orm").One<"youtube_source_config", false>;
4537
+ }>;
4538
+ export declare const youtubeChannelExtensionsRelations: import("drizzle-orm").Relations<"youtube_channel_extensions", {
4539
+ sourceConfig: import("drizzle-orm").One<"youtube_source_config", true>;
4540
+ }>;
4541
+ export declare const youtubeChannelSubscriptionsRelations: import("drizzle-orm").Relations<"youtube_channel_subscriptions", {
4542
+ sourceConfig: import("drizzle-orm").One<"youtube_source_config", true>;
4543
+ }>;
2441
4544
  //# sourceMappingURL=content-schema.d.ts.map