import { PropertyKeysAsResponse } from "../definitions/PropertyKeysAsResponse";
import { HeadersOption, ConnectionOption } from "@avst-api/commons";
import { AssistedErrorStrategyOption } from "../handled-api/common";
import { ErrorStrategyOption } from "../handled-api/common";
import { EntityPropertyAsResponse } from "../definitions/EntityPropertyAsResponse";
import { PageOfDashboardsAsResponse } from "../definitions/PageOfDashboardsAsResponse";
import { ErrorCollectionAsResponse } from "../definitions/ErrorCollectionAsResponse";
import { DashboardDetails } from "../definitions/DashboardDetails";
import { DashboardAsResponse } from "../definitions/DashboardAsResponse";
import { PageBeanDashboardAsResponse } from "../definitions/PageBeanDashboardAsResponse";
import { SharePermission } from "../definitions/SharePermission";
export declare namespace Dashboard {
    namespace Property {
        namespace GetPropertyKeys {
            interface Options extends Options.Base, HeadersOption, AssistedErrorStrategyOption {
            }
            namespace Response {
                type OK = PropertyKeysAsResponse;
                type Error = undefined;
            }
            namespace Options {
                interface Base {
                    /**
                     * The ID of the dashboard.
                     */
                    dashboardId: string;
                    /**
                     * The ID of the dashboard item.
                     */
                    itemId: string;
                }
                interface RawApi extends Base, ConnectionOption, HeadersOption {
                }
                interface HandledApi extends RawApi, ErrorStrategyOption {
                }
            }
        }
        namespace GetProperty {
            interface Options extends Options.Base, HeadersOption, AssistedErrorStrategyOption {
            }
            namespace Response {
                type OK = EntityPropertyAsResponse;
                type Error = undefined;
            }
            namespace Options {
                interface Base {
                    /**
                     * The ID of the dashboard.
                     */
                    dashboardId: string;
                    /**
                     * The ID of the dashboard item.
                     */
                    itemId: string;
                    /**
                     * The key of the dashboard item property.
                     */
                    propertyKey: string;
                }
                interface RawApi extends Base, ConnectionOption, HeadersOption {
                }
                interface HandledApi extends RawApi, ErrorStrategyOption {
                }
            }
        }
        namespace SetProperty {
            interface Options extends Options.Base, HeadersOption, AssistedErrorStrategyOption {
            }
            type Body = any;
            namespace Response {
                type OK = any;
                type Error = undefined;
            }
            namespace Options {
                interface Base {
                    /**
                     * The ID of the dashboard.
                     */
                    dashboardId: string;
                    /**
                     * The ID of the dashboard item.
                     */
                    itemId: string;
                    /**
                     * The key of the dashboard item property. The maximum length is 255 characters.
                     */
                    propertyKey: string;
                    body: Dashboard.Property.SetProperty.Body;
                }
                interface RawApi extends Base, ConnectionOption, HeadersOption {
                }
                interface HandledApi extends RawApi, ErrorStrategyOption {
                }
            }
        }
        namespace DeleteProperty {
            interface Options extends Options.Base, HeadersOption, AssistedErrorStrategyOption {
            }
            namespace Response {
                type OK = undefined;
                type Error = undefined;
            }
            namespace Options {
                interface Base {
                    /**
                     * The ID of the dashboard.
                     */
                    dashboardId: string;
                    /**
                     * The ID of the dashboard item.
                     */
                    itemId: string;
                    /**
                     * The key of the dashboard item property.
                     */
                    propertyKey: string;
                }
                interface RawApi extends Base, ConnectionOption, HeadersOption {
                }
                interface HandledApi extends RawApi, ErrorStrategyOption {
                }
            }
        }
    }
    namespace GetDashboards {
        interface Options extends Options.Base, HeadersOption, AssistedErrorStrategyOption {
        }
        namespace Response {
            type OK = PageOfDashboardsAsResponse;
            type Error = ErrorCollectionAsResponse;
        }
        namespace Options {
            interface Base {
                /**
        * The filter applied to the list of dashboards. Valid values are:
        
         *  `favourite` Returns dashboards the user has marked as favorite.
         *  `my` Returns dashboards owned by the user.
        */
                filter?: "my" | "favourite";
                /**
                 * The index of the first item to return in a page of results (page offset).
                 */
                startAt?: number;
                /**
                 * The maximum number of items to return per page.
                 */
                maxResults?: number;
            }
            interface RawApi extends Base, ConnectionOption, HeadersOption {
            }
            interface HandledApi extends RawApi, ErrorStrategyOption {
            }
        }
    }
    namespace CreateDashboard {
        interface Options extends Options.Base, HeadersOption, AssistedErrorStrategyOption {
        }
        type Body = DashboardDetails;
        namespace Response {
            type OK = DashboardAsResponse;
            type Error = ErrorCollectionAsResponse;
        }
        namespace Options {
            interface Base {
                body: Dashboard.CreateDashboard.Body;
            }
            interface RawApi extends Base, ConnectionOption, HeadersOption {
            }
            interface HandledApi extends RawApi, ErrorStrategyOption {
            }
        }
    }
    namespace SearchDashboards {
        interface Options extends Options.Base, HeadersOption, AssistedErrorStrategyOption {
        }
        namespace Response {
            type OK = PageBeanDashboardAsResponse;
            type Error = ErrorCollectionAsResponse;
        }
        namespace Options {
            interface Base {
                /**
                 * String used to perform a case-insensitive partial match with `name`.
                 */
                dashboardName?: string;
                /**
                 * User account ID used to return dashboards with the matching `owner.accountId`. This parameter cannot be used with the `owner` parameter.
                 */
                accountId?: string;
                /**
                 * Group name used to returns dashboards that are shared with a group that matches `sharePermissions.group.name`.
                 */
                groupname?: string;
                /**
                 * Project ID used to returns dashboards that are shared with a project that matches `sharePermissions.project.id`.
                 */
                projectId?: number;
                /**
        * [Order](#ordering) the results by a field:
        
         *  `description` Sorts by dashboard description. Note that this sort works independently of whether the expand to display the description field is in use.
         *  `favourite_count` Sorts by dashboard popularity.
         *  `id` Sorts by dashboard ID.
         *  `is_favourite` Sorts by whether the dashboard is marked as a favorite.
         *  `name` Sorts by dashboard name.
         *  `owner` Sorts by dashboard owner name.
        */
                orderBy?: "description" | "-description" | "+description" | "favorite_count" | "-favorite_count" | "+favorite_count" | "id" | "-id" | "+id" | "is_favorite" | "-is_favorite" | "+is_favorite" | "name" | "-name" | "+name" | "owner" | "-owner" | "+owner";
                /**
                 * The index of the first item to return in a page of results (page offset).
                 */
                startAt?: number;
                /**
                 * The maximum number of items to return per page.
                 */
                maxResults?: number;
                /**
        * Use [expand](#expansion) to include additional information about dashboard in the response. This parameter accepts a comma-separated list. Expand options include:
        
         *  `description` Returns the description of the dashboard.
         *  `owner` Returns the owner of the dashboard.
         *  `viewUrl` Returns the URL that is used to view the dashboard.
         *  `favourite` Returns `isFavourite`, an indicator of whether the user has set the dashboard as a favorite.
         *  `favouritedCount` Returns `popularity`, a count of how many users have set this dashboard as a favorite.
         *  `sharePermissions` Returns details of the share permissions defined for the dashboard.
        */
                expand?: string;
            }
            interface RawApi extends Base, ConnectionOption, HeadersOption {
            }
            interface HandledApi extends RawApi, ErrorStrategyOption {
            }
        }
    }
    namespace GetDashboard {
        interface Options extends Options.Base, HeadersOption, AssistedErrorStrategyOption {
        }
        namespace Response {
            type OK = DashboardAsResponse;
            type Error = ErrorCollectionAsResponse | undefined;
        }
        namespace Options {
            interface Base {
                /**
                 * The ID of the dashboard.
                 */
                id: string;
            }
            interface RawApi extends Base, ConnectionOption, HeadersOption {
            }
            interface HandledApi extends RawApi, ErrorStrategyOption {
            }
        }
    }
    namespace UpdateDashboard {
        interface Options extends Options.Base, HeadersOption, AssistedErrorStrategyOption {
        }
        type Body = {
            /**
             * The name of the dashboard.
             */
            name?: string;
            /**
             * The description of the dashboard.
             */
            description?: string;
            /**
             * The details of any share permissions for the dashboard.
             */
            sharePermissions?: Array<SharePermission>;
        };
        namespace Response {
            type OK = DashboardAsResponse;
            type Error = ErrorCollectionAsResponse;
        }
        namespace Options {
            interface Base {
                /**
                 * The ID of the dashboard to update.
                 */
                id: string;
                body: Dashboard.UpdateDashboard.Body;
            }
            interface RawApi extends Base, ConnectionOption, HeadersOption {
            }
            interface HandledApi extends RawApi, ErrorStrategyOption {
            }
        }
    }
    namespace DeleteDashboard {
        interface Options extends Options.Base, HeadersOption, AssistedErrorStrategyOption {
        }
        namespace Response {
            type OK = undefined;
            type Error = ErrorCollectionAsResponse;
        }
        namespace Options {
            interface Base {
                /**
                 * The ID of the dashboard.
                 */
                id: string;
            }
            interface RawApi extends Base, ConnectionOption, HeadersOption {
            }
            interface HandledApi extends RawApi, ErrorStrategyOption {
            }
        }
    }
    namespace CopyDashboard {
        interface Options extends Options.Base, HeadersOption, AssistedErrorStrategyOption {
        }
        type Body = DashboardDetails;
        namespace Response {
            type OK = DashboardAsResponse;
            type Error = ErrorCollectionAsResponse;
        }
        namespace Options {
            interface Base {
                id: string;
                body: Dashboard.CopyDashboard.Body;
            }
            interface RawApi extends Base, ConnectionOption, HeadersOption {
            }
            interface HandledApi extends RawApi, ErrorStrategyOption {
            }
        }
    }
}
//# sourceMappingURL=dashboard.d.ts.map