@datawheel/bespoke 0.9.3 → 1.0.0-beta.1

package/dist/types-WI9fSG9b.d.mts

@@ -0,0 +1,847 @@
+import { Model, Sequelize, ForeignKey } from 'sequelize';
+
+type BlockType = "generator" | "image" | "paragraph" | "selector" | "stat" | "subtitle" | "title" | "visualization" | "nav" | "reset_button" | "fallback" | "section_flag";
+type BlockSettings = {
+    width?: {
+        stretch: boolean;
+        unit: string;
+        value: string;
+    };
+    display?: string;
+    align?: string;
+    access?: string[];
+    allowed?: string;
+    allowedLogic?: string;
+    fallback?: boolean;
+};
+type TypeGeneratorSettings = {
+    useProxy?: string;
+};
+type TypeImageSettings = unknown;
+type TypeParagraphSettings = unknown;
+type TypeSelectorSettings = unknown;
+type TypeStatSettings = {
+    name: string;
+    description?: string;
+};
+type TypeSubtitleSettings = unknown;
+type TypeTitleSettings = {
+    order?: string;
+};
+type TypeVizSettings = unknown;
+type TypeResetButtonSettings = unknown;
+type TypeNavSettings = {
+    min?: string;
+    max?: string;
+    variant?: string;
+    scrollPadding?: number;
+};
+type TypeFallbackSettings = unknown;
+type EntitySettings$2 = {
+    generator: TypeGeneratorSettings;
+    section_flag: TypeGeneratorSettings;
+    image: TypeImageSettings;
+    paragraph: TypeParagraphSettings;
+    selector: TypeSelectorSettings;
+    stat: TypeStatSettings;
+    subtitle: TypeSubtitleSettings;
+    title: TypeTitleSettings;
+    visualization: TypeVizSettings;
+    nav: TypeNavSettings;
+    reset_button: TypeResetButtonSettings;
+    fallback: TypeFallbackSettings;
+};
+interface Content {
+    api?: string;
+    simple?: {
+        compare?: string;
+        limit?: number;
+    };
+    simpleEnabled?: boolean;
+    logic?: string;
+}
+interface LocaleContent {
+    id: number;
+    locale: string;
+    content: Content;
+}
+interface Block<T extends BlockType> {
+    /** Entity ID */
+    id: number;
+    /** Parent Report ID */
+    section_id: number;
+    blockcol: string;
+    blockrow: string;
+    contentByLocale: Record<string, LocaleContent>;
+    settings: Partial<EntitySettings$2[T]> & BlockSettings;
+    shared: boolean;
+    type: T;
+    original_type?: T;
+}
+interface NestedBlock<T extends BlockType> extends Block<T> {
+    inputs: AnyBlock[];
+    consumers: AnyBlock[];
+}
+interface NormalizedBlock<T extends BlockType> extends Block<T> {
+    inputs: number[];
+    consumers: number[];
+}
+type AnyBlock = Block<"image"> | Block<"paragraph"> | Block<"selector"> | Block<"stat"> | Block<"subtitle"> | Block<"title"> | Block<"generator"> | Block<"visualization"> | Block<"nav"> | Block<"reset_button"> | Block<"fallback"> | Block<"section_flag">;
+type AnyNestedBlock = NestedBlock<"image"> | NestedBlock<"paragraph"> | NestedBlock<"selector"> | NestedBlock<"stat"> | NestedBlock<"subtitle"> | NestedBlock<"title"> | NestedBlock<"generator"> | NestedBlock<"visualization"> | NestedBlock<"nav"> | NestedBlock<"reset_button"> | NestedBlock<"fallback"> | NestedBlock<"section_flag">;
+type AnyNormalizedBlock = NormalizedBlock<"image"> | NormalizedBlock<"paragraph"> | NormalizedBlock<"selector"> | NormalizedBlock<"stat"> | NormalizedBlock<"subtitle"> | NormalizedBlock<"title"> | NormalizedBlock<"generator"> | NormalizedBlock<"visualization"> | NormalizedBlock<"nav"> | NormalizedBlock<"reset_button"> | NormalizedBlock<"fallback"> | NormalizedBlock<"section_flag">;
+
+interface VariantLocaleAttribute {
+    name: string;
+    type: "constant" | "variable";
+    value: string;
+}
+interface VariantLocaleSettings {
+    idKey: string;
+    labelKey: string;
+    accessor: string;
+    path: string;
+    properties?: Record<string, unknown>;
+    attributes: VariantLocaleAttribute[];
+    zValueKey: string;
+    [key: string]: unknown;
+}
+interface VariantSettings {
+    overrideNames?: boolean;
+    overrideRelevance?: boolean;
+    regenerateSlugs?: boolean;
+    keepOldMembers?: boolean;
+    doIngest?: boolean;
+    order?: number;
+    [key: string]: unknown;
+}
+interface Variant {
+    id: number;
+    dimension_id: number;
+    settings: VariantSettings;
+    config: Record<string, VariantLocaleSettings>;
+    name: string;
+    slug: string;
+    visible: boolean;
+    members_count?: number;
+}
+
+interface Dimension {
+    /** Entity ID */
+    id: number;
+    /** Parent Report ID */
+    report_id: number;
+    name: string;
+    ordering: number;
+    settings: Record<string, unknown>;
+    visible: boolean;
+}
+interface NestedDimension extends Dimension {
+    variants: Variant[];
+}
+interface NormalizedDimension extends Dimension {
+    variants: number[];
+}
+
+interface FormatterContent {
+    description: string;
+    inputType: string;
+    logic: string;
+    testValue: string;
+    type: string;
+    [key: string]: string;
+}
+interface Formatter {
+    id: number;
+    name: string;
+    content: FormatterContent;
+}
+
+type Position = "NAV" | "TOP" | "BOTTOM" | "DEFAULT";
+
+type EntitySettings$1 = {
+    allowed: string;
+    allowedLogic: string;
+    icon: string;
+    position: string;
+    memberImageBg: boolean;
+    optionsMenu: boolean;
+    showAnchor: boolean;
+    sectionType: string;
+    comparisonHide: boolean;
+    comparisonMerge: boolean;
+    hidden: boolean;
+    showInPdf: "always" | "never" | "optional";
+    margin: "0px" | "xs" | "sm" | "md" | "lg" | "xl";
+    columnGutter: "0px" | "xs" | "sm" | "md" | "lg" | "xl";
+    width: "full" | "center";
+    style: "none" | "card";
+    tags?: string | string[];
+};
+interface Section {
+    /** Entity ID */
+    id: number;
+    /** Parent Report ID */
+    report_id: number;
+    heading: number;
+    ordering: string;
+    settings: EntitySettings$1 & {
+        name: string;
+        columnSettings: Record<string, {
+            width?: number;
+            full?: boolean;
+        }>;
+    };
+}
+interface NestedSection extends Section {
+    blocks: AnyNestedBlock[];
+}
+interface NormalizedSection extends Section {
+    blocks: number[];
+}
+
+type ReportType = "report" | "story";
+type TypeReportSettings = {
+    label: string;
+    title?: string;
+    subtitle?: string;
+    comparison?: boolean;
+    compareLevels?: boolean;
+    order?: number;
+    hide?: boolean;
+    position?: Position;
+    pdf?: {
+        enabled: boolean;
+        variants: string[];
+        privacy?: string[];
+        sectionSelection?: boolean;
+        navBlockId?: number;
+    };
+    xlsx?: {
+        enabled: boolean;
+        variants: string[];
+        privacy?: string[];
+    };
+};
+type TypeStorySettings = {
+    label: string;
+    title?: string;
+    subtitle?: string;
+};
+type EntitySettings = {
+    report: TypeReportSettings;
+    story: TypeStorySettings;
+};
+interface Report<T extends ReportType> {
+    /** Entity ID */
+    id: number;
+    name: string;
+    visible: boolean;
+    date: string;
+    type: T;
+    settings: EntitySettings[T];
+}
+interface NestedReport<T extends ReportType> extends Report<T> {
+    dimensions: NestedDimension[];
+    sections: NestedSection[];
+}
+interface NormalizedReport<T extends ReportType> extends Report<T> {
+    dimensions: number[];
+    sections: number[];
+}
+type AnyReport = Report<"report"> | Report<"story">;
+type AnyNestedReport = NestedReport<"report"> | NestedReport<"story">;
+type AnyNormalizedReport = NormalizedReport<"report"> | NormalizedReport<"story">;
+
+interface DataSourceContent {
+    pattern: string;
+    logic: string;
+    testUrl: string;
+    useProxy: boolean;
+    order: number;
+    access: string[];
+    [key: string]: string | boolean | number | string[];
+}
+interface DataSource {
+    id: number;
+    name: string;
+    description: string;
+    content: DataSourceContent;
+    settings?: Record<string, unknown>;
+}
+
+type SimpleEntityMap = {
+    block: AnyBlock;
+    dimension: Dimension;
+    formatter: Formatter;
+    report: AnyReport;
+    section: Section;
+    variant: Variant;
+    datasource: DataSource;
+};
+type NestedEntityMap = {
+    block: AnyNestedBlock;
+    dimension: NestedDimension;
+    formatter: Formatter;
+    report: AnyNestedReport;
+    section: NestedSection;
+    variant: Variant;
+    datasource: DataSource;
+};
+type NormalizedEntityMap = {
+    block: AnyNormalizedBlock;
+    dimension: NormalizedDimension;
+    formatter: Formatter;
+    report: AnyNormalizedReport;
+    section: NormalizedSection;
+    variant: Variant;
+    datasource: DataSource;
+};
+
+interface BlockContentCreationAttributes {
+    locale: LocaleContent["locale"];
+}
+declare class BlockContentModel extends Model<LocaleContent, BlockContentCreationAttributes> {
+    id: number;
+    locale: LocaleContent["locale"];
+    content: LocaleContent["content"];
+}
+declare function initModel$c(sequelize: Sequelize): () => typeof BlockContentModel;
+
+interface BlockInputAttributes {
+    id: number;
+    block_id: number;
+    input_id: number;
+}
+interface BlockInputCreationAttributes {
+    block_id: number;
+    input_id: number;
+}
+declare class BlockInputModel extends Model<BlockInputAttributes, BlockInputCreationAttributes> {
+    id: number;
+    block_id: number;
+    input_id: number;
+}
+declare function initModel$b(sequelize: Sequelize): () => typeof BlockInputModel;
+
+interface BlockAttributes {
+    id: number;
+    section_id: ForeignKey<number>;
+    block_input?: BlockInputAttributes;
+    blockcol: string;
+    blockrow: string;
+    settings: Record<string, unknown>;
+    shared: boolean;
+    type: string;
+}
+interface BlockCreationAttributes {
+    blockcol: string;
+    blockrow: string;
+    section_id: number;
+    type: BlockType;
+    contentByLocale: {
+        locale: string;
+    }[];
+    inputs?: BlockCreationAttributes[];
+    consumers?: BlockCreationAttributes[];
+}
+declare class BlockModel extends Model<BlockAttributes, BlockCreationAttributes> {
+    id: number;
+    section_id: number;
+    block_input?: BlockInputAttributes;
+    contentByLocale: BlockContentModel[];
+    inputs: BlockModel[];
+    consumers: BlockModel[];
+    getContent(locale: string): BlockContentModel;
+    toJSON(): AnyNestedBlock;
+}
+declare function initModel$a(sequelize: Sequelize): (models: ReportsDB) => typeof BlockModel;
+
+interface FormatterAttributes {
+    id: number;
+    name: string;
+    content: FormatterContent;
+}
+interface FormatterCreationAttributes {
+    name: string;
+    content?: FormatterContent;
+}
+declare class FormatterModel extends Model<FormatterAttributes, FormatterCreationAttributes> {
+    id: number;
+    name: string;
+    content: FormatterContent;
+}
+declare function initModel$9(sequelize: Sequelize): () => typeof FormatterModel;
+
+declare class ImageContentModel extends Model {
+    id: number;
+    locale: string;
+    meta: string;
+}
+declare function initModel$8(sequelize: Sequelize): () => typeof ImageContentModel;
+
+interface ImageAttributes {
+    id: number;
+    url: string;
+    author: string;
+    license: string;
+    splash: any;
+    thumb: any;
+}
+interface ImageCreationAttributes {
+    url: string;
+}
+declare class ImageModel extends Model<ImageAttributes, ImageCreationAttributes> {
+    id: number;
+    url: string;
+    author: string;
+    license: string;
+    splash: any;
+    thumb: any;
+    contentByLocale: ImageContentModel[];
+    getContent(locale: string): ImageContentModel;
+}
+declare function initModel$7(sequelize: Sequelize): (models: ReportsDB) => typeof ImageModel;
+
+interface VariantAttributes {
+    id: number;
+    dimension_id: number;
+    settings: Record<string, unknown>;
+    config: Record<string, VariantLocaleSettings>;
+    name: string;
+    slug: string;
+    visible: boolean;
+}
+interface VariantCreationAttributes {
+    dimension_id: number;
+    slug: Variant["slug"];
+    name: Variant["name"];
+}
+declare class VariantModel extends Model<VariantAttributes, VariantCreationAttributes> {
+    id: number;
+    dimension_id: number;
+    config: Variant["config"];
+    name: Variant["name"];
+    settings: Variant["settings"];
+    slug: Variant["slug"];
+    visible: Variant["visible"];
+    dimension: DimensionModel;
+    members: SearchModel[];
+    get report(): ReportModel;
+    toJSON(): Variant;
+}
+declare function initModel$6(sequelize: Sequelize): (models: ReportsDB) => typeof VariantModel;
+
+interface DimensionAttributes {
+    id: number;
+    report_id: number;
+    name: string;
+    ordering: NestedDimension["ordering"];
+    settings: Record<string, unknown>;
+    visible: boolean;
+}
+interface DimensionCreationAttributes {
+    report_id: number;
+    name: string;
+    ordering?: number;
+    variants?: VariantCreationAttributes[];
+}
+declare class DimensionModel extends Model<DimensionAttributes, DimensionCreationAttributes> {
+    id: number;
+    report_id: number;
+    name: string;
+    ordering: number;
+    report: ReportModel;
+    variants: VariantModel[];
+    toJSON(): NestedDimension;
+}
+declare function initModel$5(sequelize: Sequelize): (models: ReportsDB) => typeof DimensionModel;
+
+interface SectionAttributes {
+    id: number;
+    report_id: number;
+    heading: NestedSection["heading"];
+    ordering: NestedSection["ordering"];
+    settings: NestedSection["settings"];
+}
+interface SectionCreationAttributes {
+    report_id: SectionAttributes["report_id"];
+    ordering: SectionAttributes["ordering"];
+    blocks?: BlockCreationAttributes[];
+}
+declare class SectionModel extends Model<SectionAttributes, SectionCreationAttributes> {
+    id: number;
+    report_id: number;
+    blocks: BlockModel[];
+    toJSON(): NestedSection;
+}
+declare function initModel$4(sequelize: Sequelize): (models: ReportsDB) => typeof SectionModel;
+
+interface ReportAttributes {
+    id: number;
+    date: string;
+    name: string;
+    settings: Record<string, unknown>;
+    type: AnyReport["type"];
+    visible: boolean;
+}
+interface ReportCreationAttributes {
+    name: string;
+    dimensions?: DimensionCreationAttributes[];
+    sections?: SectionCreationAttributes[];
+}
+declare class ReportModel extends Model<ReportAttributes, ReportCreationAttributes> {
+    id: number;
+    date: Date;
+    name: string;
+    settings: Record<string, unknown>;
+    type: AnyReport["type"];
+    visible: boolean;
+    dimensions: DimensionModel[];
+    sections: SectionModel[];
+    toJSON(): AnyNestedReport;
+}
+declare function initModel$3(sequelize: Sequelize): (models: ReportsDB) => typeof ReportModel;
+
+interface SearchContentByLocale {
+    locale: string;
+    name: string;
+}
+interface SearchContentAttributes {
+    id: number;
+    annotations: Record<string, unknown>;
+    attributes: Record<string, unknown>;
+    contentByLocale?: SearchContentByLocale[];
+    keywords: string[];
+    locale: string;
+    name: string;
+}
+interface SearchContentCreationAttributes {
+    name: string;
+}
+declare class SearchContentModel extends Model<SearchContentAttributes, SearchContentCreationAttributes> {
+    id: number;
+    annotations: Record<string, unknown>;
+    attributes: Record<string, unknown>;
+    keywords: string[];
+    locale: string;
+    name: string;
+}
+declare function initModel$2(sequelize: Sequelize): () => typeof SearchContentModel;
+
+interface DataSourceAttributes {
+    id: number;
+    name: string;
+    description: string;
+    content: DataSourceContent;
+}
+interface DataSourceCreationAttributes {
+    name: string;
+    content?: DataSourceContent;
+}
+declare class DataSourceModel extends Model<DataSourceAttributes, DataSourceCreationAttributes> {
+    id: number;
+    name: string;
+    content: DataSourceContent;
+}
+declare function initModel$1(sequelize: Sequelize): () => typeof DataSourceModel;
+
+declare const modelFactoryMap: {
+    block: typeof initModel$a;
+    block_content: typeof initModel$c;
+    block_input: typeof initModel$b;
+    formatter: typeof initModel$9;
+    image: typeof initModel$7;
+    image_content: typeof initModel$8;
+    report: typeof initModel$3;
+    dimension: typeof initModel$5;
+    variant: typeof initModel$6;
+    search: typeof initModel;
+    search_content: typeof initModel$2;
+    section: typeof initModel$4;
+    datasource: typeof initModel$1;
+};
+
+type AssociationFactoryMap = typeof modelFactoryMap;
+type ModelFactoryMap = {
+    [K in keyof AssociationFactoryMap]: ReturnType<AssociationFactoryMap[K]>;
+};
+type ReportsDB = {
+    sequelize: Sequelize;
+} & {
+    [K in keyof ModelFactoryMap]: ReturnType<ModelFactoryMap[K]>;
+};
+
+interface SearchAttributes {
+    id: string;
+    zvalue: number;
+    slug: string;
+    image_id: number;
+    content_id: number;
+    dimension_id: number;
+    variant_id: number;
+    report_id: number;
+    visible: boolean;
+}
+interface SearchCreationAttributes {
+    id: string;
+    slug: string;
+    zvalue: number;
+    dimension_id: number;
+    variant_id: number;
+    report_id: number;
+}
+declare class SearchModel extends Model<SearchAttributes, SearchCreationAttributes> {
+    id: string;
+    slug: string;
+    visible: boolean;
+    zvalue: number;
+    content_id: number;
+    dimension_id: number;
+    image_id: number;
+    report_id: number;
+    variant_id: number;
+    dimension: DimensionModel;
+    image: ImageModel;
+    report: ReportModel;
+    variant: VariantModel;
+    contentByLocale: SearchContentModel[];
+    getContent(locale: string): SearchContentModel;
+}
+declare function initModel(sequelize: Sequelize): (models: ReportsDB) => typeof SearchModel;
+
+interface SuccessResult<T> {
+    ok: true;
+    status: number;
+    wrapper: boolean;
+    data: T;
+}
+interface FailureResult<E = string> {
+    ok: false;
+    status: number;
+    error: E;
+}
+type Result<T, E = string> = SuccessResult<T> | FailureResult<E>;
+type EntityType = "block" | "dimension" | "formatter" | "report" | "section" | "variant" | "datasource";
+type CreateParams = {
+    block: Pick<SimpleEntityMap["block"], "blockcol" | "blockrow" | "section_id" | "type"> & {
+        locales: Array<string>;
+    };
+    dimension: Pick<NestedEntityMap["dimension"], "name" | "report_id" | "ordering">;
+    formatter: Pick<SimpleEntityMap["formatter"], "name" | "content">;
+    report: Pick<SimpleEntityMap["report"], "name">;
+    section: Pick<SimpleEntityMap["section"], "ordering" | "report_id">;
+    variant: Pick<SimpleEntityMap["variant"], "name" | "slug" | "dimension_id">;
+    datasource: Pick<SimpleEntityMap["datasource"], "name" | "description" | "content">;
+};
+type CreateBulkParams = {
+    block: (Pick<SimpleEntityMap["block"], "blockcol" | "blockrow" | "section_id" | "type"> & {
+        locales: Array<string>;
+    })[];
+    section: Pick<SimpleEntityMap["section"], "ordering" | "report_id">[];
+};
+type ReadParams = {
+    id?: number | number[];
+    include?: boolean | string;
+    locales?: string[];
+};
+type UpdateParams = {
+    block: Partial<NestedEntityMap["block"]> & {
+        id: number;
+        inputAction?: {
+            operation: "create" | "delete";
+            input: {
+                input_id: number;
+                block_id: number;
+            };
+        };
+    };
+    dimension: Partial<NestedEntityMap["dimension"]> & {
+        id: number;
+    };
+    formatter: Partial<NestedEntityMap["formatter"]> & {
+        id: number;
+    };
+    report: Partial<NestedEntityMap["report"]> & {
+        id: number;
+    };
+    section: Partial<NestedEntityMap["section"]> & {
+        id: number;
+    };
+    variant: Partial<NestedEntityMap["variant"]> & {
+        id: number;
+    };
+    datasource: Partial<NestedEntityMap["datasource"]> & {
+        id: number;
+    };
+};
+type UpdateBulkParams = {
+    block: Partial<NestedEntityMap["block"]> & {
+        id: number;
+        inputAction?: {
+            operation: "create" | "delete";
+            input: {
+                input_id: number;
+                block_id: number;
+            };
+        };
+        notInclude?: boolean;
+    }[];
+    section: Partial<NestedEntityMap["section"]> & {
+        id: number;
+    }[];
+};
+type DeleteParams = number;
+type CreateResponse<T extends EntityType> = NestedEntityMap[T];
+type UpdateResponse<T extends EntityType> = NestedEntityMap[T];
+type DeleteResponse = {
+    id: number;
+    parentType?: string;
+    parentId?: number;
+};
+type CreateBulkResponse<T extends keyof CreateBulkParams> = NestedEntityMap[T][];
+type UpdateBulkResponse<T extends keyof UpdateBulkParams> = NestedEntityMap[T][];
+interface CreateMethod<T extends EntityType> {
+    (params: CreateParams[T]): Promise<Result<CreateResponse<T>>>;
+}
+interface CreateBulkMethod<T extends keyof CreateBulkParams> {
+    (params: CreateBulkParams[T]): Promise<Result<CreateBulkResponse<T>>>;
+}
+interface ReadMethod<T extends EntityType> {
+    (): Promise<Result<SimpleEntityMap[T][]>>;
+    (params: {
+        id: number | number[];
+    }): Promise<Result<SimpleEntityMap[T][]>>;
+    (params: {
+        id?: number | number[];
+        include: false;
+    }): Promise<Result<SimpleEntityMap[T][]>>;
+    (params: {
+        id?: number | number[];
+        include: true;
+    }): Promise<Result<NestedEntityMap[T][]>>;
+    (params: ReadParams): Promise<Result<SimpleEntityMap[T][] | NestedEntityMap[T][]>>;
+}
+interface UpdateMethod<T extends EntityType> {
+    (params: UpdateParams[T]): Promise<Result<UpdateResponse<T>>>;
+}
+interface UpdateBulkMethod<T extends keyof UpdateBulkParams> {
+    (params: UpdateBulkParams[T]): Promise<Result<UpdateBulkResponse<T>>>;
+}
+interface DeleteMethod {
+    (params: DeleteParams): Promise<Result<DeleteResponse>>;
+}
+interface SearchReportParams {
+    query: string;
+    locale: string;
+    limit: number;
+    offset?: number;
+    visible: boolean;
+    includes: boolean;
+    noImage: boolean;
+    format: "results" | "profiles" | "grouped";
+    variant: number[];
+    dimension: number[];
+    report: number[];
+    all?: boolean;
+    origin?: "flexsearch" | "typesense";
+    sort?: "report" | "name" | string;
+    direction?: string;
+}
+interface SearchReportItem {
+    name: string;
+    id: string;
+    path: string;
+    confidence: number;
+    members: Array<Record<string, any>>;
+}
+interface SearchReportResponse {
+    meta: {
+        [key: string]: any;
+    };
+    results: Array<SearchReportItem>;
+}
+interface UpdateMemberParams {
+    content_id: number;
+    contentByLocale: Record<string, any>[];
+    image: Record<string, any> | null;
+    image_id: number;
+}
+interface UpdateMemberResponse extends SearchAttributes {
+}
+interface ReadMetadataParams {
+    report_id?: number;
+    count?: boolean | string;
+}
+interface ReadMetadataResponse {
+    data: {
+        [key: string]: any;
+    }[];
+}
+interface SearchUsersParams {
+    query?: string;
+    role_id?: string;
+    page?: number;
+    [key: string]: any;
+}
+interface UpdateUserParams {
+    user_id: string;
+    roles?: {
+        id: string;
+        name: string;
+    }[];
+    app_metadata?: {
+        [key: string]: any;
+    };
+    user_metadata?: {
+        [key: string]: any;
+    };
+}
+interface UpdateMyDataParams {
+    report_id?: number;
+    user_metadata?: Record<string, any>;
+}
+interface ReadPrivateBlocksParams {
+    report_id: number;
+    locale: string;
+    section_id: number[];
+    userToken?: string | null;
+}
+interface InternalReadPrivateBlocksParams extends ReadPrivateBlocksParams {
+    roles: string[];
+}
+interface ReadPrivateBlocksResponse {
+    params: {
+        [key: string]: any;
+    };
+    data: {
+        [key: string]: any;
+    }[];
+}
+interface RevalidateReportRequest {
+    profilePrefix: string;
+    reportId: number;
+    variantPaths?: {
+        variantId: number;
+        prefix: string;
+        variantSlug: string;
+    }[];
+}
+interface RevalidateReportResponse {
+    reportId: number;
+    revalidated: number;
+    samples: string[];
+    paths: string[];
+}
+interface RevalidateUrlRequest {
+    target: string;
+}
+interface RevalidateUrlResponse {
+    target: string;
+}
+interface ReadEnvSecretsResponse {
+    secrets: {
+        [key: string]: any;
+    };
+}
+
+export { type AnyBlock as A, type VariantAttributes as B, SearchContentModel as C, type DataSource as D, type InternalReadPrivateBlocksParams as E, type Formatter as F, type CreateMethod as G, type DeleteMethod as H, ImageModel as I, type ReadMethod as J, type UpdateMethod as K, type CreateBulkMethod as L, type UpdateBulkMethod as M, type NestedDimension as N, type UpdateMemberParams as O, type UpdateMemberResponse as P, type NormalizedEntityMap as Q, type Result as R, type SearchUsersParams as S, type NestedEntityMap as T, type UpdateUserParams as U, type Variant as V, type AnyNestedBlock as a, type AnyReport as b, type AnyNestedReport as c, type Section as d, type NestedSection as e, type DeleteParams as f, type ReadParams as g, type Dimension as h, type SearchReportParams as i, type SearchReportResponse as j, type ReadMetadataParams as k, type ReadMetadataResponse as l, type UpdateMyDataParams as m, type ReadPrivateBlocksParams as n, type ReadPrivateBlocksResponse as o, type RevalidateUrlRequest as p, type RevalidateUrlResponse as q, type RevalidateReportRequest as r, type RevalidateReportResponse as s, type ReadEnvSecretsResponse as t, type SearchReportItem as u, type ReportsDB as v, type SearchAttributes as w, type SearchContentAttributes as x, type ReportAttributes as y, type DimensionAttributes as z };