Query data model

export type DatastoreQuery = {
	table_id?: string;
	database_id?: string;
	query?: {
		sql?: string; // Raw SQL – when set, executed directly (table_id optional) 
		select?: any; 
		expand?: any; 
		filter?: any; 
		sort_fields?: any; 
		sort_order?: 'asc' | 'desc'; 
		limit?: number; 
		offset?: number; 
		aggregate?: any; 
		is_count_only?: boolean; 
	}; // What to run: a raw `sql` statement, or a structured query (select, filter, sort, limit/offset, aggregate)
	response?: {
		items?: []; 
		aggregates?: any; 
		total_count?: number; 
	};
	metadata?: [];
	raw?: any;
} 

import { z } from 'zod';

export const ZodDatastoreQuery = z.object({
	table_id: z.string().optional(),
	database_id: z.string().optional(),
	query: z.object({
			sql: z.string().optional().describe("Raw SQL – when set, executed directly (table_id optional)"),
			select: z.unknown().optional(),
			expand: z.unknown().optional(),
			filter: z.unknown().optional(),
			sort_fields: z.unknown().optional(),
			sort_order: z.enum("asc", "desc").optional(),
			limit: z.number().optional(),
			offset: z.number().optional(),
			aggregate: z.unknown().optional(),
			is_count_only: z.boolean().optional()
}).optional().describe("What to run: a raw `sql` statement, or a structured query (select, filter, sort, limit/offset, aggregate)"),
	response: z.object({
			items: z.array().optional(),
			aggregates: z.unknown().optional(),
			total_count: z.number().optional()
}).optional(),
	metadata: z.array().optional(),

});

import dataclasses

@dataclasses.dataclass
class DatastoreQueryQuerySort_order(str, Enum):
	asc = 'asc'
	desc = 'desc'

@dataclasses.dataclass
class PropertyDatastoreQueryQuery:
	"""Raw SQL – when set, executed directly (table_id optional)"""
	sql: Optional[str]
	select: Optional[PropertyDatastoreQuerySelect]
	expand: Optional[PropertyDatastoreQueryExpand]
	filter: Optional[PropertyDatastoreQueryFilter]
	sort_fields: Optional[PropertyDatastoreQuerySort_fields]
	sort_order: Optional[DatastoreQueryQuerySort_order]
	limit: Optional[int]
	offset: Optional[int]
	aggregate: Optional[PropertyDatastoreQueryAggregate]
	is_count_only: Optional[bool]

@dataclasses.dataclass
class PropertyDatastoreQueryResponse:
	items: Optional[PropertyDatastoreQueryItems]
	aggregates: Optional[PropertyDatastoreQueryAggregates]
	total_count: Optional[int]

@dataclasses.dataclass
class DatastoreQuery:
	table_id: Optional[str]
	database_id: Optional[str]
	"""What to run: a raw `sql` statement, or a structured query (select, filter, sort, limit/offset, aggregate)"""
	query: Optional[PropertyDatastoreQueryQuery]
	response: Optional[PropertyDatastoreQueryResponse]
	metadata: Optional[PropertyDatastoreQueryMetadata]