import { CustomObject, type CustomObjectStandardFieldIdentifier } from "../custom-object.mjs";
import { Field } from "../field.mjs";
import { CustomObjectFieldSection } from "../custom-object-field-section.mjs";
import type { RipplingSDK } from "../../../client.mjs";
import { extendCustomObject as extendObject } from "../../../core/platform/custom-objects/definition.mjs";
import type { CustomObjectCategoryDefinition } from "../../../core/platform/custom-objects/category.mjs";
import type { CustomObjectRecordsClient, TypedBatchWriteOptions, TypedRecordPageOptions, TypedRecordQueryOptions, TypedRecordPage, TypedRecordWriteResult } from "../../../core/platform/custom-objects/manager.mjs";
import { type RqlFieldToken, type RqlComparableValue, type RqlFragment } from "../../../core/platform/custom-objects/rql.mjs";
import type { AnyCustomObjectDefinition, CustomObjectDefinition, FieldDefinitions, SectionDefinitions, NameFieldDefinition, RecordShape, LogicalCustomObjectName, LogicalCategoryName } from "../../../core/platform/custom-objects/types.mjs";
import type { RequestOptions } from "../../../internal/request-options.mjs";
import type { FieldListParams, CustomObjectField, CustomObjectFieldsPageCursorURL } from "../../../resources/custom-objects/fields.mjs";
import type { CustomObject as DeployedCustomObject } from "../../../resources/custom-objects/custom-objects.mjs";
import type { APIPromise } from "../../../core/api-promise.mjs";
import type { PagePromise } from "../../../core/pagination.mjs";
import type { ValueParser } from "./function.mjs";
import { type ObjectCreateInput, type ObjectUpdateInput, type ObjectBulkUpdateInput } from "./_object-records.mjs";
export type { ObjectCreateInput, ObjectUpdateInput, ObjectBulkUpdateInput } from "./_object-records.mjs";
export type DefineCustomObjectProps<A extends `${string}__c`, F extends FieldDefinitions, C extends string = `${Unsuffixed<A>}_category`, S extends SectionDefinitions = {}, N extends NameFieldDefinition = {
    kind: 'text';
}> = Omit<ObjectOptions<S, F, N>, 'pluralLabel'> & {
    apiName: A;
    name: string;
    pluralName?: string;
    category?: CategoryInput<C>;
};
export type DefinedCustomObject<D extends {
    fields: object;
    apiName: string;
}> = Omit<D, 'fields' | 'inputs' | 'records' | 'schema'> & {
    readonly fields: {
        readonly [K in keyof D['fields']]: Omit<D['fields'][K], 'apiName'> & {
            readonly apiName: `${Unsuffixed<Extract<K, string>>}__c`;
            readonly objectApiName: D['apiName'];
        };
    };
    readonly records: D extends AnyCustomObjectDefinition ? Readonly<ObjectRecords<D>> : never;
    readonly schema: D extends AnyCustomObjectDefinition ? Readonly<ObjectSchema> : never;
    readonly inputs: D extends AnyCustomObjectDefinition ? {
        readonly create: ValueParser<ObjectCreateInput<D>>;
        readonly update: ValueParser<ObjectUpdateInput<D>>;
    } : never;
};
/** Authenticated records transport supplied at the operation's call site. */
export interface ObjectRecordsContext {
    readonly customObjects: {
        readonly records: CustomObjectRecordsClient;
    };
}
/** Schema resources supplied at the operation's call site. */
export interface ObjectSchemaContext {
    readonly customObjects: Pick<RipplingSDK['customObjects'], 'retrieve' | 'fields'>;
}
export type ObjectRecordListOptions<D extends AnyCustomObjectDefinition> = TypedRecordPageOptions & {
    where?: ObjectFilter<D['apiName']>;
};
/** Typed record operations; writes return readable records or ID-only receipts. Supply an authenticated client at each call. */
export interface ObjectRecords<D extends AnyCustomObjectDefinition> {
    create(ctx: ObjectRecordsContext, input: ObjectCreateInput<D>): Promise<TypedRecordWriteResult<D>>;
    createMany(ctx: ObjectRecordsContext, rows: readonly ObjectCreateInput<D>[], options?: TypedBatchWriteOptions): Promise<readonly TypedRecordWriteResult<D>[]>;
    get(ctx: ObjectRecordsContext, recordID: string): Promise<RecordShape<D>>;
    getByExternalID(ctx: ObjectRecordsContext, externalID: string): Promise<RecordShape<D>>;
    update(ctx: ObjectRecordsContext, recordID: string, patch: ObjectUpdateInput<D>): Promise<TypedRecordWriteResult<D>>;
    updateMany(ctx: ObjectRecordsContext, rows: readonly ObjectBulkUpdateInput<D>[], options?: TypedBatchWriteOptions): Promise<readonly TypedRecordWriteResult<D>[]>;
    delete(ctx: ObjectRecordsContext, recordID: string): Promise<void>;
    deleteMany(ctx: ObjectRecordsContext, recordIDs: readonly string[], options?: TypedBatchWriteOptions): Promise<void>;
    /** List records with optional typed filters and cursor pagination. */
    list(ctx: ObjectRecordsContext, options?: ObjectRecordListOptions<D>): Promise<TypedRecordPage<D>>;
    /** Run a raw RQL filter with cursor pagination. */
    query(ctx: ObjectRecordsContext, options?: TypedRecordQueryOptions): Promise<TypedRecordPage<D>>;
}
/** Deployed object metadata, separate from the local field definitions. */
export interface ObjectSchema {
    retrieve(ctx: ObjectSchemaContext, options?: RequestOptions): APIPromise<DeployedCustomObject>;
    readonly fields: Readonly<ObjectSchemaFields>;
}
export interface ObjectSchemaFields {
    list(ctx: ObjectSchemaContext, params?: FieldListParams, options?: RequestOptions): PagePromise<CustomObjectFieldsPageCursorURL, CustomObjectField>;
}
export interface CustomObjectOperations<D extends AnyCustomObjectDefinition> {
    readonly records: Readonly<ObjectRecords<D>>;
    readonly schema: Readonly<ObjectSchema>;
}
/** The same operations with the authenticated client supplied by client.objects(definition). */
export interface ObjectClient<D extends AnyCustomObjectDefinition> {
    create(input: ObjectCreateInput<D>): Promise<TypedRecordWriteResult<D>>;
    createMany(rows: readonly ObjectCreateInput<D>[], options?: TypedBatchWriteOptions): Promise<readonly TypedRecordWriteResult<D>[]>;
    get(recordID: string): Promise<RecordShape<D>>;
    getByExternalID(externalID: string): Promise<RecordShape<D>>;
    update(recordID: string, patch: ObjectUpdateInput<D>): Promise<TypedRecordWriteResult<D>>;
    updateMany(rows: readonly ObjectBulkUpdateInput<D>[], options?: TypedBatchWriteOptions): Promise<readonly TypedRecordWriteResult<D>[]>;
    delete(recordID: string): Promise<void>;
    deleteMany(recordIDs: readonly string[], options?: TypedBatchWriteOptions): Promise<void>;
    list(options?: ObjectRecordListOptions<D>): Promise<TypedRecordPage<D>>;
    query(options?: TypedRecordQueryOptions): Promise<TypedRecordPage<D>>;
    schema: {
        retrieve(options?: RequestOptions): APIPromise<DeployedCustomObject>;
    };
    fields: {
        list(params?: FieldListParams, options?: RequestOptions): PagePromise<CustomObjectFieldsPageCursorURL, CustomObjectField>;
    };
}
export type ObjectFilter<A extends string> = RqlFragment & {
    readonly [filterOwner]: A;
};
export declare function defineCustomObject<const A extends `${string}__c`, const F extends FieldDefinitions, C extends string = `${Unsuffixed<A>}_category`, S extends SectionDefinitions = {}, N extends NameFieldDefinition = {
    kind: 'text';
}>(props: DefineCustomObjectProps<A, F, C, S, N>): DefinedCustomObject<CustomObjectDefinition<LogicalCustomObjectName<Unsuffixed<A>>, LogicalCategoryName<C>, S, F, N>>;
/** Existing extension semantics, with the same additive field tokens and parsers. */
export declare function extendCustomObject<B extends AnyCustomObjectDefinition, S extends SectionDefinitions = {}, F extends FieldDefinitions = {}>(base: B, extension: Omit<Parameters<typeof extendObject<B, S, F>>[1], 'fields'> & {
    fields?: Extract<keyof B['fields'], keyof F> extends never ? F & ApiNamedMap<F> : never;
    sections?: ApiNamedMap<S>;
}): DefinedCustomObject<ReturnType<typeof extendObject<B, S, F>>>;
export declare const eq: <T, const A extends string>(field: FieldToken<T, A>, value: RqlComparableValue<NoInfer<T>> | null) => ObjectFilter<A>;
export declare const ne: <T, const A extends string>(field: FieldToken<T, A>, value: RqlComparableValue<NoInfer<T>> | null) => ObjectFilter<A>;
export declare const lt: <T extends string | number, const A extends string>(field: FieldToken<T | null, A>, value: NoInfer<T>) => ObjectFilter<A>;
export declare const lte: <T extends string | number, const A extends string>(field: FieldToken<T | null, A>, value: NoInfer<T>) => ObjectFilter<A>;
export declare const gt: <T extends string | number, const A extends string>(field: FieldToken<T | null, A>, value: NoInfer<T>) => ObjectFilter<A>;
export declare const gte: <T extends string | number, const A extends string>(field: FieldToken<T | null, A>, value: NoInfer<T>) => ObjectFilter<A>;
export declare const inArray: <T, const A extends string>(field: FieldToken<T, A>, values: readonly RqlComparableValue<NoInfer<T>>[]) => ObjectFilter<A>;
export declare const notInArray: <T, const A extends string>(field: FieldToken<T, A>, values: readonly RqlComparableValue<NoInfer<T>>[]) => ObjectFilter<A>;
export declare const isNull: <T, const A extends string>(field: FieldToken<T, A>) => ObjectFilter<A>;
export declare const isNotNull: <T, const A extends string>(field: FieldToken<T, A>) => ObjectFilter<A>;
export declare const and: <const A extends string>(first: ObjectFilter<A>, ...rest: ObjectFilter<NoInfer<A>>[]) => ObjectFilter<A>;
export declare const or: <const A extends string>(first: ObjectFilter<A>, ...rest: ObjectFilter<NoInfer<A>>[]) => ObjectFilter<A>;
export declare const not: <const A extends string>(filter: ObjectFilter<A>) => ObjectFilter<A>;
type Unsuffixed<N extends string> = N extends `${infer Name}__c` ? Name : N;
type ApiNamedMap<T> = {
    [K in keyof T]: string extends K ? T[K] : K extends `${string}__c` ? T[K] : never;
};
type CategoryInput<N extends string> = `${N}__c` | CustomObjectCategoryDefinition<LogicalCategoryName<N>>;
type ObjectOptions<S extends SectionDefinitions, F extends FieldDefinitions, N extends NameFieldDefinition> = Pick<AnyCustomObjectDefinition, 'description' | 'pluralLabel' | 'icon' | 'ownerRole' | 'enableHistory'> & {
    sections?: S & ApiNamedMap<S>;
    fields: F & ApiNamedMap<F> & {
        [K in keyof F]: string extends Exclude<F[K]['section'], undefined> ? F[K] : Exclude<F[K]['section'], undefined> extends keyof NoInfer<S> ? F[K] : never;
    };
    nameField?: N;
};
/** @internal Forward client helpers to the definition operations. */
export declare function createObjectClient<D extends AnyCustomObjectDefinition>(ctx: ObjectRecordsContext & ObjectSchemaContext, definition: D): ObjectClient<D>;
declare const filterOwner: unique symbol;
type FieldToken<T, A extends string> = Pick<RqlFieldToken<T>, 'apiName' | '__valueType__'> & {
    readonly objectApiName: A;
};
declare const objectScope: unique symbol;
/** Carry parent identity through helpers while still accepting existing constructor instances. */
export type ObjectScoped<TObject extends ObjectReference, TDefinition> = TDefinition & {
    readonly [objectScope]: TObject['apiName'];
};
export declare function scopedDefinition<TObject extends ObjectReference, TDefinition extends object>(_object: TObject, definition: TDefinition): ObjectScoped<TObject, TDefinition>;
export declare function fieldReferences<TObject extends ObjectReference>(owner: TObject, field: DefinitionFieldReference<TObject>): object[];
/** Keep dependency collection in sync with layout-driven field moves. */
export declare function trackFieldSection<T extends Field>(field: T, section: CustomObjectFieldSection): T;
export declare function fieldSectionReferences(field: Field): object[];
export type ObjectReference = AnyCustomObjectDefinition;
export type DefinitionFieldReference<TObject extends ObjectReference> = TObject['fields'][keyof TObject['fields']] | ObjectScoped<TObject, Field> | CustomObjectStandardFieldIdentifier;
export type SectionReference<TObject extends ObjectReference> = ObjectScoped<TObject, CustomObjectFieldSection> | Extract<keyof TObject['sections'], string> | 'general';
export declare function manifestSection<TObject extends ObjectReference>(object: TObject, reference: SectionReference<TObject>): CustomObjectFieldSection;
/** References and compilation reuse one materialized schema; authored children remain explicit roots. */
export declare function manifestObject(reference: ObjectReference): CustomObject;
/** Adapts a typed schema field to the existing layout, view, and rule component APIs. */
export declare function manifestField<TObject extends ObjectReference>(object: TObject, field: NoInfer<DefinitionFieldReference<TObject>>): Field;
//# sourceMappingURL=custom-object.d.mts.map