import type { NobjcObject } from "objc-js";
import type { _NSArray } from "../Foundation/NSArray.js";
import type { _NSCoding } from "../Foundation/NSCoding.js";
import type { _NSDate } from "../Foundation/NSDate.js";
import type { _NSObject } from "../Foundation/NSObject.js";
import type { _NSString } from "../Foundation/NSString.js";
export declare class _ISyncClient extends _NSObject {
    static alloc(): _ISyncClient;
    static new(): _ISyncClient;
    init(): _ISyncClient;
    /**
     * Each client is identified by an id. There are no restrictions on the content or length of an id, but it must be unique across all clients. This is specified when the client is registered and can never be changed afterwards.
     * @deprecated
     */
    clientIdentifier(): _NSString;
    /**
     * A hint as to what kind of thing this client syncs data for. Valid types are ISyncClientTypeApplication (an application such as iCal or AB), ISyncClientTypeDevice (a physical device like a phone, iPod or Palm), ISyncClientTypeServer (.Mac) and ISyncClientTypePeer (not yet implemented).
     * @deprecated
     */
    clientType(): _NSString;
    /**
     * The name of the client - in an ideal world, this will be the actual name of the device or application, such as "My iPod" or iCal. If you refer to this client when dealing with the user, you should use the display name. The display name doesn't have to be unique across all clients, but it probably will end up being that way. There is no magical discovery or divination of display names; the name is specified when the client is first registered and may be changed later by the client (or any other user of the SyncServices API).
     * @deprecated
     */
    displayName(): _NSString;
    /** @deprecated */
    setDisplayName$(displayName: _NSString): void;
    /**
     * An image may be associated with a client. This is used in applications like iSync to represent the client.
     * @deprecated
     */
    imagePath(): _NSString;
    /** @deprecated */
    setImagePath$(path: _NSString): void;
    /**
     * NSString
     * @deprecated
     */
    supportedEntityNames(): _NSArray;
    /**
     * More information taken from the device description. These methods indicate a conduit's ability to accept or provide changes to records of a particular type. Again, these do not specify a device's willingness to do so - that is left for the conduit to negotiate with the engine when it starts a sync session. They are advisory methods only. For example, the iPod conduit will probably indicate that is can accept changes to contacts and calendars but will never provide changes to the same.
     * @deprecated
     */
    canPushChangesForEntityName$(entityName: _NSString): boolean;
    /** @deprecated */
    canPullChangesForEntityName$(entityName: _NSString): boolean;
    /**
     * Return information about the last sync. -lastSyncDate specifies the start date of the last sync, even if that sync was a failure. It returns nil if the device has never synced a record type. If a device is syncing the record type when asked, -lastSyncStatus will return ISyncStatusRunning but -lastSyncDate will continue to return the date of the last sync. The engine will maintain this information for as long as a device supports a record type name (ie. the record type name is returned from -entityNames). When a device stops supporting a record type, this information is erased from the engine's database. Should the device later start support the record type again, these methods will act as if the device had never before synced it.
     * @deprecated
     */
    lastSyncDateForEntityName$(entityName: _NSString): _NSDate;
    /** @deprecated */
    lastSyncStatusForEntityName$(entityName: _NSString): number;
    /**
     * NSString
     * @deprecated
     */
    enabledEntityNames(): _NSArray;
    /** @deprecated */
    isEnabledForEntityName$(entityName: _NSString): boolean;
    /**
     * NSString
     * @deprecated
     */
    setEnabled$forEntityNames$(flag: boolean, entityNames: _NSArray): void;
    /**
     * Some clients might accept records and specify a format dictionary that changes some of the relationships that were pulled. In 10.6 we make the assumption that clients will not do this. If a client needs to format relationships they can indicate this by invoking setFormatsRelationships:. They can also indicate this by using the FormatsRelationships keyword in their client description plist.
     * @deprecated
     */
    formatsRelationships(): boolean;
    /** @deprecated */
    setFormatsRelationships$(flag: boolean): void;
    /**
     * Tell the engine the client wants to pull the Truth. The engine will not let the client push any changes. The client is expected to erase its data store at the start of the pull phase, before pulling any changes. This option remains in effect until the client successfully passes through the pull phase of a sync session. After that, the engine expects the client to synchronize normally.
     * @deprecated
     */
    shouldReplaceClientRecordsForEntityName$(entityName: _NSString): boolean;
    /**
     * NSString
     * @deprecated
     */
    setShouldReplaceClientRecords$forEntityNames$(flag: boolean, entityNames: _NSArray): void;
    /**
     * As a convenience to the conduit author, arbitrary objects can be associated with a device. Any object can be used (we have a garbage-in-garbage-out policy) as long as it is archivable (ie. conforms to NSCoding). Coordinating concurrent access to this information is entirely the responsibility of the client.
     * @deprecated
     */
    objectForKey$(key: _NSString): NobjcObject;
    /** @deprecated */
    setObject$forKey$(value: _NSCoding, key: _NSString): void;
    /**
     * id <ISyncFiltering >
     * @deprecated
     */
    filters(): _NSArray;
    /**
     * id <ISyncFiltering >
     * @deprecated
     */
    setFilters$(filters: _NSArray): void;
    /**
     * Specifies that the receiver wants to synchronize with clients of the specified type (application, device, server or peer). For example, Address Book might register to synchronize with all client types. It will be given a chance to join a sync whenver any client synchronizes the Contacts entities. .Mac might register to synchronize only with device types, so it can participate when a Palm of phone is synchronized. The client will only be notified if it has entities in common with the client initiating the sync. A client may be notified in one of two ways. It may specify the path of a tool or application which will be launched by the sync engine. The tool will be passed four arguments on the command line: "--sync <client id> --entitynames <entity names>". The entity names is a single string suitable for passing to -[NSString componentsSeparatedByString: " ,"]. If the tool wishes to sync any of these entities, it may create an ISyncSession to join the sync. The tool is not limited to syncing only these entities, but it must sync at least one of them. If the tool terminates without creating a sync session, the engine will assume the client does not want to participate in the sync. Alternatively, an observer object may be registered. The sync engine will invoke the selector on the observer. The selector should have the following signature -(void)client:(ISyncClient *)client mightWantToSyncEntityNames:(NSArray *)entityNames. If it wishes to join the sync, it must create an ISyncSession before returning from the method. Only one observer per client per machine may be registered. If an observer is registered in a different process, -setSyncAlertHandler:selector: will throw an exception. An observer is automatically removed when its process exits, of course. You can register both a sync tool and an observer, but only one of the notification methods will be used. If both a tool and an observer are registered, only the observer will be called. When a client creates a sync session, it specifies how long it is willing to wait to start syncing (the "before date" parameter). The sync engine will wait at most that amount of time for a notified clients to join the sync. If a notified client takes too long, the sync will proceed without it.
     * @deprecated
     */
    shouldSynchronizeWithClientsOfType$(clientType: _NSString): boolean;
    /** @deprecated */
    setShouldSynchronize$withClientsOfType$(flag: boolean, clientType: _NSString): void;
    /** @deprecated */
    syncAlertToolPath(): _NSString;
    /** @deprecated */
    setSyncAlertToolPath$(path: _NSString): void;
    /** @deprecated */
    setSyncAlertHandler$selector$(handler: NobjcObject, selector: string): void;
}
